czkawka é uma ferramenta de código aberto que foi criada para encontrar arquivos duplicados (e imagens, vídeos ou músicas) e apresentá-los através de linhas de comando ou interfaces gráficas, com ênfase na velocidade. Esta parte da documentação pode lhe interessar:

Verificação mais rápida para grande número de duplicatas

Por padrão para todos os arquivos agrupados pelo mesmo tamanho são computados hash parciais (hash de apenas 2KB cada arquivo). Esse hash é calculado geralmente muito rápido, especialmente em SSDs e processadores multicore rápidos. Mas ao digitalizar centenas de milhares ou milhões de arquivos com HDD ou processador lento, normalmente essa etapa pode levar muito tempo.

Com a versão GUI, os hashes serão armazenados em um cache para que a busca por duplicatas posteriormente seja muito mais rápida.

Exemplos:

Crie alguns arquivos de teste:

Geramos imagens aleatórias e copiamos a.jpgpara b.jpgobter uma duplicata.

$ convert -size 1000x1000 plasma:fractal a.jpg
$ cp -v a.jpg b.jpg
'a.jpg' -> 'b.jpg'
$ convert -size 1000x1000 plasma:fractal c.jpg
$ convert -size 1000x1000 plasma:fractal d.jpg
$ ls --size
total 1456
364 a.jpg  364 b.jpg  364 c.jpg  364 d.jpg

Verifique apenas o tamanho:

$ linux_czkawka_cli dup --directories /run/shm/test/ --search-method size
Found 2 files in 1 groups with same size(may have different content) which took 361.76 KiB:
Size - 361.76 KiB (370442) - 2 files 
/run/shm/test/b.jpg
/run/shm/test/a.jpg

Verifique os arquivos por seus hashes:

$ linux_czkawka_cli dup --directories /run/shm/test/ --search-method hash
Found 2 duplicated files in 1 groups with same content which took 361.76 KiB:
Size - 361.76 KiB (370442) - 2 files 
/run/shm/test/b.jpg
/run/shm/test/a.jpg

Verifique os arquivos analisando-os como imagens:

$ linux_czkawka_cli image --directories /run/shm/test/
Found 1 images which have similar friends
/run/shm/test/a.jpg - 1000x1000 - 361.76 KiB - Very High
/run/shm/test/b.jpg - 1000x1000 - 361.76 KiB - Very High

Você provavelmente gostaria de fazer uma comparação completa (ou hash) no primeiro e no último 1 MiB ou mais, onde os metadados podem viver que podem ser editados sem introduzir deslocamentos nos dados compactados. Além disso, a granularidade de leitura do armazenamento geralmente é de pelo menos 512 bytes e não 16, então é melhor fazer isso; um pouco de tempo extra de CPU para comparar mais dados é trivial. (Alinhado em um limite de 512 bytes)

(Um tamanho de setor de gravação de pelo menos 4096B é típico, mas um tamanho de setor lógico de 512 pode permitir que um disco SATA envie apenas o 512B solicitado pela rede, se o kernel não ampliar a solicitação para uma página inteira. provavelmente seria; o pagecache é gerenciado em páginas inteiras.)

Lembre-se de que o bit-rot é possível , especialmente se os arquivos tiverem sido armazenados em DVD-R ou outra mídia óptica. Eu não excluiria um "duplicado" sem verificar se há bits idênticos (ou pelo menos hashes idênticos). Descartar duplicatas rapidamente com base em uma assinatura de hash de uma parte inicial de um arquivo é útil, mas você ainda deseja fazer uma verificação completa antes de declarar dois arquivos duplicados para a maioria dos propósitos.

Se dois arquivos são quase iguais, mas têm algumas diferenças de bits, useffmpeg -i foo.mp4 -f null - para encontrar falhas, decodificar, mas não fazer nada com a saída.

Se você encontrar uma diferença bit a bit, mas nenhum arquivo tiver erros que um decodificador notará, use

ffmpeg -i foo.mp4 -f framecrc  foo.fcrc

