Descarga delsum - Descargar el código fuente de delsum

delsum

Otras categorias

v0.2.1

Descargar

`delsum`

delsum es una aplicación CLI para descubrir las suma de verificación utilizadas en un archivo.

Actualmente hay tres subcomandos:

check : Dada una especificación del algoritmo de suma de verificación y una lista de archivos, esto simplemente genera las suma de verificación de estos archivos.
part : Dada una especificación del algoritmo de suma de verificación y una lista de archivos con suma de verificación correspondiente, esto encuentra partes de los archivos que tienen la suma de verificación dada
reverse : dada una lista de archivos con las suma de verificación correspondientes, esto encuentra los parámetros de suma de verificación utilizados

`check`

Este subcomando calcula una suma de verificación con un algoritmo dado.

Ejemplo:

 $ 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

Se puede especificar un algoritmo directamente como un argumento con -m o se puede proporcionar una lista de algoritmos en un archivo.

El inicio o el final del rango para calcular la suma de verificación se da con -S o -E y también puede ser negativo para hacerlos en relación con el final. Por ejemplo, para calcular la suma de verificación de todos los bytes, excepto los dos últimos, uno especifica -S 0 y -E-3 (es inclusivo, por lo que -3 sigue siendo parte de la suma).

Para los algoritmos disponibles y cómo especificarlos, vea aquí.

`part`

Este subcomando encuentra todas las partes de una lista de archivos donde coinciden todas las sumas de verificación dadas. Las partes del archivo que coinciden tienen que ser las mismas las mismas archivos.

Ejemplo:

 $ 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

En este caso, la suma de verificación coincide en la parte 0x8:-0x3 , donde -0x3 es relativa desde el final. Este es un rango inclusivo, lo que significa que una suma de verificación que va desde el principio hasta el final tendría el rango 0x0:-0x1 . Si los archivos fueran de los tamaños 15, 16 y 18 bytes respectivamente, entonces esta salida significaría que

file_a tiene chechsum 1234 de byte 8 a 13
file_b tiene chechsum 5678 de byte 8 a 14
file_c tiene la suma de verificación abcd de Byte 8 a 16

También se puede hacer que el final de las piezas sea relativo desde el inicio del archivo (y no del final) utilizando el indicador -s . Además, los -S y -E permiten que uno limite dónde los rangos comienzan y terminan especificando rangos (también inclusivos). Por ejemplo, cuando normalmente, los rangos 0x1:0xa , 0x3:0x10 y 0x4:0xb se emitirían, especificando -S0x0:0x3 solo permitiría que la parte de inicio de los rangos esté entre 0 y 3 inclusive, por lo que 0x4 no se imprimiría. Esto puede ayudar a evitar falsos positivos y también puede reducir el tiempo de ejecución.

Existe una pequeña posibilidad de que salga algo como 0x1,0x6:0x5,0x10 . Esto solo significa que cada combinación es posible. En este caso, uno tendría 0x1:0x5 , 0x1:0x10 y 0x6:0x10 . Si bien 0x6:0x5 en teoría también sería una opción, no es válida ya que está al revés.

Al explotar la linealidad de las suma de verificación, todo este proceso se puede hacer en un momento más o menos loglinear, pero tenga en cuenta que tiene una sobrecarga de espacio grande (lineal) y puede quedarse sin memoria si lo ejecuta en un montón de archivos de 500MB.

También se puede dar una lista de algoritmos en un archivo como entrada a -M . Esto puede ser útil, ya que permite simplemente poner el algoritmo de suma de verificación más común allí y mirar si algún algoritmos en cualquier parte de los archivos tiene la suma de verificación deseada. Para los algoritmos disponibles y cómo especificarlos, vea aquí.

`reverse`

Este subcomando encuentra parámetros de un algoritmo de suma de verificación.

Con archivos y suma de verificación dados, busca esos parámetros de algoritmo para los cuales los archivos completos tienen las suma de verificación dadas.

Tenga en cuenta que al menos se debe especificar el algoritmo fundamental y el ancho de la suma de verificación (por ejemplo, crc width=32 ). Para los algoritmos disponibles y cómo especificarlos, vea aquí.

Ejemplo:

 $ 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

Generalmente necesita 3 archivos, y para algoritmos distintos de modsum , al menos uno de los archivos debe tener una longitud diferente. También es posible especificar algunos parámetros del algoritmo (usando por ejemplo -m 'crc width=32 init=0' ), que necesita menos archivos o produce menos falsos positivos.

