Ip-Protokoll und (CRC-16) Berechnung... Und ich versteh nix.

[Kedariodakon]

Ich hab so ein kleines Problem mit der Checksumberechnung von einm IP-Protokoll Packet...
1. Ich kann es noch nicht per Hand berechnen, da ich da nicht wirklich durchsteig...
2. wenn ich sie berechnen lasse, bekomm ich was anderes raus als sollte...

Erst mal was dazu:
Internet Protocol

Code:

    0                   1                   2                   3   
    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |Version|  IHL  |Type of Service|          Total Length         |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |         Identification        |Flags|      Fragment Offset    |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |  Time to Live |    Protocol   |         Header Checksum       |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |                       Source Address                          |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |                    Destination Address                        |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   |                    Options                    |    Padding    |
   +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

So die Headerchecksume wird aus dem Header berechnet...

RFC 791

Zitat:

Zitat von RFC 791

Header Checksum: 16 bits

A checksum on the header only. Since some header fields change
(e.g., time to live), this is recomputed and verified at each point
that the internet header is processed.

The checksum algorithm is:

The checksum field is the 16 bit one's complement of the one's
complement sum of all 16 bit words in the header. For purposes of
computing the checksum, the value of the checksum field is zero.

This is a simple to compute checksum and experimental evidence
indicates it is adequate, but it is provisional and may be replaced
by a CRC procedure, depending on further experience.

so nun habe ich hier mal ein IP-Packet:

Delphi-Quellcode:

Const
  cProto: Array[ $00..$2D ] Of Byte =
       ( $45, $00, $00, $28, $A2, $EE, $40, $00, $80, $06, $0E, $55, $C0, $A8, $64, $39,
         $C0, $A8, $64, $02, $06, $4D, $01, $BD, $0A, $62, $36, $C5, $47, $E8, $96, $1E,
         $50, $10, $FC, $FD, $42, $12, $00, $00, $00, $00, $00, $00, $00, $00 );

Der Header sollte dann folgendes sein:

Delphi-Quellcode:

Const
  cIPHeader: Array[ $00..$09 ] Of Byte = ( $45, $00, $00, $28,
                                           $A2, $EE, $40, $00,
                                           $80, $06 );

Aber wenn ich die Checksumme mit tools wie z.B. dem HxD-Hexeditor :) berechnnen lasse, komme nicht auf die Checksumme von 0x0E55 ...
laut Ethereal ist die Checksumme aber io.

Kann mir wer sagen ob die tools falsch rechnen, ich den Ip-Header falsch abgrenze, oder ka..

Vieleicht is ja auch wer so lieb mir genau zu erklären wie ich das per Hand ausrechnen kann *liebgug*
Irgendwie wird auf Bit-Ebene durch 2 dividiert und der Rest ist die Checksumme...
Und da hört es schon auf...



Bye

[Kedariodakon]

Hat keiner nen kleinen Tip???
Ich bin der Lösung nähmlich noch kein Stück näher gekommen :(

Bye

[shmia]

Zitat:

Zitat von Kedariodakon

so nun habe ich hier mal ein IP-Packet:

Delphi-Quellcode:

Const
  cProto: Array[ $00..$2D ] Of Byte =
       ( $45, $00, $00, $28, $A2, $EE, $40, $00, $80, $06, $0E, $55, $C0, $A8, $64, $39,
         $C0, $A8, $64, $02, $06, $4D, $01, $BD, $0A, $62, $36, $C5, $47, $E8, $96, $1E,
         $50, $10, $FC, $FD, $42, $12, $00, $00, $00, $00, $00, $00, $00, $00 );

Der Header sollte dann folgendes sein:

Delphi-Quellcode:

Const
  cIPHeader: Array[ $00..$09 ] Of Byte = ( $45, $00, $00, $28,
                                           $A2, $EE, $40, $00,
                                           $80, $06 );

Aber wenn ich die Checksumme mit tools wie z.B. dem HxD-Hexeditor :) berechnnen lasse, komme nicht auf die Checksumme von 0x0E55 ...
laut Ethereal ist die Checksumme aber io.

Nein, der IP-Header hört nicht bei dem Eintrag "Header Checksum", sondern umfasst min. 6 * 4 Bytes = 24 Bytes.
Also grob so:

Delphi-Quellcode:

IPHeader : Array[0..12-1] of Word;
Result := 0;
for i:=0 to 12-1 do
begin
   if i <> 5 then    // das Feld Header Checksum auslassen
      Inc(Result, not IPHeader[i]);
   Result := not Result;  // one's Complement
end;

[Kedariodakon]

:wiejetzt:

Zitat:

Zitat von shmia

Nein, der IP-Header hört nicht bei dem Eintrag "Header Checksum", sondern umfasst min. 6 * 4 Bytes = 24 Bytes.
Also grob so:

