Skip to content

CRC-Prüfsummenrechner

Hex oder Text einfügen, alle 63 CRC-8-, CRC-16- und CRC-32-Varianten auf einmal berechnen. Prüfsumme passt nicht? Wert eintragen, das Tool nennt die Variante: MODBUS, CCITT-FALSE, XMODEM, KERMIT. Rechnet lokal im Browser.

Kein Tracking Läuft im Browser Kostenlos
Alles wird lokal in Ihrem Browser berechnet — die eingefügten Daten verlassen dieses Gerät nicht.
Zum Ausprobieren

Alle 63 Varianten

Jede Zeile rechnet während der Eingabe neu.
Variante Ergebnis Poly Init RefIn/RefOut XorOut
CRC-8
CRC-8/AUTOSAR 0x2F 0xFF false / false 0xFF
CRC-8/BLUETOOTH 0xA7 0x00 true / true 0x00
CRC-8/CDMA2000 0x9B 0xFF false / false 0x00
CRC-8/DARC 0x39 0x00 true / true 0x00
CRC-8/DVB-S2 0xD5 0x00 false / false 0x00
CRC-8/GSM-A 0x1D 0x00 false / false 0x00
CRC-8/GSM-B 0x49 0x00 false / false 0xFF
CRC-8/HITAG 0x1D 0xFF false / false 0x00
CRC-8/I-432-1 CRC-8/ITU 0x07 0x00 false / false 0x55
CRC-8/I-CODE 0x1D 0xFD false / false 0x00
CRC-8/LTE 0x9B 0x00 false / false 0x00
CRC-8/MAXIM-DOW CRC-8/MAXIM · DOW-CRC 0x31 0x00 true / true 0x00
CRC-8/MIFARE-MAD 0x1D 0xC7 false / false 0x00
CRC-8/NRSC-5 0x31 0xFF false / false 0x00
CRC-8/OPENSAFETY 0x2F 0x00 false / false 0x00
CRC-8/ROHC 0x07 0xFF true / true 0x00
CRC-8/SAE-J1850 CRC-8/J1850 0x1D 0xFF false / false 0xFF
CRC-8/SMBUS CRC-8 0x07 0x00 false / false 0x00
CRC-8/TECH-3250 CRC-8/AES · CRC-8/EBU 0x1D 0xFF true / true 0x00
CRC-8/WCDMA 0x9B 0x00 true / true 0x00
CRC-16
CRC-16/ARC CRC-16 · CRC-16/IBM · CRC-16/LHA 0x8005 0x0000 true / true 0x0000
CRC-16/CDMA2000 0xC867 0xFFFF false / false 0x0000
CRC-16/CMS 0x8005 0xFFFF false / false 0x0000
CRC-16/DDS-110 0x8005 0x800D false / false 0x0000
CRC-16/DECT-R R-CRC-16 0x0589 0x0000 false / false 0x0001
CRC-16/DECT-X X-CRC-16 0x0589 0x0000 false / false 0x0000
CRC-16/DNP 0x3D65 0x0000 true / true 0xFFFF
CRC-16/EN-13757 0x3D65 0x0000 false / false 0xFFFF
CRC-16/GENIBUS CRC-16/DARC · CRC-16/EPC · CRC-16/EPC-C1G2 · CRC-16/I-CODE 0x1021 0xFFFF false / false 0xFFFF
CRC-16/GSM 0x1021 0x0000 false / false 0xFFFF
CRC-16/IBM-3740 CRC-16/CCITT-FALSE · CRC-16/AUTOSAR 0x1021 0xFFFF false / false 0x0000
CRC-16/IBM-SDLC CRC-16/X-25 · CRC-16/X25 · CRC-16/ISO-HDLC · CRC-B · X-25 0x1021 0xFFFF true / true 0xFFFF
CRC-16/ISO-IEC-14443-3-A CRC-A 0x1021 0xC6C6 true / true 0x0000
CRC-16/KERMIT CRC-16/CCITT · CRC-16/CCITT-TRUE · CRC-16/V-41-LSB · CRC-CCITT 0x1021 0x0000 true / true 0x0000
CRC-16/LJ1200 0x6F63 0x0000 false / false 0x0000
CRC-16/M17 0x5935 0xFFFF false / false 0x0000
CRC-16/MAXIM-DOW CRC-16/MAXIM 0x8005 0x0000 true / true 0xFFFF
CRC-16/MCRF4XX 0x1021 0xFFFF true / true 0x0000
CRC-16/MODBUS 0x8005 0xFFFF true / true 0x0000
CRC-16/NRSC-5 0x080B 0xFFFF true / true 0x0000
CRC-16/OPENSAFETY-A 0x5935 0x0000 false / false 0x0000
CRC-16/OPENSAFETY-B 0x755B 0x0000 false / false 0x0000
CRC-16/PROFIBUS CRC-16/IEC-61158-2 0x1DCF 0xFFFF false / false 0xFFFF
CRC-16/RIELLO 0x1021 0xB2AA true / true 0x0000
CRC-16/SPI-FUJITSU CRC-16/AUG-CCITT 0x1021 0x1D0F false / false 0x0000
CRC-16/T10-DIF 0x8BB7 0x0000 false / false 0x0000
CRC-16/TELEDISK 0xA097 0x0000 false / false 0x0000
CRC-16/TMS37157 0x1021 0x89EC true / true 0x0000
CRC-16/UMTS CRC-16/BUYPASS · CRC-16/VERIFONE 0x8005 0x0000 false / false 0x0000
CRC-16/USB 0x8005 0xFFFF true / true 0xFFFF
CRC-16/XMODEM CRC-16/ACORN · CRC-16/LTE · CRC-16/V-41-MSB · ZMODEM 0x1021 0x0000 false / false 0x0000
CRC-32
CRC-32/AIXM CRC-32Q 0x814141AB 0x00000000 false / false 0x00000000
CRC-32/AUTOSAR 0xF4ACFB13 0xFFFFFFFF true / true 0xFFFFFFFF
CRC-32/BASE91-D CRC-32D 0xA833982B 0xFFFFFFFF true / true 0xFFFFFFFF
CRC-32/BZIP2 CRC-32/AAL5 · CRC-32/DECT-B · B-CRC-32 0x04C11DB7 0xFFFFFFFF false / false 0xFFFFFFFF
CRC-32/CD-ROM-EDC 0x8001801B 0x00000000 true / true 0x00000000
CRC-32/CKSUM CRC-32/POSIX 0x04C11DB7 0x00000000 false / false 0xFFFFFFFF
CRC-32/ISCSI CRC-32C · CRC-32/BASE91-C · CRC-32/CASTAGNOLI · CRC-32/INTERLAKEN 0x1EDC6F41 0xFFFFFFFF true / true 0xFFFFFFFF
CRC-32/ISO-HDLC CRC-32 · CRC-32/ADCCP · CRC-32/V-42 · CRC-32/XZ · PKZIP 0x04C11DB7 0xFFFFFFFF true / true 0xFFFFFFFF
CRC-32/JAMCRC 0x04C11DB7 0xFFFFFFFF true / true 0x00000000
CRC-32/MEF 0x741B8CD7 0xFFFFFFFF true / true 0x00000000
CRC-32/MPEG-2 0x04C11DB7 0xFFFFFFFF false / false 0x00000000
CRC-32/XFER 0x000000AF 0x00000000 false / false 0x00000000
Eigene Parameter

