Determinación del algoritmo CRC a partir de datos + aplicación CRC integrada.

Question

Tengo un conjunto de datos protegidos por sumas de comprobación de 16 bits que necesito corregir. Las ubicaciones de suma de comprobación son conocidas, las áreas exactas en las que se calculan y el algoritmo exacto utilizado para calcularlas no lo son. 16 bits, LSB primero. Sospecho que es una especie de CRC de 16 bits, pero no he podido encontrar el código que realmente está calculando las sumas de comprobación.

Ejemplo:

00 4E00FFFF26EC14091E00A01830393630 
10 30313131313030393030363030313030 
20 30303131313030393030363030313030 
30 30303131313030393030363030313030 
40 3030FFFF225E363436304D313037**0CE0** 
50 64000000000000008080808080800000 
60 00000000**BE6E**FC01E001EB0013010500 

sumas de comprobación se almacenan a 4E y 64. No sé si están calcuated a partir del desplazamiento en la primera palabra al principio de cada sección de datos o de partida después de eso, o en todo el rango He intentado varios algoritmos CRC comunes y polinomios sin suerte. No hay referencias o especificaciones disponibles para esta aplicación.

Aquí hay otra sección de datos con diferentes CRCs en aras de la comparación.

00 4E00FFFF26C014091600A01030393132 
10 30313131313030393030313230313030 
20 30303131313030393030313230313030 
30 30303131313030393030313230313030 
40 3030FFFF225E343231324F313044**8348** 
50 64000000000000008080808080800000 
60 00000000**72F8**E001EB00130105000E01 

Mi pregunta es, ¿alguien puede identificar el algoritmo? ¿Hay alguna forma de calcular el polinomio CRC y otros factores a partir de los datos y el CRC?

Gracias!

Editar:

Una búsqueda de mi desmontaje para el CRC16 común polinomio 0xA001 reveló esta función:

34F86 ; =============== S U B R O U T I N E ======================================= 
34F86 
34F86 
34F86 Possible_Checksum:     ; CODE XREF: MEM_EXT_4:00034FEEP 
34F86           ; MEM_EXT_4:0003503AP ... 
34F86     mov  [-r0], r9  ; Move Word 
34F88     mov  r4, r12   ; Move Word 
34F8A     mov  r5, r13   ; Move Word 
34F8C     shr  r4, #14   ; Shift Right 
34F8E     shl  r5, #2   ; Shift Left 
34F90     or  r5, r4   ; Logical OR 
34F92     mov  r4, r12   ; Move Word 
34F94     mov  DPP0, r5  ; Move Word 
34F98     and  r4, #3FFFh  ; Logical AND 
34F9C     movb rl3, [r4]  ; Move Byte 
34F9E     mov  DPP0, #4  ; Move Word 
34FA2     movbz r9, rl3   ; Move Byte Zero Extend 
34FA4     mov  r15, #0   ; Move Word 
34FA6 
34FA6 loc_34FA6:        ; CODE XREF: MEM_EXT_4:00034FC8j 
34FA6     mov  r4, [r14]  ; Move Word 
34FA8     xor  r4, r9   ; Logical Exclusive OR 
34FAA     and  r4, #1   ; Logical AND 
34FAC     jmpr cc_Z, loc_34FBA ; Relative Conditional Jump 
34FAE     mov  r4, [r14]  ; Move Word 
34FB0     shr  r4, #1   ; Shift Right 
34FB2     xor  r4, #0A001h  ; Logical Exclusive OR 
34FB6     mov  [r14], r4  ; Move Word 
34FB8     jmpr cc_UC, loc_34FC0 ; Relative Conditional Jump 
34FBA ; --------------------------------------------------------------------------- 
34FBA 
34FBA loc_34FBA:        ; CODE XREF: MEM_EXT_4:00034FACj 
34FBA     mov  r4, [r14]  ; Move Word 
34FBC     shr  r4, #1   ; Shift Right 
34FBE     mov  [r14], r4  ; Move Word 
34FC0 
34FC0 loc_34FC0:      

Answer 1

El código que envió desde loc_34FA6 abajo es básicamente la siguiente:

unsigned short 
crc16_update(unsigned short crc, unsigned char nextByte) 
{ 
    crc ^= nextByte; 

    for (int i = 0; i < 8; ++i) { 
     if (crc & 1) 
      crc = (crc >> 1)^0xA001; 
     else 
      crc = (crc >> 1); 
    } 

    return crc; 
} 

Este es un CRC-16 con un polinomio 0xA001. Una vez que encuentre el rango de datos para el cual se aplica el CRC-16, usted inicializará CRC a 0xFFFF y la llamará a esta función para cada byte en la secuencia. Almacene el valor de retorno y páselo nuevamente la próxima vez. El valor devuelto al final es su CRC final.

No estoy seguro de lo que está haciendo el prólogo ...

Answer 2

De manera más general, que forma parte del concepto de que el CRC es cuando se computa el CRC de algún archivo de datos y, a continuación, añadir la CDN relativo a la fin, obtienes un archivo cuyo CRC es un valor que depende de la longitud del archivo, pero no de su contenido. (Para algunos algoritmos CRC, ni siquiera depende de la longitud del archivo).

Por lo tanto, si sospecha que la aplicación que está tratando de realizar ingeniería inversa utiliza, por ejemplo, CRC16, y tiene un programa que calcula CRC16 y tiene varias muestras de la misma longitud, simplemente calcule el CRC16 de esos archivos de datos (que incluyen la suma de comprobación). Si vuelve con los mismos datos de suma de comprobación todas las veces (para archivos de la misma longitud), entonces deben contener una suma de comprobación CRC con el mismo ancho y polinomio.

Por ejemplo, una vez tuve que realizar una ingeniería inversa de algunos archivos en los que el desarrollador pensaba que estaba siendo inteligente cambiando el algoritmo CRC32 cambiando dos constantes. No tenía que encontrar el código objeto que verificaba la suma de comprobación, desmontarlo y luego descubrirlo de la manera difícil. Esta simple prueba lo clavó.