Op maandag 04 maart 2002 18:20 schreef Otis het volgende:
Allemaal leuk, maar WAT doen ze met die nummers? Het probleem is nl. niet of de encryptie goed genoeg is, maar of men via slinkse wijze niet op die bak kan komen en zo de encryptie te omzeilen.
Doet me denken aan de meest fantastische copy protection schema's waarbij in de code ergens staat:
code:
1
2
3
4
5
6
| bool bResult = CheckCopyProtection();
if(!bResult)
{
// copy. abort
} |
waarbij men niet het complete copy protection schema gaat kraken, maar botweg de test uitcomment (ik heb het even in C geplaatst hierboven, maar dat 'uitcommenten' doe je natuurlijk dan in een disassembly door NOPs erovereen te plakken) met NOPs.
NOP: 0x90 ;-)
Dat is waar, maar niet remote-exploitable. Wat hier staat is nog geen encryptie. De sleutels zijn doorgaans niet het probleem, de encryptie is dat wel! Het eenvoudigweg x-orren is vaak voldoende, maar als dit op meer documenten wordt toegepast, kun je met statistieken en 'know-text', zonder de sleutel de boel decoderen.
Veel encryptiemethoden hebben deze zwakheden niet meer, omdat er meer wordt gedaan dan xor. Denk aan xor met de encryptie-serie én met de vorige byte, dit stuurt de meeste statistische methoden het riet in...
Op maandag 04 maart 2002 18:20 schreef Otis het volgende:
Een volledige random reeks getallen is overigens erg moeilijk te genereren, want je seeds zijn zelden random. Echter je kunt dmv het combineren van een aantal bijna random seeds (electronenstraal positie monitor, clock pulses since boot, etc) een seed genereren die vrijwel volmaakt random is en daarmee een rijtje getallen genereren. In feite dus onmogelijk te raden wat het volgende getal wordt. Maar nogmaals; wat heb je aan de info als je weet wat het volgende getal wordt? Kun je dan meteen de handel decrypten of niet? Want dat is me niet duidelijk.
Random bestaat niet. punt.
Als je een dobbelsteen gooit, en je weet
alle omgevingsparameters (gewicht + vorm dobbelsteen, zwaartekracht, hoogte, structuur ondergrond, ...) dan kun je voorspellen wat je gaat gooien.
Gelukkig hebben we zelden échte random getallen nodig, onbegrijpelijke series zijn voldoende. Als we een bepaald proces niet tot in de puntjes begrijpen, levert dit voor mensen informatie op die enorm 'random' lijkt te zijn. Net als dat chinees voor mijn idee willekeurige klanken zijn. (NFI

)
Momenteel begrijpen we nog erg weinig van radioactief verval, daar kun je dus een serie op baseren. Direct gebruiken voor encrytie is niet erg handig, want voor encryptie moet je een bekende reeks hebben. (!)
Seed & Serie
Bij random getallen bestaan er twee belangrijke begrippen. Seed en Serie. De seed is een getal waar de serie op gebaseerd is. Hoe willekeuriger het getal, hoe willekeuriger de serie.
Stel: ik heb een formule om een serie te genereren:
code:
1
2
3
4
5
6
7
8
| f(x) -> (f(x-1) * 2) % 10
(% == modulus == rest na deling.)
De seed f(0) = 1
Mijn reeks wordt dan:
1 2 4 8 6 2 4 8 6 2 4 8 6 2 4 8 6
Een andere seed levert op:
3 6 2 4 8 6 2 4 8 6 2 4 8 6 2 4 8 |
Zoals je ziet is mijn reeks niet erg sterk.
Stel de volgende formules:
code:
1
2
3
| g(x) -> g(x-1) + 1
f(x) -> fix(g(x-1)/10 + g(x)) % 10
(fix betekent afkappen, ook wel INT genoemd) |
Zoals je willicht ziet is de reeks van g bij een seed 9 de volgende:
9 10 11 12 13 14 15 16 17 18 19 20 21
De echte reeks f is dan
? 1 2 3 4 5 6 7 8 9 0 1 3
Als de formule niet bekend is, is het een zeer moeilijk karwij om de formule te achterhalen. Maar: als je de formule weet, kun je al een stuk meer. Als je de waarde 3 krijgt, en je weet (toevallig) dat de seed niet zo groot was, dan weet je bijna zeker dat die gevolgd wordt door 4.
Als je echter de waarde 1 krijg, weet je niet of die gevolgd wordt door een 2 of door een 3.
Waar nu deze westrijd om gaat is om ZONDER de seed de formule (en zijn parameters) te achterhalen. Op zich is dat onzin. Die formule wordt een keer bekend. Het wordt dan de grap om de seed te vinden aan de hand van de gegeven getallen icm de formule. Als je dat kan, dan is het kraken van een beveiliging een eitje geworden.
Daadwerkelijke encrytie
Ik noemde al XOR als encryptiemethode. Die werkt als volgt:
code:
1
2
3
4
5
6
7
8
9
10
11
| -Coderen-
origineel: 00100100
code: 10010110 <- deze komt uit zo'n reeks
XOR----------------
resultaat: 10110010
-Decoderen:
ingekomen: 10110010
code: 10010110 <- uit dezelfde reeks!
XOR----------------
origineel: 00100100 |
het is er dus op gebaseerd dat beide partijen de 'code' kennen, de eerder genoemde reeks. Zonder die code kom je niet ver.
Nu is het erg veel werk om zo'n code in zijn geheel over te sturen, dus stuur je alleen de sleutel over: of beter nog, die stuur je helemaal niet over, want als een aftappende partij de sleutel ziet, kan hij de rest van de verbinding ook decoderen.
(ik sla hier nu een heel belanrijk deel over: public & private keys - Dat is denk ik de complex voor /14, en bovendien snap ik het niet goed genoeg om het hier uit te leggen. Als iemand het wel snapt: voel je vrij)
disclaimer 
Bij de bovenstaande formules is het kraken van de seed met brute-force een eitje. Het lijkt me niet verstandig om die écht toe te gaan passen. In Real Life wordt er echter gebruik gemaakt van veel grotere seeds (sleutels), die niet met brute force te kraken zijn.