Nutzen Sie das, wenn Ihre Gerätedokumentation ein Polynom nennt, das nicht in der Tabelle oben steht.

Ergebnis
Alle 63 Variantenparametersätze werden in der Testsuite gegen ihre veröffentlichten Katalog-Prüfwerte abgesichert, und CRC-32/ISO-HDLC wird zusätzlich gegen zlib.crc32 aus Node als unabhängige Referenz gegengeprüft. — Go Tools Team · Sep 6, 2026

Vom Engineering-Team von Go Tools gebaut und verifiziert.

Schnelle Antworten

CRC-32 von „123456789“

0xCBF43926 0xCBF43926 für CRC-32/ISO-HDLC, die Variante, die ZIP, PNG, Ethernet und gzip verwenden.

CRC-16/MODBUS von „123456789“

0x4B37 0x4B37, mit poly 0x8005, init 0xFFFF, Eingang und Ausgang reflektiert, kein finales XOR.

CRC-16/CCITT-FALSE von „123456789“

0x29B1 0x29B1. Der formale Katalogname lautet CRC-16/IBM-3740: poly 0x1021, init 0xFFFF, keine Reflexion.

Wie viele CRC-Varianten gibt es?

63 Dieser Rechner deckt 63 katalogisierte Varianten ab: 20 mit Breite 8, 31 mit Breite 16 und 12 mit Breite 32.