Delphi-Quellcode:

IPHeader : Array[0..12-1] of Word;
Result := 0;
for i:=0 to 12-1 do
begin
   if i <> 5 then    // das Feld Header Checksum auslassen
      Inc(Result, not IPHeader[i]);
   Result := not Result;  // one's Complement
end;

hmm der Header in dem Fall ist doch aber nur 20Bytes, welches aber den CRC mit einschließt, und irgendwo hab ich gelesen, dass die beiden IP-Felder nicht mit in der Checksumme einberechnet werden... :gruebel:

Also wird die Checksumme aus 24 Bytes berechnet sprich: "Version", "IHL", "Type of Service", "Total Length", "Identification", "Flags", "Fragment Offset", "Time to Live", "Protocol", "Source Address", "Destination Address" (=16Byte) + weiteren 8Bytes aus "Options", "Padding" und Datenteil...
Hab ich das nun korrect verstanden? :drunken:


Bye

[shmia]

Zitat:

Zitat von Kedariodakon

:wiejetzt:
hmm der Header in dem Fall ist doch aber nur 20Bytes, welches aber den CRC mit einschließt, und irgendwo hab ich gelesen, dass die beiden IP-Felder nicht mit in der Checksumme einberechnet werden... :gruebel:

Also wird die Checksumme aus 24 Bytes berechnet sprich: "Version", "IHL", "Type of Service", "Total Length", "Identification", "Flags", "Fragment Offset", "Time to Live", "Protocol", "Source Address", "Destination Address" (=16Byte) + weiteren 8Bytes aus "Options", "Padding" und Datenteil...

Nicht ganz. Die Nutzdaten (Payload) gehören nicht mit in die Prüfsumme.
Grund: die Prüfsumme muss jedesmal wenn das Paket durch einen Router geht neu berechnet werden
Würden die Nutzdaten mit in die Prüfsumme einfliesen, würde das den Transport verzögern.
Die Prüfsumme wird über den gesamten Header gebildet; also von "Version" bis einschliesslich "Padding".

Hier nochmals mein geänderter Sourcecode:

Delphi-Quellcode:

IPHeader : Array[0..12-1] of Word;
Result := 0;
//The checksum field is the 16 bit one's complement of the one's 
//complement sum of all 16 bit words in the header. For purposes of 
//computing the checksum, the value of the checksum field is zero. 

IPHeader[5] := 0;  // also Prüfsumme löschen

// jetzt den ganzen IP-Header Wort für Wort summieren
// one's complement = not
for i:=0 to 12-1 do
begin
   Inc(Result, not IPHeader[i]);
end;
Result := not Result;  // one's Complement

[Kedariodakon]

sry erstmal, das ich erst jetzt schreibe, war mir nicht anders möglich...

Zitat:

Zitat von shmia

Nicht ganz. Die Nutzdaten (Payload) gehören nicht mit in die Prüfsumme.
Grund: die Prüfsumme muss jedesmal wenn das Paket durch einen Router geht neu berechnet werden
Würden die Nutzdaten mit in die Prüfsumme einfliesen, würde das den Transport verzögern.

Nun das da 1-2Bytes Nutzdaten die Geschwindigkeit so ausbremsen ??? Der Rest muß ja auch ausgelesen werden... Irgendwie muß man ja mal zu der CRC kommen...

Zitat:

Zitat von shmia

Die Prüfsumme wird über den gesamten Header gebildet; also von "Version" bis einschliesslich "Padding".

:wiejetzt: Wie soll ich denn dann auf die 24Bytes kommen? Der Header ist ohne CRC nur 18 Bytes lang... weil in dem Beispielfall kein Paddig bzw. Optionen anfielen...

Zum nächsten Erzeugt deine Funktion nen Integerüberlauf :zwinker:
Ok mit ausgeschalteten Überprüfungen bekomm ich zwar ein Ergebniss aber nicht das Richtige...


Das ist ein komplettes IP-Packet:

Delphi-Quellcode:

Const
  cProto: Array[ $00..$2D ] Of Byte  =
   ( $45, $00, $00, $28, $A2, $EE, $40, $00, $80, $06, $0E, $55, $C0, $A8, $64, $39,
     $C0, $A8, $64, $02, $06, $4D, $01, $BD, $0A, $62, $36, $C5, $47, $E8, $96, $1E,
     $50, $10, $FC, $FD, $42, $12, $00, $00, $00, $00, $00, $00, $00, $00 );

Dieses nun zerlegt:

Code:

