Winzip Encryption Engine Reversing
 
Vi consiglio di lavorare tutti sulla stessa versione: WinZip Version 8.1 SR-1 (5266)
http://download.winzip.com/winzip81.exe
 
Ricominciamo con un corso abbastanza semplice... Stavolta analizzeremo WinZip... Cosa? Essi, proprio lui, ma stavolta nessuno andra' alla ricerca del seriale, studieremo in maniera piu' approfondita l'algoritmo di crittazione dei file che utilizza... Ma perche'? Per il semplice fatto che e' abbastanza debole, ma studiandolo negli ultimi due giorni mi sono reso conto che probabilmente e' possibile crackare l'algoritmo in pochissimo tempo a dispetto della pass utilizzata (e non parlo dei ben noti plain-text attack, ma di qualcosa che al momento ancora non e' ancora apparso, a quanto pare, agli occhi di nessuno) soltanto che non sono un crittografo e ho bisogno del vostro aiuto ;), cosi studieremo tutti quanti questo algoritmo e vedremo quali saranno le vostre idee a riguardo, per tutta la durata del corso non vi diro' nulla sulle mie supposizioni in modo da non viziare le vostre idee, cmq procediamo...
Devo fornirvi qualche piccola nota a riguardo... Vi consiglio innanzitutto di usare ida, raggiungere la routine e' molto semplice e anzi son curioso di vedere come procederete, poi un paio di cenni sull'algo: l'algoritmo che usa winzip e' molto simile a quello utilizzato dal pkzip, in realta' sono state fatte delle piccolissime modifiche che aumentano effettivamente la sicurezza anche se, a quanto pare... Aprono qualche falla. Le specifiche del pkzip sono liberamente accessibili e ci spiegano come decrittare un file ma non come crittarlo ;p, esaminiamo la routine di decrypt:
 
L'algoritmo utilizzato dal pkzip e' stato creato da: Roger Schlafly e critta il flusso di dati compresso (gia qui abbiamo una prima traccia), il signor Schlafly per complicare la vita a coloro che avrebbero voluto utilizzare gli attacchi di tipo plain-text ha ben pensato di anteporre ad ogni file crittato (seconda traccia) tre chiavi di 32-bit, e potete facilmente intuirne il motivo. Quindi sappiamo che ogni file crittato ha 12byte in testa (all'inizio dell'area dati) che possono essere suddivisi in tre chiavi, Key[0], Key[1], Key[2]. All'inizio le chiavi sono random (altra traccia ;p) e vengono crittate con tre chiavi costanti che prendono i loro valori dalla nostra password (traccia estremamente importante), a questo punto il file viene crittato e alla fine le chiavi vengono reinizializzate tramite una routine pseudo-random (molti zipper usano proprio rand(), Winzip ha un suo generatorino interno di numeri random) e il risultato viene modificato con un CRC-32 (che in winzip _dovrebbe_ essere uguale a quello di pkzip). Il documento della pkware dice che servono tre fasi per leggere un file crittato:

1. Inizializzare le tre chiavi di 32-bit con la password immessa
2. Leggere e decrittare i 12byte dell'encryption header e quindi reinizializzare le tre chiavi
3. Leggere e decrittare il flusso di dati compresso usando queste belle tre chiavi

La pkware gentilmente ci fornisce lo pseudocodice per tutte e tre le fasi (ho cambiato qualcosa per renderlo piu' chiaro), vediamo la prima:

Fase 1:
Key(0) = 0x12345678
Key(1) = 0x23456789
Key(2) = 0x34567890

for(i=0; i<length(password)-1; i++){
   update_keys(password(i))
}

Ecco la definzione di update_keys():

update_keys(char){
   Key(0) = crc32(key(0), char)
   Key(1) = Key(1) + (Key(0) & 0x000000FF)
   Key(1) = Key(1) * 134775813 + 1
   Key(2) = crc32(key(2), key(1) >> 24)
}

Il prototipo di crc32 e': crc32(old_crc, char);
Questa routine dato un CRC e un carattere, ritorna un nuovo CRC applicando un algo di CRC-32 che ora vi spiego perche' e' banalissimo:
questa bestia di algoritmo e' stata creata da David Schwaderer ;p e funziona in maniera davvero semplice, il magic value e' rappresentato dal numero: 0xdebb20e3, il registro utilizzato per il calcolo del CRC e' posto di default a -1 ovvero: 0xFFFFFFFF e viene aggiornato prendendo il complemento a uno del risultato del CRC. Ok e' finito, sono 10 righe di asm ma ve l'ho messo giusto per completezza.

Fase 2:
Questa fase e' stata introdotta per rendere piu' difficile il plaintext attack, vediamo cosa fa:

Leggi i 12byte dell'encryption header e mettili in:
char buffer[12] (i dati ovviamente partono a Buffer[0] e terminano a Buffer[11])

for(i=0; i<12; i++){
   char C = buffer[i] ^ decrypt_byte() // Ovviamente il simbolo ^ rappresenta lo XOR.
   update_keys(C)
   buffer(i) = C
}

Ecco la definizione di decrypt_byte():

unsigned char decrypt_byte(){
   local unsigned short temp
   temp = Key(2) | 2              // Il | e' l'OR
   decrypt_byte = ((temp * (temp ^ 1)) >> 8)    // Ihihihih
}

Dopo che l'header e' stato decrittato gli ultimi 1 o 2 byte di "buffer" sono il byte/word alti del CRC del file che stiamo decrittando. Dalla versione 2.0 di pkzip in poi viene usato un byte per il CRC invece di due, come invece accadeva nelle versioni precedenti e viene utilizzato per verificare se la password immessa e' esatta o meno (traccia).

Fase 3:
A questo punto il decrypting diventa banale:

loop until done{
   read a character into C
   Temp = C ^ decrypt_byte()
   update_keys(temp)
   output Temp
}

Ed ora vi chiederete: che dobbiamo fare? Aprite il Winzip, spiegate come arrivare alle routine, ovviamente trovate le tre routine e spiegate l'algoritmo che utilizza il WinZip, se avete voglia anche le sue differenze con quello di PKzip, una volta fatto questo proponete un metodo di attacco efficiente e dite se secondo voi l'algoritmo presenta delle falle, una c'e' di sicuro, poi a fine corso tutti assieme potremo tirare su un tool per sfruttarla, potete utilizzare la mailinglist per progredire nei vostri lavori e potete anche riunirvi in gruppo, buon divertimento. Ah, io ho impiegato due giorni (in pratica poche ore) per studiare il tutto, percio' un mese dovrebbe andar bene anche per i piu newbies vista la banalita' degli algoritmi utilizzati.


-=Quequero=-