[System32]

Ciao ragazzi,
con sommo piacere sono riuscito a reversare i vari algoritmi lato client, quelli del pacchetto di autenticazione e selezione server/canali, per intenderci.

encrypt:

Codice:

0051ED03      8BF8             MOV EDI,EAX
0051ED05      85FF             TEST EDI,EDI
0051EC0F      7E 22            JLE SHORT nostalex.0051EC33
0051EC11      BE 01000000      MOV ESI,1
0051EC16      8D45 FC          LEA EAX,DWORD PTR SS:[EBP-4]
0051EC19      E8 8A65EEFF      CALL nostalex.004051A8
0051EC1E      8B55 FC          MOV EDX,DWORD PTR SS:[EBP-4]
0051EC21      8A5432 FF        MOV DL,BYTE PTR DS:[EDX+ESI-1]
0051EC25      80F2 C3          XOR DL,0C3
0051EC28      80C2 0F          ADD DL,0F
0051EC2B      885430 FF        MOV BYTE PTR DS:[EAX+ESI-1],DL
0051EC2F      46               INC ESI
0051EC30      4F               DEC EDI
0051EC31     ^75 E3            JNZ SHORT nostalex.0051EC16

0051EC25 80F2 C3 XOR DL,0C3
0051EC28 80C2 0F ADD DL,0F

decrypt:

Codice:

0051F089   8B45 F8          MOV EAX,DWORD PTR SS:[EBP-8]
0051F08C   8A5C38 FF        MOV BL,BYTE PTR DS:[EAX+EDI-1]
0051F090   80EB 0F          SUB BL,0F
0051F093   8B45 F4          MOV EAX,DWORD PTR SS:[EBP-C]
0051F096   FF00             INC DWORD PTR DS:[EAX]
0051F098   80FB 0A          CMP BL,0A
0051F09B   74 19            JE SHORT nostalex.0051F0B6
0051F09D   8D45 EC          LEA EAX,DWORD PTR SS:[EBP-14]
0051F0A0   8BD3             MOV EDX,EBX
0051F0A2   E8 C15DEEFF      CALL nostalex.00404E68
0051F0A7   8B55 EC          MOV EDX,DWORD PTR SS:[EBP-14]
0051F0AA   8D45 F0          LEA EAX,DWORD PTR SS:[EBP-10]
0051F0AD   E8 A65EEEFF      CALL nostalex.00404F58
0051F0B2   47               INC EDI
0051F0B3   4E               DEC ESI
0051F0B4  ^75 D3            JNZ SHORT nostalex.0051F089

0051F090 80EB 0F SUB BL,0F

hash attuale, lo potete trovare all'address 0051F5D8:

Codice:

FCCCDAA0C5C0BE133D7A028C82938FC3905D4F7F68D3C3EE632B855343106CA5

l'algoritmo di generazione è alquanto imbarazzante, MD5(NostaleX.dat) + MD5(Nostale.dat)

ultimo parametro del pacchetto:

MD5(HASH + ID)

algoritmo password:

non mi è ancora ben chiara la logica della password,
premetto che non ho esaminato via debugger.

password: test
password criptata: 37673426E527A31774
password in hex: 74657374

da quanto ho capito la password viene segmentata a blocco di 4, partendo dalla fine, ed il primo, iniziale, viene scartato.

37 6734 26E5 27A3 1774
di conseguenza: 673426E527A31774

6 7 3 4 2 6 E 5 2 7 A 3 1 7 7 4

come viene generato il blocco iniziale ? 37 per intenderci.
da che schermata dipendono i byte secondari ? 6 3 2 E 2 A 1 7 per intenderci.
un array statico oppure dipendenti dal primo ?
qualcuno ne è a conoscenza ?
o me la devo sbrigare io ?

Ciao !

[roxas9797]

buonritorno d3v1l

thx per gli algoritmi <3

[System32]

Cosa centra ora d3v1l ? non lo conosco personalmente ammesso sia una persona, animale o cosa.
La discussione contiene una domanda in rosso, non era una release ma una richiesta di aiuto.

Ciao !

[roxas9797]

D: oook
se non ricordo male
se la password è formata da un totale di caratteri pari, vengono generati 3 "numeri/lettere" a caso
se la password è formata da un totale di caratteri dispari, vengono generati 4 "numeri/lettere" a caso.
password: test (pari)
password criptata: 376[casuali] 73426E527A31774
73426E527A31774 = password in hex + "letteri e numeri a caso"

[~Giorigo1~]

