Newsgroup: it.comp.sicurezza.crittografia
Titolo: generatore di numeri random

ho scritto un generatore di numeri random (ritengo non pseudo-random) che si
basa sul rumore generato dall'ADC della scheda audio.
volevo sapere se secondo voi questo approccio può essere interessante o
meno.
se volete provarlo il link è
http://www.n-side.it/CAFxXcrossway/Stuff/GRK040404.zip
vi sarei infinitamente grato se poteste rispondermi direttamente via mail
(l'indirizzo è anche raggiungibile dal sito qui sotto.
ciao e grazie a tutti per l'attenzione.
--
CAFxXcrossway -> 
www.cafxx.cjb.net

 mail (l'indirizzo č anche raggiungibile dal sito qui sotto.
Non capisco perché non preferisci parlarne pubblicamente. Parlandone solo in
due, alcune cose potrebbero sfuggire piů facilmente.
Cristiano

 
http://www.n-side.it/CAFxXcrossway/Stuff/GRK040404.zip
Gli darò un'occhiata appena ho un attimo.
Lapo
- --
L a p o   L u c h i n i
l a p o @ l a p o . i t
w w w . l a p o . i t /
http://www.megatokyo.it
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.4 (Cygwin)
Comment: Using GnuPG with Mozilla - 
http://enigmail.mozdev.org
iEYEARECAAYFAkBwDcgACgkQaJiCLMjyUvutQgCg7ZdIdKZHZFIf7/soCzvxol8Y
ndkAn3lv5hPEqvi+qJBLSd102/Hxhj11
=B/uj
-----END PGP SIGNATURE-----

 appena avrò un attimo di respiro scriverò qualcosa di meglio.
Bene, appena l'avrai scritto lo leggerò volentieri.
Cristiano

 suo funzionamento.
in poche parole: al momento da linea di comando spepifichi quanti secondi di
audio registrare e quanti byte random outputtare.
il programma registra dalla scheda audio quel tot di secondi e poi una
*stupidissima* funzione di hashing mescola tutto:
in c:
    for (counter = 0; counter < 44100 * 2 * seconds; counter++) {
        sample = waveinputheader[counter / (44100 * 2)].lpData[counter %
(44100 * 2)];
        key[(counter >> 3) % keylenght] ^= sample << (counter % 8);
    }
waveinputheader è una struct di windows che contiene un puntatore (lpData)
al buffer contenente i dati audio. io creo tante di queste strutture quanti
sono i secondi di registrazione contenenti ciascuna un buffer da un secondo.
ogni buffer contiene 88200bytes (44.1khz x 16bit).
--
CAFxXcrossway -> 
www.cafxx.cjb.net
"Cristiano" <cristi...@NSquipo.it> ha scritto nel messaggio
news:8oPec.64804$rM4.2...@news4.tin.it...


 192khz, stereo, 32bit... pura entropia! ;-)
Hai provato a fare una FFT del segnale che ottieni? che forma ha lo
spettro? piatto o a righe?
HappyCactus che non sempre quel che sembra random...
-- 
*    HappyCactus - Linux User #209744 - BOFH Certified Engineer    *
*                         
http://www.google.com
                    *
*                                                                  *
*                           ET IN ARCADIA EGO                      *

 campioni variano tra -5 e +7...
Va tutto bene, *MA* usa SHA256, non una funzione di hashing "non
crittografica".
Meglio ancora usa un "sistema CSPRNG completo" pensato in toto da un
crittografo tipo Yarrow o Fortuna (design by Bruce Schneier).
Lapo
- --
L a p o   L u c h i n i
l a p o @ l a p o . i t
w w w . l a p o . i t /
http://www.megatokyo.it
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.4 (Cygwin)
Comment: Using GnuPG with Mozilla - 
http://enigmail.mozdev.org
iEYEARECAAYFAkB9AlIACgkQaJiCLMjyUvugegCgjHOfF3/ywdItSBrcfTDgFg82
0HoAoMXsRTlN/+K0QFgQfNf2VBfstLKw
=99ai
-----END PGP SIGNATURE-----

 ogni buffer contiene 88200bytes (44.1khz x 16bit).
Hai un motivo particolare per creare tutte quelle strutture? Io ne usavo
solo una in cui riversavo tutti i bit campionati.
Cristiano

 > penso sia sufficiente... anche perchč, volendo, posso spingere fino a


 testare il generatore con un programma serio.
una semplice implementazione dello SHA già pronta in c dove me la posso
trovare?
secondo te va bene che tipo registro x secondi di audio poi hasho tutto e
outputto l'hash e così via concatenando? o devo fare altre cose (tipo hash a
cascata)?
--
CAFxXcrossway -> 
www.cafxx.cjb.net
"Cristiano" <cristi...@NSquipo.it> ha scritto nel messaggio
news:Bwffc.53866$hc5.2...@news3.tin.it...


 mi trova una unica riga (sotto i circa 40hz) [...]
... Non č un buon segno, anche se mi sarei aspettato i 50 Hz della rete
elettrica invece di 40. Riesci a verificare bene quella frequenza?
Probabilmente, testando la sequenza, ottieni un fallimento sistematico di
qualche test (specialmente quelli per l'autocorrelazione e la DFT).
Scusa se insisto, ma appena hai tempo ti consiglierei di testare la
sequenza.
Cristiano

 o devo fare altre cose (tipo hash a cascata)?
... Sicuramente ci sono molti metodi migliori e più complessi.
Il primo che mi viene in mente è di tenere un buffer per l'hash al quale
aggiungi sempre i bit senza mai chiuderlo, cioè fai:
1) inizializzi il buffer principale;
2) aggiungi i bit al buffer principale;
3) inizializzi un buffer temporaneo;
4) copi il buffer principale in quello temporaneo;
5) calcoli l'hash del buffer temporaneo;
6) ritorni a 2.
Ovviamente ce ne sono altri, ma questo è già un passo avanti.
Cristiano

 40hz) per il resto è una linea "tremolante" pressochè continua.
