Die Bestimmung CRC-Algorithmus von Daten + CRC - eingebettete Anwendung.

Question

Ich habe eine Reihe von Daten, die von 16-Bit-Prüfsummen geschützt, die ich korrigieren müssen. Die Prüfsumme Stellen bekannt sind, die genauen Bereiche, die sie auf und die genaue Algorithmus berechnet werden verwendet, um sie zu berechnen sind es nicht. 16bit, LSB zuerst. Ich vermute, es ist eine Art von 16-Bit-CRC, aber ich habe nicht den Code zu finden in der Lage, die die Prüfsummen tatsächlich ist die Berechnung.

Beispiel:

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

Prüfsummen sind in 4E gespeichert und 64. Ich weiß nicht, ob sie in dem ersten Wort am Anfang jeden Datenabschnittes von der Offset calcuated beginnen oder danach beginnen, oder auf dem gesamten Bereich. Ich habe eine Reihe von gemeinsamen CRC-Algorithmen versucht und Polynomen ohne Glück. Es gibt keine Hinweise oder Spezifikationen für diese Anwendung zur Verfügung.

Hier ist ein weiterer Datenabschnitt mit unterschiedlichen CRCs für Vergleiches willen.

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

Meine Frage ist, kann jemand den Algorithmus identifizieren? Gibt es eine Möglichkeit, das CRC-Polynom und andere Faktoren, die von den Daten und der CRC zu berechnen?

Danke!

Edit:

Eine Suche nach meiner Demontage für die gemeinsame CRC16 Polynom 0xA001 ergab diese Funktion:

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

Der Code, den Sie von loc_34FA6 gepostet unten ist im Grunde die folgenden:

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;
}

Dies ist ein CRC-16 mit einem 0xA001 Polynom. Sobald Sie den Bereich der Daten herauszufinden, für welche die CRC-16 gilt, initialisieren Sie CRC 0xFFFF und der Aufruf dieser Funktion für jedes Byte in der Sequenz. Lagern Sie den Rückgabewert und gibt es in der nächsten Zeit durch zurück. Der Wert am Ende zurückgegeben wird, ist Ihre endgültige CRC.

Ich bin mir nicht sicher, was der Prolog tut ...

Answer 2

Allgemeiner Teil des Konzepts der CRC ist, dass das, wenn Sie die CRC einiger Datendatei zu berechnen, und dann die CRC am Ende anhängen, Sie eine Datei erhalten, die CRC ist etwas Wert ist, der von der Länge der abhängig Datei, aber nicht dessen Inhalt. (Für einige CRC-Algorithmen, ist es nicht einmal auf der Dateilänge abhängig.)

Also, wenn Sie die App vermuten, versuchen Sie Reverse-Engineering wird mit CRC16 sagen, und Sie haben ein Programm, das CRC16 berechnet, und Sie haben mehrere Proben der gleichen Länge, berechnen nur die CRC16 dieser Datendateien (zu denen auch die Prüfsumme). Wenn es mit den gleichen Prüfsumme Daten jedes Mal (für Dateien mit der gleichen Länge) zurückkommt, dann müssen sie ein CRC-Prüfsumme mit der gleichen Breite und Polynom enthalten.

Zum Beispiel, ich hatte einmal zu umkehren einige Dateien konstruieren, wo der Entwickler dachte, dass er durch eine Änderung des CRC-32-Algorithmus, indem zwei Konstanten clever war. Ich habe nicht den Objektcode, der die Prüfsumme verifiziert, zerlegen und dann herauszufinden, die harte Weise. Dieser einfache Test genagelt es.