4. Chat-Protokoll entschlüsseln

Chat-Protokoll entschlüsseln

  • B

    Ich weis nicht ob das so einfach geht. Denn ein Protokoll umfasst einige Steuerbefehle wie EOT (End of Transmission), CR (Connection Request), CC (Connection Confirm), ACK (Ackknowledge), Timeout, ... Ein Protokoll ist im Endeffekt nichts anderes als ein Automat, er bekommt eine Nachricht und wechselt danach in einen anderen Zustand. Und dadurch kommt auf jeden Fall eine Menge
    Auf jeden Fall stehst du vor einer Menge Arbeit.

    0
  • C

    Hmm eigentlich ist Protokoll das falsche Wort, denke ich...
    Diese Bytes werden empfangen, wenn ich als Client Text an den (Game)Server sende...
    Ich möchte halt auch manuell etwas an den Server senden können (Ohne Text einzugeben).

    MfG

    0
  • B

    Und gerade deswegen sind vermutlich einige Steuerbytes(bits) darunter, denn nach dem OSI-Referenzmodell ist das was der Empfänger empfängt immer ein Packet aus Nutz- und Steuerdaten. Schaue dir doch mal die 0 an. Diese steht oft am Ende der Nachricht, aber nie innerhalb.

    Auch stimmt schon ein einfaches Mapping nicht. Wenn man annimmt dass ein Zeichen einem Byte entspricht, ist in allen Fällen ein Byte zuviel da. Ich habe aber die Vermutung das vielleicht nur 7 Bits für ein Zeichen verwendet wird. Deswegen würde ich mir mal gas Ganze in Bitdarstellung anzeigen lassen und damit weitermachen.

    Und wenn es ganz brutal kommt, ist das Ganze noch durch eine Verschlüsselung geschützt, aber hierbei sieht es nicht aus.

    0
  • C

    Ok danke, dachte das wäre vielleicht einfacher.
    Dann lass ich das lieber.

    MfG

    0
  • D

    Recht trivial würde ich sagen:
    ASCII-Code des Zeichens * 2^(1-Position)

    In die Richtung geht es jedenfalls. Habe es nicht überprüft, aber die Folge von Leerzeichen (=ASCII 32) lässt darauf schließen. Ebenso die einzelnen Buchstaben.

    Aber wie gesagt, da steckt noch etwas mehr drin, es entspricht nicht immer genau dem Muster, siehe Leerzeichen-Folge

    0
  • B

    Ganz so einfach ist es nicht. Es ist wahrscheinlich überhaupt nicht möglich, die Verschlüsselung mit den gegebenen Informationen zu entschlüsseln, weil der Schlüsseltext bei gleichem Klartext nicht immer gleich ist. Es muss irgendein zustandsbehaftetes Element geben.

    0
  • D

    Größtenteils wohl schon. Wenn etwas anders ist, dann nur das letzte Byte.

    0
  • B

    Ganz allgmein ist das Problem doch das man hier ein wenig Reverse Engineering betreiben muss. Und mit einem entsprechenden Zeit- und Materialaufwand kann man sicherlich jedes Protokoll knacken. Es kann halt durchaus möglich sein dass man erst nach Jahren das Protokoll komplett verstanden hat.

    Deswegen sage ich ja auch dass das Ganze massiv Zeitaufwändig ist und nur selten empfehlenswert ist. Ich denke dass sich das Ganze nur für die kleinsten Programme eigent, welche hobbymäßig geschrieben wurden.

    Mal noch eine Frage an ceplusplus@loggedoff. Darf ich mal fragen um was für ein Chat-Protokoll es sich handelt ? Wenn es sich um ICQ, AIM, JABBER, ... handelt, würde ich mir vielleicht mal den Quelltext von dem Open Source Programm Miranda ansehen.

    0
  • N

    Habs mal grob überflogen ... und schon sind mir ein paar Sachen aufgefallen.

    1. Das Alignment in deiner Darstellung der empfangenen Bytes ist (vermutlich) falsch.
    Es sieht eher nach folgendem aus :

    Prefix (x) bit
    Datenblock warscheinlich 8bit-codiert
    Suffix (x) bit

    2. Mehr daten :D, insbesondere Sonderzeichen wären interessant.

    3. Beim Suffix kann es sich um reines Padding handeln, auffüllen bis ...

    4. Aus folgenden zwei Zeilen lassen sich interessante Zusammenhänge ableiten, falls ich das richtig Interpretiere ...
    7+8 Leerzeichen :
    64, 32, 16, 8, 4, 2, 1, 68
    64, 32, 16, 8, 4, 2, 129, 0

    Nun eine kesse (mathematische) Annahme :
    Die Kodierung ist c=7bit pro Zeichen ... rest p=Padding.

    Beidemal 64 bit also :

    7c + p = 64
    8    c + p = 64

    Das Alphabet a-z ist nach deiner Aussage 24 Byte lang = 192bit

    26*c + p = 192

    Das padding ist also in diesen Fällen 8, 10 und 15 bit.

    Alle Angaben sind wie immer ohne Gewähr.

    0
  • C

    Danke, aber die Prioritäten haben sich geändert 😕
    Ich muss dringend folgendes Entschlüsseln, um einen Servercrash zu verhindern:

    263			128, 127, 0, 56, 8