Version             (4   Bit        $4  ):= 4
IHL                 (4   Bit        $5  ):= 5  --> Headerlänge 20 Byte 
Type Of Service     (1   Byte       $00 ):= 0
Total Length        (2   Byte     $0028 ):= 40
Identification      (2   Byte     $A2EE ):= 41710
Flags               (3   Bit            ):= 0 1 0
Fragment Offset     (1 Byte + 5 Bit     ):= 0
Time to Live        (1   Byte       $80 ):= 128
Protocol            (1   Byte       $06 ):= 6
Header Checksum     (2   Byte     $0E55 ):= 3669
Source Address      (4   Byte $C0A86439 )
Destination Address (4   Byte $C0A86402 )
-----------------------------------------
                  = 20   Byte

-> 0 Byte Options + 0 Byte Padding...
-> Datenteil ( 20 Byte ):

Delphi-Quellcode:

Const
  cData: Array[ $00..$13 ] Of Byte  =
   ( $06, $4D, $01, $BD, $0A, $62, $36, $C5, $47, $E8, $96, $1E, $50, $10, $FC, $FD,
     $42, $12, $00, $00 );

-> 4Bytes := $00 Padding...


Soweit so gut!
Wenn du nun aus cProto den CRC $0E55 berechnest bist mein Held/Heldin :angel:
Ich habst immernoch nicht geschafft...
Ich bin scheinbar einfach zu plöd dafür :wall:


Bye

[Basilikum]

hier meine Routine:

Delphi-Quellcode:

Function                          CalcIPChecksum(Const Packet : Pointer;Const Bytes : LongWord) : Word;
Var
  Checksum                        : LongWord;
  X                               : Integer;
begin
  Checksum:=0;
  For X:=1 To (Bytes shr 1) Do Checksum:=Checksum + PWords(Packet)^[X - 1];
  If ((Bytes and 1) > 0) Then Checksum:=Checksum + PBytes(Packet)^[Bytes - 1];
  CheckSum:=(CheckSum shr 16) + (CheckSum and $FFFF);
  CheckSum:=CheckSum + (CheckSum shr 16);
  Result:=Word(not Checksum);
end;

die Checksumme wird von den ersten n Bytes des Packets berechnet, wobei n die Header-Länge gemäss IP-Header ist.

Zu beachten ist:
- vor der Berechnung wird das Feld der Checksumme im IP-Header auf $0000 gesetzt
- die Checksumme liegt im Packet in Network-Byte-Order vor.... mittels WinSock.NToHS lässt sich ein Word (S-hort) von Network-Byte-Order zu Host-Byte-Order wandeln (WinSock.HToNS für Gegenrichtung)

[Kedariodakon]

Zitat:

Zitat von Basilikum

hier meine Routine:

Delphi-Quellcode:

Function                          CalcIPChecksum(Const Packet : Pointer;Const Bytes : LongWord) : Word;
Var
  Checksum                        : LongWord;
  X                               : Integer;
begin
  Checksum:=0;
  For X:=1 To (Bytes shr 1) Do Checksum:=Checksum + PWords(Packet)^[X - 1];
  If ((Bytes and 1) > 0) Then Checksum:=Checksum + PBytes(Packet)^[Bytes - 1];
  CheckSum:=(CheckSum shr 16) + (CheckSum and $FFFF);
  CheckSum:=CheckSum + (CheckSum shr 16);
  Result:=Word(not Checksum);
end;

die Checksumme wird von den ersten n Bytes des Packets berechnet, wobei n die Header-Länge gemäss IP-Header ist.

Zu beachten ist:
- vor der Berechnung wird das Feld der Checksumme im IP-Header auf $0000 gesetzt

:wall: :wiejetzt:
1. Was ist PWords???
2. Was ist PBytes???
3. Kommt in Packet mein Byte Array? Wenn ja warum arbeitest du dann mit Pointern?
4. Kommt in Bytes die Länge des Byte Arrays? Wenn ja ein Word reicht aus, da ein Ip-Packet net größer als 1500 Bytes werden kann.

Zitat:

Zitat von Basilikum

...
- die Checksumme liegt im Packet in Network-Byte-Order vor.... mittels WinSock.NToHS lässt sich ein Word (S-hort) von Network-Byte-Order zu Host-Byte-Order wandeln (WinSock.HToNS für Gegenrichtung)

Bahnhof *tüttüt* :zwinker:

Bye

[Basilikum]

Zitat:

Zitat von Kedariodakon

:wall: :wiejetzt:
1. Was ist PWords???
2. Was ist PBytes???
3. Kommt in Packet mein Byte Array? Wenn ja warum arbeitest du dann mit Pointern?
4. Kommt in Bytes die Länge des Byte Arrays? Wenn ja ein Word reicht aus, da ein Ip-Packet net größer als 1500 Bytes werden kann.

Zitat:

Zitat von Basilikum

