Ethernet CRC32-Berechnung - software-vs-Algorithmische Ergebnis

Ich versuche zu berechnen, die Frame Check Sequence (FCS) ein Ethernet-Paket byte für byte. Das Polynom ist 0x104C11DB7.
Ich folgte dem XOR-SHIFT-Algorithmus, der hier zu sehen http://en.wikipedia.org/wiki/Cyclic_redundancy_check oder hier http://www.woodmann.com/fravia/crctut1.htm

Davon ausgehen, die Informationen, soll eine CRC ist nur ein byte. Lassen Sie uns sagen, es ist 0x03.

  1. Schritt: pad mit 32 bits nach rechts

    0x0300000000

  2. richten Sie das Polynom und die Daten auf der linken Seite mit dem ersten bit ungleich null und xor Ihnen

    0x300000000 xor 0x209823B6E = 0x109823b6e

  3. nehmen Rest ausrichten und xor wieder

    0x109823b6e xor 0x104C11DB7 = 0x0d4326d9

Da gibt es keine mehr, etwas Links der CRC32 von 0x03 sollte 0x0d4326d9

Leider alle software-Implementierungen sagen mir, ich bin falsch, aber was habe ich falsch gemacht oder was werden Sie anders machen?

Python sagt mir:

 "0x%08x" % binascii.crc32(chr(0x03))
 0x4b0bbe37

Dem online-tool hier http://www.lammertbies.nl/comm/info/crc-calculation.html#intr erhält das gleiche Ergebnis.
Was ist der Unterschied zwischen meiner hand Berechnung und der Algorithmus der software verwendet?

UPDATE:

Stellt sich heraus, es war eine ähnliche Frage bereits auf stack overflow:

Finden Sie hier eine Antwort Python CRC-32 woes

Obwohl dies nicht sehr intuitiv. Wenn Sie möchten, eine formale Beschreibung, wie es gemacht wird für Ethernet-frames können Sie die Ethernet-Standard 802.3 Dokument Teil 3 - Kapitel 3.2.9 Frame Check Sequence-Feld

Können weiterhin das Beispiel von oben:

  1. Umgekehrter bit-Reihenfolge Ihrer Meldung. Das ist der Weg, Sie kommen in den receiver etwas.

    0x03 daher ist 0xC0

  2. Ergänzen die ersten 32 bit der Nachricht. Beachten Sie, dass wir Schreibblock die Einzel-byte mit 32 bit wieder.

    0xC000000000 xor 0xFFFFFFFF = 0x3FFFFFFF00

  3. Runden das Xor-und shift-Methode von oben wieder. Nach etwa 6 Schritt erhalten Sie:

    0x13822f2d

  4. Den oben genannten bit-sequense wird dann ergänzt.

    0x13822f2d xor 0xFFFFFFFF = 0xec7dd0d2

  5. Denken Sie daran, dass wir die umgekehrte bit-Reihenfolge, um die Darstellung auf dem Ethernet-Kabel in Schritt eins. Jetzt haben wir eine umgekehrte Schritt, und wir endlich die Erfüllung unserer quest.

    0x4b0bbe37

Wer kam auf diese Weise zu tun, es sein sollte ...

Eine Menge Zeit, Sie wirklich wollen, zu wissen, es die Nachricht, die Sie erhalten ist korrekt. Um dies zu erreichen, nehmen Sie die empfangene Nachricht einschließlich der FCS und führen Sie den gleichen Schritt 1 bis 5 wie oben. Das Ergebnis sollte sein, was Sie nennen Rückstand. Die ist eine Konstante für ein gegebenes Polynom. In diesem Fall ist es 0xC704DD7B.

Als mcdowella erwähnt, Sie haben zu spielen, um mit Ihren bits, bis Sie es richtig machen, je nach Anwendung, die Sie verwenden.

InformationsquelleAutor der Frage sebs | 2012-02-15

  1. 5

    Diese Python-snippet schreibt die korrekte CRC für Ethernet:

    # write payload
for byte in data:
    f.write('%02X\n' % ord(byte))