Aspetta: hai detto che campioni a 44,1kHz, per quale ragione usi 64k
bande? significa che usi finestre di quasi due secondi, per cui se, ad
esempio, hai un segnale a frequenza lentamente variabile, correlato, con
una analisi del genere ottieni uno spettro falsamente distribuito in
frequenza, quando invece, puntualmente, sarebbe a linee.
L'analisi la devi fare a finestre molto piu' piccole, e vedere come
evolve lo spettro nel tempo.
Oppure, appunto, fare un test di autocorrelazione.
HappyCactus che francamente non ha mai creduto alla storia del rumore
bianco della scheda audio.


 bianco della scheda audio.
In che senso?
Che ci sia "dell'entropia" direi che non ci sono dubbi.
Che poi sia buona "così come è" (ovvero che sia rumore effetivamente
bianco, distribuito equamente in frequenza) è assolutamente impensabile,
ma comunque può essere una buona base, se (e solo se) usata bene...
Dopo aver "sbiancato" il rumore con un hash crittografico ben poco conta
la precedente "distribuzione" dello stesso, a meno ovviamente che l'hash
venga "rotto" da altri punti di vista.
- --
L a p o   L u c h i n i
l a p o @ l a p o . i t
w w w . l a p o . i t /
http://www.megatokyo.it
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.4 (Cygwin)
Comment: Using GnuPG with Mozilla - 
http://enigmail.mozdev.org
iEYEARECAAYFAkB+Uk4ACgkQaJiCLMjyUvv6xgCg0QZ4fkUecMtjp8ecUg88MUmx
R7YAoLgdee6rbPzzcr3xr8dEWc028EMo
=XheG
-----END PGP SIGNATURE-----

 usata bene...
Proprio questo. Troppo spesso ho sentito dire che la scheda audio e' una
ottima fonte di entropia (ma dove?)
perche', invece, non collegare la scheda audio con il pool di entropia
del kernel di linux?


ti ho mandato via mail uno screenshot dell'analisi FFT.
--
CAFxXcrossway -> 
www.cafxx.cjb.net
"Cristiano" <cristi...@NSquipo.it> ha scritto nel messaggio
news:qfhfc.75480$rM4.3...@news4.tin.it...


 ha scritto nel messaggio
news:20040415092...@wiseowl.intranet.dvoptic.com...


 ti ho mandato via mail uno screenshot dell'analisi FFT.
Non ho ricevuto nulla; hai tolto NS?
Cristiano

 bianco della scheda audio.
Io c'avevo creso, ma poi mi sono ricreso.
Cristiano

 errato.
Aspetta, mi pare che non ne usciamo fuori. Sembra che hai paura a testare
'sti cavolo di bit con un test serio; mi mandi qualche centinaio di kappa
che te li testo io?
*Non* mi mandare megabyte di roba che ci metto mezza giornata a scaricarli!
Inviami solo 200, 300 kbyte! Togli NS dall'indirizzo.
Cristiano

 del kernel di linux?
Beh, usare /dev/random, oggi come oggi, equivale a usare Yarrow...
proprio quello che consiglio.
I vantaggi sono ovvi: il sistema funziona anche nel caso che l'entropia
iniziale sia veramente poca e l'output è crittograficamente sicuro.
Io andrei un po' oltre affermando che ogni applicaiozne che ha biosgno
di numeri casuail SERI deve implementare "di suo" un sistema tipo Yarrow
o Fortuna, e non dare *MAI* per scontato che perfino /dev/random produca
"roba già buona"... un approccio forse un po' paranoico, ma che di certo
diminuisce di molto i rischi.
Inoltre una volta messo su un sistema del genere "ogni entropia è
buona", nel senso che una volta messa nel calderone tutto fa brodo...
(l'unico possibile danno nell' "esagerare" è sprecare troppi cicli di
CPU ad hashare roba che in realtà non contiene nulla)
- --
L a p o   L u c h i n i
l a p o @ l a p o . i t
w w w . l a p o . i t /
http://www.megatokyo.it
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.4 (Cygwin)
Comment: Using GnuPG with Mozilla - 
http://enigmail.mozdev.org
iEYEARECAAYFAkB/GioACgkQaJiCLMjyUvtktwCg6nWk+X8xNMwEtKeVGeGyxGw1
ALIAoJqg38mPIxVkxcRpvHRH8+PJMnuJ
=WUZh
-----END PGP SIGNATURE-----