Was ist eine CRC?

Eine zyklische Redundanzprüfung fasst einen Datenblock als die Koeffizienten eines sehr langen binären Polynoms auf, teilt ihn in Modulo-2-Arithmetik durch ein festes Generatorpolynom und behält den Rest. Dieser Rest ist die Prüfsumme. Beliebt ist die Konstruktion, weil die Division auf Schiebeoperationen und XOR zusammenschrumpft, was in Hardware fast nichts kostet, und weil die Algebra harte Garantien liefert statt statistischer Hoffnung: Ein gut gewähltes 16-Bit-Polynom erkennt jeden Einzelbitfehler, jeden Doppelbitfehler innerhalb einer brauchbaren Blocklänge, jede ungerade Anzahl gekippter Bits und jeden Burst von höchstens 16 aufeinanderfolgenden gestörten Bits.

Unübersichtlich wird CRC in der Praxis dadurch, dass das Polynom nur einer von sechs Parametern ist. Zwei Implementierungen können sich beim Polynom einig sein und trotzdem bei jedem Ergebnis auseinanderlaufen, weil sie sich im Startwert des Registers unterscheiden, darin, ob Eingabebytes und Ausgaberegister in der Bitreihenfolge umgedreht werden, und in der Konstante, die am Ende hineingeXORt wird. Eine CRC-Variante ist dieser ganze Parametersatz, nicht das Polynom allein — deshalb benennt ein Name wie „CRC-16“ für sich genommen so gut wie nichts, und deshalb stehen auf dieser Seite das Polynom, der Startwert, beide Reflexionsflags und das finale XOR neben jedem Ergebnis, mit der Breite als Gruppenüberschrift.

Ein Vorbehalt, den die Tabelle nicht zeigen kann: Ein 16-Bit-Polynom erkennt jede ungerade Anzahl gekippter Bits nur dann, wenn x+1 es teilt. Für die beiden, denen Sie am ehesten begegnen, 0x1021 und 0x8005, trifft das zu, aber nicht für alle — CRC-16/T10-DIF und CRC-16/PROFIBUS gehören zu den Ausnahmen.

// CRC-16/MODBUS: poly=0x8005, init=0xFFFF, refin/refout=true, xorout=0x0000
// Written in the reflected form, so the polynomial appears bit-reversed as 0xA001.
function crc16Modbus(bytes) {
  let crc = 0xffff;
  for (const byte of bytes) {
    crc ^= byte;
    for (let i = 0; i < 8; i++) {
      crc = crc & 1 ? (crc >>> 1) ^ 0xa001 : crc >>> 1;
    }
  }
  return crc;
}

crc16Modbus([0x01, 0x03, 0x00, 0x00, 0x00, 0x0a]); // 0xCDC5
// On the wire Modbus RTU sends the low byte first: ... 0x0A 0xC5 0xCD

Was dieser Rechner leistet

Alle 63 Varianten auf einmal

CRC-8, CRC-16 und CRC-32 rechnen während der Eingabe gemeinsam neu. Kein Auswahlfeld, in dem Sie erst raten müssen, bevor überhaupt etwas zu sehen ist.

Rückwärtssuche

Tragen Sie die Prüfsumme ein, die Sie bekommen haben, und die Varianten, die sie erzeugen, werden hervorgehoben — ein unbekannter Algorithmus ist damit in einem Schritt bestimmt statt in zwanzig.

Formale Namen und Handbuchnamen

Jede Zeile nennt den Namen aus dem RevEng-Katalog und dazu die Aliase aus der Praxis: CCITT-FALSE, CRC-16/IBM, CRC-32C, X-25 und die übrigen.

Vollständige Parametertabelle

Polynom, Startwert, beide Reflexions-Flags und finales XOR stehen direkt neben dem Ergebnis, sodass Sie einen Treffer gegen die Spezifikation absichern können.

Eigene Parameter

Breite, Polynom, Startwert, Reflexion und finales XOR sind frei einstellbar — für Polynome, die es nie in einen Katalog geschafft haben.

Läuft vollständig offline

Gerechnet wird in Ihrem Browser. Telegramme aus dem Produktivbetrieb und Firmware-Abbilder verlassen den Rechner nicht.