# write FCS
crc = zlib.crc32(data)&0xFFFFFFFF
for i in range(4):
    b = (crc >> (8*i)) & 0xFF
    f.write('%02X\n' % b)

    Gerettet hätte mir etwas Zeit, wenn ich fand diese hier.

    InformationsquelleAutor der Antwort maxy

  2. 3

    Es ist in der Regel ein bisschen von Versuch und Irrtum erforderlich, um die CRC-Berechnungen zu entsprechen, weil Sie nie Lesen was genau gemacht werden muss. Manchmal muss man das bit-reverse input Byte oder das Polynom, manchmal müssen Sie beginnen mit einem nicht-null-Wert, und so weiter.

    Einen Weg zur Umgehung dieses ist der Blick auf die Quelle für ein Programm es richtig, wie http://sourceforge.net/projects/crcmod/files/ (zumindest ist es Forderungen zu entsprechen, und kommt mit einem unit-test für diese).

    Anderen zu spielen, um mit einer Implementierung. Zum Beispiel, wenn ich den Rechner an http://www.lammertbies.nl/comm/info/crc-calculation.html#intr ich kann sehen, dass ihm 00000000 erzeugt eine CRC von 0x2144DF1C, aber geben Sie "FFFFFFFF" produziert "FFFFFFFF" - es ist also nicht genau die Polynomdivision, die Sie beschreiben, für welche 0 hätte Prüfsumme 0

    Aus einem kurzen Blick auf den source-code und diese Ergebnisse ich denke, Sie brauchen, um zu starten mit einem CRC-0xFFFFFFFF - aber ich könnte falsch sein, und Sie könnten am Ende Ihren code Debuggen der Seite der Implementierung, die Verwendung der entsprechenden printfs, um herauszufinden, wo die ersten Verschieden, und die Festsetzung der Unterschiede.

    InformationsquelleAutor der Antwort mcdowella

  3. 3

    Gibt es eine Reihe von Orten im Internet, wo Sie Lesen, dass die bit-Reihenfolge muss Umgekehrt werden, bevor die Berechnung des FCS, aber die 802.3-Spezifikation ist nicht einer von Ihnen. Ich zitiere aus der 2008-version von der Skillung: 

    3.2.9 Frame Check Sequence (FCS) field

A cyclic redundancy check (CRC) is used by the transmit and receive algorithms to
generate a CRC value for the FCS field. The FCS field contains a 4-octet (32-bit)
CRC value. This value is computed as a function of the contents of the protected
fields of the MAC frame: the Destination Address, Source Address, Length/Type 
field, MAC Client Data, and Pad (that is, all fields except FCS). The encoding is
defined by the following generating polynomial.

  G(x) = x32 + x26 + x23 + x22 + x16 + x12 + x11 
             + x10 + x8 + x7 + x5 + x4 + x2 + x + 1

Mathematically, the CRC value corresponding to a given MAC frame is defined by 
the following procedure:

a) The first 32 bits of the frame are complemented.
b) The n bits of the protected fields are then considered to be the coefficients
   of a polynomial M(x) of degree n – 1. (The first bit of the Destination Address
   field corresponds to the x(n–1) term and the last bit of the MAC Client Data 
   field (or Pad field if present) corresponds to the x0 term.)
c) M(x) is multiplied by x32 and divided by G(x), producing a remainder R(x) of
   degree ≤ 31.
d) The coefficients of R(x) are considered to be a 32-bit sequence.
e) The bit sequence is complemented and the result is the CRC.

The 32 bits of the CRC value are placed in the FCS field so that the x31 term is
the left-most bit of the first octet, and the x0 term is the right most bit of the
last octet. (The bits of the CRC are thus transmitted in the order x31, x30,..., 
x1, x0.) See Hammond, et al. [B37].

    Sicherlich die restlichen bits in dem Rahmen sind übertragen in umgekehrter Reihenfolge, aber das schließt nicht den FCS. Wieder aus der spec:

    3.3 Order of bit transmission

Each octet of the MAC frame, with the exception of the FCS, is transmitted least
significant bit first.

    InformationsquelleAutor der Antwort Daniel Wisehart

  4. 2

    http://en.wikipedia.org/wiki/Cyclic_redundancy_check

    sämtliche Daten für die ethernet-und die fülle an wichtigen details, zum Beispiel gibt es (mindestens) 2 Konventionen zu Kodieren Polynom in einer 32-bit-Wert, der größte Begriff, der zuerst oder der kleinste Begriff ersten.

    InformationsquelleAutor der Antwort Dima Tisnek

Schreibe einen Kommentar