265			128, 127, 0, 72, 8
267			128, 127, 0, 88, 8
269			128, 127, 0, 104, 8
271			128, 127, 0, 120, 8
273			128, 127, 0, 136, 8
275			128, 127, 0, 152, 8
277			128, 127, 0, 168, 8
279			128, 127, 0, 184, 8
281			128, 127, 0, 200, 8
283			128, 127, 0, 216, 8
285			128, 127, 0, 232, 8
287			128, 127, 0, 248, 8
289			128, 127, 0, 8, 9
291			128, 127, 0, 24, 9
293			128, 127, 0, 40, 9
295			128, 127, 0, 56, 9
297			128, 127, 0, 72, 9
299			128, 127, 0, 88, 9
301			128, 127, 0, 104, 9
303			128, 127, 0, 120, 9
305			128, 127, 0, 136, 9
307			128, 127, 0, 152, 9
309			128, 127, 0, 168, 9
311			128, 127, 0, 184, 9
313			128, 127, 0, 200, 9
315			128, 127, 0, 216, 9
317			128, 127, 0, 232, 9
319			128, 127, 0, 248, 9
321			128, 127, 0, 8, 10
323			128, 127, 0, 24, 10

Leicht...
zB. 56, 8 zu Word = 2104 / 8 = 263

--------------------------------------------------

263			224, 31, 0, 14, 2
265			224, 31, 0, 18, 2
267			224, 31, 0, 22, 2
269			224, 31, 0, 26, 2
271			224, 31, 0, 30, 2
273			224, 31, 0, 34, 2
.....
385			224, 31, 0, 2, 3
387			224, 31, 0, 6, 3
389			224, 31, 0, 10, 3

Dasselbe...
zB. 14, 2 zu Word = 526 / 2 = 263

--------------------------------------------------

269			252, 3, 64, 67, 224
271			252, 3, 192, 67, 224
273			252, 3, 64, 68, 224

Hier ist es total anders... Byte 3 und 4 anstatt 4 und 5
64 und 67 zu Word = 17216 / 64 = 269
192 und 67 zu Word = 17344 / 64 = 271

--------------------------------------------------

263			192, 63, 0, 28, 4
265			224, 31, 0, 18, 194
267			192, 63, 0, 44, 4
269			192, 63, 0, 52, 4
271			192, 63, 0, 60, 4
273			224, 31, 0, 34, 194

Teils gar keine Ahnung...

--------------------------------------------------

263			254, 1, 224, 32, 0
265			254, 1, 32, 33, 0
267			254, 1, 96, 33, 0
269			254, 1, 160, 33, 0
271			254, 1, 224, 33, 0
273			254, 1, 32, 34, 0
275			254, 1, 96, 34, 0
277			254, 1, 160, 34, 0