Durchgerechnete Beispiele

Der Prüfwert aus dem Katalog

123456789
CRC-32/ISO-HDLC = 0xCBF43926, CRC-16/MODBUS = 0x4B37, CRC-8/SMBUS = 0xF4

Jede CRC-Variante im RevEng-Katalog veröffentlicht ihr Ergebnis für die ASCII-Zeichenkette 123456789. Damit ist diese Eingabe der Standard-Selbsttest: Weicht eine Bibliothek von der Tabelle hier ab, liegt der Fehler bei der Bibliothek.

Ein Modbus-RTU-Anfragetelegramm

01 03 00 00 00 0A
CRC-16/MODBUS = 0xCDC5

Halteregister von Slave 1 lesen. Modbus RTU hängt das niederwertige CRC-Byte zuerst an, das Telegramm geht also als 01 03 00 00 00 0A C5 CD auf die Leitung — eine Vertauschung, auf die ein großer Teil der nicht nachvollziehbaren Prüfsummen zurückgeht.

Dieselben Bytes, vier CRC-16-Antworten

DEADBEEF
MODBUS = 0xC19B, CCITT-FALSE = 0x4097, XMODEM = 0xC457, KERMIT = 0x1915

Im Hex-Modus gelesen, also vier Bytes statt der acht Zeichen der Zeichenkette. Die vier bekanntesten CRC-16-Varianten sind sich darüber vollkommen uneins. Kaputt ist deswegen nichts: Sie unterscheiden sich in Startwert, Reflexion und finalem XOR, nicht in der Korrektheit.

Rückwärtssuche aus einer Geräteantwort

123456789 mit erwartetem Wert 0x29B1
CRC-16/IBM-3740 (im Handbuch meist CRC-16/CCITT-FALSE genannt)

Genau für diesen Fall ist der Rechner gebaut. Sie haben die Daten und die Prüfsumme, die jemand anderes berechnet hat, aber nicht den Namen der Variante — also suchen Sie den Parametersatz, der den Wert reproduziert.

So benutzen Sie den CRC-Rechner

  1. 1

    Text oder Hex wählen

    Protokolltelegramme sind praktisch immer hexadezimal. Text brauchen Sie nur, wenn Sie eine buchstäbliche Zeichenkette prüfen, etwa den Selbsttestwert 123456789.

  2. 2

    Daten einfügen

    Im Hex-Modus werden Trennzeichen ignoriert: 01 03 00 00 00 0A, 0x01 0x03 und 010300 00000A werden alle akzeptiert.

  3. 3

    Die passende Variante ablesen

    Die Tabelle ist nach Breite gruppiert. Die formalen Namen stammen aus dem RevEng-Katalog, darunter stehen die Aliase, die vermutlich in Ihrem Gerätehandbuch auftauchen.

  4. 4

    Oder rückwärts arbeiten

    Wenn Sie bereits eine Prüfsumme haben und die Variante suchen, tragen Sie den Wert in das Feld für den erwarteten Wert ein und lesen die hervorgehobene Zeile ab.

Warum Ihre Prüfsumme nicht passt

Den Text „01 03“ prüfen statt der Bytes

Bleibt der Textmodus stehen, verrechnet der Rechner die ASCII-Zeichen Ihres Hexdumps statt der Bytes, für die sie stehen. Auf den Hex-Modus umschalten — die Byte-Anzahl unter dem Modusschalter sagt Ihnen, welche Lesart Sie bekommen haben.

✗ Falsch
Text mode, input "01 03" -> 5 bytes: 30 31 20 30 33
✓ Richtig
Hex mode, input "01 03" -> 2 bytes: 01 03

Gegen eine byte-vertauschte Prüfsumme vergleichen

Modbus RTU überträgt das niederwertige CRC-Byte zuerst. Ein Telegramm, das auf C5 CD endet, trägt die Prüfsumme 0xCDC5, nicht 0xC5CD.

✗ Falsch
expected 0xC5CD  (bytes read in transmission order)
✓ Richtig
expected 0xCDC5  (bytes reassembled low-byte-first)

Das Prüfsummenfeld in die eigene Berechnung einbeziehen

Die CRC deckt die Bytes vor ihr ab. Schiebt man das ganze Telegramm samt Anhang zurück in die Berechnung, kommt ein Residuum heraus und nicht die Prüfsumme.

