, teknikker til identifikation nøgler, som modsætter sig vold og ordbog angreb.omfatter delphi kilde til analyse af nøgler, nøgler, nøgler og omdanne passphrases permuting.,,, [256bit nøgler til en stærk kryptering], //kildekode på bunden, sikring af en god cryptosystem bygger på nøglen.uanset hvor stor en nøgle, der vil være en imponerende fald i sikkerhed, hvis det er dårligt, der anvendes af software.nøgler, skal måles i henhold til de dele af entropi, der er indeholdt i dem, og simple nøgler skal være annulleret.de indeholder mange forskellige roller, og har ingen mærkbar mønstre.kun hvis disse betingelser er opfyldt, vil en vigtig modstå ordbog og brutal kraft angreb.,,, en af de vigtigste er entropi foranstaltninger størrelsen af uforudsigelige ting.,,, at brugerne vil normalt kun anvende alfanumeriske tegn, du må kun bruge det minimale antal bits muligt at repræsentere den nøgle.ved hjælp af 8 bits pr. art: der er 256 forskellige personer, der er til rådighed.en angriber ved brugeren kun vil anvende alfanumeriske tegn (62 tegn, 6 bit), og vil ikke genere en undersøgelse for 194 andre tegn.en praktisk teknik er til at omregne hver karakter (1 byte) i en 6bit nummer, og concatenating så ved siden af hinanden.du kan kun give små bogstaver og et par numre og reducere hver karakter at 5bits (32 tegn).det er vigtigt at kræve, at brugeren anvender kodeord, der er større for at opnå samme centrale størrelse.med det sagt, at det er en 8 karakter centrale bør ikke anses for at være 64bits, men faktisk 48bits (6bits x 8 tegn).nøgler med lav entropi udgør en sikkerhedsrisiko, uanset hvor godt designede resten af systemet er konstrueret til.,,, kort sagt et ord nøgler bør ikke tolereres inden for en cryptosystem.selv hvis du optimere entropi, der er simpelthen ikke nok vigtige data i en 5 karakter er nøglen til at modstå en brutal kraft angreb.en 30bit nøgle (6bits x 5 bogstaver), kun giver mulighed for et par milliarder nøgler, som kun tager et par timer, inden for en magtfuld computer.en nøgle på mindst 128bits bør være forpligtet til sesitive data. dette sikrer en levetid for et par år, inden der opstår et behov for en ny og mere afgørende.på 6bits pr. art. det betyder, at nøglen skulle være 22 eller flere tegn.dette kan synes at være store, men intet stopper dig fra at bruge sætninger.som et eksempel kan se udtrykket "elevatoren kørte op", det er 25 tegn.nøglen er 150 bit lange, men let at huske.alle nøgler skal behandles på denne måde.der er ingen undskyldning for at tillade, at en bruger, for at bruge et 8 karakter nøgle og bringer hele cryptosystem.,,, en central giver bedre modstand mod algoritmisk søgninger, da det indeholder mange forskellige personer.hvis nøgle er 22 tegn, men kun indeholder 4 forskellige roller, så det er meget svag.for at holde det enkelt mindst halvdelen af personerne i et centralt skal være forskellige (22 karakter centrale bør have mindst 11 forskellige tegn).flere forskellige personer i et centralt gør det sværere at statistisk forudsige næste karakter.selv om sådan et angreb, er det usandsynligt, at der ikke er plads til fejl.forebyggelse af alle kendte former for angreb og foregribelse af brud før er af stor betydning, uanset hvor ubetydelig risiko kan virke.en risiko er altid en risiko.det er vigtigt at tilskynde brugere til at have de mest forskellige tegn, kan de huske i hver nøgle til algoritmisk søgninger giver ingen resultater.,,, som elsker mønstre, de vigtigste søgninger og hans liv meget lettere.brugerne lader til at mene, at nøglerne som: "bingobingo" er mere sikre end dem, der ligesom: "bingo", men faktum er, at de kun er lidt bedre.klog som kender alle tricks brugere udvikle for at gøre deres nøgler er sværere at gætte.med et ord, to gange, bør være stærkt begrænset.ofte brugere tilføje tal ved udgangen af den nøgle, for at gøre det mindre forudsigelig.desværre er 80% af tiden antallet er 123, og de andre 20% er 321.for en mand til at afprøve disse ekstra nøgler, han skal også prøve med 123 tilføjes til hver enkelt central samt 321.det betyder, at han har til at gennemsøge 3 gange så mange nøgler. dette udgør kun 1,5 lidt stigning i stedet for 18bits 3 tegn bør tilbyde.prøvning af nøgler til mønstre, kan være en meget kompliceret hindring, og vil ikke blive behandlet i dette dokument.efter klare mønstre er blevet annulleret, det er klogt at vedtage de vigtigste gennem en ensrettet hash funktion såsom sha eller haval.disse funktioner tage et input af data og skabe en, der ikke har løst forhold til input til alle mulige bidrag er der kun én output.produktionen fra disse hash functions er tilsyneladende tilfældige og effektivt vil skjule noget diskret mønstre.,,, at mønstre, gør det meget vanskeligt for en angriber, søge svage nøgler.,,,, //* * * * * bemærkninger:,,, kilden arbejde er en del af et bibliotek i fremskridt cummulating 3 års forskning.det er meningen, at det skal være et eksempel, men hvis du ønsker at bruge det i et program, en lille smule kredit ville være rart.,,, disse centrale rutiner er blevet optimeret, og skrevet et dusin gange, jeg har prøvet at sige, så godt jeg kunne.proceduren strukturer kan forekomme besynderligt, fordi jeg originaly skrev dem i c + +.denne pseudo - nummergeneratoren kommer fra en ukendt kilde, og gennemførelsen af haval er en alvorlig] [ændring af david barton er haval.pas fandt i dcpcrypt 1.3 komponent suite.jeg brugte forbindelse indkapsling, så proceduren ville ikke være instantierede i en multi-threaded miljø (server, måske?.,,, beskrivelse:,, [mutatekey], omdanner en nøgle til en anden ved at udvide og komprimering.ingen tidligere nøgler kan bestemmes ved den nuværende afgørende, men alle de efterfølgende nøgler kan være.det er en nyttig tilføjelse entropi til en nøgle, således at der ikke er nogen genveje til brutal søgning) eller med møder, som kan få brug for at anvende flere sessionsnøgler.,,, [passwordtokey], omdanner en snor med 64 mulige tegn: a - 2 ',' "- 2, 0" - '9', '_ "og". i en 256bit ved at gå ud af 2 ting fra hver art (64 tegn har kun brug for 6bits repræsenterer hver, i stedet for 8bits til 256 tegn), og så bruger mutatekey at tilføje entropi.,,, [ananlyzekey], behandler en nøgle er entropi ved søgning mønstre, regner de dele, der er nødvendige for pr. art, evaluering, 0 /1 (kombineret) fordeling, og får en summative vurdering af de vigtigste målt i lidt længde.,,, en komplet eksempel på dette kan ses på http://www.geocities.com/drmungkee/software/codebase.html),,,, //******************* UNIT BEGINS HERE ****************************************,, unit keyfunc;,, interface,,, type,, key256=array[0..7]of longword;,,, Prng_CTX=record,, r:array[1..97]of real;,, x1,x2,x3:longword;,, end;,, TPrng_CTX=^Prng_CTX;,,, Haval_CTX=record,, lenhi,lenlo:longword;,, Index:longword;,, hash:array[0..7]of longword;,, hashbuffer:array[0..127]of byte;,, end;,, THaval_CTX=^Haval_CTX;,,, KeyStatistics=record,, KeyLength:longword;,, KeySize:longword;,, CharCount:byte;,, CharBits:byte;,, Patterns:longword;,, Differential:longword;,, BruteLength:longword;,, Rating:longword;,, end;,, TKeyStatistics=^Keystatistics;,,, procedure mutatekey (var - nøgle: key256), fungerer passwordtokey (pass: string): key256;,, funktion analyzepassword (pass: string): keystatistics;,,, gennemførelse, i denne bit_mask: system [0 - 7] byte = (1,2,4,8,16,32,64128);,, hash_size = 256;,, prngm1: longword = 259.200;,, prngi1: longword = 7141;,, prngc1: longword = 54773;,, prngm2: longword = 134456;,, prngi2: longword = 8121;,, prngc2: longword = 28411;,, prngm3: longword = 243.000;,, prngi3: longword = 4561;,, prngc3: longword = 51349;,,, //*******************************************************************, //haval, //,, //hidrørende fra david barton er haval.pas (dcpcrypt 1.3 komponent suite) //,, //* * *****************************************************************,,, 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;,, end;,,, procedure HavalUpdate(ctx:THaval_CTX;const Buffer; Size: longint);,, var p:^byte;,, begin,, HavalUpdateLen(ctx,size);,, p:=@buffer;,, while size>0 do,, begin,, if(sizeof(ctx.hashbuffer)-ctx.index)<=longword(size)then,, begin,, move(p^,ctx.hashbuffer[ctx.index],sizeof(ctx.hashbuffer)-ctx.index);,, dec(size,sizeof(ctx.hashbuffer)-ctx.index);,, inc(p,sizeof(ctx.hashbuffer)-ctx.index);,, HavalCompress(ctx);,, end else,, begin,, move(p^,ctx.hashbuffer[ctx.index],size);,, inc(ctx.index,size);,, size:=0;,, end;,, end;,, end;,,, procedure HavalFinal(ctx:THaval_CTX;var digest);,, begin,, ctx.hashbuffer[ctx.index]:=$80;,, if ctx.index>118 then HavalCompress(ctx);,, ctx.hashbuffer[118]:=((HASH_SIZE and 3)shl 6)or(5 shl 3)or 1;,, ctx.hashbuffer[119]:=(HASH_SIZE shr 2)and $FF;,, move(ctx.lenlo,ctx.hashbuffer[120],sizeof(ctx.lenlo));,, move(ctx.lenhi,ctx.hashbuffer[124],sizeof(ctx.lenhi));,, HavalCompress(ctx);,, move(ctx.hash,digest,HASH_SIZE div 8);,, HavalFlush(ctx);,, end;,,, //******************************************************************************,, // PRNG,, //******************************************************************************,,, procedure PrngInit(ctx:TPrng_CTX;seed:longword);,, var i:byte;,, begin,, ctx.x1:=(seed+PrngC1)mod PrngM1;,, ctx.x1:=(ctx.x1*PrngI1+PrngC1)mod PrngM1;,, ctx.x2:=ctx.x1 mod PrngM2;,, ctx.x1:=(ctx.x1*PrngI1+PrngC1)mod PrngM1;,, ctx.x3:=ctx.x1 mod PrngM3;,, for i:=1 to 97 do,, begin,, ctx.x1:=(ctx.x1*PrngI1+PrngC1)mod PrngM1;,, ctx.x2:=(ctx.x2*PrngI2+PrngC2)mod PrngM2;,, ctx.r[i]:=(ctx.x1+ctx.x2/PrngM2)/PrngM1;,, end;,, end;,,, function Prng(ctx:TPrng_CTX):longword;,, var i:longword;,, begin,, ctx.x1:=(ctx.x1*PrngI1+PrngC1)mod PrngM1;,, ctx.x2:=(ctx.x2*PrngI2+PrngC2)mod PrngM2;,, ctx.x3:=(ctx.x3*PrngI3+PrngC3)mod PrngM3;,, i:=1+(97*ctx.x3)div PrngM3;,, Prng:=trunc($FFFFFFFF*ctx.r[i]);,, ctx.r[i]:=(ctx.x1+ctx.x2/PrngM2)/PrngM1;,, end;,,, procedure PrngFlush(ctx:TPrng_CTX);,, var i:byte;,, begin,, ctx.x1:=0;,, ctx.x2:=0;,, ctx.x3:=0;,, for i:=1 to 97 do ctx.r[i]:=0;,, end;,,, //******************************************************************************,, // Key Routines,, //******************************************************************************,,, procedure MutateKey(var key:key256);,, var i:byte;,, exp_key:array[0..1,0..7]of longword;,, ran_ctx:Prng_CTX;,, hash_ctx:Haval_CTX;,, temp_key:key256;,, begin,,, // *** [1]feed key as 8 seeds into PRNG to generate 16 longs,, for i:=0 to 7 do,, begin,, PrngInit(@ran_ctx,key[i]); //use key as seed data,, exp_key[0,i]:=Prng(@ran_ctx); //expand key,, exp_key[1,i]:=not Prng(@ran_ctx); //negate to reduce PRNG relationship,, end;,,, // *** [2]feed [1] as 64 bytes into SHA256,, for i:=0 to 7 do temp_key[i]:=key[i];,,, HavalInit(@hash_ctx);,, HavalUpdate(@hash_ctx,exp_key[0][0],64); //feed expanded key as data,, HavalFinal(@hash_ctx,key);,,, // *** [3]xor(^) [2] and [1] to produce the final key,, for i:=0 to 7 do key[i]:=key[i]xor temp_key[i]; //reduce HASH relationship,, end;,,, function PasswordToKey(pass:string):key256;,, var i,j:integer;,, temp_chars:array[0..42]of byte;,, key_size:byte;,, temp_key:array[0..31]of byte;,, temp_pos:byte;,, bit_pos:byte;,, begin,,, // *** [1]convert 8bit Chars to 6bit bytes,, for i:=1 to length(pass)do,, sag byte (pass [i]), 97... 122: temp_chars [i]: = byte (pass [i]) - 97 //hvis a. z tildele 0 - 25, 65 - 90: temp_chars [i]: = byte (pass [i]) - 39 //hvis a. z tildele 26-51, 48... 57: temp_chars [i]: = byte (pass [i]) + 4; //- 0. 9 tildele 52-61, byte (. '): temp_chars [i]: = 62; //hvis.assign 62,, byte('_'):temp_chars[i]:=63; //if _ assign 63,, end;,,, key_size:=(length(pass)*6)div 8; //keysize with 6bit chars,,, // *** [2]append 6bit Chars to each other,, temp_pos:=0; //temp buffer position,, bit_pos:=0; //bit position,,, for i:=0 to key_size-1 do //concatonate 6bit chars together,, begin,, temp_key[i]:=0;,, for j:=0 to 7 do,, begin,, inc(temp_key[i],,, ((temp_chars[temp_pos] and BIT_MASK[bit_pos]) shr bit_pos) shl j);,, inc(bit_pos,1);,, if bit_pos=6 then,, begin,, bit_pos:=0;,, inc(temp_pos,1);,, end;,, end;,, end;,,, // *** [3]make full 256bit key,, if key_size<44 then,, begin,, j:=0;,, for i:=key_size to 43 do //fill in empty bytes,, begin,, temp_key[i]:=temp_key[j]xor i;,, inc(j,1);,, end;,, end;,,, // *** [4]eliminate english language redundancy,, MutateKey(key256(temp_key));,, PasswordToKey:=key256(temp_key);,, end;,,, function AnalyzePassword(pass:string):KeyStatistics;,, var i,j:longword;,, key:array[0..1023]of byte;,, chars:array[0..255] of byte;,, pat_pos,pat_len:longword;,, ones,zeros:longword;,, stat:KeyStatistics;,, begin,,, // *** [1]count keylenght,, stat.KeyLength:=length(pass);,,, // *** [2]copy key to buffer,, for i:=0 to stat.KeyLength-1 do key[i]:=byte(pass[i]);,,, // *** [3]count char repetition,, for i:=0 to 255 do chars[i]:=0;,, for i:=0 to stat.KeyLength-1 do inc(chars[key[i]],1);,,, // *** [4]count different characters,, stat.CharCount:=0;,, for i:=0 to 255 do if chars[i]<>0 then inc(stat.CharCount,1);,,, // *** [5]count charbits,, stat.CharBits:=0;,, for i:=0 to 7 do if stat.CharCount > BIT_MASK[i] then inc(stat.CharBits,1);,,, // *** [6]count patterns,, pat_pos:=0;,, pat_len:=0;,, repeat,, i:=pat_pos;,, repeat,, if (key[i]=key[pat_pos])and(i<>pat_pos)then //if match is found,, repeat,, inc(pat_len,1); //increment pattern size,, inc(i,1); //move to next char,, inc(pat_pos,1); //next char in pattern,, until (key[i]<>key[pat_pos])or(i=stat.KeyLength); //until pattern ends,, inc(i,1);,, until (i>stat.KeyLength-1); //until finished searching for this pattern,, inc(pat_pos,1); //start new pattern with the next char,, until pat_pos>stat.KeyLength; //until all patterns have been searched,,, if pat_len=0 then stat.Patterns:=0,, else stat.Patterns:=(pat_len*100)div stat.KeyLength;,,, // *** [7]count bit-differential,, ones:=0;,, zeros:=0;,, for i:=0 to stat.KeyLength-1 do,, for j:=0 to 7 do,, if (key[i] and BIT_MASK[j])=0 then inc(zeros,1) else inc(ones,1);,,, stat.Differential:=(longword(abs(ones-zeros))*100)div(stat.KeyLength*8);,,, // *** [8]count brutelength,, stat.brutelength: = stat.charbits * stat.keylength;,,, //* * * [9] regne keysize,, stat.keysize: = stat.keylength * 8;,,, //* * * [10] tæller rating: = bl - ((((pat + et) /2) /100) * bl). vurderingen: = stat.brutelength - ((((stat.patterns + stat.differential) div. 2) * stat.brutelength) div. 100);,,, analyzepassword: = stat,,,,,,.,,, (c) ophavsret drmungkee, 2001 (www.drmungkee.com, drmungkee @ hotmail. com),