Byte 3 und 4 zu Word
zB 224, 32 zu Word = 8416 / 32 = 264

    Links das was rauskommen soll, wenn das rechts entschlüsselt wird.

    Ich brauche aber eine fixe Formel, mit der ich aus den 5 Bytes die linke Zahl errechnen kann...
    Wenn das schwer sein sollte und jemand sich Zeit nehmen kann, würde ich auch bezahlen.

    Manchmal muss man aus den letzten zwei Bytes ein Word machen und dieses dann durch das letzte Byte dividieren, manchmal geht das aber nicht...
    Ich verstehe es nicht 😞

    Danke!
    MfG

    0
  • ?

    Ich versuche mal was zur Lösung beizusteuern.

    Mir sind da ein paar Regelmäßigkeiten aufgefallen:

    Wenn rechts bei den fünf Bytes an dritter Stelle eine 0 steht, kann man aus dem vierten und fünften Byte ein Word machen und dieses durch das fünfte Byte teilen. Das Ergebnis ist die linke Zahl.

    Wenn an der dritten Stelle keine 0 steht, kann man aus dem dritten und vierten Byte ein Word machen und dieses durch das vierte Byte teilen. Das Ergebnis ist die linke Zahl.

    Das würde einen Großteil erklären. Bleiben würde nur noch das hier:

    263 192, 63, 0, 28, 4
    265 224, 31, 0, 18, 194
    267 192, 63, 0, 44, 4
    269 192, 63, 0, 52, 4
    271 192, 63, 0, 60, 4
    273 224, 31, 0, 34, 194

    Teils gar keine Ahnung...

    Bei Zeile 1, 3, 4 und 5 passt das, was ich unter 1) geschrieben habe. Nur was ist mit Zeile 2 und 6? Das fünfte Byte ist dreistellig (jeweils die Zahl 194). Was man damit machen muss, weiß ich nicht.

    Hoffe das hilft ein bisschen.

    MfG
    DerRatlose

    0
  • ?

    Anstelle es selbst zu entschlüsseln würde ich mal Google bemühen.
    (Fast) jedes Problem ist schon mal von irgend jemand anderen gelößt worden.

    0
  • C

    @DerRatlose
    Danke, aber das hab ich eigentlich selbst schon gesagt..

    @MisterX
    Nach was denn suchen? Das ist ein Client-Server Protokoll eines nicht allzu bekannten Computerspiels. Dazu finde ich garnix.

    MfG

    0
  • ?

    @ceplusplus@loggedoff:

    Kommen folgende Zahlen in etwa hin?

    123    224,31,0,246,0 
123    248,7,128,61,0

666    192,63,0,104,10
666    252,3,128,166,0

    Falls ja, dann enthalten die 5 Bytes eine Art "12-bit-Ringpuffer".

    Byte 1+2 geben einen Hinweis auf den "Bit"-Offset, ab wo die Zahl (12-bit!) entweder in Byte 3+4 oder in Byte 5+4 beginnt.

    0
  • C

    Hey!

    Das kann ich leider nicht sagen. Die ID's beginnen immer erst bei 263 und inkrementieren sich dann um meist 2, aber manchmal auch mehr...
    Ich habe mal mitgeloggt:

    (Links Uhrzeit ... unwichtig)

    Bytes:

    3:33:8 - 224, 31, 0, 14, 2, 
3:50:24 - 248, 7, 128, 132, 0, 
3:57:56 - 129, 127, 0, 96, 8, 
4:1:19 - 255, 0, 224, 16, 0, 
4:6:25 - 252, 3, 0, 68, 56, 
5:39:5 - 248, 7, 128, 137, 0, 
6:29:47 - 254, 1, 192, 34, 0, 
6:31:34 - 248, 7, 0, 140, 0, 
6:46:33 - 252, 3, 128, 70, 0, 
6:53:25 - 255, 0, 192, 17, 0, 
7:9:36 - 252, 3, 128, 71, 32, 
7:12:30 - 129, 127, 0, 0, 9, 
7:13:33 - 254, 1, 64, 36, 0, 
7:20:30 - 252, 3, 128, 73, 0, 
7:20:38 - 224, 31, 0, 78, 2, 
7:22:21 - 252, 3, 64, 74, 0, 
7:23:37 - 128, 127, 0, 88, 9, 
7:31:7 - 252, 3, 64, 75, 0, 
7:34:18 - 128, 127, 0, 120, 9, 
7:40:1 - 192, 63, 0, 196, 4, 
7:41:42 - 129, 127, 0, 152, 9, 
7:42:10 - 224, 31, 0, 106, 2, 
7:45:14 - 248, 7, 128, 155, 0, 
7:49:59 - 128, 127, 0, 200, 9, 
7:51:44 - 224, 31, 0, 122, 2, 
7:51:45 - 240, 15, 0, 63, 1, 
7:52:59 - 224, 31, 0, 128, 2, 
7:53:46 - 129, 127, 0, 16, 10, 
7:54:15 - 252, 3, 192, 80, 0, 
7:55:42 - 255, 0, 96, 20, 0, 
7:56:41 - 255, 0, 128, 20, 0, 
7:57:56 - 128, 127, 0, 80, 10, 
7:58:13 - 254, 1, 128, 41, 136, 
7:58:44 - 192, 63, 0, 60, 5, 
7:59:12 - 128, 127, 0, 128, 10, 
8:0:18 - 252, 3, 128, 84, 56,

    ID's

    3:33:12 - 263