roxas ti sbagli pienamente..
Incomincio innanzitutto con il dire che quelle lettere non sono generate a random, bensì sono estratte
casualmente da una tabella con byte precisi.
Successivamente il fatto del pari/dispari se ricordo bene è la soluzione di trollface, ma da come ho potuto vedere la password viene semplicemente divisa in segmenti da 4 come detto su. Il pari ed il dispari non centrano proprio, a volte è di due, a volte di tre. Poi dico che anche l'algoritmo da te elencato è sbagliato , esso procede in questa maniera : C'è un ciclo il quale preleva ogni volta un byte della password proseguendo per ordine, lo converte in esadecimale, ed estrae un bytes casualmente dalla tabella, lo affianca all'hex del byte della password, ed inverte il secondo ed il terzo byte. Esempio, abbiamo la password "test", si avvia il ciclo. preleva il primo byte, 't', prende il suo ascii e lo converte in HEX.(in questo caso l'hex è : 74 se ricordo bene). A questo punto estra un byte casualmente dall'array prendiamo caso sia 24 e lo affianca a 74 in questa maniera : 2474, poi inverte il 2 ed il 3 byte cosi : 2744. Ecco criptato il primo carattere della password Per rispondere alla domanda se la prima parte della password è dipendente dagli altri segmenti da 4, credo sia estratta anch'essa dalla tabella, quindi non dipendente, saluti ^^. System32 spero di averti schiarito i dubbi riguardo la password, se vuoi vedere tu stesso l'algoritmo assembly va da : 0051F71E a : 0051F7B3.
Aggiungo inoltre che non penso sia D3V!L, ha detto che aveva abbandonato questa roba e perlopiù mi ha anche aggiunto su skype.

[System32]

@~Giorigo1~ Inanzi tutto ti ringrazio per la risposta alquanto dettagliata.
Si è a conoscenza di questa tabella ? Se si, potresti farmela presente ?

Penso comunque che ci darò un occhiata personalmente,
preferisco stare sul sicuro.

Grazie ancora,
Ciao !

[~Giorigo1~]

System32 la sto cercando attualmente tra le call dell'algoritmo,
appena trovo tutti i bytes, aggiorno il seguente post con la tabella ^^

[roxas9797]

l'algoritmo della password di nostale non è complesso,

la password viene convertita in hex e poi confusa con lettere e numeri a caso..
se la password è composta da un numero dispari di caratteri all'inizio vengono inserite solo 3 cifre mentre
se la password è composta da un numero di caratteri pari vengono inserite 4 cifre.

esempio:

server = è composto da 6 caratteri = 6 è un numero pari = 4 cifre precedono la password convertita in hex.
prova = è composto da 5 caratteri = 5 è un numero dispari = 3 cifre procedono la password convertita in hex.

oltre a ciò tra ogni cifre/lettera della password viene inserito una lettera/cifra a caso..

esempio:

74657374 = parola test convertita in hex.
diventerà 7B43625673327E4 [i numeri in rosso li ho buttati a caso]..

quindi dato che test è composto da 4 cifre (4 = numero pari) il tutto diventerà:

10027B43625673327E4 [i numeri in rosso li ho buttati a caso]..

questa è tutta farina di d3v1l se ti interessa

è uguale alla mia ma più approfondita °° quindi controlla

[InfiniteCash]

@[System32] Confermo pienamente, non sei d3v!l in quanto devil e solo frutto del ingenio di una persona come shimox bin sei frutto per caso di quella stessa persona?

[~Giorigo1~]

Roxas, la mia risposta è completamente diversa dalla tua.. Rileggi bene, la mia è quella corretta non il vecchio algoritmo ipotizzato che è errato, ovvero quello elencato da te..
Cerco di essere un più schematico :
1.Quelle lettere/numeri non sono a caso, ma sono estratti da un array con bytes specifici.. Non è generato nulla casualmente.
2.L'algoritmo da te elencato è sbagliato.. oltre a fatto che i bytes non sono a caso ma non vengono inseriti semplicemente tra un byte e l'altro della password, ho scritto sopra l'algoritmo corretto, vengono affiancati 1 byte della password ed 1 byte estratto dall'array, e poi vengono invertiti il 2 ed il 3 byte.. Ho fatto anche l'esempio : 24(byte estratto)74(byte password) quindi
2474 è appena li affianca e poi dopo diventa 2744 poichè il 4 ed il 7 vengono scambiati di posto(il secondo byte ed il terzo byte vengono appunto invertiti) spero hai capito adesso.
3.Per quanto riguarda il pari e dispari, è un altro byte estratto dall'array, nulla di casuale.
Spero di essere stato chiaro ^^.

[roxas9797]

ah allora chiedo venia TT , so solo che ho facendo in quel modo riuscivo a leggere le password xD sorry

[System32]

(06-01-2014 05:41 PM)InfiniteCash Ha scritto:  @[System32] Confermo pienamente, non sei d3v!l in quanto devil e solo frutto del ingenio di una persona come shimox bin sei frutto per caso di quella stessa persona?

Mi dispiace ma tendo a non capire, se vuoi rispiegarmelo con calma non esitare a mandarmi un PM.

(05-01-2014 11:43 PM)~Giorigo1~ Ha scritto:  System32 la sto cercando attualmente tra le call dell'algoritmo,
appena trovo tutti i bytes, aggiorno il seguente post con la tabella ^^