...
- die Checksumme liegt im Packet in Network-Byte-Order vor.... mittels WinSock.NToHS lässt sich ein Word (S-hort) von Network-Byte-Order zu Host-Byte-Order wandeln (WinSock.HToNS für Gegenrichtung)

Bahnhof *tüttüt* :zwinker:

Bye

1.:

Delphi-Quellcode:

type
  PWords = ^TWords;
  TWords = Array[0..high(word)] Of Word;

2.:

Delphi-Quellcode:

type
  PBytes = ^TBytes;
  TBytes = Array[0..high(word)] Of Byte;

3. Packet soll ein Pointer auf das 1. Byte des IP-Header sein

4. Richtig; allerdings verwende ich einheitlich LongWord, wenn es um die Grösse von Pointer-Daten geht

Zitat:

Zitat von Kedariodakon

Bahnhof *tüttüt* :zwinker:

:)

Delphi-Quellcode:

Const
  cProto: Array[ $00..$2D ] Of Byte  =
   ( $45, $00, $00, $28, $A2, $EE, $40, $00, $80, $06, $0E, $55, $C0, $A8, $64, $39,
     $C0, $A8, $64, $02, $06, $4D, $01, $BD, $0A, $62, $36, $C5, $47, $E8, $96, $1E,
     $50, $10, $FC, $FD, $42, $12, $00, $00, $00, $00, $00, $00, $00, $00 );
var
  headerlen : LongWord;
  buf : array[0..$f * 4 - 1] of byte;
  cs : word;
begin
  headerlen:=(cProto[0] and $0f) shl 2;
  move(cProto,buf,headerlen);

  cs:=pwords(@buf)^[5];

  pwords(@buf)^[5]:=0; // checksum feld 0-en vor Berechnung
  pwords(@buf)^[5]:=CalcIPChecksum(@buf,headerlen); // Checksum neu berechnen  

  Assert(cs = pwords(@buf)^[5],'Checksum incorrect');
end;

[Kedariodakon]

*tüttüt*
Zusammenfassung:

Delphi-Quellcode:

Function    CRC2Test: Word;
Type
   PWords = ^TWords;
   TWords = Array[0..high(word)] Of Word;
   PBytes = ^TBytes;
   TBytes = Array[0..high(word)] Of Byte;

   Function CalcIPChecksum(Const Packet : Pointer;Const Bytes : LongWord) : Word;
   Var
      Checksum                        : LongWord;
      X                               : Integer;
   Begin
      Checksum:=0;
      For X:=1 To (Bytes shr 1) Do Checksum:=Checksum + PWords(Packet)^[X - 1];
      If ((Bytes and 1) > 0) Then Checksum:=Checksum + PBytes(Packet)^[Bytes - 1];
      CheckSum:=(CheckSum shr 16) + (CheckSum and $FFFF);
      CheckSum:=CheckSum + (CheckSum shr 16);
      Result:=Word(not Checksum);
   End;

Const 
   cProto: Array[ $00..$2D ] Of Byte  =
   ( $45, $00, $00, $28, $A2, $EE, $40, $00, $80, $06, $0E, $55, $C0, $A8, $64, $39, 
       $C0, $A8, $64, $02, $06, $4D, $01, $BD, $0A, $62, $36, $C5, $47, $E8, $96, $1E,
     $50, $10, $FC, $FD, $42, $12, $00, $00, $00, $00, $00, $00, $00, $00 ); 
Var
  headerlen : LongWord; 
   buf : Array[0..$f * 4 - 1] Of byte;
  cs : word; 
Begin
   headerlen:=(cProto[0] and $0f) shl 2;
   move(cProto,buf,headerlen);

   cs:=pwords(@buf)^[5];

   pwords(@buf)^[5]:=0; // checksum feld 0-en vor Berechnung
   pwords(@buf)^[5]:=CalcIPChecksum(@buf,headerlen); // Checksum neu berechnen

   Assert(cs = pwords(@buf)^[5],'Checksum incorrect');
   Result   := cs;
End;

Dann kommt bei mir 21774 raus obwohl 3669 das richtige ergebniss wär ?!?!?

:wall:

Bin ich zu blöd?
Im Grunde soll doch die Checksum das 1er Komplement der Summe alle Word vom Ip-Header sein, wobei aber die Checksumm auf 0 gesetzt wird korrekt?

Vereinfacht:

Delphi-Quellcode:

Function   CRC1Test: Word;
Const
   cIPPHeader: Array[ $00..$09 ] Of Integer  =
      (   $4500, $0028, $A2EE, $4000, $8006, $0000, $C0A8, $6439,   $C0A8, $6402   );
Begin
   Result   := Not ( Word( SumInt( cIPPHeader ) And $FFFF ) );
End;

Aber auch hier lieg ich mit 3 zuviel :love:

Bye