Download de delsum - Download de código -fonte delsum

delsum

Outras categorias

v0.2.1

Baixar

`delsum`

delsum é um aplicativo da CLI para descobrir as somas de verificação usadas em um arquivo.

Atualmente, existem três subcomando:

check : dada a especificação do algoritmo de soma de verificação e uma lista de arquivos, isso simplesmente produz as somas de verificação desses arquivos.
part : Dada uma especificação do algoritmo de soma de verificação e uma lista de arquivos com somas de verificação correspondentes, isso encontra partes dos arquivos que têm a soma de verificação fornecida
reverse : dada uma lista de arquivos com somas de verificação correspondentes, isso encontra os parâmetros de soma de verificação usados

`check`

Este subcomando calcula uma soma de verificação com um determinado algoritmo.

Exemplo:

 $ delsum check -m 'crc width=32 poly=0x4c11db7 init=0xffffffff xorout=0xffffffff refin=true refout=true' file_a file_b file_c
700b14f5,e1207917,79741cb2

Um algoritmo pode ser especificado diretamente como um argumento com -m ou uma lista de algoritmos pode ser fornecida em um arquivo.

O início ou o final do intervalo para calcular a soma de verificação é dado com -S ou -E e também pode ser negativo para torná -los em relação ao final. Por exemplo, para calcular a soma de verificação de todos os bytes, exceto os dois últimos, um especifica -S 0 e -E-3 (é inclusivo, então -3 ainda faz parte da soma).

Para os algoritmos disponíveis e como especificá -los, consulte aqui.

`part`

Este subcomando encontra todas as partes de uma lista de arquivos em que todas as folhas de verificação dadas correspondem. As partes do arquivo que correspondem deve ser o mesmo acréscimo os arquivos.

Exemplo:

 $ delsum part -m 'modsum width=16 module=ffff' -c 1234,5678,abcd file_a file_b file_c
modsum width=16 module=ffff:
    0x8:-0x3

Nesse caso, a soma de verificação corresponde na parte 0x8:-0x3 , onde -0x3 é relativa a partir do final. Este é um intervalo inclusivo, o que significa que uma soma de verificação que vai do início ao final teria o intervalo 0x0:-0x1 . Se os arquivos tivessem tamanhos 15, 16 e 18 bytes, respectivamente, essa saída significaria que

file_a tem soma de verificação 1234 do byte 8 a 13
file_b tem soma de verificação 5678 de byte 8 a 14
file_c tem soma de verificação abcd do byte 8 a 16

Pode -se também ter o final das peças relativas desde o início do arquivo (e não o fim) usando o sinalizador -s . Além disso, os -S e -E permitem restringir onde as faixas começam e terminam especificando intervalos (também inclusive). Por exemplo, quando normalmente, os intervalos 0x1:0xa , 0x3:0x10 e 0x4:0xb seriam emitidos, a especificação -S0x0:0x3 apenas permitiria que a parte inicial dos intervalos estivesse entre 0 e 3 inclusive, então 0x4 não seria impresso. Isso pode ajudar a evitar falsos positivos e também pode reduzir o tempo de execução.

Há uma pequena chance de que ele produza algo como 0x1,0x6:0x5,0x10 é a saída. Isso significa apenas que cada combinação é possível. Nesse caso, alguém teria 0x1:0x5 , 0x1:0x10 e 0x6:0x10 . Embora 0x6:0x5 teoricamente também fosse uma opção, não é válida, pois é para trás.

Ao explorar a linearidade das somas de cheques, todo esse processo pode ser feito em tempo aproximado, mas lembre -se de que ele tem um grande espaço (linear) no alto e você poderá ficar sem memória se executá -lo em um monte de arquivos de 500 MB.

Também é possível fornecer uma lista de algoritmos em um arquivo como entrada para -M . Isso pode ser útil, pois permite simplesmente colocar o algoritmo de soma de verificação mais comum lá e procurar se houver algum algoritmos em qualquer parte dos arquivos tiver a soma de verificação desejada. Para os algoritmos disponíveis e como especificá -los, consulte aqui.

`reverse`

Este subcomando encontra parâmetros de um algoritmo de soma de verificação.

Com arquivos e somas de verificação especificadas, ele pesquisa esses parâmetros de algoritmo para os quais os arquivos inteiros têm as somas de verificação fornecidas.

Observe que pelo menos o algoritmo fundamental e a largura da soma de verificação devem ser especificados (por exemplo, crc width=32 ). Para os algoritmos disponíveis e como especificá -los, consulte aqui.

Exemplo:

 $ delsum reverse -m 'crc width=32' -c 700b14f5,e1207917,79741cb2 file_a file_b file_c
crc width=32 poly=0x4c11db7 init=0xffffffff xorout=0xffffffff refin=true refout=true

Você geralmente precisa de 3 arquivos e para algoritmos que não sejam modsum pelo menos um dos arquivos precisa ter um comprimento diferente. Também é possível especificar alguns parâmetros do algoritmo (usando, por exemplo -m 'crc width=32 init=0' ), que precisa de menos arquivos ou produz menos falsos positivos.