Avendo 10 minuti a disposizione ho dato un occhiata all'algoritmo, nulla di approfondito, questo direi che basta a confermare la tua teoria.

Codice:

0051F736   8D4D A4          LEA ECX,DWORD PTR SS:[EBP-5C]
0051F739   8B45 F8          MOV EAX,DWORD PTR SS:[EBP-8]
0051F73C   0FB64418 FF      MOVZX EAX,BYTE PTR DS:[EAX+EBX-1]
0051F741   BA 02000000      MOV EDX,2
0051F746   E8 61C4EEFF      CALL nostalex.0040BBAC
0051F74B   8B45 A4          MOV EAX,DWORD PTR SS:[EBP-5C]
0051F74E   50               PUSH EAX
0051F74F   8D4D A0          LEA ECX,DWORD PTR SS:[EBP-60]
0051F752   8B04B5 D87C6600  MOV EAX,DWORD PTR DS:[ESI*4+667CD8]
0051F759   BA 02000000      MOV EDX,2
0051F75E   E8 49C4EEFF      CALL nostalex.0040BBAC
0051F763   8B55 A0          MOV EDX,DWORD PTR SS:[EBP-60]
0051F766   8D45 EC          LEA EAX,DWORD PTR SS:[EBP-14]
0051F769   59               POP ECX
0051F76A   E8 2D58EEFF      CALL nostalex.00404F9C
0051F76F   8B45 EC          MOV EAX,DWORD PTR SS:[EBP-14]
0051F772   8A40 01          MOV AL,BYTE PTR DS:[EAX+1]
0051F775   8845 E7          MOV BYTE PTR SS:[EBP-19],AL
0051F778   8D45 EC          LEA EAX,DWORD PTR SS:[EBP-14]
0051F77B   E8 285AEEFF      CALL nostalex.004051A8
0051F780   8B55 EC          MOV EDX,DWORD PTR SS:[EBP-14]
0051F783   8A52 02          MOV DL,BYTE PTR DS:[EDX+2]
0051F786   8850 01          MOV BYTE PTR DS:[EAX+1],DL
0051F789   8D45 EC          LEA EAX,DWORD PTR SS:[EBP-14]
0051F78C   E8 175AEEFF      CALL nostalex.004051A8
0051F791   8A55 E7          MOV DL,BYTE PTR SS:[EBP-19]
0051F794   8850 02          MOV BYTE PTR DS:[EAX+2],DL
0051F797   8D45 F0          LEA EAX,DWORD PTR SS:[EBP-10]
0051F79A   8B55 EC          MOV EDX,DWORD PTR SS:[EBP-14]
0051F79D   E8 B657EEFF      CALL nostalex.00404F58
0051F7A2   8D46 01          LEA EAX,DWORD PTR DS:[ESI+1]
0051F7A5   B9 17000000      MOV ECX,17
0051F7AA   99               CDQ
0051F7AB   F7F9             IDIV ECX
0051F7AD   8BF2             MOV ESI,EDX
0051F7AF   43               INC EBX
0051F7B0   FF4D DC          DEC DWORD PTR SS:[EBP-24]
0051F7B3  ^75 81            JNZ SHORT nostalex.0051F736

Riguardo i bytes ci darò un occhiata non appena ne avrò l'occasione, in caso ti informerò via PM con la relativa tabella o se sarà ancora aperta la discussione qua.

(06-01-2014 08:30 PM)roxas9797 Ha scritto:  ah allora chiedo venia TT , so solo che ho facendo in quel modo riuscivo a leggere le password xD sorry

Tranquillo, nulla di grave.
Casomai sei riuscito ad adattare la funzione per ottenere un risultato discreto/temporaneo ma sicuro che il pari/dispari sia applicabile in ogni caso ? da quanto ho visto, il blocco iniziale varia dai 2 ai 4 caratteri mentre la tua teoria si basa su 3 e 4.

Se riuscite a trovare qualcosa, prima di me ed ammesso che vi faccia piacere, postate pure.

Ciao !

[~Giorigo1~]

Ho rivisto la funzione, il pari / dispari credo proprio sia una cazzata..
A volte sono due, a volte tre ed a volte quattro i byte, credo sia estratto come il resto dalla tabella con i bytes ^^ Quindi system, il blocco iniziale, è estratto come il resto

[System32]

Si, è quello che ho detto io nel post precedente.

Ecco la tabella promessa:
2E, 2A, 17, 4F, 20, 24, 47, 11, 5B, 37, 53, 43, 15, 34, 45, 25, 4B, 1D, 2F, 58, 2B, 32, 63

Direi che si può chiudere.
Ciao !

[~Giorigo1~]

Che dire, grazie per la tabella : mi hai risparmiato un bel po di lavoro anche perché ultimamente sto davvero poco al computer.. Un bel 1 per la tabella, segnalo chiusura

[Lord Freud]

Chiudo come da richiesta.