Grazie.
Ciao,
un TJL73 ancora cordiale...
-- 
*Istituto Nazionale per le Adozioni a Distanza*
Adotta un non quotante! Con un contributo di soli 5 post al mese
potrai aiutare un non quotante a reinserirsi nella societa`,
insegnandogli a quotare nel suo paese di origine.           -- Stardust®

 Io c'avevo creso, ma poi mi sono ricreso.
Creso come il leggendario personaggio? e adesso, ci cresi o no?
HappyPerplessoCactus


> Non ho ricevuto nulla; hai tolto NS?
ops... fatto.
--
CAFxXcrossway -> 
www.cafxx.cjb.net

> Grazie.
Prego... non c'č di che.
--
CAFxXcrossway -> 
www.cafxx.cjb.net

 chirp
Se non ricordo male Prati ci ha insegnato: la trasformata di un chirp, è
un chirp.
Ma che c'entra? ^_^""
- --
L a p o   L u c h i n i
l a p o @ l a p o . i t
w w w . l a p o . i t /
http://www.megatokyo.it
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.4 (Cygwin)
Comment: Using GnuPG with Mozilla - 
http://enigmail.mozdev.org
iEYEARECAAYFAkB/5yQACgkQaJiCLMjyUvs0+gCgu/F6gCKK7RHOTxyWAHYqiPr7
ViIAoP0xzdIrtf4N6FLX9+J4DTd4Qigq
=Gp/A
-----END PGP SIGNATURE-----

 Ma che c'entra? ^_^""
Se non mi ricordo male il modulo della trasformata non ha righe, e'
abbastanza piatto, ma e' un segnale tutt'altro che aleatorio. Ma potrei
sbagliare.


 e adesso, ci cresi o no?
No, se mi sono ricreso... non ci credo piů.
Cristiano

 ops... fatto.
Ricevuti sia l'immagine che i bit.
L'immagine non mi dice nulla, i bit testati risultano buoni, ad una prima
analisi.
Il test che potremmo chiamare definitivo, dovresti farlo testando un
centinaio di quelle sequenze che mi hai inviato. Però, stavolta bisogna che
fai da solo. :-)
Io mi sarei aspettato una cosa peggiore da un algoritmo così semplice; si
vede che la scheda ha un discreto rumore.
Cristiano

 fai da solo. :-)
ho fatto il test su 20mb di dati con diehard (rabigete ho qualche problema a
farlo partire... continua a fare il test quello sul vettore anche se nel
file para.txt inserisco il nome del file corretto, come mai?). sotto ci sono
i risultati. ci sono solo un paio di test falliti miseramente (quelli in cui
p-value=1), e che dovrei ricontrollare.
 BIRTHDAY SPACINGS TEST, M= 512 N=2**24 LAMBDA=  2.0000
           random.key      using bits  1 to 24 p-value=  .359630
           random.key      using bits  2 to 25 p-value=  .555489
           random.key      using bits  3 to 26 p-value=  .899820
           random.key      using bits  4 to 27 p-value=  .991398
           random.key      using bits  5 to 28 p-value=  .531536
           random.key      using bits  6 to 29 p-value=  .718022
           random.key      using bits  7 to 30 p-value=  .222798
           random.key      using bits  8 to 31 p-value=  .213789
           random.key      using bits  9 to 32 p-value=  .421407
   The 9 p-values were
        .359630   .555489   .899820   .991398   .531536
        .718022   .222798   .213789   .421407
  A KSTEST for the 9 p-values yields  .261352
----------------------------------------------------------------------------
----
           OPERM5 test for file random.key
 chisquare for 99 degrees of freedom= 97.563; p-value= .477976
           OPERM5 test for file random.key
 chisquare for 99 degrees of freedom=127.186; p-value= .970334
----------------------------------------------------------------------------
----
    Binary rank test for random.key
         Rank test for 31x31 binary matrices:
        rows from leftmost 31 bits of each 32-bit integer
      rank   observed  expected (o-e)^2/e  sum
        28       212     211.4   .001602     .002
        29      5077    5134.0   .633066     .635
        30     23180   23103.0   .256320     .891
        31     11531   11551.5   .036467     .927
  chisquare=  .927 for 3 d. of f.; p-value= .348965
    Binary rank test for random.key
         Rank test for 32x32 binary matrices:
        rows from leftmost 32 bits of each 32-bit integer
      rank   observed  expected (o-e)^2/e  sum
        29       195     211.4  1.274968    1.275
        30      5115    5134.0   .070391    1.345
        31     23113   23103.0   .004288    1.350
        32     11577   11551.5   .056184    1.406
  chisquare= 1.406 for 3 d. of f.; p-value= .413707
----------------------------------------------------------------------------
----
 b-rank test for bits  1 to  8 p=1-exp(-SUM/2)= .78689
 b-rank test for bits  2 to  9 p=1-exp(-SUM/2)= .66997
 b-rank test for bits  3 to 10 p=1-exp(-SUM/2)= .65234
 b-rank test for bits  4 to 11 p=1-exp(-SUM/2)= .39140
 b-rank test for bits  5 to 12 p=1-exp(-SUM/2)= .53496
 b-rank test for bits  6 to 13 p=1-exp(-SUM/2)= .70682
 b-rank test for bits  7 to 14 p=1-exp(-SUM/2)= .29751
 b-rank test for bits  8 to 15 p=1-exp(-SUM/2)= .70157
 b-rank test for bits  9 to 16 p=1-exp(-SUM/2)= .41916
 b-rank test for bits 10 to 17 p=1-exp(-SUM/2)= .82730
 b-rank test for bits 11 to 18 p=1-exp(-SUM/2)= .77494
 b-rank test for bits 12 to 19 p=1-exp(-SUM/2)= .42175
 b-rank test for bits 13 to 20 p=1-exp(-SUM/2)= .74352
 b-rank test for bits 14 to 21 p=1-exp(-SUM/2)= .58565
 b-rank test for bits 15 to 22 p=1-exp(-SUM/2)= .97944
 b-rank test for bits 16 to 23 p=1-exp(-SUM/2)= .95456
 b-rank test for bits 17 to 24 p=1-exp(-SUM/2)= .61965
 b-rank test for bits 18 to 25 p=1-exp(-SUM/2)= .91448
 b-rank test for bits 19 to 26 p=1-exp(-SUM/2)= .02121
 b-rank test for bits 20 to 27 p=1-exp(-SUM/2)= .02912
 b-rank test for bits 21 to 28 p=1-exp(-SUM/2)= .85554
 b-rank test for bits 22 to 29 p=1-exp(-SUM/2)= .21953
 b-rank test for bits 23 to 30 p=1-exp(-SUM/2)= .37896
 b-rank test for bits 24 to 31 p=1-exp(-SUM/2)= .00615
 b-rank test for bits 25 to 32 p=1-exp(-SUM/2)= .63564
   TEST SUMMARY, 25 tests on 100,000 random 6x8 matrices
 These should be 25 uniform [0,1] random variables:
     .786891     .669975     .652341     .391404     .534960
     .706824     .297511     .701568     .419163     .827300
     .774941     .421749     .743518     .585652     .979441
     .954558     .619651     .914479     .021213     .029124
     .855537     .219525     .378964     .006146     .635636
   brank test summary for random.key
       The KS test for those 25 supposed UNI's yields
                    KS p-value= .713807
----------------------------------------------------------------------------
----
  No. missing words should average  141909. with sigma=428.
 tst no  1:  141915 missing words,     .01 sigmas from mean, p-value= .50529
 tst no  2:  142106 missing words,     .46 sigmas from mean, p-value= .67707
 tst no  3:  141219 missing words,   -1.61 sigmas from mean, p-value= .05338
 tst no  4:  141670 missing words,    -.56 sigmas from mean, p-value= .28802
 tst no  5:  142163 missing words,     .59 sigmas from mean, p-value= .72331
 tst no  6:  141848 missing words,    -.14 sigmas from mean, p-value= .44303
 tst no  7:  141926 missing words,     .04 sigmas from mean, p-value= .51554
 tst no  8:  142182 missing words,     .64 sigmas from mean, p-value= .73796
 tst no  9:  141066 missing words,   -1.97 sigmas from mean, p-value= .02440
 tst no 10:  142083 missing words,     .41 sigmas from mean, p-value= .65755
 tst no 11:  142146 missing words,     .55 sigmas from mean, p-value= .70986
 tst no 12:  143150 missing words,    2.90 sigmas from mean, p-value= .99813
 tst no 13:  142016 missing words,     .25 sigmas from mean, p-value= .59841
 tst no 14:  141455 missing words,   -1.06 sigmas from mean, p-value= .14423
 tst no 15:  141700 missing words,    -.49 sigmas from mean, p-value= .31239
 tst no 16:  141565 missing words,    -.80 sigmas from mean, p-value= .21055
 tst no 17:  141721 missing words,    -.44 sigmas from mean, p-value= .32996
 tst no 18:  141809 missing words,    -.23 sigmas from mean, p-value= .40733
 tst no 19:  141697 missing words,    -.50 sigmas from mean, p-value= .30991
 tst no 20:  142267 missing words,     .84 sigmas from mean, p-value= .79833
----------------------------------------------------------------------------
----
    OPSO for random.key      using bits 23 to 32        142607  2.406  .9919
    OPSO for random.key      using bits 22 to 31        142615  2.433  .9925
    OPSO for random.key      using bits 21 to 30        142253  1.185  .8820
    OPSO for random.key      using bits 20 to 29        142266  1.230  .8906
    OPSO for random.key      using bits 19 to 28        141847  -.215  .4149
    OPSO for random.key      using bits 18 to 27        142207  1.026  .8477
    OPSO for random.key      using bits 17 to 26        141845  -.222  .4122
    OPSO for random.key      using bits 16 to 25        142112   .699  .7577
    OPSO for random.key      using bits 15 to 24        142090   .623  .7334
    OPSO for random.key      using bits 14 to 23        142182   .940  .8265
    OPSO for random.key      using bits 13 to 22        142562  2.251  .9878
    OPSO for random.key      using bits 12 to 21        142219  1.068  .8572
    OPSO for random.key      using bits 11 to 20        142124   .740  .7704
    OPSO for random.key      using bits 10 to 19        141862  -.163  .4352
    OPSO for random.key      using bits  9 to 18        142015   .364  .6422
    OPSO for random.key      using bits  8 to 17        141688  -.763  .2227
    OPSO for random.key      using bits  7 to 16        141761  -.511  .3045
    OPSO for random.key      using bits  6 to 15        142209  1.033  .8493
    OPSO for random.key      using bits  5 to 14        142030   .416  .6613
    OPSO for random.key      using bits  4 to 13        141622  -.991  .1609
    OPSO for random.key      using bits  3 to 12        142284  1.292  .9018
    OPSO for random.key      using bits  2 to 11        142677  2.647  .9959
    OPSO for random.key      using bits  1 to 10        141917   .026  .5106
    OQSO for random.key      using bits 28 to 32        141640  -.913  .1806
    OQSO for random.key      using bits 27 to 31        141963   .182  .5722
    OQSO for random.key      using bits 26 to 30        142422  1.738  .9589
    OQSO for random.key      using bits 25 to 29        142136   .768  .7789
    OQSO for random.key      using bits 24 to 28        142437  1.789  .9632
    OQSO for random.key      using bits 23 to 27        142368  1.555  .9400
    OQSO for random.key      using bits 22 to 26        142449  1.829  .9663
    OQSO for random.key      using bits 21 to 25        142304  1.338  .9095
    OQSO for random.key      using bits 20 to 24        142186   .938  .8258
    OQSO for random.key      using bits 19 to 23        142706  2.701  .9965
    OQSO for random.key      using bits 18 to 22        142338  1.453  .9269
    OQSO for random.key      using bits 17 to 21        142484  1.948  .9743
    OQSO for random.key      using bits 16 to 20        142288  1.284  .9004
    OQSO for random.key      using bits 15 to 19        142453  1.843  .9673
    OQSO for random.key      using bits 14 to 18        142322  1.399  .9191
    OQSO for random.key      using bits 13 to 17        142319  1.389  .9175
    OQSO for random.key      using bits 12 to 16        142260  1.189  .8827
    OQSO for random.key      using bits 11 to 15        142253  1.165  .8780
    OQSO for random.key      using bits 10 to 14        141647  -.889  .1869
    OQSO for random.key      using bits  9 to 13        142804  3.033  .9988
    OQSO for random.key      using bits  8 to 12        142718  2.741  .9969
    OQSO for random.key      using bits  7 to 11        142469  1.897  .9711
    OQSO for random.key      using bits  6 to 10        142567  2.229  .9871
    OQSO for random.key      using bits  5 to  9        142450  1.833  .9666
    OQSO for random.key      using bits  4 to  8        142077   .568  .7151
    OQSO for random.key      using bits  3 to  7        142576  2.260  .9881
    OQSO for random.key      using bits  2 to  6        141959   .168  .5669
    OQSO for random.key      using bits  1 to  5        142579  2.270  .9884
     DNA for random.key      using bits 31 to 32        142442  1.571  .9419
     DNA for random.key      using bits 30 to 31        141980   .208  .5826
     DNA for random.key      using bits 29 to 30        142228   .940  .8264
     DNA for random.key      using bits 28 to 29        142403  1.456  .9273
     DNA for random.key      using bits 27 to 28        141646  -.777  .2186
     DNA for random.key      using bits 26 to 27        141838  -.210  .4167
     DNA for random.key      using bits 25 to 26        142882  2.869  .9979
     DNA for random.key      using bits 24 to 25        141771  -.408  .3416
     DNA for random.key      using bits 23 to 24        141449 -1.358  .0872
     DNA for random.key      using bits 22 to 23        141836  -.216  .4144
     DNA for random.key      using bits 21 to 22        142129   .648  .7415
     DNA for random.key      using bits 20 to 21        143234  3.908 1.0000
     DNA for random.key      using bits 19 to 20        141717  -.567  .2852
     DNA for random.key      using bits 18 to 19        142415  1.492  .9321
     DNA for random.key      using bits 17 to 18        142288  1.117  .8680
     DNA for random.key      using bits 16 to 17        142459  1.621  .9475
     DNA for random.key      using bits 15 to 16        142597  2.029  .9787
     DNA for random.key      using bits 14 to 15        141919   .029  .5114
     DNA for random.key      using bits 13 to 14        143241  3.928 1.0000
     DNA for random.key      using bits 12 to 13        142468  1.648  .9503
     DNA for random.key      using bits 11 to 12        141762  -.435  .3319
     DNA for random.key      using bits 10 to 11        142189   .825  .7953
     DNA for random.key      using bits  9 to 10        143183  3.757  .9999
     DNA for random.key      using bits  8 to  9        142018   .321  .6257
     DNA for random.key      using bits  7 to  8        141906  -.010  .4961
     DNA for random.key      using bits  6 to  7        142451  1.598  .9450
     DNA for random.key      using bits  5 to  6        142545  1.875  .9696
     DNA for random.key      using bits  4 to  5        142218   .911  .8187
     DNA for random.key      using bits  3 to  4        142619  2.093  .9818
     DNA for random.key      using bits  2 to  3        141985   .223  .5883
     DNA for random.key      using bits  1 to  2        142973  3.138  .9991
----------------------------------------------------------------------------
----
   Test results for random.key
 Chi-square with 5^5-5^4=2500 d.of f. for sample size:2560000
                               chisquare  equiv normal  p-value
  Results fo COUNT-THE-1's in successive bytes:
 byte stream for random.key       3167.93      9.446     1.000000
 byte stream for random.key       3201.16      9.916     1.000000
----------------------------------------------------------------------------
----
 Chi-square with 5^5-5^4=2500 d.of f. for sample size: 256000
                      chisquare  equiv normal  p value
  Results for COUNT-THE-1's in specified bytes:
           bits  1 to  8  2560.16       .851      .802566
           bits  2 to  9  2627.26      1.800      .964044
           bits  3 to 10  2422.01     -1.103      .135017
           bits  4 to 11  2584.66      1.197      .884402
           bits  5 to 12  2566.46       .940      .826373
           bits  6 to 13  2506.58       .093      .537048
           bits  7 to 14  2589.98      1.272      .898394
           bits  8 to 15  2519.54       .276      .608837
           bits  9 to 16  2533.51       .474      .682221
           bits 10 to 17  2702.02      2.857      .997861
           bits 11 to 18  2530.45       .431      .666635
           bits 12 to 19  2588.16      1.247      .893762
           bits 13 to 20  2570.12       .992      .839300
           bits 14 to 21  2637.53      1.945      .974111
           bits 15 to 22  2670.63      2.413      .992092
           bits 16 to 23  2714.33      3.031      .998781
           bits 17 to 24  2530.84       .436      .668629
           bits 18 to 25  2578.54      1.111      .866652
           bits 19 to 26  2761.73      3.701      .999893
           bits 20 to 27  2595.07      1.345      .910609
           bits 21 to 28  2723.67      3.163      .999220
           bits 22 to 29  2556.85       .804      .789314
           bits 23 to 30  2630.09      1.840      .967101
           bits 24 to 31  2583.87      1.186      .882201
           bits 25 to 32  2495.52      -.063      .474716
----------------------------------------------------------------------------
----
           CDPARK: result of ten tests on file random.key
            Of 12,000 tries, the average no. of successes
                 should be 3523 with sigma=21.9
            Successes: 3531    z-score:   .365 p-value: .642555
            Successes: 3529    z-score:   .274 p-value: .607947
            Successes: 3520    z-score:  -.137 p-value: .445521
            Successes: 3501    z-score: -1.005 p-value: .157553
            Successes: 3498    z-score: -1.142 p-value: .126820
            Successes: 3508    z-score:  -.685 p-value: .246694
            Successes: 3477    z-score: -2.100 p-value: .017844
            Successes: 3502    z-score:  -.959 p-value: .168804
            Successes: 3553    z-score:  1.370 p-value: .914635
            Successes: 3543    z-score:   .913 p-value: .819442
           square size   avg. no.  parked   sample sigma
             100.            3516.200       21.981
            KSTEST for the above 10: p=  .435350
----------------------------------------------------------------------------
----
               This is the MINIMUM DISTANCE test
              for random integers in the file random.key
     Sample no.    d^2     avg     equiv uni
           5     .4847    .8347     .385640
          10     .9829    .7562     .627617
          15     .5449    .6159     .421695
          20     .4802    .7150     .382835
          25     .6145    .7163     .460744
          30    2.4121    .8565     .911449
          35     .2712    .7934     .238542
          40    1.6348    .8270     .806611
          45     .1876    .8334     .171796
          50    1.7932    .8547     .835059
          55    2.3917    .8680     .909620
          60    2.1415    .8928     .883775
          65    1.1854    .8631     .696189
          70     .1947    .8685     .177730
          75    1.6629    .8740     .811981
          80    2.1417    .9202     .883798
          85     .4110    .8948     .338354
          90     .9987    .8763     .633482
          95    2.6676    .8815     .931507
         100    1.3540    .9294     .743534
     MINIMUM DISTANCE TEST for random.key
          Result of KS test on 20 transformed mindist^2's:
                                  p-value= .315871
----------------------------------------------------------------------------
----
               The 3DSPHERES test for file random.key
 sample no:  1     r^3=  77.651     p-value= .92486
 sample no:  2     r^3=  41.127     p-value= .74612
 sample no:  3     r^3=  12.671     p-value= .34452
 sample no:  4     r^3=  58.708     p-value= .85871
 sample no:  5     r^3=  80.673     p-value= .93206
 sample no:  6     r^3=  13.892     p-value= .37066
 sample no:  7     r^3=   1.145     p-value= .03744
 sample no:  8     r^3=   2.590     p-value= .08271
 sample no:  9     r^3=  23.587     p-value= .54444
 sample no: 10     r^3=  23.358     p-value= .54096
 sample no: 11     r^3=  21.961     p-value= .51907
 sample no: 12     r^3=  12.081     p-value= .33148
 sample no: 13     r^3=  42.328     p-value= .75608
 sample no: 14     r^3=  10.717     p-value= .30039
 sample no: 15     r^3=  14.102     p-value= .37505
 sample no: 16     r^3=  43.207     p-value= .76313
 sample no: 17     r^3=  46.981     p-value= .79113
 sample no: 18     r^3=  15.727     p-value= .40799
 sample no: 19     r^3=  20.403     p-value= .49344
 sample no: 20     r^3=   6.686     p-value= .19977
       3DSPHERES test for file random.key           p-value= .122346
----------------------------------------------------------------------------
----
            RESULTS OF SQUEEZE TEST FOR random.key
         Table of standardized frequency counts
     ( (obs-exp)/sqrt(exp) )^2
        for j taking values <=6,7,8,...,47,>=48:
     -.8      .5    -1.3      .8    -1.9      .8
      .1    -1.6      .4     -.5     -.4    -1.7
    -1.7    -2.0     -.9     -.3    -3.1    -2.1
      .3     1.0    -1.0     2.9     2.4      .4
     2.1     3.5     1.1     2.8     2.6     3.7
     1.6     1.0     -.8      .2     1.6     1.5
      .3     1.8      .5     -.1     2.4      .0
     -.1
           Chi-square with 42 degrees of freedom:115.782
              z-score=  8.050  p-value=1.000000
______________________________________________________________
----------------------------------------------------------------------------
----
                Test no.  1      p-value  .036162
                Test no.  2      p-value  .923399
                Test no.  3      p-value  .971143
                Test no.  4      p-value  .550504
                Test no.  5      p-value  .560349
                Test no.  6      p-value  .180489
                Test no.  7      p-value  .473630
                Test no.  8      p-value  .309702
                Test no.  9      p-value  .015079
                Test no. 10      p-value  .911911
   Results of the OSUM test for random.key
        KSTEST on the above 10 p-values:  .454631
----------------------------------------------------------------------------
----
           The RUNS test for file random.key
     Up and down runs in a sample of 10000
_________________________________________________
                 Run test for random.key     :
       runs up; ks test for 10 p's: .156681
     runs down; ks test for 10 p's: .458265
                 Run test for random.key     :
       runs up; ks test for 10 p's: .135774
     runs down; ks test for 10 p's: .837644
----------------------------------------------------------------------------
----
                Results of craps test for random.key
  No. of wins:  Observed Expected
                                98693    98585.86
 Chisq=  33.97 for 20 degrees of freedom, p=  .97370
               Throws Observed Expected  Chisq     Sum
            SUMMARY  FOR random.key
                p-value for no. of wins: .684100
                p-value for throws/game: .973697
  Test completed.  File random.key
::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
:::::
--
CAFxXcrossway -> 
www.cafxx.cjb.net

 ricontrollare.
Ho visto che fallisce "COUNT-THE-1's in successive bytes". Hai piů riprovato
questo test con altre sequenze?
Non vedo i test della versione 0.2 (Gorilla, GCD e Tough Bday). Hai usato
una versione vecchia?
Non so se ne sei al corrente, ma per far funzionare dh correttamente
dovresti trovare i post sparpagliati per tutto sci.crypt relativi a tutti i
bug.
L'ultima versione (che dovrebbe essere la 0.2b) che io sappia, ha solo uno o
due test bacati: uno č l'overlap sum test (ho postato qualche messaggio su
sci.crypt), l'altro non me lo ricordo piů.
Cristiano

 un sinc)
No, sono certo di no: il sinc è la trasformata del rettangolo, e quindi
non di un chirp.
Cosa intendi con "sinc un po' particolare"?
per definizione sinc(x)=sin(2*pi*x)/x
Non è che ce ne sono 'tipi' più o meno particolari...
Certo, se il chirp lo consideri limitato in frequenza (= moltiplicato
per un rettangolo), la sua trasformata risulta covnoluta per un sinc.
Ma qualcosa convoluto con un sinc non è un sinc, è una funzione diversa.
Andando a memoria (non trovo gli appunti del terzo anno...) comunque
resto convinto che la trasformata di un chirp è sempre un chirp;
eventualmente non resta che verificare:
chirp(t) = sin (2 %pi f t^2)
chirp(f) = integrate(chirp(t) * exp(- 2 * %i * %pi * f * t), t)
= integrate(sin (2 %pi f t^2) * exp(- 2 * %i * %pi * f * t), t)
Mi piacerebbe non aver perso la manualità di un tempo ed essere ancora
capace di risolvere a mano questo semplice integrale.
- --
L a p o   L u c h i n i
l a p o @ l a p o . i t
w w w . l a p o . i t /
http://www.megatokyo.it
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.4 (Cygwin)
Comment: Using GnuPG with Mozilla - 
http://enigmail.mozdev.org
iEYEARECAAYFAkCCRD4ACgkQaJiCLMjyUvtXKwCfeut7X2XkTMBw/2u24M3Y6c2G
YhEAn2OY4+9dDWHRVcEJyv2CfCqzxLjz
=twfU
-----END PGP SIGNATURE-----

 Come creduto.
Buffo, avevo un compagno delle superiore che usava sempre quella
"storipiatura"...
- --
L a p o   L u c h i n i
l a p o @ l a p o . i t
w w w . l a p o . i t /
http://www.megatokyo.it
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.4 (Cygwin)
Comment: Using GnuPG with Mozilla - 
http://enigmail.mozdev.org
iEYEARECAAYFAkCCReYACgkQaJiCLMjyUvthnACfYoZJYhqMBeQ1i4+M9ODOCoUL
ITMAn1J6yBQcP2hE9CxQDfDuY9XTOsDZ
=Yv6i
-----END PGP SIGNATURE-----

 sbagliare.
Forse quello che ricordi è che il chirp viene usato ad esempio nei radar
perché ha una autocorrelazione che praticamente è una delta nello 0,
quindi si può avere dei radar con potenza distribuita anche su svariati
secondi di segnale, e ottenere lo stesso effetto di un radar con potenza
impulsiva, quindi cno risoluzione molto maggiore.
Questo comunque c'entra abbastanza oco con l'autocorrelazione di un
segnale "putativamente bianco"...
- --
L a p o   L u c h i n i
l a p o @ l a p o . i t
w w w . l a p o . i t /
http://www.megatokyo.it
-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1.2.4 (Cygwin)
Comment: Using GnuPG with Mozilla - 
http://enigmail.mozdev.org
iEYEARECAAYFAkCCROkACgkQaJiCLMjyUvtm/gCg2bo50rfHKSRAcZqsowGCA35F
hiMAnixqnJwZjIQqseMbMQg7MZWPtk1s
=dk/0
-----END PGP SIGNATURE-----

 bugs.
Da quel che mi ricordo, dovresti andare qui
http://stat.fsu.edu/pub/diehard/
e riempire il modulo che compare, poi scarichi il programma.
Per i bug, come ti dicevo, devi scandagliare tutto sci.crypt; ne ha (o ne
aveva) talmente tanti che non č possibile dare veloci ragguagli. Il
consiglio piů veloce č di non usarlo.
Tieni presente che i tre nuovi test di cui l'autore dice: "generators that
pass the three tests seem to pass all the tests in the Diehard Battery of
Tests." li ho inclusi in RaBiGeTe togliendo i bug e verificandoli
scrupolosamente, per cui...
Cristiano

ah beh... allora...
in questo momento sto facendo un test sui 20mb con questi parametri
[General]
NT 1  # Number of tests
n 20000000 B  # Sequence length [kb, Mb, Gb, kB, MB, GB; b=bits, B=bytes]
auto_n 0  # If =1 n will be accomodated to run all the enabled tests
GenStat 1 # NOT USED If =1 will be showed sample mean, std dev., skewness
and kurtosis
ShowPvals 1 # If =1 the p-values will be showed while the test generates
them
OverallTestNumber 0 # If =0 the overall p-value for the test# is skipped (it
is really useless)
filename "c:\documenti\programmi\shield\random.key" # Full path of the input
file
# You can change the test order but NOT the test names
[Enable] 1= test enabled, 0= test disabled
1 DFT # My very sensitive test
1 AMLS # Based on Mitzenmacher's "Advanced Multi-Level Strategy"
1 Serial two-bit # FIPS140
1 Blocks'n'gaps # FIPS140 Runs
1 Short blocks # FIPS140 Poker. Setting the blocks width equal to 1 yields
the frequency test.
1 Long blocks # NIST BlockFrequency
1 Serial
1 Runs
1 Non overlapping template matchings
1 Cumulative sum
1 Autocorrelation
1 Maurer
1 6x8
1 31x31
1 32x32
1 Gorilla
1 GCD
1 Tough birthday spacings
# TEST PARAMETERS (DON'T CHANGE THE TEST NAMES, change only the numbers)
[DFT]
128 Mb # max n used in the DFT test (save the memory and the running time)
[Maurer]
2 12 2 1000 # min, max, step, N. If max=16 this test needs about 1 Gbit
[Short blocks]
2 20 2 # min, max, step
[Long blocks]
1024 65536 256 # min, max, step
[Autocorrelation]
2 512 2 # min, max, step
[Non overlapping template matchings]
2 20 2 1000 # min, max, step, templates
[Serial]
2 512 2 # min, max, step
[Rank 6x8]
2 512 1 # min, max, step
cosa succede se il valore mio di n (20Mb) è minore di quello auto-impostato
con l'opzione auto_n attivata?
--
CAFxXcrossway -> 
www.cafxx.cjb.net

 con l'opzione auto_n attivata?
Il programma testa soltanto i bit che gli fornisci e quando tenta di
caricare gli altri s'interrompe con un messaggio d'errore.
Se hai 20 MByte a disposizione, ti consiglio di usare anche questi parametri
NT 100
n 1677721
auto_n 0
(non verranno eseguiti i test di dh).
Volendo puoi ridurre questi:
[Long blocks]
1024 4096 1024 # min, max, step
[Autocorrelation]
2 64 2 # min, max, step
[Non overlapping template matchings]
2 20 2 50 # min, max, step, templates
mentre [Serial] è limitato automaticamente a log2(n)-2.
Hai già disponibili i risultati?
Cristiano

ah beh... allora...
in questo momento sto facendo un test sui 20mb con questi parametri
[General]
NT 1  # Number of tests
n 20000000 B  # Sequence length [kb, Mb, Gb, kB, MB, GB; b=bits, B=bytes]




1 Autocorrelation
1 Maurer


[DFT]
128 Mb # max n used in the DFT test (save the memory and the running time)
[Maurer]
2 12 2 1000 # min, max, step, N. If max=16 this test needs about 1 Gbit
[Short blocks]
2 20 2 # min, max, step
[Long blocks]
1024 65536 256 # min, max, step
[Autocorrelation]
2 512 2 # min, max, step
[Non overlapping template matchings]
2 20 2 1000 # min, max, step, templates
[Serial]
2 512 2 # min, max, step
[Rank 6x8]
2 512 1 # min, max, step
cosa succede se il valore mio di n (20Mb) è minore di quello auto-impostato
con l'opzione auto_n attivata?
--
CAFxXcrossway -> 
www.cafxx.cjb.net

no, sta ancora macinando...
(anche perchè per sicurezza lo ho lanciato come rabigete para.txt > trng.log
e quindi non vedo neanche a che punto è)
cmq adesso ho fatto partire il generatore in un compito improbo: 125 MB.
(avevo letto che per Maurer16 ci voleva 1Gb e così volevo provare). l'unico
problemino è che ci sta mettendo circa tre ore... (eh si... è un pò lento...
ma l'entropia da qualche parte devo pure pescarla!)
forse stasera ti faccio sapere qualcosa...
mi mandi mica (mail o ng) un file para.txt già pronto con *TUTTI* i test al
"massimo grado"? così lascio acceso stanotte e domani ho i risultati...
--
CAFxXcrossway -> 
www.cafxx.cjb.net

 risultati...
A parte DFT, i test sono tutti abbastanza veloci. Tanto per capire meglio,
puoi dirmi CPU e RAM?
Ti ho mandato 3 file: "para1.txt" ha tutti test ad un grado ragionevolmente
alto. Tutto al massimo è una follia! Avresti qualche milione di numeri a 7
cifre da controllare uno per uno...
"para2.txt" esegue solo Maurer con 2  14  2  4300 (come ti dicevo più sopra)
e "para3.txt" esegue i test usando 100 sequenze da 1250000 byte.
Cristiano

 mi mandi mica (mail o ng) un file para.txt [...]
L'indirizzo 
ca...@n-side.it
 non funge. Che mail hai?
Cristiano

 No, se mi sono ricreso... non ci credo più.
ah, allora siam d'accordo.


 segnale "putativamente bianco"...
Non lo so, a questo punto comincio a dubitare dei miei ricordi di teoria
dei segnali.
Faccio ammenda per aver alzato il polverone, e mi cospargo il capo di
cenere. Qualcuno ne ha da prestarmene un chilo o due?


mi ero dimenticato di modificare l'account...
ora è giusta.
--
CAFxXcrossway -> 
www.cafxx.cjb.net
"Cristiano" <cristi...@NSquipo.it> ha scritto nel messaggio
news:_nDgc.99845$rM4.3...@news4.tin.it...


 ora è giusta.
Non funge nemmeno adesso.
Cristiano

uff... strano!
prova qui allora: 
news...@cafxx.cjb.net
--
CAFxXcrossway -> 
www.cafxx.cjb.net
"Cristiano" <cristi...@NSquipo.it> ha scritto nel messaggio
news:OtXgc.106210$rM4.4...@news4.tin.it...


 prova qui allora: 
news...@cafxx.cjb.net
Sembra che funga...
Fammi sapere.
Cristiano