✗ Falsch
01 03 00 00 00 0A C5 CD    <- trailer included
✓ Richtig
01 03 00 00 00 0A          <- payload only

Annehmen, „CRC-16“ bezeichne einen Algorithmus

Einunddreißig katalogisierte Varianten sind 16 Bit breit. Ohne die anderen fünf Parameter grenzt der Name nichts ein.

✗ Falsch
spec says: "trailer is a CRC-16"
✓ Richtig
spec says: "CRC-16/MODBUS, poly 0x8005, init 0xFFFF, refin/refout true"

Wann Sie das brauchen

Eine Modbus-Verbindung debuggen
Eine SPS weist Ihre Telegramme ab, und Sie müssen wissen, ob die CRC falsch ist oder nur die Bytes vertauscht sind. CRC-16/MODBUS berechnen und beide Reihenfolgen vergleichen.
Ein undokumentiertes Protokoll identifizieren
Sie haben Datenverkehr mitgeschnitten, dessen Zwei-Byte-Anhang nach einer Prüfsumme aussieht. Nutzlast und Anhang in die Rückwärtssuche geben und sehen, welche Variante sich dazu bekennt.
Firmware zwischen Toolchains portieren
Die Bibliothek des Herstellers und Ihre eigene Implementierung widersprechen sich. Beide gegen den Prüfwert aus dem Katalog laufen zu lassen zeigt, welche abgedriftet ist.
Eine Spezifikation schreiben oder prüfen
Steht in einem Protokolldokument nur „CRC-16“, sind Interoperabilitätsfehler vorprogrammiert. Die Parametertabelle liefert die sechs Werte, die den Algorithmus wirklich festnageln.
Gespeicherte Daten prüfen
Dateisysteme, Archivformate und Flash-Abbilder führen CRC-32-Felder mit. Eines neu zu berechnen sagt Ihnen, ob ein Block unversehrt geblieben ist.

Wie CRC funktioniert

Darstellung des Polynoms
Die Tabelle gibt Polynome in der normalen Form aus, höchstwertiges Bit zuerst: 0x8005 steht für x^16 + x^15 + x^2 + 1. Reflektierte Implementierungen schreiben dasselbe Polynom oft als 0xA001, und die Koopman-Notation verschiebt es noch einmal anders. Drei Schreibweisen für ein Polynom sind eine verbreitete Ursache für misslungene Portierungen.
Der Startwert
Das Register bei 0xFFFF statt bei 0x0000 zu starten macht die Prüfsumme empfindlich für führende Nullbytes. Bei einem Startwert von null lässt ein den Daten vorangestelltes Nullfeld die CRC unverändert — und genau diese Störung muss ein Protokoll mit Telegrammrahmen abfangen.
Reflexion
refin dreht die Bits innerhalb jedes Eingabebytes um, refout dreht das Endregister um. Hardware taktet die Bits mit dem höchstwertigen zuerst, während byteorientierte Software mit dem niederwertigsten zuerst günstiger fährt; die reflektierten Parameterformen bringen beides zur Deckung.
Finales XOR
xorout wird zuletzt angewendet, und es ist nicht einfach ein init am anderen Ende. An die Nachricht angehängte Nullbytes werden in beiden Fällen erkannt. Was ein xorout ungleich null ändert, ist das Residuum, das ein Empfänger erhält, wenn er die CRC über Nachricht und Prüfsumme zusammen laufen lässt: Bei xorout null ist dieses Residuum selbst null, sodass Nullen hinter dem CRC-Feld weiterhin durchgehen. Außerdem sorgt es dafür, dass eine Nachricht aus lauter Nullen eine Prüfsumme ungleich null ergibt.
Der Prüfwert
Jede katalogisierte Variante veröffentlicht ihr Ergebnis für die ASCII-Zeichenkette 123456789. Die 63 Werte, die diese Seite bei dieser Eingabe zeigt, sind genau jene veröffentlichten Konstanten — so wird die Engine dieser Seite getestet.

So kommt ein passendes Ergebnis heraus