3:50:29 - 265
3:57:59 - 268
4:1:24 - 270
4:6:31 - 272
5:39:12 - 275
6:29:53 - 278
6:31:41 - 280
6:46:37 - 282
6:53:31 - 284
7:9:41 - 286
7:12:35 - 288
7:13:36 - 290
7:20:37 - 294
7:20:42 - 295
7:22:25 - 297
7:23:43 - 299
7:31:14 - 301
7:34:24 - 303
7:40:8 - 305
7:41:49 - 307
7:42:12 - 309
7:45:19 - 311
7:50:0 - 313
7:51:50 - 319
7:51:50 - 317
7:53:2 - 320
7:53:50 - 322
7:54:18 - 323
7:55:48 - 326
7:56:49 - 328
7:58:0 - 330
7:58:20 - 332
7:58:50 - 335
7:59:18 - 336
8:0:25 - 338

    Sollte synchron sein, also immer gleiche Zeile.
    (Die ID's wurden immer erst paar Sekunden nach den empfangenen Bytes erfasst, ich kann nicht jede Millisekunde im Serverfenster abfragen... also user joined den server - sendet Bytes - Programm erfasst die daraus entstandene ID)
    Danke!
    MfG

    0
  • ?

    @ceplusplus@loggedoff:

    Guck Dir die bytes mal "binär" an:

    ---------------------------------------------------------
128,     127,     0,       88,      9,        bytes (dez)
10000000 01111111 00000000 01011000 00001001  bytes (bin)
                           hijkl     abcdefg  "index"-bezeichner
                                    10000000  byte 1  -> 128

299             id (dez)
abcd efghijkl   "index"-bezeichner
0001 00101011   id (bin) 12-bit
---------------------------------------------------------
255,     0,       224,     16,      0,        bytes (dez)
11111111 00000000 11100000 00010000 00000000  bytes (bin)
                  ijkl     abcdefgh           "index"-bezeichner
                  11111111                    byte 1  -> 255

270             id (dez)
abcd efghijkl   "index"-bezeichner
0001 00001110   id (bin) 12-bit
---------------------------------------------------------

    Darum vermute ich mal, daß

    -> die id eine 12-bit-Zahl ist,
    -> (12-bit, da einige Beispiele offenbar "binären" Speichermüll enthalten)
    -> die id, je nach byte 1,
    -> entweder in byte 4+5 oder
    -> in byte 5+4 "rotiert" drinsteckt.

    Die "Rotation" geht aus Byte 1 hervor.

    Probier mal folgendes:

    union {
  unsigned char  byte [2];
  unsigned short word;
 } rotate;

 unsigned char shift;
 unsigned char bytes [] = {
 192, 63, 0, 196, 4
 };

// 1. mitzählen wie oft byte 1 um 1 nach links geshiftet werden kann und 
//    eine 1 dabei herausgeshiftet wird :-)

 shift = 0;

 while (1) {
  if ( (bytes [0] & 0x80) == 0 ) {
   break;
  }
  shift     = shift + 1;
  bytes [0] = bytes [0] << 1;
 }

// 2. je nach shift (1..8) entweder byte 3+4 oder byte 5+4 ins union setzen

 switch (shift) {
  case 1 :
  case 2 :
  case 3 :
  case 4 : {
   rotate.byte [1] = bytes [4];  // byte 5           // 10000000 - 11110000
   rotate.byte [0] = bytes [3];  // byte 4
   break;
  }
  case 5 :
  case 6 :
  case 7 :
  case 8 : {
   rotate.byte [1] = bytes [2];  // byte 3           // 11111000 - 11111111
   rotate.byte [0] = bytes [3];  // byte 4
   break;
  }

 }

// 3. beide bytes als "word" um anzahl shift nach links "rotieren" lassen

 rotate.word = (rotate.word >> (16-shift)) | (rotate.word << shift);

// 4. anschließend noch rotate.word um 4 nach rechts shiften
//    rotate.word -> id (12-bit)

 rotate.word = rotate.word >> 4;

    Viel Glück! 😋

    0
  • C

    Hey!

    Danke für deine Mühe! Du hast es anscheinend fast geschafft, leider passen ein paar ID's nicht. Ich hab mal den ganzen Tag geloggt:

    8:23:34 - 514 - 224, 31, 0, 4, 196
8:24:17 - 516 - 240, 15, 0, 4, 2
[b]8:27:16 - 8 - 248, 7, 0, 4, 1[/b]
8:27:44 - 521 - 224, 31, 0, 18, 4
8:30:50 - 526 - 192, 63, 0, 56, 8
8:30:56 - 527 - 224, 31, 0, 30, 4
[b]8:31:28 - 16 - 248, 7, 0, 8, 1[/b]
8:32:23 - 531 - 255, 0, 48, 33, 0
[b]8:32:24 - 20 - 248, 7, 0, 10, 1[/b]
8:35:7 - 536 - 255, 0, 128, 33, 0
8:35:31 - 537 - 252, 3, 64, 134, 0

    8:39:41 - 550 - 224, 31, 0, 76, 4
[b]8:40:42 - 40 - 248, 7, 0, 20, 1
8:41:33 - 43 - 248, 7, 128, 21, 1
8:41:44 - 45 - 248, 7, 128, 22, 1
8:42:8 - 47 - 248, 7, 128, 23, 1[/b]
8:43:58 - 564 - 129, 127, 0, 160, 17
8:46:0 - 566 - 240, 15, 0, 54, 2
8:46:18 - 568 - 240, 15, 0, 56, 2
[b]8:47:13 - 59 - 248, 7, 128, 29, 1[/b]
8:48:46 - 577 - 192, 63, 0, 4, 9
[b]8:49:20 - 71 - 248, 7, 128, 35, 1[/b]
8:49:26 - 584 - 254, 1, 0, 73, 0
8:53:15 - 587 - 128, 127, 0, 88, 18

    8:53:17 - 589 - 254, 1, 160, 73, 0
8:53:18 - 590 - 254, 1, 192, 73, 0
[b]8:53:20 - 79 - 248, 7, 128, 39, 1
8:53:20 - 80 - 248, 7, 0, 40, 1[/b]
8:53:21 - 593 - 254, 1, 32, 74, 0
8:53:24 - 594 - 255, 0, 32, 37, 14

    8:53:41 - 603 - 192, 63, 0, 108, 9
8:54:0 - 605 - 129, 127, 0, 232, 18
[b]8:54:22 - 94 - 248, 7, 0, 47, 1
8:54:44 - 95 - 248, 7, 128, 47, 1[/b]
8:55:33 - 610 - 254, 1, 64, 76, 0
8:55:38 - 611 - 255, 0, 48, 38, 0

    9:3:2 - 629 - 224, 31, 0, 234, 4
9:4:47 - 631 - 192, 63, 0, 220, 137
[b]9:5:48 - 122 - 248, 7, 0, 61, 81[/b]
9:6:12 - 635 - 224, 31, 0, 246, 4
[b]9:7:7 - 125 - 248, 7, 128, 62, 81[/b]
9:9:14 - 639 - 192, 63, 0, 252, 9
9:9:55 - 642 - 224, 31, 0, 4, 5

    Beginnen aber nicht alle mit "248, 7". Ganz unten im log zB.:

    2:40:55 - 1092 - 240, 15, 0, 68, 4
2:41:9 - 1093 - 240, 15, 0, 69, 68
[b]2:45:30 - 73 - 252, 3, 64, 18, 113[/b]
2:45:47 - 1099 - 129, 127, 0, 88, 34
2:46:13 - 1101 - 192, 63, 0, 52, 17

    Insgesamt sind es sehr viele ID's. Anbei der gesamte log.
    Man erkennt eigentlich leicht, welche ID's nicht stimmen und wie sie in etwa sein sollten. Aber Achtung, ab 2048 beginnen die ID's wieder von vorne, aber dann bei weniger als 263, also zB. bei 5. Das ist schon richtig so.

    http://rhonkar.kilu.de/collectedData.txt

    (Leider fehlt mir die Erfahrung um das Problem nun selbst zu lösen. Ich würde wohl einiges an Einarbeitungszeit benötigen, die ich derzeit nicht habe. Aber deine Erklärung hab ich mir schon abgespeichert ;))

    Danke nochmals!
    MfG

    0
  • S

    sagt mal... schlaft ihr eigentlich? 😃

    0
  • ?

    @sothis_:
    *grins* Dann guck mal in die verlinkte Logdatei. Da sind auch Uhrzeiten mit bei. 😃

    @ceplusplus@loggedoff:
    Auweiha! Das "Rotate" war falsch!

    Im Prinzip muß man nur 4 der 5 bytes in eine andere Reihenfolge bringen. Danach entsprechend byte 2 ein union hin-und hershiften :

    -----------------------------------------------------------------
