Teknikker for å identifisere nøkler som motstår brute-force og ordbok angrep. Inkluderer Delphi kilde for å analysere nøkler, konvertering passfraser til nøkler og permutasjon nøkler. [256bit nøkler for sterk kryptering] //kildekode bottomThe sikkerheten til god kryptosystem er avhengig av nøkkelen. Uansett hvor stor en nøkkel, vil det være en imponerende redusert sikkerhet hvis det er dårlig brukes av programvaren. Nøkler bør måles i henhold til de biter av entropi finnes i dem, og enkle nøkler skal tas til følge. De bør inneholde mange forskjellige tegn, og har ingen discernable mønstre. Først når disse vilkårene er oppfylt, vil en nøkkel tåle ordbok og brute force attacks.A nøkkelen entropi måler mengden av uforutsigbare bits.Considering brukere vil vanligvis bare bruke alfanumeriske tegn, bør du bare bruke minimum antall bits mulig å representere det nøkkel. Ved hjelp av 8 bits per tegn betyr at det er 256 forskjellige tegn som er tilgjengelig. En angriper kjenner brukeren vil bare bruke alfanumeriske tegn (62 tegn, 6 biter), og vil ikke bry testing for de 194 andre tegn. En praktisk metode er å omdanne hvert tegn (1 byte) inn i en 6bit tall, og å lenke sammen deretter ved siden av hverandre. Du kan tillate bare små bokstaver og noen tall og redusere hvert tegn til 5bits (32 tegn). Det er viktig å kreve at brukeren kan bruke passord som er større for å oppnå den samme nøkkelen størrelse. Med dette sagt, bør en 8 tegntast ikke anses å være 64bits, men faktisk 48bits (6bits x 8 tegn). Taster med lav entropi utgjøre en sikkerhetstrussel uansett hvor godt utformet resten av systemet er designed.Short, ett ord nøkler bør ikke bli tolerert i et kryptosystem. Selv om du optimalisere entropi, er det rett og slett ikke nok viktige data i en fem tegntast for å tåle et brute force angrep. En 30bit tasten (6bits x 5 tegn) tillater bare en mulighet for et par milliarder nøkler, som tar bare et par timer til eksos på en kraftig datamaskin. En viktig av minst 128bits bør kreves for sesitive data; Dette sikrer en periode på et par år før det oppstår behov for en ny og lengre nøkkel. På 6bits per tegn betyr dette nøkkelen bør være 22 eller flere tegn. Dette kan virke stor, men ingenting stopper deg fra å bruke setninger. Som et eksempel kan se på uttrykket "heisen gikk opp", det er 25 tegn. Nøkkelen er 150 bits lang, men likevel lett å huske. Alle nøkler bør behandles på denne måten. Det er ingen unnskyldning for å la en bruker å bruke en 8 tegntast og at det går hele cryptosystem.A nøkkelen gir bedre motstand mot algoritmisk søk ​​når den inneholder mange forskjellige tegn. Hvis nøkkelen er 22 tegn langt, men bare inneholder 4 forskjellige karakterer, så er det alvorlig svak. For å holde ting enkelt, bør minst halvparten av karakterene i en nøkkel være annerledes (22 tegntast bør ha minst 11 forskjellige tegn). Flere forskjellige tegn i en nøkkel gjøre det vanskeligere å statistisk forutsi neste tegn. Selv om et slikt angrep er usannsynlig, er det ikke rom for feil. Forebygging av alle kjente typer angrep og forutse brudd før hånd er av ytterste-størst betydning uansett hvor ubetydelig risiko kan virke. En risiko er alltid en risiko. Det er viktig å oppfordre brukere til å ha de mest forskjellige karakterer de kan huske i hver tast for å lage algoritmisk søk ​​ga ingen results.Attackers elsker mønstre, gjøre de viktige søk og livet hans mye enklere. Brukere synes å mene at nøkler som: "bingobingo" er sikrere enn de som: "bingo", men faktum er at de er bare litt bedre. Smart angripere kjenner alle triksene brukerne tenke å gjøre sine nøkler vanskeligere å gjette. Ved hjelp av et ord to ganger bør sterkt frarådes. Ofte brukere legge sammen tall på slutten av nøkkelen, for å gjøre det mindre forutsigbart. Dessverre 80% av tiden antallet er 123, og den andre 20% er 321. For en angriper å teste disse ekstra taster, må han også teste med 123 lagt til hver tast, samt 321. Dette betyr at han har til å søke 3 ganger så mange nøkler; Dette utgjør bare en 1,5 bit økning i stedet for 18bits 3 tegn bør tilby. Testing nøkler etter mønstre kan være en svært kompleks hinder, og vil ikke bli diskutert i denne artikkelen. Etter åpenbare mønstre har blitt underkjent er det lurt å passere nøkkelen gjennom en enveis hash-funksjon som SHA eller Haval. Disse funksjonene ta en inngang for data og skape en ut som ikke har noen løsbar forhold til inngangs; for alle mulige inngangs det er bare en utgang. Utgangen av disse hash funksjoner er tilsynelatende tilfeldig og vil effektivt skjule noen diskrete patterns.Eliminating mønstre gjør det svært vanskelig for en angriper tosearch for svake keys.//***** MERKNADER: Kilden nedenfor er en del av et bibliotek i gang cummulating 3 års forskning. Det er ment å være et eksempel, men hvis du ønsker å bruke den i et program, en liten bit av kreditt være nice.These viktige rutiner er optimalisert og re-skrevet et dusin ganger, jeg har prøvd å kommentere så godt jeg kunne. Prosedyren strukturer kan virke merkelig, fordi jeg originaly skrev dem i C ++. Den pseudo random number generator kommer fra en ukjent kilde, og denne implementeringen av Haval er en [alvorlig] modifikasjon av David Barton haval.pas funnet i DCPcrypt 1,3 komponent suite. Jeg brukte sammenheng innkapsling, slik at prosedyrene ikke ville ha å brukes i en multi-threaded miljø (server kanskje?) Beskrivelse:. [MutateKey] Forvandler en nøkkel til et annet ved å utvide og komprimere. Ingen tidligere nøkler kan bestemmes ved den nåværende nøkkel, men alle de etterfølgende nøkler kan være. Dette er nyttig for å legge entropi på en tast (slik at det ikke finnes noen snarveier for å brute søk) eller for økter som kan trenge å bruke flere session-tastene [PasswordToKey] Konverterer en streng med 64 mulige tegn:. 'A' - 'z ',' A '-' Z ',' 0 '-' 9 ',' _ 'og' '. inn i en 256bit ved å utelate 2 biter fra hvert tegn (64 tegn trenger bare 6bits å representere hver, i stedet for 8bits for 256 tegn), og deretter bruker MutateKey å legge entropi. [AnanlyzeKey] Undersøker en tastenes entropi ved å søke etter mønstre, teller bitene som trengs per karakter, evaluering 0/1 (binær) distribusjon, og utleder en summativ vurdering av de viktigste målt i bit-lengde. (en komplett eksempel på dette finner du på http://www.geocities.com/drmungkee /software/codebase.html)//******************* enheten begynner HER ******************* ********************* enhet keyfunc; interfacetype key256 = array [0..7] av Long; Prng_CTX = rekord r: array [1..97] av fast; x1, x2, x3: Long; slutt; TPrng_CTX = ^ Prng_CTX; Haval_CTX = rekord lenhi, lenlo: Long; Indeks: Long; hash: array [0..7] av Long; hashbuffer: array [0..127] av byte; slutt; THaval_CTX = ^ Haval_CTX; KeyStatistics = rekord KeyLength: Long; KeySize: Long; CharCount: byte; CharBits: byte; Mønstre: Long; Differential: Long; BruteLength: Long; Vurdering: Long; slutt; TKeyStatistics = ^ KeyStatistics; prosedyre MutateKey (var viktige: key256); funksjon PasswordToKey (pass: string): key256, funksjon AnalyzePassword (pass: string): KeyStatistics; implementationconst BIT_MASK: array [0..7] i byte = (1, 2,4,8,16,32,64,128); HASH_SIZE = 256; PrngM1: Long = 259200; PrngI1: Long = 7141; PrngC1: Long = 54773; PrngM2: Long = 134456; PrngI2: Long = 8121; PrngC2: Long = 28411; PrngM3: Long = 243000; PrngI3: Long = 4561; PrngC3: Long = 51349; //****************************************** ************************* //Haval ////Avledet fra David Barton haval.pas (DCPcrypt 1,3 komponent suite) ////* ************************************************** **************** prosedyre HavalCompress (CTX: THaval_CTX); funksjon rr32 (x: Long; c: longint): Long, registrere, assembler; asm mov ECX, EDX ror EAX, cl slutten; Prosedyren r1 (var x7, x6, x5, x4, x3, x2, x1, x0: Long; konst w: Long); Var t: Long; begynne t: = ((x2) og ((x6) xor (x1)) xor (x5) og (x4) xor (x0) og (x3) xor (x6)); X7: = rr32 (t, 7) + rr32 (x7,11) + W; slutt; Prosedyren r2 (var x7, x6, x5, x4, x3, x2, x1, x0: Long, const w, c: Long); Var t: Long; begynne t: = (x3 og (x4 og (ikke x0) xor x1 og x2 xor x6 xor x5) xor x1 og (x4 xor x2) xor x0 og x2 xor x5); X7: = rr32 (t, 7) + rr32 (x7,11) + w + c; slutt; Prosedyren r3 (var x7, x6, x5, x4, x3, x2, x1, x0: Long, const w, c: Long); Var t: Long; begynne t: = ((x4) og ((x1) og (x3) xor (x2) xor (x5)) xor (x1) og (x0) xor (x3) og (x6) xor (x5)); X7: = rr32 (t, 7) + rr32 (x7,11) + w + c; slutt; Prosedyren R4 (var x7, x6, x5, x4, x3, x2, x1, x0: Long, const w, c: Long); Var t: Long; begynne t: = (x3 og (x5 og (ikke x0) xor x2 og (ikke x1) xor x4 xor x1 xor x6) xor x2 og (x4 og x0 xor x5 xor x1) xor x0 og x1 xor x6); X7: = rr32 (t, 7) + rr32 (x7,11) + w + c; slutt; Prosedyren r5 (var x7, x6, x5, x4, x3, x2, x1, x0: Long, const w, c: Long); Var t: Long; begynne t: = (x1 og (x3 og x4 og x6 xor (ikke x5)) xor x3 og x0 xor x4 og x5 xor x6 og x2); X7: = rr32 (t, 7) + rr32 (x7,11) + w + c; end; Var t7, t6, T5, T4, T3, T2, T1, t0: Long; w: array [0..31] av Long, begynner 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]; flytte (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, m [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], $ 57,489,862); 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, m [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, m [2], $ C4BFE81B); R4 (t2, t1, t0, T7, t6, T5, T4, T3, w [7], $ 66,282,193); 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, m [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; prosedyre HavalUpdateLen (CTX: THaval_CTX; len: Long), begynner inc (ctx.lenlo, (len SHL 3)); hvis ctx.lenlo < (len SHL 3) deretter økes (ctx.lenhi); inc (ctx.lenhi, len shr 29); end; prosedyre HavalFlush (CTX: THaval_CTX), begynner ctx.lenhi: = 0; ctx.lenlo: = 0; ctx.index: = 0; fillchar (ctx.hashbuffer, sizeof (ctx.hashbuffer), 0); fillchar (ctx.hash, sizeof (ctx.hash), 0); end; prosedyre HavalInit (CTX: THaval_CTX), begynner HavalFlush (CTX); ctx.hash [0]: = $ 243F6A88; ctx.hash [1]: = $ 85A308D3; ctx.hash [2]: = $ 13198A2E; ctx.hash [3]: = $ 03.707.344; ctx.hash [4]: ​​= $ A4093822; ctx.hash [5]: = $ 299F31D0; ctx.hash [6]: = $ 082EFA98; ctx.hash [7]: = $ EC4E6C89; ende; prosedyre HavalUpdate (CTX: THaval_CTX, const Buffer, Størrelse: longint); Var p: ^ byte; begynne HavalUpdateLen (CTX, størrelse); p: = @ buffer; mens størrelsen > 0 ikke begynne if (sizeof (ctx.hashbuffer) -ctx.index) < = Long (størrelse), og start trekk (p ^, ctx.hashbuffer [ctx.index], sizeof (ctx.hashbuffer) -ctx .index); desember (størrelse, sizeof (ctx.hashbuffer) -ctx.index); inc (p, sizeof (ctx.hashbuffer) -ctx.index); HavalCompress (CTX); ende annet begynne flyttingen (p ^, ctx.hashbuffer [ctx.index], størrelse); inc (ctx.index, størrelse); størrelse: = 0; slutt; end, end, prosedyre HavalFinal (CTX: THaval_CTX; Var fordøye); begynne ctx.hashbuffer [ctx.index]: = $ 80; hvis ctx.index > 118 da HavalCompress (CTX); ctx.hashbuffer [118]: = ((HASH_SIZE og 3) SHL 6) eller (5 SHL 3) eller 1; ctx.hashbuffer [119]: = (HASH_SIZE SHR 2) og $ FF; flytte (ctx.lenlo, ctx.hashbuffer [120], sizeof (ctx.lenlo)); flytte (ctx.lenhi, ctx.hashbuffer [124], sizeof (ctx.lenhi)); HavalCompress (CTX); flytte (ctx.hash, fordøye, HASH_SIZE div 8); HavalFlush(ctx);end;//******************************************************************************//PRNG //*********************************************** ******************************* prosedyre PrngInit (CTX: TPrng_CTX; seed: Long); Var jeg: byte; begynne 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-97 gjøre begynne 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, fungere PRNG (CTX: TPrng_CTX): Long; Var i: Long, begynner 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: = AVKORT ($ FFFFFFFF * ctx.r [i]); ctx.r [i]: = (ctx.x1 + ctx.x2 /PrngM2) /PrngM1; ende; prosedyre PrngFlush (CTX: TPrng_CTX); Var jeg: byte, begynner ctx.x1: = 0; ctx.x2: = 0; ctx.x3: = 0; for i: = 1-97 vet ctx.r [i]: = 0; end; //**************************** ************************************************** //Nøkkel Rutiner //******************************************** ********************************** prosedyre MutateKey (var nøkkelen: key256); Var i: byte; exp_key: array [0..1,0..7] av Long; ran_ctx: Prng_CTX; hash_ctx: Haval_CTX; temp_key: key256; begynne //*** [1] mate nøkkel som 8 frø i PRNG å generere 16 lengter etter jeg: = 0-7 gjør begynne PrngInit (@ ran_ctx, tast [i]); //Bruk nøkkelen som frø data exp_key [0, i]: = PRNG (ran_ctx); //Utvide nøkkelen exp_key [1, i]: = ikke PRNG (ran_ctx); //Negere å redusere PRNG forholdet slutt; //*** [2] mate [1] som 64 byte i SHA256 for jeg: = 0-7 gjøre temp_key [i]: = tast [i]; HavalInit (hash_ctx); HavalUpdate (@ hash_ctx, exp_key [0] [0], 64); //Fôr utvidet nøkkel som data HavalFinal (@ hash_ctx, nøkkel); //*** [3] xor (^) [2] og [1] for å produsere den endelige nøkkelen for i: = 0-7 gjøre tast [i ]: = tast [i] xor temp_key [i]; //Redusere HASH relationshipend; funksjon PasswordToKey (pass: string): key256; Var i, j: integer; temp_chars: array [0..42] av byte; key_size: byte; temp_key: array [0..31] av byte; temp_pos: byte; bit_pos: byte; begynne //*** [1] konvertere 8bit Tegn til 6bit byte for i: = 1 til lengde (pass) gjør saken byte (passere [i]) av 97..122: temp_chars [i]: = byte (pass [i]) - 97; //Hvis a-å tildele 0-25 65..90: temp_chars [i]: = byte (passere [i]) - 39; //Hvis A-Å tildele 26-51 48..57: temp_chars [i]: = byte (passere [i]) + 4; //Hvis 0..9 tildele 52-61 byte ( '.'): Temp_chars [i]: = 62; //Hvis. tildele 62 byte ( '_'): temp_chars [i]: = 63; //Hvis _ overdra 63 ende; key_size: = (lengde (pass) * 6) div 8; //Keysize med 6bit tegn //*** [2] føye 6bit Tegn til hverandre temp_pos: = 0; //temp buffer posisjon bit_pos: = 0; //Bit posisjon for i: = 0 til key_size-en trenger //concatonate 6bit chars sammen begynne temp_key [i]: = 0; for j: = 0-7 gjør begynne inc (temp_key [i], ((temp_chars [temp_pos] og BIT_MASK [bit_pos]) shr bit_pos) SHL j); Inc (bit_pos, 1); hvis bit_pos = 6 da begynne bit_pos: = 0; Inc (temp_pos, 1); slutt; slutt; ende; //*** [3] gjøre full 256bit nøkkel hvis key_size < 44 da begynne j: = 0; for i: = key_size til 43 gjøre //fylle tomme byte begynne temp_key [i]: = temp_key [j] xor i; inc (j, 1); slutt; end; //*** [4] eliminere engelske språket redundans MutateKey (key256 (temp_key)); PasswordToKey: = key256 (temp_key); end; funksjon AnalyzePassword (pass: string): KeyStatistics; Var i, j: Long; Nøkkelen: array [0..1023] av byte; tegn: array [0..255] av byte; pat_pos, pat_len: Long; de, nuller: Long; statistikk: KeyStatistics; begynne //*** [1] count keylenght stat.KeyLength: = lengde (pass); //*** [2] kopiere nøkkelen til buffer for i: = 0 til stat.KeyLength-en gjøre nøkkel [i]: = byte (passere [i]); //*** [3] telle røye repetisjon for i: = 0 til 255 gjøre tegn [i]: = 0; for i: = 0 til stat.KeyLength-en gjøre Inc (tegn [key [i]], 1); //*** [4] telle forskjellige tegn stat.CharCount: = 0; for i: = 0 til 255 gjøre hvis tegn [i] < > 0 deretter økes (stat.CharCount, 1); //*** [5] telle charbits stat.CharBits: = 0; for i: = 0-7 gjøre hvis stat.CharCount > BIT_MASK [i] deretter økes (stat.CharBits, 1); //*** [6] count mønstre pat_pos: = 0; pat_len: = 0; jeg gjentar: = pat_pos; gjenta om (tast [i] = nøkkel [pat_pos]) og (i < > pat_pos) så //hvis kampen blir funnet gjenta inc (pat_len, 1); //Tilvekst mønsterstørrelsen økes (i, 1); //Flytter til neste røye inc (pat_pos, 1); //Neste røye mønsteret til (tast [i] < > nøkkel [pat_pos]) eller (i = stat.KeyLength); //Inntil mønster ender inc (i, 1); før (i > stat.KeyLength-1); //Til ferdig søker etter dette mønsteret inc (pat_pos, 1); //Start nytt mønster med neste char til pat_pos > stat.KeyLength; //Til alle mønstre har blitt søkt om pat_len = 0 da stat.Patterns: = 0 ellers stat.Patterns: = (pat_len * 100) div stat.KeyLength; //*** [7] teller bit-differensial seg: = 0; nuller: = 0; for i: = 0 til stat.KeyLength-en gjøre for j: = 0-7 gjøre hvis (tast [i] og BIT_MASK [j]) = 0, så økes (nuller, 1) annet Inc (enere, 1); stat.Differential: = (Long (abs (de-nuller)) * 100) div (stat.KeyLength * 8); //*** [8] count brutelength stat.BruteLength: = stat.CharBits * stat.KeyLength; //*** [9] count keysize stat.KeySize: = stat.KeyLength * 8; //*** [10] count vurdering: = BL - ((((klapp + DIF) /2) /100) * BL) stat.Rating: = stat.BruteLength- ((((stat.Patterns + stat.Differential) div 2) * stat.BruteLength) div 100); AnalyzePassword:. = Stat; ende; ende (C) Copyright DrMungkee 2001 (www.drmungkee.com, [email protected])