Die Parameter nennen, nicht den Algorithmus
Schreiben Sie in Spezifikationen „poly 0x1021, init 0xFFFF, refin false, refout false, xorout 0x0000“. „CRC-16/CCITT“ hat schon mindestens drei verschiedene Dinge bedeutet.
Die Byte-Reihenfolge getrennt prüfen
Wenn eine Prüfsumme nur eine Byte-Vertauschung vom Treffer entfernt ist, stimmt der Algorithmus und der Telegrammrahmen ist falsch. Behandeln Sie das als zwei verschiedene Fehler.
Zuerst gegen den Prüfwert verifizieren
Bevor Sie Ihre Daten untersuchen, stellen Sie sicher, dass Ihre Implementierung für 123456789 den Katalogwert liefert. Das trennt einen kaputten Algorithmus in Sekunden von einer kaputten Eingabe.
Klar festlegen, was abgedeckt ist
Die meisten Abweichungen kommen daher, dass Startkennungen, Adressen oder Längenfelder mitgerechnet oder ausgelassen werden. Legen Sie genau fest, über welche Bytes die CRC läuft, und schreiben Sie es auf.
Keine CRC verwenden, wo ein MAC gebraucht wird
CRC ist linear und ohne Aufwand fälschbar. Sobald ein Angreifer die Daten verändern könnte, nehmen Sie stattdessen HMAC.

Häufige Fragen

Warum liefert mein Gerät eine andere CRC als dieser Rechner?
Fast immer deshalb, weil zwei verschiedene Varianten verglichen werden. Allein für CRC-16 sind 31 Parametersätze katalogisiert, und MODBUS, CCITT-FALSE, XMODEM und KERMIT erzeugen aus identischen Bytes vier völlig unabhängige Zahlen. Tragen Sie den Wert des Geräts in das Feld für den erwarteten Wert ein: Reproduziert ihn eine Variante, wird die passende Zeile hervorgehoben, und die Frage ist beantwortet. Passt keine, sind die geprüften Daten nicht die, für die Sie sie halten — kontrollieren Sie die Byte-Reihenfolge und ob Start- und Endekennung des Telegramms in die Berechnung einfließen.
Welche CRC-16 verwendet Modbus?
CRC-16/MODBUS: Generatorpolynom 0x8005, Startwert 0xFFFF, Eingang und Ausgang beide reflektiert, kein finales XOR. Verwirrung stiftet dabei weniger der Algorithmus als die Übertragungsreihenfolge — Modbus RTU sendet das niederwertige CRC-Byte zuerst, ein Telegramm mit der Prüfsumme 0xCDC5 trägt am Ende also die Bytes C5 CD. Ein durchgerechnetes Telegramm steht im Leitfaden zu den CRC-16-Varianten.
Was ist der Unterschied zwischen CRC-16/CCITT und CRC-16/CCITT-FALSE?
Das sind zwei verschiedene Algorithmen mit verwirrend ähnlichen Namen — genau deshalb hat der RevEng-Katalog beide umbenannt. Was allgemein CCITT-FALSE heißt, ist CRC-16/IBM-3740: Startwert 0xFFFF, keine Reflexion. Mit dem bloßen CCITT ist üblicherweise CRC-16/KERMIT gemeint: Startwert 0x0000, Eingang und Ausgang reflektiert. Dieser Rechner zeigt zu jeder Zeile sowohl den formalen Namen als auch den, der wahrscheinlich in Ihrem Gerätehandbuch steht.
Erkennt eine CRC, dass eine Datei manipuliert wurde?
Nein. CRC ist ein Fehlererkennungscode für zufällige Störungen auf einem verrauschten Kanal, und er ist linear — jeder kann eine Nachricht ändern und so nachziehen, dass die CRC weiterhin passt. Gegen einen absichtlich handelnden Angreifer brauchen Sie einen kryptografischen Hash wie SHA-256 oder eine authentifizierte Konstruktion wie HMAC. CRC ist hervorragend in dem, wofür sie gebaut wurde, und bietet keinerlei Sicherheit.
Was bewirken refin und refout genau?
refin dreht die Bitreihenfolge innerhalb jedes Eingabebytes um, bevor es in das Register läuft; refout dreht die Bitreihenfolge des Endregisters um. Es gibt sie, weil Hardware-Schieberegister und tabellenbasierte Software-Implementierungen die Bits in entgegengesetzter Richtung takten, und die reflektierten Formen lassen beide bei derselben Zahl herauskommen. Mit der Byte-Reihenfolge hat das nichts zu tun: Reflexion wirkt auf die Bits innerhalb eines Bytes, während die Endianness die Reihenfolge der Bytes selbst festlegt.
Ich habe nur die Prüfsumme, nicht die Daten. Kann das Werkzeug rückwärts rechnen?
Nein, und kein Werkzeug kann das. Eine CRC presst eine beliebig lange Nachricht in 8, 16 oder 32 Bit, also teilen sich unzählige verschiedene Nachrichten jeden einzelnen Wert — eine Frage des Aufwands ist das nicht. Die Rückwärtssuche auf dieser Seite beantwortet eine engere Frage: Gegeben die Daten und eine Prüfsumme, die jemand daraus berechnet hat, welcher Parametersatz verbindet beide. Wenn Sie die Antwort eines Geräts mitgeschnitten haben, aber nicht die Nutzdaten dahinter, schneiden Sie zuerst die Nutzdaten mit. Zur Wahl zwischen den Breiten statt zur Identifikation einer Variante siehe den Leitfaden zu den CRC-16-Varianten.
Warum zeigt der Rechner 63 Varianten, wenn mein Gerät nur eine nennt?
Weil die nützliche Frage meist nicht lautet „berechne eine CRC“, sondern „welche von diesen hat den Wert erzeugt, den ich vor mir habe“. Werkzeuge, die zuerst eine Variante ausgewählt haben wollen, setzen voraus, dass die Antwort schon bekannt ist. Alle Varianten gleichzeitig anzuzeigen macht aus der Identifikation ein einziges Nachschlagen, und über die Parameterspalten lässt sich der Treffer gegen die Spezifikation prüfen, statt einem Namen zu vertrauen.
Werden meine Daten irgendwohin gesendet?
Nein. Die gesamte Berechnung läuft in Ihrem Browser, mit derselben Engine, die auch die Tabelle auf dieser Seite gefüllt hat — kein Upload, kein API-Aufruf, kein Logging. Sie können die Netzwerkverbindung trennen, und das Tool arbeitet weiter. Das zählt, weil CRC-Eingaben oft Telegramme aus dem Produktivbetrieb oder Firmware-Abbilder sind.

