¿Cuál es la forma más fácil (usando una herramienta gráfica o línea de comando en Ubuntu Linux) para saber si dos archivos binarios son iguales o no (excepto las marcas de tiempo)? No necesito realmente extraer la diferencia. Solo necesito saber si son iguales o no.

El Unix estándar diffmostrará si los archivos son iguales o no:

[me@host ~]$ diff 1.bin 2.bin
Binary files 1.bin and 2.bin differ

Si no hay salida del comando, significa que los archivos no tienen diferencias.

Usa el cmpcomando. Esto saldrá limpiamente si son binarios iguales, o imprimirá donde ocurre la primera diferencia y saldrá.

Encontré que Visual Binary Diff era lo que estaba buscando, disponible en:

• Ubuntu:

  sudo apt install vbindiff
  

• Arch Linux:

  sudo pacman -S vbindiff
  

• Mac OS X a través de MacPorts :

  port install vbindiff
  

• Mac OS X a través de Homebrew:

  brew install vbindiff
  

Use sha1 para generar suma de comprobación:

sha1 [FILENAME1]
sha1 [FILENAME2]

Terminé usando hexdump para convertir los archivos binarios a su representación hexadecimal y luego los abrí en meld / kompare / cualquier otra herramienta diff. A diferencia de ti, buscaba las diferencias en los archivos.

hexdump tmp/Circle_24.png > tmp/hex1.txt
hexdump /tmp/Circle_24.png > tmp/hex2.txt

meld tmp/hex1.txt tmp/hex2.txt

Puede usar la función hash MD5 para verificar si dos archivos son iguales, con esto no puede ver las diferencias en un nivel bajo, pero es una forma rápida de comparar dos archivos.

md5 <filename1>
md5 <filename2>

Si los dos hashes MD5 (la salida del comando) son iguales, entonces, los dos archivos no son diferentes.

Use el comando cmp. Consulte Archivos binarios y Forzar comparaciones de texto para obtener más información.

cmp -b file1 file2

Para encontrar defectos de memoria flash, tuve que escribir este script que muestra todos los bloques de 1K que contienen diferencias (no solo el primero como lo cmp -bhace)

#!/bin/sh

f1=testinput.dat
f2=testoutput.dat

size=$(stat -c%s $f1)
i=0
while [ $i -lt $size ]; do
  if ! r="`cmp -n 1024 -i $i -b $f1 $f2`"; then
    printf "%8x: %s\n" $i "$r"
  fi
  i=$(expr $i + 1024)
done

Salida:

   2d400: testinput.dat testoutput.dat differ: byte 3, line 1 is 200 M-^@ 240 M- 
   2dc00: testinput.dat testoutput.dat differ: byte 8, line 1 is 327 M-W 127 W
   4d000: testinput.dat testoutput.dat differ: byte 37, line 1 is 270 M-8 260 M-0
   4d400: testinput.dat testoutput.dat differ: byte 19, line 1 is  46 &  44 $

Descargo de responsabilidad: pirateé el guión en 5 min. No admite argumentos de línea de comandos ni admite espacios en los nombres de archivo

Diferenciar con las siguientes opciones haría una comparación binaria para verificar si los archivos son diferentes y generaría si los archivos también son los mismos:

diff -qs {file1} {file2}

Si está comparando dos archivos con el mismo nombre en diferentes directorios, puede usar este formulario en su lugar:

diff -qs {file1} --to-file={dir2}

OS X El Capitan

Prueba diff -s

Respuesta corta: corre diffcon el -sinterruptor.

Respuesta larga: sigue leyendo.

Aquí hay un ejemplo. Comencemos creando dos archivos con contenido binario aleatorio:

$ dd if=/dev/random bs=1k count=1 of=test1.bin
1+0 records in
1+0 records out
1024 bytes (1,0 kB, 1,0 KiB) copied, 0,0100332 s, 102 kB/s

                                                                                  
$ dd if=/dev/random bs=1k count=1 of=test2.bin
1+0 records in
1+0 records out
1024 bytes (1,0 kB, 1,0 KiB) copied, 0,0102889 s, 99,5 kB/s

Ahora hagamos una copia del primer archivo:

$ cp test1.bin copyoftest1.bin

Ahora test1.bin y test2.bin deberían ser diferentes:

$ diff test1.bin test2.bin
Binary files test1.bin and test2.bin differ

... y test1.bin y copyoftest1.bin deben ser idénticos:

$ diff test1.bin copyoftest1.bin

¡Pero espera! ¿Por qué no hay salida?

La respuesta es: esto es por diseño. No hay salida en archivos idénticos.

Pero hay diferentes códigos de error:

$ diff test1.bin test2.bin
Binary files test1.bin and test2.bin differ

$ echo $?
1


$ diff test1.bin copyoftest1.bin

$ echo $?
0

Ahora, afortunadamente, no tiene que verificar los códigos de error cada vez porque puede usar el interruptor -s(o --report-identical-files) para hacer que diff sea más detallado:

$ diff -s test1.bin copyoftest1.bin
Files test1.bin and copyoftest1.bin are identical

Radiff2 es una herramienta diseñada para comparar archivos binarios, similar a la forma en que los diferenciales regulares comparan archivos de texto.

Prueba radiff2cuál es parte del radare2desensamblador. Por ejemplo, con este comando:

radiff2 -x file1.bin file2.bin

Obtiene una salida de dos columnas con bastante formato donde se resaltan las diferencias.

Mis favoritos usando xxd hex-dumper del paquete vim:

1) usando vimdiff (parte de vim)

#!/bin/bash
FILE1="$1"
FILE2="$2"
vimdiff <( xxd "$FILE1" ) <( xxd "$FILE2" )

2) usando diff

#!/bin/bash
FILE1=$1
FILE2=$2
diff -W 140 -y <( xxd $FILE1 ) <( xxd $FILE2 ) | colordiff | less -R -p '  \|  '

md5sum binary1 binary2

Si el md5sum es igual, los binarios son iguales

P.ej

md5sum new*
89c60189c3fa7ab5c96ae121ec43bd4a  new.txt
89c60189c3fa7ab5c96ae121ec43bd4a  new1.txt
root@TinyDistro:~# cat new*
aa55 aa55 0000 8010 7738
aa55 aa55 0000 8010 7738


root@TinyDistro:~# cat new*
aa55 aa55 000 8010 7738
aa55 aa55 0000 8010 7738
root@TinyDistro:~# md5sum new*
4a7f86919d4ac00c6206e11fca462c6f  new.txt
89c60189c3fa7ab5c96ae121ec43bd4a  new1.txt

Hay una forma relativamente simple de verificar si dos archivos binarios son iguales.

Si utiliza la entrada / salida de archivos en un lenguaje de programación; puede almacenar cada bit de ambos archivos binarios en sus propias matrices.

En este punto, la verificación es tan simple como:

if(file1 != file2){
    //do this
}else{
    /do that
}