tegen brute aanval en woordenboek aanvallen.Met inbegrip van de bond, het wachtwoord van Delphi bron, sleutel en de vervanging van de sleutel.,,, [256 beetje sleutel encryptievorm.,,, ///////de source code op de bodem, een goed van cryptografische veiligheid afhankelijk is van de sleutel.Hoe groot het een sleutel is, als het niet goed gaat met de software, zal er een opgelegd te verminderen.De sleutel moet gebaseerd zijn op een maatregel bevat de entropie, en eenvoudige sleutel moet worden afgewezen.Ze moet bestaan uit een aantal verschillende rollen, en geen duidelijk patroon.Alleen als aan deze voorwaarden wordt voldaan, zal een van de belangrijkste door de woordenboeken en de brute aanval, een van de belangrijkste van de entropie van de hoeveelheid onvoorspelbaar zijn, en de gebruikers meestal gebruik, rekening houdend met de alfanumerieke tekens, je moet alleen met de minste stukjes kan duiden op de sleutel.Het gebruik van 8. Elk karakter van betekent dat er 256 verschillende karakters zijn beschikbaar.De dader weet alleen gebruik zal maken van gebruikers (62 tekens alfanumerieke tekens, 6) en niet voor andere 194 karakter te testen.Een praktische technologie, zal elk karakter (1 byte) 6 stukjes, en dan met elkaar verbonden.Je kan de kleine letters en cijfers en de vermindering van het karakter van elk 5bits (32 tekens).Is het van belang te eisen van de gebruiker meer gebruik van de codes van de grootte van de sleutel voor het bereiken van dezelfde.Dit zegt dat een 8 tekens niet moet worden beschouwd als een van de belangrijkste de 64 - bits, maar in feite 48bits (6 X 8 tekens).De sleutel van de lage entropie vormt een bedreiging van de veiligheid, hoe zorgvuldig ontworpen systeem van de rest van de ontwerp -,,, in één woord de sleutel van de encryptie systeem moet niet worden getolereerd.Zelfs als je de optimalisering van de entropie, in vijf tekens van kritische gegevens niet voldoende om tegen de sleutel in de brute aanval.Een 30bit belangrijke (6 X 5 letters) mogen alleen een waarschijnlijk een paar miljoen sleutels, het duurt maar een paar uur om op een krachtige computer.Ten minste 128 bit sleutel zouden gevoelig moeten zijn om ervoor te zorgen dat de vereiste gegevens; dat over een paar jaar geleden heeft een nieuwe en meer de sleutel.Dit betekent dat in de zes belangrijkste moet elk karakter is 22 karakters.Dit is misschien groot, maar niet tegen je zin.Als een voorbeeld van, laten we eens kijken naar een zin "lift" is het 25 karakters.De sleutel is 150 lang, maar het is nog steeds moeilijk te onthouden.Alle sleutels op deze manier behandeld worden.Geen reden om de gebruikers de sleutel van acht letters, ten koste van het hele systeem en een wachtwoord, een van de belangrijkste anti - algoritme zoeken die beter tegen, als het bevat vele verschillende karakters.Als de sleutel is een karakter, maar bevat 4 verschillende karakter, het is erg zwak.Simpel te houden, ten minste de helft van de karakters in een sleutel moeten zijn verschillende (22 karakter van de belangrijkste moeten ten minste elf verschillende tekens).Meer verschillende karakters in een van de belangrijkste statistische prognoses moeilijker om het volgende karakter.Hoewel deze aanval niet mogelijk is, is er geen ruimte voor fouten.Het voorkomen van alle bekende soorten aanvallen, en prognoses in de hand van de mazen in de wet is absoluut de meest belangrijke, hoe onbelangrijk lijken de risico 's.Risico 's zijn altijd een risico.Belangrijk is om de gebruiker heeft de meest verschillende rollen, ze kan je bij elke belangrijke, de berekening van de opbrengst van de resultaten, niet zoeken, de aanvaller. Liefde, ze de sleutel zoeken en z 'n leven gemakkelijker te maken.De gebruiker schijnt te denken dat de sleutel: "bingo" als veiliger dan: "bingo", maar in feite zijn ze gewoon een beetje beter.Wijs de aanvaller kennen alle trucs, ontwerp van de gebruikers, zodat ze de sleutels nog moeilijk om te raden.Met één woord twee keer moeten ontmoedigen.Onder normale omstandigheden aan het einde van de gebruiker van de sleutel nummer, zodat het niet kan worden voorspeld.Helaas is de tijd van 80% van het aantal en de andere 20% is 123, 321.De aanvaller voor het testen van deze extra sleutel, hij moet er ook een test 123 toegevoegd aan elke sleutel en 321.Dit betekent dat hij moet zoeken drie keer zoveel sleutels; dit vormt slechts een stijging van 1,5 drie tekens en 18bits worden verstrekt.Test - model kan een zeer complexe belemmeringen, en niet in dit verslag besproken.In een duidelijk patroon is verboden door de nadruk te leggen op de hasj zoals zand of Harvard is verstandig.Deze functie om de input van gegevens, en het creëren van een niet voor de inbreng van de betrekkingen, en elke mogelijke bijdrage slechts een output.De produktie van deze functie is schijnbaar willekeurige effectief een discrete wijze camouflage.,,, afschaffing van - de aanvaller, heel moeilijk, zwakke sleutels zoeken.,,,,,,, /* * * * * * * Noot: bron bellows in drie jaar is de vooruitgang op het gebied van een deel van de cummulating Bibliotheek.Het is een voorbeeld van, maar als je het wil gebruiken in de context van een procedure, een beetje krediet is goed, deze sleutel is optimalisering van routine en tien keer opnieuw te schrijven, ik probeer zo goed mogelijk te maken.De structuur van het programma ziet er vreemd uit, omdat ik het geschreven in de C + +.De generator van onbekende oorsprong, die tot Harvard in dcpcrypt 1.3 groep vond een ernstige] 戴维巴顿 wijziging van de haval.pas.Ik zal in de context van het programma niet in de verpakking in het milieu (multi - threaded concretisering van de server misschien?Beschrijving:,,,,, [mutatekey], door de uitbreiding, en - omgezet in een centraal.Zonder een sleutel voor de sleutel kan worden vastgesteld, maar de follow - up van alle sleutels.Dit is zeer nuttig de belangrijkste (zo is van de toenemende onzekerheid brute zoeken geen kortere weg) of een gesprek, dit kan het gebruik van meer dan één sessie.,,, [passwordtokey], zet de 64 kan de personages: "A - Z - Z -, 0" 9 "," _ "en" 256 beetje. "Voor de liet twee van elk karakter (64 tekens slechts zes bits elk karakter, in plaats van 256 bytes), en door gebruik te maken van mutatekey toegenomen entropie.,,, [ananlyzekey], controleer de sleutel van de entropie, door het zoeken naar patronen, moet elk karakter van de stukken, evaluatie 0 /1 (verdeling van de binaire), en een beëindiging van de beoordeling van de meting van de lengte van de belangrijkste kenmerken.,,, (een voorbeeld kan worden gevonden in de http://www.geocities.com/drmungkee/software/codebAse.html),,,, //******************* eenheid BEGINS hier ****************************************, te keyfunc;,,,,, type, een key256=array[0..7]of longword;,,,, Prng_CTX=record, r:array[1..97]of - x1, X2;,,,,, aan het einde van x3:longword;; TPrng_CTX=^Prng_CTX;,,,,,, Haval_CTX=record, lenhi, lenlo:longword;, Index:longword;,,,,, hash:array[0..7]of longword; hashbuffer:array[0..127]of byte;,,,,,,,,, KeyStatistics=record THaval_CTX=^Haval_CTX;,,,, KeyLength:longword; KeySize:longword;,,,,, CharCount:byte; CharBits:byte; Patterns: longword;,,,,, Differential:longword; BruteLength:longword;,,,,,,, Rating:longword; TKeyStatistics=^Ke.Ystatistics;,,, programma 's mutatekey (var: de sleutel tot key256);,, passwordtokey (door de functie van:...): key256;,, analyzepassword (door de functie van:...): keystatistics;,,,,, dat bit_mask:const - [0] = (7), 1,2,4,8,16,3264128);,, hash_size = 256 prngm1:,,,,, prngi1: = 259.200; = 7141;,, prngc1: = 54773;,, prngm2: = 134456;,, prngi2: = 8121;,, prngc2: = 28411;,, prngm3: = 243000;,, prngi3: = 4561 prngc3:;,,,,, 51349 =; //////////////*******************************************************************, Harvard,,, /, van de haval.pas, /戴维巴顿 (dcpcrypt 1,3 onderdeel) //////////////,,, * * * * * * * * * * * * * * * * * * * * *****************************************************************,,, procedure HavalCompress(ctx:THaval_CTX);,,, function rr32(x:longword;c:longint):longword;register;assembler;,, asm,, mov ecx,edx,, ror eax,cl,, end;,, procedure r1(var x7,x6,x5,x4,x3,x2,x1,x0:longword;const w:longword);,, var t:longword;,, begin,, t:=((x2)and((x6)xor(x1))xor(x5)and(x4)xor(x0)and(x3)xor(x6));,, x7:=rr32(t,7)+rr32(x7,11)+w;,, end;,, procedure r2(var x7,x6,x5,x4,x3,x2,x1,x0:longword;const w,c:longword);,, var t:longword;,, begin,, t:=(x3 and(x4 and(not x0)xor x1 and x2 xor x6 xor x5)xor x1 and(x4 xor x2),, xor x0 and x2 xor x5);,, x7:=rr32(t,7)+rr32(x7,11)+w+c;,, end;,, procedure r3(var x7,x6,x5,x4,x3,x2,x1,x0:longword;const w,c:longword);,, var t:longword;,, begin,, t:=((x4)and((x1)and(x3)xor(x2)xor(x5))xor(x1)and(x0)xor(x3)and(x6),, xor(x5));,, x7:=rr32(t,7)+rr32(x7,11)+w+c;,, end;,, procedure r4(var x7,x6,x5,x4,x3,x2,x1,x0:longword;const w,c:longword);,, var t:longword;,, begin,, t:=(x3 and(x5 and(not x0)xor x2 and(not x1)xor x4 xor x1 xor x6)xor x2,, and(x4 and x0 xor x5 xor x1)xor x0 and x1 xor x6);,, x7:=rr32(t,7)+rr32(x7,11)+w+c;,, end;,, procedure r5(var x7,x6,x5,x4,x3,x2,x1,x0:longword;const w,c:longword);,, var t:longword;,, begin,, t:=(x1 and(x3 and x4 and x6 xor(not x5))xor x3 and x0 xor x4 and x5,, xor x6 and x2);,, x7:=rr32(t,7)+rr32(x7,11)+w+c;,, end;,,, var t7,t6,t5,t4,t3,t2,t1,t0:longword;,, w:array[0..31] of longword;,, begin,, t0:=ctx.hash[0];,, t1:=ctx.hash[1];,, t2:=ctx.hash[2];,, t3:=ctx.hash[3];,, t4:=ctx.hash[4];,, t5:=ctx.hash[5];,, t6:=ctx.hash[6];,, t7:=ctx.hash[7];,, move(ctx.hashbuffer,w,sizeof(w));,, r1(t7,t6,t5,t4,t3,t2,t1,t0,w[ 0]);,, r1(t6,t5,t4,t3,t2,t1,t0,t7,w[ 1]);,, r1(t5,t4,t3,t2,t1,t0,t7,t6,w[ 2]);,, r1(t4,t3,t2,t1,t0,t7,t6,t5,w[ 3]);,, r1(t3,t2,t1,t0,t7,t6,t5,t4,w[ 4]);,, r1(t2,t1,t0,t7,t6,t5,t4,t3,w[ 5]);,, r1(t1,t0,t7,t6,t5,t4,t3,t2,w[ 6]);,, r1(t0,t7,t6,t5,t4,t3,t2,t1,w[ 7]);,, r1(t7,t6,t5,t4,t3,t2,t1,t0,w[ 8]);,, r1(t6,t5,t4,t3,t2,t1,t0,t7,w[ 9]);,, r1(t5,t4,t3,t2,t1,t0,t7,t6,w[10]);,, r1(t4,t3,t2,t1,t0,t7,t6,t5,w[11]);,, r1(t3,t2,t1,t0,t7,t6,t5,t4,w[12]);,, r1(t2,t1,t0,t7,t6,t5,t4,t3,w[13]);,, r1(t1,t0,t7,t6,t5,t4,t3,t2,w[14]);,, r1(t0,t7,t6,t5,t4,t3,t2,t1,w[15]);,, r1(t7,t6,t5,t4,t3,t2,t1,t0,w[16]);,, r1(t6,t5,t4,t3,t2,t1,t0,t7,w[17]);,, r1(t5,t4,t3,t2,t1,t0,t7,t6,w[18]);,, r1(t4,t3,t2,t1,t0,t7,t6,t5,w[19]);,, r1(t3,t2,t1,t0,t7,t6,t5,t4,w[20]);,, r1(t2,t1,t0,t7,t6,t5,t4,t3,w[21]);,, r1(t1,t0,t7,t6,t5,t4,t3,t2,w[22]);,, r1(t0,t7,t6,t5,t4,t3,t2,t1,w[23]);,, r1(t7,t6,t5,t4,t3,t2,t1,t0,w[24]);,, r1(t6,t5,t4,t3,t2,t1,t0,t7,w[25]);,, r1(t5,t4,t3,t2,t1,t0,t7,t6,w[26]);,, r1(t4,t3,t2,t1,t0,t7,t6,t5,w[27]);,, r1(t3,t2,t1,t0,t7,t6,t5,t4,w[28]);,, r1(t2,t1,t0,t7,t6,t5,t4,t3,w[29]);,, r1(t1,t0,t7,t6,t5,t4,t3,t2,w[30]);,, r1(t0,t7,t6,t5,t4,t3,t2,t1,w[31]);,, r2(t7,t6,t5,t4,t3,t2,t1,t0,w[ 5],$452821E6);,, r2(t6,t5,t4,t3,t2,t1,t0,t7,w[14],$38D01377);,, r2(t5,t4,t3,t2,t1,t0,t7,t6,w[26],$BE5466CF);,, r2(t4,t3,t2,t1,t0,t7,t6,t5,w[18],$34E90C6C);,, r2(t3,t2,t1,t0,t7,t6,t5,t4,w[11],$C0AC29B7);,, r2(t2,t1,t0,t7,t6,t5,t4,t3,w[28],$C97C50DD);,, r2(t1,t0,t7,t6,t5,t4,t3,t2,w[ 7],$3F84D5B5);,, r2(t0,t7,t6,t5,t4,t3,t2,t1,w[16],$B5470917);,, r2(t7,t6,t5,t4,t3,t2,t1,t0,w[ 0],$9216D5D9);,, r2(t6,t5,t4,t3,t2,t1,t0,t7,w[23],$8979FB1B);,, r2(t5,t4,t3,t2,t1,t0,t7,t6,w[20],$D1310BA6);,, r2(t4,t3,t2,t1,t0,t7,t6,t5,w[22],$98DFB5AC);,, r2(t3,t2,t1,t0,t7,t6,t5,t4,w[ 1],$2FFD72DB);,, r2(t2,t1,t0,t7,t6,t5,t4,t3,w[10],$D01ADFB7);,, r2(t1,t0,t7,t6,t5,t4,t3,t2,w[ 4],$B8E1AFED);,, r2(t0,t7,t6,t5,t4,t3,t2,t1,w[ 8],$6A267E96);,, r2(t7,t6,t5,t4,t3,t2,t1,t0,w[30],$BA7C9045);,, r2(t6,t5,t4,t3,t2,t1,t0,t7,w[ 3],$F12C7F99);,, r2(t5,t4,t3,t2,t1,t0,t7,t6,w[21],$24A19947);,, r2(t4,t3,t2,t1,t0,t7,t6,t5,w[ 9],$B3916CF7);,, r2(t3,t2,t1,t0,t7,t6,t5,t4,w[17],$0801F2E2);,, r2(t2,t1,t0,t7,t6,t5,t4,t3,w[24],$858EFC16);,, r2(t1,t0,t7,t6,t5,t4,t3,t2,w[29],$636920D8);,, r2(t0,t7,t6,t5,t4,t3,t2,t1,w[ 6],$71574E69);,, r2(t7,t6,t5,t4,t3,t2,t1,t0,w[19],$A458FEA3);,, r2(t6,t5,t4,t3,t2,t1,t0,t7,w[12],$F4933D7E);,, r2(t5,t4,t3,t2,t1,t0,t7,t6,w[15],$0D95748F);,, r2(t4,t3,t2,t1,t0,t7,t6,t5,w[13],$728EB658);,, r2(t3,t2,t1,t0,t7,t6,t5,t4,w[ 2],$718BCD58);,, r2(t2,t1,t0,t7,t6,t5,t4,t3,w[25],$82154AEE);,, r2(t1,t0,t7,t6,t5,t4,t3,t2,w[31],$7B54A41D);,, r2(t0,t7,t6,t5,t4,t3,t2,t1,w[27],$C25A59B5);,, r3(t7,t6,t5,t4,t3,t2,t1,t0,w[19],$9C30D539);,, r3(t6,t5,t4,t3,t2,t1,t0,t7,w[ 9],$2AF26013);,, r3(t5,t4,t3,t2,t1,t0,t7,t6,w[ 4],$C5D1B023);,, r3(t4,t3,t2,t1,t0,t7,t6,t5,w[20],$286085F0);,, r3(t3,t2,t1,t0,t7,t6,t5,t4,w[28],$CA417918);,, r3(t2,t1,t0,t7,t6,t5,t4,t3,w[17],$B8DB38EF);,, r3(t1,t0,t7,t6,t5,t4,t3,t2,w[ 8],$8E79DCB0);,, r3(t0,t7,t6,t5,t4,t3,t2,t1,w[22],$603A180E);,, r3(t7,t6,t5,t4,t3,t2,t1,t0,w[29],$6C9E0E8B);,, r3(t6,t5,t4,t3,t2,t1,t0,t7,w[14],$B01E8A3E);,, r3(t5,t4,t3,t2,t1,t0,t7,t6,w[25],$D71577C1);,, r3(t4,t3,t2,t1,t0,t7,t6,t5,w[12],$BD314B27);,, r3(t3,t2,t1,t0,t7,t6,t5,t4,w[24],$78AF2FDA);,, r3(t2,t1,t0,t7,t6,t5,t4,t3,w[30],$55605C60);,, r3(t1,t0,t7,t6,t5,t4,t3,t2,w[16],$E65525F3);,, r3(t0,t7,t6,t5,t4,t3,t2,t1,w[26],$AA55AB94);,, r3(t7,t6,t5,t4,t3,t2,t1,t0,w[31],$57489862);,, r3(t6,t5,t4,t3,t2,t1,t0,t7,w[15],$63E81440);,, r3(t5,t4,t3,t2,t1,t0,t7,t6,w[ 7],$55CA396A);,, r3(t4,t3,t2,t1,t0,t7,t6,t5,w[ 3],$2AAB10B6);,, r3(t3,t2,t1,t0,t7,t6,t5,t4,w[ 1],$B4CC5C34);,, r3(t2,t1,t0,t7,t6,t5,t4,t3,w[ 0],$1141E8CE);,, r3(t1,t0,t7,t6,t5,t4,t3,t2,w[18],$A15486AF);,, r3(t0,t7,t6,t5,t4,t3,t2,t1,w[27],$7C72E993);,, r3(t7,t6,t5,t4,t3,t2,t1,t0,w[13],$B3EE1411);,, r3(t6,t5,t4,t3,t2,t1,t0,t7,w[ 6],$636FBC2A);,, r3(t5,t4,t3,t2,t1,t0,t7,t6,w[21],$2BA9C55D);,, r3(t4,t3,t2,t1,t0,t7,t6,t5,w[10],$741831F6);,, r3(t3,t2,t1,t0,t7,t6,t5,t4,w[23],$CE5C3E16);,, r3(t2,t1,t0,t7,t6,t5,t4,t3,w[11],$9B87931E);,, r3(t1,t0,t7,t6,t5,t4,t3,t2,w[ 5],$AFD6BA33);, , , r3(t0,t7,t6,t5,t4,t3,t2,t1,w[ 2],$6C24CF5C);,, r4(t7,t6,t5,t4,t3,t2,t1,t0,w[24],$7A325381);,, r4(t6,t5,t4,t3,t2,t1,t0,t7,w[ 4],$28958677);,, r4(t5,t4,t3,t2,t1,t0,t7,t6,w[ 0],$3B8F4898);,, r4(t4,t3,t2,t1,t0,t7,t6,t5,w[14],$6B4BB9AF);,, r4(t3,t2,t1,t0,t7,t6,t5,t4,w[ 2],$C4BFE81B);,, r4(t2,t1,t0,t7,t6,t5,t4,t3,w[ 7],$66282193);,, r4(t1,t0,t7,t6,t5,t4,t3,t2,w[28],$61D809CC);,, r4(t0,t7,t6,t5,t4,t3,t2,t1,w[23],$FB21A991);,, r4(t7,t6,t5,t4,t3,t2,t1,t0,w[26],$487CAC60);,, r4(t6,t5,t4,t3,t2,t1,t0,t7,w[ 6],$5DEC8032);,, r4(t5,t4,t3,t2,t1,t0,t7,t6,w[30],$EF845D5D);,, r4(t4,t3,t2,t1,t0,t7,t6,t5,w[20],$E98575B1);,, r4(t3,t2,t1,t0,t7,t6,t5,t4,w[18],$DC262302);,, r4(t2,t1,t0,t7,t6,t5,t4,t3,w[25],$EB651B88);,, r4(t1,t0,t7,t6,t5,t4,t3,t2,w[19],$23893E81);,, r4(t0,t7,t6,t5,t4,t3,t2,t1,w[ 3],$D396ACC5);,, r4(t7,t6,t5,t4,t3,t2,t1,t0,w[22],$0F6D6FF3);,, r4(t6,t5,t4,t3,t2,t1,t0,t7,w[11],$83F44239);,, r4(t5,t4,t3,t2,t1,t0,t7,t6,w[31],$2E0B4482);,, r4(t4,t3,t2,t1,t0,t7,t6,t5,w[21],$A4842004);,, r4(t3,t2,t1,t0,t7,t6,t5,t4,w[ 8],$69C8F04A);,, r4(t2,t1,t0,t7,t6,t5,t4,t3,w[27],$9E1F9B5E);,, r4(t1,t0,t7,t6,t5,t4,t3,t2,w[12],$21C66842);,, r4(t0,t7,t6,t5,t4,t3,t2,t1,w[ 9],$F6E96C9A);,, r4(t7,t6,t5,t4,t3,t2,t1,t0,w[ 1],$670C9C61);,, r4(t6,t5,t4,t3,t2,t1,t0,t7,w[29],$ABD388F0);,, r4(t5,t4,t3,t2,t1,t0,t7,t6,w[ 5],$6A51A0D2);,, r4(t4,t3,t2,t1,t0,t7,t6,t5,w[15],$D8542F68);,, r4(t3,t2,t1,t0,t7,t6,t5,t4,w[17],$960FA728);,, r4(t2,t1,t0,t7,t6,t5,t4,t3,w[10],$AB5133A3);,, r4(t1,t0,t7,t6,t5,t4,t3,t2,w[16],$6EEF0B6C);,, r4(t0,t7,t6,t5,t4,t3,t2,t1,w[13],$137A3BE4);,, r5(t7,t6,t5,t4,t3,t2,t1,t0,w[27],$BA3BF050);,, r5(t6,t5,t4,t3,t2,t1,t0,t7,w[ 3],$7EFB2A98);,, r5(t5,t4,t3,t2,t1,t0,t7,t6,w[21],$A1F1651D);,, r5(t4,t3,t2,t1,t0,t7,t6,t5,w[26],$39AF0176);,, r5(t3,t2,t1,t0,t7,t6,t5,t4,w[17],$66CA593E);,, r5(t2,t1,t0,t7,t6,t5,t4,t3,w[11],$82430E88);,, r5(t1,t0,t7,t6,t5,t4,t3,t2,w[20],$8CEE8619);,, r5(t0,t7,t6,t5,t4,t3,t2,t1,w[29],$456F9FB4);,, r5(t7,t6,t5,t4,t3,t2,t1,t0,w[19],$7D84A5C3);,, r5(t6,t5,t4,t3,t2,t1,t0,t7,w[ 0],$3B8B5EBE);,, r5(t5,t4,t3,t2,t1,t0,t7,t6,w[12],$E06F75D8);,, r5(t4,t3,t2,t1,t0,t7,t6,t5,w[ 7],$85C12073);,, r5(t3,t2,t1,t0,t7,t6,t5,t4,w[13],$401A449F);,, r5(t2,t1,t0,t7,t6,t5,t4,t3,w[ 8],$56C16AA6);,, r5(t1,t0,t7,t6,t5,t4,t3,t2,w[31],$4ED3AA62);,, r5(t0,t7,t6,t5,t4,t3,t2,t1,w[10],$363F7706);,, r5(t7,t6,t5,t4,t3,t2,t1,t0,w[ 5],$1BFEDF72);,, r5(t6,t5,t4,t3,t2,t1,t0,t7,w[ 9],$429B023D);,, r5(t5,t4,t3,t2,t1,t0,t7,t6,w[14],$37D0D724);,, r5(t4,t3,t2,t1,t0,t7,t6,t5,w[30],$D00A1248);,, r5(t3,t2,t1,t0,t7,t6,t5,t4,w[18],$DB0FEAD3);,, r5(t2,t1,t0,t7,t6,t5,t4,t3,w[ 6],$49F1C09B);,, r5(t1,t0,t7,t6,t5,t4,t3,t2,w[28],$075372C9);,, r5(t0,t7,t6,t5,t4,t3,t2,t1,w[24],$80991B7B);,, r5(t7,t6,t5,t4,t3,t2,t1,t0,w[ 2],$25D479D8);,, r5(t6,t5,t4,t3,t2,t1,t0,t7,w[23],$F6E8DEF7);,, r5(t5,t4,t3,t2,t1,t0,t7,t6,w[16],$E3FE501A);,, r5(t4,t3,t2,t1,t0,t7,t6,t5,w[22],$B6794C3B);,, r5(t3,t2,t1,t0,t7,t6,t5,t4,w[ 4],$976CE0BD);,, r5(t2,t1,t0,t7,t6,t5,t4,t3,w[ 1],$04C006BA);,, r5(t1,t0,t7,t6,t5,t4,t3,t2,w[25],$C1A94FB6);,, r5(t0,t7,t6,t5,t4,t3,t2,t1,w[15],$409F60C4);,, inc(ctx.hash[0],t0);,, inc(ctx.hash[1],t1);,, inc(ctx.hash[2],t2);,, inc(ctx.hash[3],t3);,, inc(ctx.hash[4],t4);,, inc(ctx.hash[5],t5);,, inc(ctx.hash[6],t6);,, inc(ctx.hash[7],t7);,, fillchar(w,sizeof(w),0);,, ctx.index:=0;,, fillchar(ctx.hashbuffer,sizeof(ctx.hashbuffer),0);,, end;,,, procedure HavalUpdateLen(ctx:THaval_CTX;len:longword);,, begin,, inc(ctx.lenlo,(len shl 3));,, if ctx.lenlo<(len shl 3)then inc(ctx.lenhi);,, inc(ctx.lenhi,len shr 29);,, end;,,, procedure HavalFlush(ctx:THaval_CTX);,, begin,, ctx.lenhi:=0;,, ctx.lenlo:=0;,, ctx.index:=0;,, fillchar(ctx.hashbuffer,sizeof(ctx.hashbuffer),0);,, fillchar(ctx.hash,sizeof(ctx.hash),0);,, end;,,, procedure HavalInit(ctx:THaval_CTX);,, begin,, HavalFlush(ctx);,, ctx.hash[0]:=$243F6A88;,, ctx.hash[1]:=$85A308D3;,, ctx.hash[2]:=$13198A2E;,, ctx.hash[3]:=$03707344;,, ctx.hash[4]=$A4093822, ctx.hash[5]::;,,, =$299F31D0; ctx.hash[6]: =$082EFA98;,, ctx.hash[7]: =$EC4E6C89;,,,,,,, de procedure HavalUpdate (ctx:THaval_CTX; totaal buffer; groot: longint);,, var p:^byte;,,, ", HavalUpdateLen (ctx, size); p:=@buffer;,,,,, size> 0 doen, beginnen, als een groot (ctx.hashbuffer) -ctx.index) < =longword (size), gaan, gaan!,, (P ^, ctx.hashbuffer[ctx.index] (ctx.hashbuffer), de omvang van -ctx.index);,, DEC (omvang, een groot (ctx.hashbuffer) -ctx.index);,, Inc (P, groot (ctx.hashbuffer) -ctx.index); HavalCompress (,,,, aan het einde van de ctx); anders gaan beginnen,,,, (P ^, ctx.hashbuffer[ctx.index], size);,, Inc (ctx.index, size); size:=0;,,,,,,,,,,,,,,,,De procedure HavalFinal (ctx:THaval_CTX; var, het repertorium);,,, =$80 beginnen, ctx.hashbuffer[ctx.index]:;,, als ctx.index> 118 dan HavalCompress (ctx);,, ctx.hashbuffer[118]: = ((HASH_SIZE en 3) shl 6) of (5 shl 3) of 1;,, ctx.hashbuffer[119]: = (HASH_SIZE psy - 2) en $FF;,, MOVE (ctx.lenlo, ctx.hashbuffer[120], groot (ctx.lenlo)); en (ctx.lenhi, om ctx.hashbuffer[124], groot (ctx.lenhi);,, HavalCompress (ctx);,, MOVE (ctx.hash Digest, HASH_SIZE div, 8);,, HavalFlush (ctx);,,,,,,,, /////////******************************************************************************, prng, //*** ***************************************************************************,,,. PrngInit (ctx:TPrng_CTX; seed:longword);,, var i:byte;Ik ctx.x1:= (,,,,,, seed+PrngC1). PrngM1; ctx.x1:= (MOD PrngM1 ctx.x1*PrngI1+PrngC1); ctx.x2:=ctx.x1 MOD PrngM2;,,,, ctx.x1:= (MOD PrngM1 ctx.x1*PrngI1+PrngC1); ctx.x3:=ctx.x1 MOD PrngM3;,,,, voor i:=1 tot 97 doen, ik ctx.x1:= (,,, ctx.x1*PrngI1+PrngC1). PrngM1, ctx.x2:=;, (ctx.x2*PrngI2+PrngC2). PrngM2;,, ctx.r[i]: = (ctx.x1+ctx.x2/PrngM2) /PrngM1;,,,,,,,,,,, de functie Prng (ctx:TPrng_CTX): longword;,, var i:longword;,,, ", ctx.x1:= (ctx.x1*PrngI1+PrngC1). PrngM1;,, ctx.x2:= (ctx.x2*PrngI2+PrngC2). PrngM2, ctx.x3:=;, (ctx.x3*PrngI3+PrngC3). PrngM3;,, i:=1+ (97*ctx.x3) die PrngM3;,,,, Prng:=trunc ($FFFFFFFF*ctx.r[i]); ctx.r[i]: = (ctx.x1+ctx.x2/PrngM2) /PrngM1;,,,,, procedur einde;E PrngFlush (ctx:TPrng_CTX);,, var i:byte;,,,,, ", ctx.x1:=0; ctx.x2:=0;,,,, ctx.x3:=0; voor i:=1 tot 97 do ctx.r[i]: = 0;,,,,,,,, /////////******************************************************* ***********************, Key Routines //******************************************************************************,,,,, De procedure MutateKey (var key:key256);,,,, exp_key:array[var i:byte; 0..1,0..7]of longword;,,,, ran_ctx:Prng_CTX; hash_ctx:Haval_CTX;,,, ik temp_key:key256;,,,, * * * * * * * ///////[1]feed sleutel als consumenten in de steun van de burgers prng 8. 16, 7 longs, voor i:=0 te doen, ik PrngInit (,, @ran_ctx, //use sleutel als key[i]); zaad, exp_key[0, I: gegevens, =Prng (@ran_ctx); //expand sleutel, en exp_key[1, I: =not Prng (@ran_ctx); //negate te verstrekken, prng relatie, einde;,,, ///////64 bytes * * * * * * * [2]feed [1] als in sha256,, voor i:=0 tot en met 7 do temp_key[i]: =key[i];,,,,, HavalInit (@hash_ctx); HavalUpdate (@hash_ctx, exp_key[0][0], 64); //feed uitgebreid. Als de gegevens, en HavalFinal (@hash_ctx, sleutel,,, * * * * * * *); ///////[3]xor (^) [2] en [1]. Volgens de laatste sleutel, voor i:=0 Tot en met 7 do key[i]: =key[i]xor temp_key[i]; //reduce - relatie,,,,,,, functie PasswordToKey (pass:string): key256, var I, j:integer;, het gaat temp_chars:array[0..42]of;,,,,,,, key_size:byte; temp_key:array[0..31]of byte temp_pos:byte;,,,,,,, bit_pos:byte; ///////[1]convert beginnen,,, * * * * * * * - Chars te 6bit bytes,, voor i:=1 lengte (pas) te doen.Zaak C - byte (door middel van [het]), 97... Ik]:= byte (door de 122:temp_chars [[M]) - 97; ///////- 0 - 25 als A. De toewijzing van,, 65... 90:temp_chars [ik]:= byte (door middel van [het]) - 39; ///////26-51 als A. Z - toewijzing, 48, 57:temp_chars [. Ik]:= byte (door middel van [het]) + 4; ///////als 0, 9 toewijzing van opdrachten, byte ("): temp_chars [ik]:= 62; ///////als.Het toewijzen van 62, byte ('_'): temp_chars[i]: 63; //if _ kent, 63, einde;,,, key_size:= (lengte (pas) 6) die 8; //keysize met 6bit Char * * * * * * * [2]append 6bit,,, ///////Chars aan elke andere, temp_pos:=0; //temp buffer, positie, bit_pos:=0; //bit positie.,, voor i:=0 te key_size-1 do //concatonate Char, ik 6bit samen, temp_key[i]: = 0;,,,, voor j:=0 te beginnen 7 do, Inc (temp_key[i],,,,,, (temp_chars[temp_pos] en BIT_MASK[bit_pos]) shl psy bit_pos); j), Inc (bit_pos, 1), als bit_pos=6;, dan, ik bit_pos:=0;,,,,, Inc. (temp_pos, 1);,,,,,,,,,,,,,,, * * * * * * *. ///////[3]make 256 beetje, sleutel, als key_size< 44 dan.Ik j:=0;,,,,, voor i:=key_size tot 43 do //fill in lege bytes, ik temp_key[i]:,,, =temp_key[j]xor I;,, Inc. (J. 1);,,,,,,,,,,, * * * * * * * [4]. ///////MutateKey te elimineren, ontslag, (key256 (temp_key));,, PasswordToKey:=key256 (temp_key);,,,,,,, functie AnalyzePassword (pass:string): KeyStatistics;,, var I, j:longword;,,,, key:array[0..1023]of byte; chars:array[0..255] van byte;,, pat_pos, pat_len:longword;,, die, zeros:longword;,,, ik stat:KeyStatistics;,,, * * * * * * *. ///////[1]count keylenght,, stat.KeyLength:= lengte (pas) ///////[2]copy;,,, * * * * * * * de sleutel tot buffer,, voor i:=0 te stat.KeyLength-1 do key[i]: =byte (pass[i]);,,, ///////repet [3]count Char * * * * * * *In i:=0 255, voor te doen chars[i]: = 0;,, voor i:=0 te stat.KeyLength-1 do Inc (chars[key[i]], 1);,,, * * * * * * * [4]count verschillende tekens ///////stat.CharCount:=0;,,,, voor i:=0 tot 255 doen als chars[i]< > 0 Dan Inc (stat.CharCount, 1) ///////;,,, * * * * * * * [5]count charbits stat.CharBits:=0;,,,, voor i:=0 tot en met 7 doen als stat.CharCount > BIT_MASK[i] dan Inc (stat.CharBits, 1);,,, * * * * * * * ///////[6]count patronen, pat_pos:=0;,,,,,, herhaal, pat_len:=0; i:=pat_pos;,, herhaal, als (key[i]=key[pat_pos]) en (i< > pat_pos) dan //if match is gevonden, herhaal, Inc. (pat_len, 1); ///////patroon, dat de grootte, Inc (I, 1); //move naar de volgende, CHAR, Inc (pat_pos, 1); dat het, in //next Char.Tot (key[i]< > key[pat_pos]) of (i=stat.KeyLength); //until patroon eindigt, Inc. (I, 1);,, tot (i> stat.KeyLength-1); //until gedaan zoeken voor dit patroon,, Inc. (pat_pos, 1); //start nieuwe patroon met de volgende, CHAR, tot pat_pos> stat.KeyLength; //until; alle patronen hebben searched,,, als pat_len=0, anders dan stat.Patterns:=0, stat.Patterns:= (pat_len*100) die stat.KeyLength;,,, * * * * * * * [7]count ///////bit-differential ones:=0;,,,,,, zeros:=0; voor i:=0 te stat.KeyLength-1 doen, voor j:=0 tot en met 7 doen, als key[i] en BIT_MASK[j]) = Inc (nullen., 1) Inc (anders dan, 1);,,, stat.Differential:= (longword (ABS (ones-zeros)) * 100) DIV (stat.KeyLength*8);,,, ///////[8]count brutele * * * * * * *De kracht van stat.brutelength:= stat.charbits * * * * * * * stat.keylength;,,,,, * * * * * * * * * * * * * * * * * * * * * ///////[9] van de grootte van de sleutel, stat.keysize:= tellen, stat.keylength * 8;,,, * * * * * * * * * * * * * * * * * * * * * ///////[10] percentage: = bl ((((PAT + 1) /2) /100) * bl), de statistische evaluatie: = stat.brutelength,,, ((((stat.patterns + stat.differential) die 2) * * * stat.brutelength) die 100);,,,,, analyzepassword:= statistieken; tot slot,,,,,,, (C) het auteursrecht drmungkee, 2001 (www.drmungkee.com, drmungkee @ Hotmail. COM),