271             id (dez)
abcd efghijkl   "index"-bezeichner
0001 00001111   id (bin) 12-bit

128,     127,     0,       120,     8           bytes (dez)
1        2        3        4        5           byte nr.
10000000 01111111 00000000 01111000 00001000    bytes (bin)
                           hijkl     abcdefg   "index"-bezeichner
                                    10000000    byte 1 -> 128

5        4        3        2                    byte nr.
00001000 01111000 00000000 01111111             bytes (bin)
 abcdefg hijkl                                 "index"-bezeichner
10000000                                        byte 1 -> 128

-----------------------------------------------------------------
271          
abcd efghijkl
0001 00001111

252,     3,       192,     67,      224 
1        2        3        4        5
11111100 00000011 11000000 01000011 11100000 
                  kl       cdefghij       ab
                                    11111100
5        4        3        2
11100000 01000011 11000000 00000011 (byte 5 enthält speichermüll)
      ab cdefghij kl
11111100
-----------------------------------------------------------------
1475
abcd efghijkl
0101 11000011

240,     15,      0,       195,     5
1        2        3        4        5
11110000 00001111 00000000 11000011 00000101
                           efghijkl     abcd
                                    11110000
5        4        3        2
00000101 11000011 00000000 00001111
    abcd efghijkl
11110000
-----------------------------------------------------------------

    So könnte es nun aussehen:

    //--------------------------------------------------
 union {
  unsigned char  byte [4];
  unsigned short word [2];
  unsigned int  dword;
 } shift;
//--------------------------------------------------
 unsigned char bytes  [] = {
254, 1, 32, 39, 0
 };
//--------------------------------------------------
 shift.byte [3] = bytes [4]; // byteorder :-(
 shift.byte [2] = bytes [3];
 shift.byte [1] = bytes [2];
 shift.byte [0] = bytes [1];
//--------------------------------------------------
 while (1) {
  if ( (shift.dword & 1) == 0) {
   break;
  }
  shift.dword = shift.dword >> 1;
 }
//--------------------------------------------------
 shift.byte [3] = 0; // achtung! kann speichermüll enthalten!
//--------------------------------------------------
 shift.dword =  shift.dword << 4;
// id -> shift.word [1]

    Weiterhin viel Glück! 😋

    0
  • C

    Hey!

    Bin dir sehr dankbar, es funktioniert nun. 👍
    Danke auch wieder für die Erklärung.

    @sothis_
    Unregelmäßig 😕

    MfG

    0
Anmelden zum Antworten