Verwandte Werkzeuge

Alle Werkzeuge anzeigen →

AES-Entschlüsselungstool — OpenSSL- & CryptoJS-kompatibel

Sicherheitswerkzeuge

AES online entschlüsseln — GCM/CBC/CTR, Passphrase oder Rohschlüssel, erkennt automatisch das OpenSSL- & CryptoJS-Format „U2FsdGVkX1“. 100 % im Browser, Schlüssel verlassen die Seite nie.

AES-Verschlüsselungstool — GCM, CBC & CTR

Sicherheitswerkzeuge

Kostenloses Online-Tool für AES-Verschlüsselung — AES-128/192/256, GCM/CBC/CTR, Passphrase (PBKDF2) oder Rohschlüssel. Läuft zu 100 % im Browser; nichts wird hochgeladen.

Bcrypt-Hash-Generator & Verifizierer

Sicherheitswerkzeuge

Bcrypt-Passwort-Hashes online erzeugen und prüfen — einstellbarer Kostenfaktor, $2b$/$2a$/$2y$. 100 % im Browser; dein Passwort wird nie hochgeladen.

HMAC-Generator & Signaturprüfer

Sicherheitswerkzeuge

Kostenloser HMAC-Generator und -Prüfer online. Berechne HMAC-SHA256/SHA1/SHA384/SHA512 mit Schlüsseln als Text, Hex oder Base64 und Ausgabe als Hex/Base64/Base64URL. 100 % in deinem Browser — Schlüssel verlassen nie die Seite.

JWT-Dekodierer

Sicherheitswerkzeuge

Dekodieren Sie JWT-Token online mit unserem kostenlosen JWT-Dekodierer. Inspizieren Sie sofort Header, Payload, Signatur, Ablauf und Claims. 100 % Browser — Ihr Token verlässt niemals Ihr Gerät. Keine Anmeldung, kein Tracking.

JWT-Kodierer & -Generator

Sicherheitswerkzeuge

Kostenloser Online-JWT-Generator & -Kodierer. Erstellen Sie Header und Payload und signieren Sie sofort mit HS256, RS256 oder ES256. 100 % im Browser — Ihr Geheimnis und Ihr Schlüssel verlassen niemals Ihr Gerät.