4. Chat-Protokoll entschlüsseln

Chat-Protokoll entschlüsseln

  • 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
  • C

    Hey @amateurknacker, bist du noch da?

    Leider muss der Algo noch überarbeitet werden. Es sind weitere Daten bekannt. Die bisjetzigen Daten waren von "Normalen Spielern" im Server. Jedoch gibt es da noch die "Spectators", dessen Daten sich doch sehr unterscheiden, zB:

    // NORMAL
unsigned char normal11[] = { 248, 7, 128, 131, 0 }; // 263
unsigned char normal12[] = { 248, 7, 128, 233, 3 }; // 2003
unsigned char normal13[] = { 248, 7, 128, 3, 0 }; // 7
unsigned char normal14[] = { 248, 7, 128, 49, 0 }; // 99
unsigned char normal15[] = { 248, 7, 0, 0, 1 }; // 512

// NORMAL - OTHER COMPUTER
unsigned char normal16[] = { 224, 31, 0, 14, 2 }; // 263
unsigned char normal17[] = { 224, 31, 0, 166, 15 }; // 2003
unsigned char normal18[] = { 224, 31, 0, 14, 0 }; // 7
unsigned char normal19[] = { 224, 31, 0, 198, 0 }; // 99
unsigned char normal20[] = { 240, 15, 0, 0, 194 }; // 512

// SPECTATOR
unsigned char spectator11[] = { 0, 0, 128, 131, 0 }; // 263
unsigned char spectator12[] = { 0, 0, 128, 233, 3 }; // 2003
unsigned char spectator13[] = { 0, 0, 128, 3, 0 }; // 7
unsigned char spectator14[] = { 0, 0, 128, 49, 0 }; // 99
unsigned char spectator15[] = { 0, 0, 0, 0, 1 }; // 512

// SPECTATOR - OTHER COMPUTER
unsigned char spectator16[] = { 0, 0, 0, 14, 2 }; // 263
unsigned char spectator17[] = { 0, 0, 0, 166, 15 }; // 2003
unsigned char spectator18[] = { 0, 0, 0, 14, 0 }; // 7
unsigned char spectator19[] = { 0, 0, 0, 198, 0 }; // 99
unsigned char spectator20[] = { 0, 0, 0, 0, 4 }; // 512

    Dies sind die Daten, daneben die ID die rauskommen muss.
    Habe selbst schon einiges probiert, aber ich komme nicht dahinter wie man die Spectator-Daten umwandelt, da teils so viele Bytes 0 sind dass ich keinen Anhaltspunkt finde...

    Achja: Ich habe jetzt die Möglichkeit, die Daten von ganz bestimmen ID's von 5 bis 2047 zu bekommen. Sowohl für Spieler als auch für Spectators.

    Danke jedenfalls!
    MfG

    //EDIT:
    So hab ich es versucht:

    unsigned long ConvertPlayerID(const unsigned char* data, unsigned long dataSize)
{
	unsigned long dword = MAKELONG(MAKEWORD(data[dataSize - 4], data[dataSize - 3]), MAKEWORD(data[dataSize - 2], data[dataSize - 1]));

	// Normal ID's
	if(data[dataSize - 5])
	{
		while(dword & 1)
			dword = dword >> 1;

		dword &= 0xFFFFFF;
		dword = dword << 4;
	}
	// Spectator ID's
	else
	{
		// NOT WORKING WELL
		if(HIWORD(dword) & 1)
			dword = dword << 1;
		else
			dword = dword >> 1;
	}

	return HIWORD(dword);
}

    spectator15 und spectator20 sind aber problematisch, 1 und 4... ich weiß nimmer weiter.

    0
  • ?

    Da das erste und das zweite Byte der "SPECTATOR"s null ist, kann man deren ID nicht eindeutig bestimmen. Irgendwie fehlt eine Information.

    Woher weißt Du, daß "{ 0, 0, 128, 233, 3 }" die ID eises "SPECTATOR"s ist (sein muß)?

    0
  • C

    Hey!

    Weil ich es nachspiele. Mache nen Server auf, joine ihn selbst, logge dabei die DirectPlay-Daten die am Server ankommen.
    Die message mit den 5 bytes als spectator ist viel kürzer, und anscheinend kann man auch einfach das erste byte hernehmen, wenn es 0 ist, ist es ein spectator...

    Es gibt da noch eine message die unmittelbar vor der Eigentlichen ankommt, mit zwei bytes die sich ständig ändern, aber ich konnte darin keinen Zusammenhang erkennen... mit den normalen Spieler-ID's ging's ja auch ohne...

    Hab trotzdem weitere Daten zusammengetragen, in Form von:

    Resultierende ID: 5
    Die zwei Bytes: 208, 6
    Die bekannten 5 Bytes: 255, 0, 80, 0, 0,

    Von 3 unterschiedlichen PC's, als normaler Spieler und als Spectator:

    http://rhonkar.kilu.de/normalpc1.txt
    http://rhonkar.kilu.de/normalpc2.txt
    http://rhonkar.kilu.de/normalpc3.txt

    http://rhonkar.kilu.de/spectatorpc1.txt
    http://rhonkar.kilu.de/spectatorpc2.txt
    http://rhonkar.kilu.de/spectatorpc3.txt

    Mehr zusammenhängende Daten scheint es einfach nicht zu geben...

    Danke!
    MfG

    0
Anmelden zum Antworten