4. Chat-Protokoll entschlüsseln

Chat-Protokoll entschlüsseln

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