Forklaring med Dephi kilde som forklarer hvordan å generere tilfeldige tall med riktige kilder til entropi og hash funksjoner. [Cryptographic Tilfeldige tall] //Source Code BellowSimply ringer Tilfeldig og bruk av Random () prosedyre er en alvorlig sikkerhetsfeil i søknaden søker å PreTect data med tilfeldige tall. En tilfeldig nummer generator får er "tilfeldigheten" fra entropi. Borlands Random () prosedyren bruker en 32bit frø som entropi, og at frø er generert av Tilfeldig prosedyre som får sin entropi systemet tid og dato som er svært sannsynlighets og kan testes for quickly.To generere tilfeldige tall som ikke kan skilles fra ren kaos er en svært vanskelig oppgave på en datamaskin, hovedsakelig fordi du er avhengig av indre tilstander som ofte er altfor forutsigbar. Ideen er å samle entropi fra de minst forutsigbare statene i systemet og dillute at entropi inne i en mye større basseng. Bassenget jeg refererer til er den interne tilstanden til tilfeldige tall generator.WHAT DET ER: Det er viktige egenskaper som må respekteres ved generering tilfeldige tall. Mer specificaly, tilfeldige tall intendedfor kryptering. Eiendommene som innblandet i dette tilfeldig tall gerenartors utforming er sterkt basert på Bruce Schneier Yarrow (www.counterpane.com) sikret første eiendommen er å sikre at det er alltid anought entropi i bassenget før outputing tilfeldige tall, slik at bassenget aldri går inn i en svekket tilstand der de neste tilfeldige tall som er utgangs har predictible information.The neste eiendom kommer i hendig hvis du skal bruke generatoren til å gjøre øktnøkler som vil endre flere ganger under en chat-økt. Det er viktig at en kompromitterte nøkler ikke vil avsløre noen av de tidligere nøkler eller noen av de neste nøkler som skal brukes. For å gjøre dette må vi eliminere den matematiske forholdet mellom tilfeldige tall som er utgang og tilstanden i pool.The tredje ønskede egenskapen innebærer at enven hvis entropien samlet fra kilder er av dårlig kvalitet (ganske forutsigbar) bassenget må ikke lide for lav entropi og utgangs tilfeldige tall må ikke viser noen tegn til dette.Jeg har testet denne enheten i stor utstrekning. Den siste og mest avgjørende test sentrert rundt den tredje eiendommen. For å gjøre et ekstremt tilfelle, begynte jeg bassenget med ingenting, men nuller i det og genererte ~ 12MB (100.000.000 biter). Jeg brukte diehard batteri av tester (http://stat.fsu.edu/~geo/diehard.html) og det gikk hele 15 med glans ... uten å samle noen entropi. Med dette er jeg fornøyd med den tilfeldige nummer generator ytelse og sende det til deg å bruke som et sikkert alternativ til det som er vanlig hos programs.HOW TIL DET FUNGERER: -To entropi samlere er opprettet: [1] en tråd som sporer muse bevegelse med ujevne mellomrom tar 4bits entropi fra musen posisjon og tilstanden til systemet med høy oppløsning timer. [2] en ventetid kalkulator som får 4bits entropi fra høyoppløselige timer når kalt av hoved app (dette blir brukt av allingTKeyGenerator.AddLatency på onkeydown tilfelle en redigeringsboks, for å telle harddisk ventetid, eller IRQ latency) Når et av de entropi samlere har akkumulert 32bits, det sender det til entropi pool.-The entroyp bassenget tar i entropi 32bits på en gang og bruker den til å fylle en entropi buffer på 256bits, når bufferen er full, er en primær reseed executed.-primær~~POS=TRUNC reseed oppdaterer den primære bassenget (en hash Kontekst: interne tilstanden til en hash-funksjon) med entropi og XORs det med bassenget ætt (dette frøet er brukt på samme måten Tilfeldig genererer randseed). Etter hver primær reseed, frøet (med nå 256bits entropi) er klar til å bli brukt til å sende ut tilfeldige tall hvis kall søknaden så ønsker det, men det vil fortsette å reseed og samle entropi uansett uavhengig av det. Etter 8 primære reseeds har funnet sted, er en sekundær reseed executed.-Sekundær reseed oppdaterer sekundære basseng med innholdet i den primære bassenget og deretter spyler innholdet i den primære bassenget i en tilstand uten entropi. Den sekundære Bassenget er vedvarende i at det aldri blir spylt og vil bære entropi biter fra ulike reseeds. En completly ny frø er generert fra den sekundære reseed (der som den primære på modifiserer den med entropi). Dette sekundære reseed forhindrer tilbakesporing egenskaper (gessing tidligere tilstander av bassenget) og sørger for at det er entropien i bassenget, selv under forhold der ny entropi er av dårlig quality.-Når du ringer programmet trenger for å generere en nøkkel kaller SafeGetKey som sikrer at ingen mer enn 8 sett 256bits av tilfeldige tall, kan genereres fra en enkelt reseed. For å gjøre dette en viktig reserve teller økes hver primær reseed, og kan ikke overstige 8. Når en du genererer et sett med tilfeldige tall nøkkelen reserve minskes og funksjonen vil returnere fasle hvis nøkkelen reserve er på 0. MERK: et program kan ignorere nøkkelen reserve og ringe ForceGetKey. Dette er svært risikabelt praksis og jeg seriøst hindre deg fra å bruke denne function.-The tilfeldig effekt skapt av getKey er et generert med entropi bassenget ætt. Frøet er brukt som en krypteringsnøkkel og deretter permuteres (med en ekspansjons-kompresjon). Den nye frø blir brukt som data som skal krypteres. Det er kryptert med den forrige frø og utvidet-komprimert i 64 runder. Disse rundene sikre at det er umulig å fastslå tilstanden til frø, den primære bassenget, den sekundære bassenget eller entorpy buffer; i sin tur hindrer noen fra å finne forrige eller neste outputs.NOTES: -Assign en variabel av typen TKeyGenerator og kaller det er .Create. Dette vil starte prosessen. Når du er ferdig, kan du ringe .Destropy.-Du kan bruke .KeyCount å finne ut tilstanden nøkkelen reserve (hvor mange getKey samtaler kan gjøres før neste reseed). Jeg sterkt godta å øke verdien av MAX_KEY_RESERVE.-Du kan manipulere hastigheten som entropi hentes fra mus ved å sette MOUSE_INTERVAL konstant (i millisekunder). En verdi lavere enn 10 er unrecommended.-No feilsjekking er gjort for å sikre at det er en høy frekvens telleren på systemet, dette bør verifiseres av ringer søknaden. Hvis det ikke er slik disk, vil den tilfeldige nummer generator fungerer, men vil produksjonen ikke-tilfeldige numbers.-Søknaden må gi 32 byte minne plass i en variabel til å passere til getKey funksjoner. Ingen feilkontroll utføres here.-Du kan endres KEY_BUILD_ROUNDS til en hvilken som helst verdi som er større enn eller lik 32, men større enn 64 er ganske useless./*********************************************************************/********************************************************************* - VIKTIG -The kilde under er en del av et bibliotek i gang cummulating 3 år med min forskning. Hvis du ønsker å bruke den i et program, en liten bit av kreditt vil være nice.NSCrypt.pas inneholder en pseudo tilfeldig nummer generator som kommer fra en ukjent kilde, og disse implementeringer av Haval og Rijndael er [alvorlig] modifikasjoner av David Barton haval.pas og rijndael.pas finnes i DCPcrypt 1,3 komponent suite.Download NSCrypt.txt og endre navnet NSCrypt.pas (dum webhost) jeg har tatt de kryptografiske funksjoner sepperatly fordi de totalt 1300 linjer together.http: //www. eccentrix.com/computer/drmungkee/NSCrypt.txt(the selve nettsiden er www.drmungkee.com)/*********************************************************************/*********************************************************************//you'll må forholde seg til dokumentasjon above.unit NoiseSpunge; interfaceuses Windows, kurs, kontroller, NSCrypt; konst SEED_SIZE = 8; PRIMARY_RESEED = SEED_SIZE; SECONDARY_RESEED = SEED_SIZE; //parametere MAX_KEY_RESERVE = 8; KEY_BUILD_ROUNDS = 64; MOUSE_INTERVAL = 10; typen Key256 = array [0..SEED_SIZE-1] av Long; TNoiseSpungeAddEntropy = prosedyre (Block: Long) av objektet, TNoiseSpungeProcedure = prosedyre objekt; TMouseCollector = klasse (TThread) beskyttet PCtx: Prng_CTX, x, y: integer; Block: Long; BitsGathered: Long, Intervall, Frekvens, thistime, Lasttime: TLargeInteger; SendMouseEntropy: TNoiseSpungeAddEntropy; offentlig konstruktør Lag, prosedyre SyncSendMouseEntropy, prosedyre Execute, styre, ende; TLatencyCollector = klasse beskyttet Block: Long; BitsGathered: Long; Tid: TLargeInteger; SendLatencyEntropy : TNoiseSpungeAddEntropy; offentlig konstruktør Lag, prosedyre MeasureLatency; slutt; TEntropyPool = klasse beskyttet Seed: Key256; EntropyBuffer: Key256; PrimaryPool: Haval_CTX; SecondaryPool: Haval_CTX; PrimaryReseedCount: byte; EntropyCount: byte; KeyReserve: byte; prosedyre PermuteSeed; prosedyre PrimaryReseed; prosedyre SecondaryReseed; Prosedyren AddEntropy (Block: Long); offentlig konstruktør Opprett; slutt; TKeyGenerator = klasse beskyttet EntropyPool: TEntropyPool; MouseCollector: TMouseCollector; LatencyCollector: TLatencyCollector; offentlig AddLatency: TNoiseSpungeProcedure; konstruktør Opprett; destructor Destroy; styre; funksjon KeyCount: byte; funksjon SafeGetKey (var Key): boolean; Prosedyren ForcedGetKey (var Key); slutt; implementationconstructor TMouseCollector.Create; begynne arvet Opprette (true); Tilfeldig; PrngInit (@ PCtx, RandSeed); FreeOnTerminate: = true; Prioritet: = tpNormal; Gjenoppta; end; prosedyre TMouseCollector.SyncSendMouseEntropy, begynner SendMouseEntropy (Block); end; prosedyre TMouseCollector.execute, Div NilHandle: pekeren; Idled: boolean, begynner NilHandle: = null; BitsGathered: = 0; Idled: = false; QueryPerformanceFrequency (Frequency); gjenta om idled = false deretter begynne MsgWaitForMultipleObjects (0, NilHandle, falsk, MOUSE_INTERVAL, 0); Idled: = true; slutt; QueryPerformanceCounter (thistime); Hvis thistime-Lasttime > Intervall deretter begynne if (x < > mouse.cursorpos.x) og (y < > mouse.cursorpos.y), og start x: = mouse.cursorpos.x; y: = mouse.cursorpos.y; Inc (Block, (((x og 15) xor (y og 15)) XOR (thistime og 15)) SHL BitsGathered); Inc (BitsGathered, 4); hvis BitsGathered = 32 da begynne PrngInit (@ PCtx, Block); Synkroniser (SyncSendMouseEntropy); Block: = 0; BitsGathered: = 0; slutt; Intervall: = ((((PRNG (PCtx) mod MOUSE_INTERVAL) div 2) + MOUSE_INTERVAL) * Frequency) div 1000; QueryPerformanceCounter (Lasttime); Idled: = false; ende annet begynne QueryPerformanceCounter (Lasttime); Idled: = false; slutt; slutt; inntil Avsluttet = true; ende, konstruktør TLatencyCollector.Create, begynner arvet Opprett; Block: = 0; BitsGathered: = 0; ende; prosedyre TLatencyCollector.MeasureLatency, begynner QueryPerformanceCounter (Time); Inc (Block, (Time og 15) SHL BitsGathered); Inc (BitsGathered, 4); hvis BitsGathered = 32 da begynne SendLatencyEntropy (Block); Block: = 0; BitsGathered: = 0; end, end, konstruktør TEntropyPool.Create, begynner arvet Opprett; HavalInit (PrimaryPool); HavalInit (SecondaryPool); FillChar (Seed, sizeof (Seed), 0); EntropyCount: = 0; PrimaryReseedCount: = 0; KeyReserve: = 0; ende; prosedyre TEntropyPool.PermuteSeed, Div TempBuffer: array [0..1] av Key256; PCtx: Prng_CTX; HCtx: Haval_CTX; I: byte; begynne for i: = 0 til SEED_SIZE-en ikke starter PrngInit (@ PCtx, Seed [i]); TempBuffer [0, i]: = PRNG (PCtx); TempBuffer [1, i]: = PRNG (PCtx); slutt; HavalInit (HCtx); HavalUpdate (@ HCtx, TempBuffer, sizeof (TempBuffer)); HavalOutput (@ HCtx, Seed); end; prosedyre TEntropyPool.PrimaryReseed, Div TempSeed: Key256; I: byte; begynne HavalUpdate (@ PrimaryPool, EntropyBuffer, sizeof (EntropyBuffer)); hvis PrimaryReseedCount begynne HavalOutput (@ PrimaryPool, TempSeed); for i: = 0 til SEED_SIZE-en gjøre Seed [i]: = Seed [i] xor TempSeed [i]; Inc (PrimaryReseedCount); ende annet SecondaryReseed; FillChar (EntropyBuffer, sizeof (EntropyBuffer), 0); hvis KeyReserve EntropyCount: = 0; ende; prosedyre TEntropyPool.SecondaryReseed, begynner HavalOutput (@ PrimaryPool, Seed); HavalUpdate (@ SecondaryPool, Seed, sizeof (Seed)); HavalOutput (@ SecondaryPool, Seed); PermuteSeed; HavalInit (PrimaryPool); PrimaryReseedCount: = 0; ende; prosedyre TEntropyPool.AddEntropy (Block: Long), begynner Move (Block, pekeren (Long (EntropyBuffer) + (EntropyCount * sizeof (Block))) ^, sizeof (Block)); Inc (EntropyCount, 1); hvis EntropyCount = PRIMARY_RESEED deretter PrimaryReseed; ende, konstruktør TKeyGenerator.Create, begynner arvet Opprett; EntropyPool: = TEntropyPool.Create; MouseCollector: = TMouseCollector.Create; MouseCollector.SendMouseEntropy: = EntropyPool.AddEntropy; LatencyCollector: = TLatencyCollector.Create; LatencyCollector.SendLatencyEntropy: = EntropyPool.AddEntropy; AddLatency: = LatencyCollector.MeasureLatency; ende; destructor TKeyGenerator.Destroy, begynner MouseCollector.terminate; LatencyCollector.destroy; EntropyPool.destroy; arvet Destroy; ende; funksjon TKeyGenerator.KeyCount: byte, begynner Resultat: = EntropyPool.KeyReserve; ende; funksjon TKeyGenerator.SafeGetKey (var Key): boolean; Var TempSeed: Key256; TempBuffer: array [0..1] av Key256; RCtx: Rijndael_CTX; PCtx: Prng_CTX; HCtx: Haval_CTX; i, j: byte; begynne hvis EntropyPool.KeyReserve = 0 da begynne Exit; Resultat: = false; ende annet Resultat: = true; Flytt (EntropyPool.Seed, TempSeed, sizeof (TempSeed)); EntropyPool.PermuteSeed; RijndaelInit (@ RCtx, EntropyPool.Seed); for i: = 0 til KEY_BUILD_ROUNDS-en gjøre begynne RijndaelEncrypt (@ RCtx, TempSeed [0]); RijndaelEncrypt (@ RCtx, TempSeed [4]); for j: = 0 til SEED_SIZE-en ikke starter PrngInit (@ pctx, TempSeed [j]); TempBuffer [0, j]: = PRNG (PCtx); TempBuffer [1, j]: = PRNG (PCtx); slutt; HavalInit (HCtx); HavalUpdate (@ HCtx, TempBuffer, sizeof (TempBuffer)); HavalOutput (@ HCtx, TempSeed); slutt; Flytt (TempSeed, Key, sizeof (TempSeed)); Desember (EntropyPool.KeyReserve, 1); end; prosedyre TKeyGenerator.ForcedGetKey (var Key); Var TempSeed: Key256; TempBuffer: array [0..1] av Key256; RCtx: Rijndael_CTX; PCtx: Prng_CTX; HCtx: Haval_CTX; i, j: byte; begynne Move (EntropyPool.Seed, TempSeed, sizeof (TempSeed)); EntropyPool.PermuteSeed; RijndaelInit (@ RCtx, EntropyPool.Seed); for i: = 0 til KEY_BUILD_ROUNDS-en gjøre begynne RijndaelEncrypt (@ RCtx, TempSeed [0]); RijndaelEncrypt (@ RCtx, TempSeed [4]); for j: = 0 til SEED_SIZE-en ikke starter PrngInit (@ pctx, TempSeed [j]); TempBuffer [0, j]: = PRNG (PCtx); TempBuffer [1, j]: = PRNG (PCtx); slutt; HavalInit (HCtx); HavalUpdate (@ HCtx, TempBuffer, sizeof (TempBuffer)); HavalOutput (@ HCtx, TempSeed); slutt; Flytt (TempSeed, Key, sizeof (TempSeed)); hvis EntropyPool.KeyReserve < 0 deretter desember (EntropyPool.KeyReserve, 1); end;. ende (C) Copyright DrMungkee 2001 (www.drmungkee.com, [email protected])