Si solo tiene archivos de una longitud dada, pero también solo se preocupan por las sumas de verificación de esa longitud, para un algoritmo, no modsum simplemente puede establecer init=0 .

Normalmente es bastante rápido; Por ejemplo, el tiempo de ejecución para el algoritmo de inversión de CRC es en la mayoría de los casos alrededor de O(n*log^2(n)*log(log(n))) donde n es el tamaño de archivos, que es gracias al algoritmo GCD rápido implementado dentro de las bibliotecas NTL y GF2X.

Para algunos parámetros, solo se buscan combinaciones probablemente:

Se busca a wordsize poderes de 2 múltiplos de 8 que son más pequeños o iguales al width
Se busca refin y refout refin = refout

Para buscar estos parámetros, especifíquelos manualmente o use el argumento CLI --extended-search .

Algoritmos

Actualmente hay tres familias de algoritmos: modsum , fletcher y crc . Se especifican así: algofamiliy width=123 para1=ff para2=true para3=10 name="algoname" . Tenga en cuenta que todos los parámetros numéricos, excepto width y wordsize son hexadecimales.

Valores comunes

Actualmente, estos son compartidos de todos los tipos de suma:

width : ancho de la suma de verificación en bits
out_endian : endian de la suma de verificación puede ser little o big
wordsize : número de bits de una palabra en el texto de entrada. Debe ser un múltiplo de 8 y entre 8 y 64. Por ejemplo, en una suma de verificación simple, usar wordsize=16 cortaría el archivo en enteros de 16 bits y los agregaría al module de módulo.
in_endian : el endian de las palabras de entrada puede ser little o big .

`modsum`

Una suma modular simple con parámetros width , init y module .

Corresponde a

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

Tenga en cuenta que para un module de 0, es equivalente a 2^width .

Los valores predeterminados para module e init son ambos 0.

`fletcher`

Una suma similar a Fletcher con parámetros width , 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

Se emite en una forma "empaquetada" donde el SUM1 se almacena en el ancho inferior/2 bits y Sum2 en el ancho más alto/2 (o el swap opuesto si está habilitado). Los parámetros son:

width : el ancho de toda la suma de verificación llena. Obligatorio.
module : el valor para reducir. module = 0 significa 2^(width/2) y es el valor predeterminado.
init : El valor para inicializar la suma de verificación regular con. El valor predeterminado es 0.
addout : el valor empaquetado que se agrega al final de la suma. La parte alta siempre se agrega a la parte alta de la suma de verificación al final, independientemente del swap . El valor predeterminado es 0.
swap : la bandera booleana que indica que la suma regular debe estar en la mitad más alta de la suma de verificación llena. El valor predeterminado es false .

`crc`

Un algoritmo CRC con parámetros de acuerdo con el modelo Rocksoft^TM, como se documenta en "una guía indolora para la detección de errores de CRC".

Tiene los siguientes parámetros:

width : el ancho en bits de la suma de verificación (y el grado de poli). Obligatorio.
poly : el polinomio del generador, en notación normal. Obligatorio (excepto por reverse ).
init : El valor inicial del estado CRC. El valor predeterminado es 0.
xorout : El valor final a Xor a la suma. El valor predeterminado es 0.
refin : la bandera booleana que indica si reflejar los bits de los bytes de entrada. El valor predeterminado es false .
refout : la bandera booleana que indica si reflejar los bits de la suma de verificación final, antes de agregar xorout . El valor predeterminado es false .

Tenga en cuenta que otros valores para wordsize con in_endian=little (el estándar) es lo mismo que intercambiar los bytes en cada grupo de bits de wordsize antes de calcular la suma de comprobación wordsize=8 .

Cómo funciona esto

Aquí se encuentra alguna explicación (incompleta) de los algoritmos utilizados.

Instalación

Hay una construcción de Linux que tiene la biblioteca NTL compilada aquí, pero tenga en cuenta que se compila sin la mayoría de las extensiones X86 modernas y, por lo tanto, no puede aprovechar algunas rutinas optimizadas en gf2x , lo que hace que CRC se invierte mucho más rápido. También soy demasiado tonto para hacer una compilación de Windows, lo siento por eso.

Este programa vincula con NTL , gf2x y gmp .

Si está en un sistema basado en Debian, puede instalarlos con

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

También pueden compilarlos ustedes mismos, ver aquí. Esto generalmente hará el binario más rápido, ya que se pueden usar extensiones de establecimiento de instrucciones y también existe la posible ajuste de los parámetros de algoritmo.

Si tiene instalación cargo , debería ser posible compilar esto en la raíz del directorio del proyecto con