Cómo volcar parte del archivo binario

Question

tengo binario y quiero extraer parte de ella, a partir de conocimientos cadena de bytes (es decir, FF D8 FF D0) y terminando con la cadena de bytes conocida (FA FF D9)

En el pasado, he usado dd para cortar parte del archivo binario desde el principio/final, pero este comando no parece ser compatible con lo que pido.

¿Qué herramienta en el terminal puede hacer esto?

Answer 1

En un solo tubo:

xxd -c1 -p file | 
    awk -v b="ffd8ffd0" -v e="aaffd9" ' 
    found == 1 { 
     print $0 
     str = str $0 
     if (str == e) {found = 0; exit} 
     if (length(str) == length(e)) str = substr(str, 3)} 
    found == 0 { 
     str = str $0 
     if (str == b) {found = 1; print str; str = ""} 
     if (length(str) == length(b)) str = substr(str, 3)} 
    END{ exit found }' | 
    xxd -r -p > new_file 
test ${PIPESTATUS[1]} -eq 0 || rm new_file 

La idea es utilizar awk entre dos xxd para seleccionar la parte del archivo que se necesita. Una vez que se encuentra el primer patrón, awk imprime los bytes hasta que se encuentre el 2do patrón y salga.

Se debe tener en cuenta el caso donde se encuentra el primer patrón pero el segundo no es. Se realiza en la parte END del script awk, que devuelve un estado de salida distinto de cero. Esta es captura por bash 's ${PIPESTATUS[1]} donde decidí eliminar el nuevo archivo.

Tenga en cuenta que en el archivo vacío también significa que no se ha encontrado nada.

Answer 2

Ubique la posición inicial/final, luego extraiga el rango.

$ xxd -g0 input.bin | grep -im1 FFD8FFD0 | awk -F: '{print $1}' 
0000cb0 
$ ^FFD8FFD0^AFFFD9^ 
0009590 
$ dd ibs=1 count=$((0x9590-0xcb0+1)) skip=$((0xcb0)) if=input.bin of=output.bin 

Answer 3

Ver this link una manera de hacer grep binario. Una vez que tenga el desplazamiento inicial y final, debe poder obtener dd para obtener lo que necesita.

Answer 4

Esto debería funcionar con las herramientas estándar (xxd, tr, grep, awk, dd). Esto maneja correctamente el problema de "patrón dividido entre líneas", también busca el patrón alineado solo en el desplazamiento de bytes (no en mordisco).

file=<yourfile> 
outfile=<youroutputfile> 
startpattern="ff d8 ff d0" 
endpattern="af ff d9" 
xxd -g0 -c1 -ps ${file} | tr '\n' ' ' > ${file}.hex 
start=$((($(grep -bo "${startpattern}" ${file}.hex\ 
    | head -1 | awk -F: '{print $1}')-1)/3)) 
len=$((($(grep -bo "${endpattern}" ${file}.hex\ 
    | head -1 | awk -F: '{print $1}')-1)/3-${start})) 
dd ibs=1 count=${len} skip=${start} if=${file} of=${outfile} 

Nota: El script anterior uso de un archivo temporal para evitar tener la conversión binaria> hexagonal dos veces. Una compensación de espacio/tiempo es canalizar el resultado de xxd directamente en los dos grep. También es posible un trazador de líneas, a expensas de la claridad.

También se podría usar tee y named pipe para evitar tener que almacenar un archivo temporal y convertir el resultado dos veces, pero no estoy seguro de que sea más rápido (xxd es rápido) y ciertamente es más complejo de escribir.

Answer 5

Una variante de la solución awk que asume que el archivo binario, una vez convertidos en hexadecimal con espacios, cabe en la memoria:

xxd -c1 -p file | 
    tr "\n" " " | 
    sed -n -e 's/.*\(ff d8 ff d0.*aa ff d9\).*/\1/p' | 
    xxd -r -p > new_file 

Answer 6

Otra solución en sed, pero utilizando menos memoria:

xxd -c1 -p file | 
    sed -n -e '1{N;N;N}' -e '/ff\nd8\nff\nd0/{:begin;p;s/.*//;n;bbegin}' -e 'N;D' | 
    sed -n -e '1{N;N}' -e '/aa\nff\nd9/{p;Q1}' -e 'P;N;D' | 
    xxd -r -p > new_file 
test ${PIPESTATUS[2]} -eq 1 || rm new_file 

La primera sed imprime desde ff d8 ff d0 hasta el final del archivo. Tenga en cuenta que necesita tantos N en -e '1{N;N;N}', ya que hay bytes en su primer patrón menos uno.

La 2da sed imprime desde el comienzo del archivo a aa ff d9. Tenga en cuenta nuevamente que necesita tantos N en -e '1{N;N}' como hay bytes en su segundo patrón menos uno.

De nuevo, se necesita una prueba para comprobar si se encuentra el 2º patrón, y eliminar el archivo si no lo está.

Tenga en cuenta que el comando Q es una extensión de GNU a sed. Si no lo tiene, debe trash el resto del archivo una vez que se encuentre el patrón (en un ciclo como el 1er sed, pero no imprimir el archivo), y verifique después de la conversión de hexadecimal a binario que el archivo_nuevo termine con el patrón de wright.