Per ora esso sia appena una copia-colla diritta di un alberino che ho fatto sulle tribune di QJ (sarà aggiornato con più Info successivamente): Sì il blocco era abbastanza piccolo alla forza bruta (quindi perché non potreste firmare un intero EBOOT, devono la forza bruta l'intero affare).
La chiave riservata non bruteforced comunque (non quel importerebbe se fosse comunque, le procedure è ancora sconosciuto). Come gli impianti di decryption è questo, i dati in primo luogo sono cifrati ed allora i dati cifrati sono firmati. Una volta passati al motore crypto, in primo luogo controllano la firma e se è valido decifreranno i dati (procedure per entrambi il & di crittografia; la firma è sconosciuta, non quello che so di comunque, forse qualcuno sa… o non). I dati cifrati falsi bruteforced per decifrare nei vostri dati scelti (per potere sfruttare il preipl). E la firma per i vostri dati cifrati falsi bruteforced ancora per farlo sembrare validi secondo il motore crypto in modo che voglia vada avanti e decifri i vostri dati cifrati falsi. L'impresa del preipl funziona come questa: In primo luogo un blocchetto decifrato di ipl: 0×00: indirizzo del carico 0×04: formato di dati 0×08: indirizzo dell'entrata 0×0C: totale di controllo del blocco precedente 0×10: dati Un esempio tipico ha potuto essere
0×040F1EA0
0×00000F50
0×00000000
0xB71C6EBA
… dati…
Quale significa i dati del carico 0xF50-byte a 0×040F1EA0. 0xB71C6EBA è il totale di controllo del blocco precedente. Allora l'indirizzo dell'entrata è 0 poiché non ha raggiunto l'estremità tuttavia e ci sono più blocchi da caricare. Una volta che ha caricato il tutto il ipl ostruisce il blocco ultimo avrà indirizzo dell'entrata di dove l'intero ipl è stato caricato (tipicamente 0×040F0000). Ed allora salterà a quell'indirizzo. Pseudocode di Preipl per il & di caricamento;
decifrare il ipl:
1.
int iplBlockNumber = 0;
2.
u32 checksum = 0;
3.
4.
// load/decrypt all encrypted ipl blocks
5.
while(1)
6.
{
7.
// copy an encrypted ipl block to 0xBFD00000-0xBFD01000 (4KB embedded cpu ram)
8.
if (LoadIplBlock(iplBlockNumber, block) <0)
9.
while(1);
10.
11.
// decrypt the ipl block in place (uh oh…)
12.
if (DecryptIplBlock(block, block))
13.
while(1);
14.
15.
// first block will have zero as its checksum since there is no previous block (another uh oh…)
16.
if (block->checksum != checksum)
17.
while(1);
18.
19.
// load the ‘data’ section of the ipl block to the specified address (0×040Fxxxx range)
20.
if (block->loadaddr)
21.
checksum = memcpy(block->loadaddr, block->data, block->blocksize);
22.
23.
// reached the end of the ipl, jump to the entry address (0×040F0000)
24.
if (block->entry)
25.
{
26.
// clear caches
27.
Dcache();
28.
Icache();
29.
30.
// jump to ipl – do not return
31.
block->entry();
32.
}
33.
34.
iplBlockNumber++;
35.
}
Mentre il preipl carica il primo blocchetto di ipl (quello falso), decifra il blocco sul posto, IE. il blocco decifrato scrive sopra appena il vostro blocco cifrato. I decrypts falsi del blocco soltanto in quattro byte di esso di tutto e 0 le così conclude in su soltanto la sovrascrittura dei primi quattro byte del vostro blocco falso (con quattro 0) dopo il decryption.
Il blocco firmato falsificato:
1.
00000000: 00 00 00 00 00 00 00 00 00 01 D0 BF 00 00 00 00
2.
00000010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
3.
00000020: 52 A1 05 CD 3A 52 59 28 0A D1 31 F1 BD 87 2E CC
4.
00000030: 14 DA 02 2F 77 88 C7 66 F3 32 07 BD 1A 08 9E 4C
5.
00000040: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
6.
00000050: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
7.
00000060: 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
8.
00000070: 04 00 00 00 10 00 00 00 00 00 00 00 00 00 00 00
9.
00000080: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
10.
00000090: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
11.
000000A0: 00 00 00 00 00 00 00 00 00 00 00 01 C6 5F 74 12
La maggior parte della parte importante alla nota: 0×20-0×3F è le firme bruteforced del hash 0xA0-0xAF è i dati cifrati bruteforced 0×70-0×73 è il formato dei dati decifrati (soltanto 4 byte) Un leggero difetto nel motore crypto ha permesso che la forza bruta fosse effettuata sull'grandezza-tempi su scala ridotta che richiesto normalmente. Dopo decryption, il preipl pensa che i dati ora siano un blocchetto decifrato di ipl. Così noti i primi byte 0×10: 0×00000000 (indirizzo del carico che è stato simulato a quattro 0 una volta decifrato) 0×00000000 (formato del blocco al carico, nessuno) 0xBFD00100 (l'indirizzo dell'entrata, la maggior parte della parte importante, dove il vostro codice senza firma è individuato) 0×00000000 (totale di controllo) Supera la prova di totale di controllo (con 0×00000000), esso salta il caricamento di tutti i dati (poiché il loadaddr è stato simulato a 0×00000000), ha veduto l'indirizzo dell'entrata di 0xBFD00100 e pensa che abbia raggiunto la conclusione del ipl ed in modo da vada salti a quell'indirizzo (che è dove il vostro codice senza firma sarà). In modo che sia essenzialmente in breve. Ma non lasci un sommario rapido di 5 min. del underestimate che di impresa lo sforzo enorme ha coinvolto nel portarlo a compimento (come i prodotti finiti conosciuti come Pandora).
Traduttore: babelfish
Nessun commento:
Posta un commento