ou -f framemd5para ver qual quadro tem uma diferença que não era um fluxo h.264 inválido. Em seguida, procure lá e inspecione visualmente qual está corrompido.

Seu método pode ser bom para detectar arquivos que são cópias corrompidas (ou editadas por metadados) uns dos outros, algo que os localizadores de duplicatas normais não farão facilmente. Comentários sob a questão apontam que jdupespode usar hashes dos primeiros N megabytes de um arquivo após uma comparação de tamanho, então esse é um passo na direção certa.

Para outros casos de uso, talvez você esteja bem com uma verificação menos rigorosa, mas dado que existem localizadores de arquivos duplicados que só comparam ou fazem hash quando há arquivos de tamanho idêntico, você pode simplesmente deixar um deles rodar (durante a noite ou enquanto você 'está saindo) e volte para uma lista totalmente verificada.

Alguns fslinttêm a opção de vincular duplicatas umas às outras (ou link simbólico), então da próxima vez que você procurar duplicatas, elas já serão o mesmo arquivo. Portanto, na minha experiência, a localização de arquivos duplicados não é algo em que senti a necessidade de adotar uma abordagem mais rápida, mas arriscada.

( fslintnunca foi atualizado para Python3, aparentemente czkawkaé um clone moderno em Rust, de acordo com uma resposta do askubuntu .)

O GNU cmpajuda você?

• Você pode usar a -sopção para suprimir a saída e usar apenas o valor de retorno
• Ele verifica o tamanho do arquivo primeiro para pular qualquer comparação em diferentes tamanhos de arquivo
• Com opções -i(pular inicial) e -n(número de bytes para comparar) você pode definir adicionalmente um intervalo de bytes que deseja comparar

Se o número de arquivos for muito grande para cmpcada par deles, você pode querer primeiro sorttodos os arquivos pelo tamanho e comparar apenas grupos com o mesmo tamanho ( uniq -Dcom -w).

Implementação de shellscript da ideia do OP, @vume

Fundo com o exemplorsync

Dê uma olhada rsync. Possui vários níveis de verificação se os arquivos são idênticos. O manual man rsyncé muito detalhado, e você pode identificar o que eu descrevo, e provavelmente também algumas outras alternativas interessantes.

• A verificação mais rigorosa é comparar cada byte, mas à medida que você escreve, leva muito tempo quando há muitos dados, por exemplo, um backup inteiro.

  -c, --checksum              skip based on checksum, not mod-time & size
  -a, --archive               archive mode; equals -rlptgoD (no -H,-A,-X)
  

• A verificação padrão é o tamanho e outros atributos de arquivo (por exemplo, carimbos de hora). Muitas vezes é considerado bom o suficiente.

• Sua ideia, @vume, significa algo entre esses dois níveis de verificação. Eu não vi nenhuma ferramenta como essa, mas eu estaria muito interessado em tal ferramenta.

Edição 1: O script de shellvumer

O shellscript a seguir vumerusa ddpara fazer o que eu acho que você quer, @vume.

#!/bin/bash

chunks=16
chnksiz=16

function usage {
 echo "Usage: ${0##*/} <file>"
}

if ! test -f "$1"
then
 usage
 exit
fi

size=$(stat --format='%s' "$1")
step=$(( size/(chunks-1) ))
#echo "step=$step"
tmpfil=$(mktemp)

if [ $size -lt 512 ]
then
 chksum=$(md5sum "$1" | sed 's/ .*//')
else
 for (( i=0;i<chunks;i++ ))
 do
  if [ $i -eq $((chunks-1)) ]
  then
   pos=$((size-chnksiz))
  else
   pos=$((i*step))
  fi
#  echo "$i: $pos"
  dd if="$1" bs=1 skip=$pos count=16 >> "$tmpfil" 2> /dev/null
 done
 chksum=$(md5sum "$tmpfil" | sed 's/ .*//')
fi

modif=$(stat --format='%y' "$1")
modif=${modif//\ /_}
echo "size=$size modif=$modif checksum=$chksum file=\"$1\""
#less "$tmpfil"
rm "$tmpfil"

Na minha estação de trabalho Lenovo C30 (antiga, mas bastante poderosa) testei vumercom o arquivo iso Ubuntu Desktop 22.04 LTS e comparei o tempo usado com md5sum,

$ time vumer ubuntu-22.04-desktop-amd64.iso
size=3654957056 modif=2022-04-19_10:25:02.000000000_+0200 checksum=ec3483153bfb965745753c4b1b92bf2e file="ubuntu-22.04-desktop-amd64.iso"

real    0m0,024s
user    0m0,018s
sys 0m0,008s

$ time md5sum ubuntu-22.04-desktop-amd64.iso
7621da10af45a031ea9a0d1d7fea9643  ubuntu-22.04-desktop-amd64.iso

real    0m19,919s
user    0m5,331s
sys 0m0,988s

Então, para arquivos grandes, é realmente muito mais rápido que o md5sum, que hoje é considerado uma ferramenta de soma de verificação [muito] simples. sha256sumé ainda mais lento.

Eu verifiquei também com um arquivo iso Debian que foi convertido para substituir algumas opções de inicialização quiet splashe persistence comparado com seu arquivo original. vumerteve azar e não verificou os poucos locais modificados. Então, aqui devemos recorrer ao carimbo de data/hora clássico para dizer a diferença. Claro que md5sumpode dizer a diferença.

$ vumer debian-live-10.0.0-amd64-standard.iso
size=865075200 modif=2019-09-05_10:14:31.000000000_+0200 checksum=b8af03a946fb400ca66f2bdb2a6bb628 file="debian-live-10.0.0-amd64-standard.iso"

$ vumer persistent-debian-live-10.0.0-amd64-standard.iso
size=865075200 modif=2019-09-12_18:01:55.000000000_+0200 checksum=b8af03a946fb400ca66f2bdb2a6bb628 file="persistent-debian-live-10.0.0-amd64-standard.iso"

$ md5sum  *debian-live-10.0.0-amd64-standard.iso
a64ae643520ca0edcbcc769bae9498f3  debian-live-10.0.0-amd64-standard.iso
574ac1f29a6c86d16353a54f6aa8ea1c  persistent-debian-live-10.0.0-amd64-standard.iso

Portanto, depende do tipo de arquivos que você possui e de como eles podem ser modificados, se vumerferramentas semelhantes são úteis.

Edit 2: Um 'oneliner' para escanear uma árvore de diretórios

Este é um 'oneliner' para escanear uma árvore de diretórios

md5sum $(for i in $(find -type f -ls|sed 's/^ *//'|tr -s ' ' '\t     '| \
cut -f 7,11|sort -n|sed 's/\t/\t     /'|uniq -Dw10|sed 's/\t */\t/'| \
cut -f 2 );do vumer "$i";done|sed -e 's/.*checksum=//'|sort|rev| \
uniq -f 1 -D|rev|tee /dev/stderr|sed -e 's/.*file=//' -e 's/"//g')|uniq -Dw32

• Havia 418 arquivos em uma árvore de diretórios (com arquivos iso e alguns outros arquivos)
• verificando o tamanho identificado 72 arquivos (potencialmente 36 pares)
• vumeridentificou 30 arquivos (15 pares) com a mesma soma de verificação vumer
• md5sumidentificou 18 arquivos (9 pares) com a mesma soma de verificação md5sum

Isso significa que vumereconomizou muito tempo; md5sumnecessário verificar apenas 30 dos 418 arquivos.

Edição 3: O shellscriptscan4dblt

Substituí o 'oneliner' por um script , scan4dblt, que também testei em algumas árvores de diretórios e fiz algumas edições no script 'doer', vumer.

#!/bin/bash

function mkfil {

tmpf0=$(mktemp)
tmpf1=$(mktemp)
tmpf2=$(mktemp)
tmpf3=$(mktemp)
tmpf4=$(mktemp)
tmpf5=$(mktemp)
}

function rmfil {

rm "$tmpf0" "$tmpf1" "$tmpf2" "$tmpf3" "$tmpf4" "$tmpf5"
}

# main

echo -n "${0##*/}: "
mkfil

# same size

find -type f -printf "%s %p\n" \
|sed 's/ /        /'|sort -n|uniq -Dw11|tee "$tmpf0" |tr -s ' ' ' ' \
|cut -d ' ' -f 2- |sed -e 's/&/\&/g' -e 's/(/\(/g' -e 's/)/\)/g' > "$tmpf1"

res=$(wc -l "$tmpf0"|sed 's/ .*//')
if [ $res -gt 1 ]
then
 echo "same size ($res):"
 cat "$tmpf0"
else
 echo "no files with the same size"
 rmfil
 exit 1
fi

# vumer

while read fnam
do
 echo -n '.'
 vumer "$fnam" >> "$tmpf2"
# echo -e "$fnam: $(vumer "$fnam")" >> "$tmpf2"
done < "$tmpf1"
echo ''
sed "$tmpf2" -e 's/.*checksum=//'|sort|uniq -Dw33|tee "$tmpf1" |sed -e 's/.*file=//' -e 's/"//g' > "$tmpf3"

res=$(wc -l "$tmpf1"|sed 's/ .*//')
if [ $res -gt 1 ]
then
 echo "vumer: ($res)"
 cat "$tmpf1"
else
 echo "vumer: no files with the same checksum"
 rmfil
 exit 1
fi

# inode

while read fnam
do
 echo -n '.'
 size=$(stat --format='%s' "$fnam")
 inod=$(stat --format='%i' "$fnam")
 printf "%12d %10d %s\n" $size $inod "$fnam" >> "$tmpf4"
done < "$tmpf3"
echo ''
#cat "$tmpf4"
#cat "$tmpf4" |sort -k3|uniq -f2 -Dw32 |sort -n > "$tmpf5"
cat "$tmpf4" |sort -k2|uniq -f1 -Dw11 |sort -n > "$tmpf5"

> "$tmpf2"
while read fnam
do
 if ! grep "$fnam" "$tmpf5" 2>&1 > /dev/null
 then
  echo "$fnam" >> "$tmpf2"
 fi
done < "$tmpf3"

res=$(wc -l "$tmpf5"|sed 's/ .*//')
if [ $res -gt 1 ]
then
 echo "inode: ($res)"
 echo "        size     inode              md5sum                 file-name"
 cat "$tmpf5"
else
 echo "inode: no files with the same inode"
fi

# md5sum

> "$tmpf4"
while read fnam
do
 echo -n '.'
 size=$(stat --format='%s' "$fnam")
 inod=$(stat --format='%i' "$fnam")
 printf "%12d %10d " $size $inod >> "$tmpf4"
 md5sum "$fnam" >> "$tmpf4"
done < "$tmpf2"
echo ''
#echo "4: ";cat "$tmpf4"
cat "$tmpf4" |sort -k3|uniq -f2 -Dw33 |sort -n > "$tmpf5"

res=$(wc -l "$tmpf5"|sed 's/ .*//')
if [ $res -gt 1 ]
then
 echo "md5sum: ($res)"
 echo "        size     inode              md5sum                 file-name"
 cat "$tmpf5"
else
 echo "md5sum: no files with the same checksum"
 rmfil
 exit 1
fi

rmfil

Editar 4: shellscript aprimorado scan4dbltmais exemplo (arquivo de saída)

O shellscript scan4dblté desenvolvido e testado com algumas árvores de diretórios, incluindo grandes arquivos iso, fotos, videoclipes e documentos. Vários bugs foram corrigidos (e a versão atual substitui a original aqui).

Exemplo:

O exemplo a seguir mostra o arquivo de saída produzido por

scan4dblt | tee /tmp/scan4dblt.out

• Pastebin com o arquivo de resultado: scan4dblt.out

Embora uma pequena minoria dos arquivos tenha sido totalmente verificada por md5sum, as verificações completas usaram a maior parte do tempo de execução. A proporção de tempo md5sumdependerá dos tamanhos dos arquivos.

Particularmente quando há muitos arquivos relativamente pequenos, essa implementação via shellscripts será ineficiente, um programa compilado seria muito melhor. Mas com arquivos enormes, por exemplo, arquivos iso e videoclipes, shellscripts podem fazer um bom trabalho.

Edit 5: Comentário adicional sobre os shellscripts

Se eu fizesse este exercício novamente, começaria salvando duplas separadamente devido aos links físicos e manteria um arquivo restante [com link físico] na lista para verificar se ele corresponde a mais um arquivo em comparações posteriores.

Também seria interessante testar como grandes blocos de dados devem ser verificados para [para a ferramenta chamada vumeraqui] fazer um bom trabalho. Isso provavelmente deve ser feito sob medida para o tipo de arquivo a ser verificado quanto a duplicatas.

Eu também testaria qual tamanho de arquivo, onde é útil com a verificação intermediária [por vumer].

Comentários finais

Fico feliz em notar quanta atenção esta pergunta recebeu, tanto respostas quanto comentários. Como Peter Cordes escreve em sua resposta (assim como nos comentários), a ferramenta de teste rápido (no meu caso vumer) pode ser melhorada de várias maneiras dependendo do tipo de arquivo que é feito para testar.

Na minha resposta, implementei apenas a ideia original do @vume e posso mostrar que é bom o suficiente em muitos casos quando combinado com outros métodos de classificação rápida para minimizar a necessidade de testes completos de soma de verificação.

Existe uma ferramenta chamada imosum que funciona de forma semelhante, por exemplo,sha256sum, but it only uses three 16 kB blocks. The samples are taken from beginning, middle and end of the file, and file size is included in the hash also.

Exemplo de uso para encontrar duplicatas:

pip install imohash
find .../your_path -type f -exec imosum {} + > /tmp/hashes
sort /tmp/hashes | uniq -w 32 --all-repeated=separate

A saída terá grupos de arquivos duplicados:

e8e7d502a5407e75dc1b856024f2c9aa  path/to/file1
e8e7d502a5407e75dc1b856024f2c9aa  other/path/to/duplicate1

e9c83ccdc726d0ec83c55c72ea151d48  path/to/file2
e9c83ccdc726d0ec83c55c72ea151d48  other/path/to/duplicate2

No meu SSD, isso levou cerca de 10 segundos para processar 72 GB de fotos digitais (10 mil arquivos).

Minha ferramenta usual ao lidar com a comparação de arquivos é usar hash. Por exemplo:

sha1sum -- * |sort >output_file

irá criar hashes e classificá-los para que você possa ver no arquivo as duplicatas.

E isso dá uma confiança muito maior de que os arquivos são os mesmos que os primeiros bytes.

Como autor da ferramenta disketo , posso recomendar que: https://github.com/martlin2cz/disketo

Clone isso e execute:

$ cd disketo
$ bin/run.pl scripts/files-with-duplicities.ds YOUR_DIRECTORY

Ele irá colocar em cada linha um caminho para o arquivo, que tenha pelo menos uma duplicata (com o mesmo nome) então com caminho para todas essas duplicidades (separadas por TAB).

Você pode personalizar a pesquisa. Em vez de "files-with-duplicities.ds" pré-instalados, forneça um script de disketo personalizado . Para comparar não apenas o nome do arquivo, mas também o tamanho, use o arquivo ds :

filter files having at-least-one of-the-same name-and-size
print files with files-of-the-same name-and-size

Se você deseja comparar com base em outra coisa (ou seja, alguns pedaços de 16 bytes do conteúdo do arquivo), use o sub personalizado:

group files by-custom-groupper sub {
        my ($file, $context) = @_;
        # TODO implement properly
        use File::Slurp;
        return read_file($file);
} as-meta "same-file-contents"
filter files having at-least-one of-the-same custom-group "same-file-contents"

print files with files-of-the-same custom-group "same-file-contents"

Ou abra um problema e eu poderia adicioná-lo.