Se você possui apenas arquivos de um determinado comprimento, mas também se preocupa apenas com somas de verificação desse comprimento, para um algoritmo e não modsum você pode simplesmente definir init=0 .

É normalmente rápido; Por exemplo, o tempo de execução do algoritmo de reversão do CRC está na maioria dos casos em torno de O(n*log^2(n)*log(log(n))) onde n é o tamanho do arquivo, que é graças ao algoritmo GCD rápido implementado nas bibliotecas NTL e GF2X.

Para alguns parâmetros, apenas combinações provavelmente são pesquisadas:

wordsize é pesquisado por poderes de 2 múltiplos de 8 que são menores ou iguais à width
refin and refout é pesquisado por refin = refout

Para pesquisar esses parâmetros, especifique-os manualmente ou use o argumento da CLI --extended-search .

Algoritmos

Atualmente, existem três famílias de algoritmos: modsum , fletcher e crc . Eles são especificados assim: algofamiliy width=123 para1=ff para2=true para3=10 name="algoname" . Observe que todos os parâmetros numéricos, exceto width e wordsize estão em hexadecimal.

Valores comuns

Atualmente, estes são compartilhados, acumula todos os tipos de soma:

width : largura da soma de verificação em bits
out_endian : endian da soma de cheque, pode ser little ou big
wordsize : Número de bits de uma palavra no texto de entrada. Deve ser um múltiplo de 8 e entre 8 e 64. Por exemplo, em uma soma de verificação simples, usando wordsize=16 cortaria o arquivo em números inteiros de 16 bits e os adicionaria module Modulo.
in_endian : o endiano das palavras de entrada, pode ser little ou big .

`modsum`

Uma soma modular simples com width dos parâmetros, init e module .

Corresponde a

 sum = init
for byte in file:
    sum = (sum + byte) % module
return sum

Observe que, para um module de 0, é equivalente a 2^width .

Os valores padrão para module e init são 0.

`fletcher`

Uma soma do tipo fletcher com width dos parâmetros, init , addout , module e swap .

Corresponde a

 sum1 = init
sum2 = 0
for byte in file:
    sum1 = (sum1 + byte) % module
    sum2 = (sum2 + sum1) % module
sum1 = (sum1 + addout.sum1) % module
sum2 = (sum2 + addout.sum2) % module
if not swap:
    returm (sum2 << (width/2)) | sum1
else:
    returm (sum1 << (width/2)) | sum2

É a saída de uma forma "embalada" em que o SUM1 é armazenado na largura inferior/2 bits e SUM2 na largura mais alta/2 (ou o oposto se swap for ativada). Os parâmetros são:

width : a largura de toda a soma de verificação embalada. Obrigatório.
module : o valor pelo qual reduzir. module = 0 significa 2^(width/2) e é o valor padrão.
init : o valor para inicializar a soma de verificação regular com. Padrões para 0.
addout : o valor embalado que é adicionado no final da soma. A parte alta é sempre adicionada à parte alta da soma de verificação no final, independentemente da swap . Padrões para 0.
swap : a bandeira booleana que indica que a soma regular deve estar na metade mais alta da soma de verificação embalada. Padrões para false .

`crc`

Um algoritmo CRC com parâmetros de acordo com o modelo RockSoft^TM, conforme documentado em "um guia indolor para detecção de erros de CRC".

Tem os seguintes parâmetros:

width : A largura nos bits da soma de verificação (e grau de poli). Obrigatório.
poly : O gerador polinômio, em notação normal. Obrigatório (exceto para reverse ).
init : o valor inicial do estado da CRC. Padrões para 0.
xorout : o valor final para XOR para a soma. Padrões para 0.
refin : a bandeira booleana indicando se deve refletir os bits dos bytes de entrada. Padrões para false .
refout : A bandeira booleana indicando se deve refletir os bits da soma de verificação final, antes de adicionar xorout . Padrões para false .

Observe que outros valores para wordsize com in_endian=little (o padrão) são os mesmos que trocar os bytes em cada grupo de bits wordsize antes de calcular o wordsize=8 soma de verificação.

Como isso funciona

Alguns (incompletos) explicações dos algoritmos utilizados são encontrados aqui.

Instalação

Há uma compilação Linux que possui a biblioteca NTL compilada aqui, mas lembre -se de que é compilada sem a maioria das extensões X86 modernas e, portanto, não pode aproveitar algumas rotinas otimizadas no gf2x o que faz com que o CRC reverte muito mais rápido. Também sou muito burro por fazer uma construção do Windows, desculpe por isso.

Este programa vincula -se ao NTL , gf2x e gmp .

Se você estiver em um sistema baseado em Debian, pode instalá-los com

 apt-get install libgmp-dev libgf2x-dev libntl-dev

Você também pode compilá -los, ver aqui. Isso geralmente torna o binário mais rápido, pois as extensões do conjunto de instruções podem ser usadas e também há o possível de ajustar os parâmetros do algoritmo.

Se você tiver cargo instalada, deve ser possível compilar isso na raiz do diretório do projeto com