Newsgroup: it.comp.sicurezza.pgp
Titolo: Curiosità sulle chiavi, e in particolare RSA........................

Volevo chiedere un paio di informazioni. Ho trovato in giro un po' di
documentazione che tratta la crittografia asimmetrica, e non ho ben
capito cosa si inteda per bit di una chiave (la dimensione in bit del
ciphertext su cui effettuare la codifica con la chiave lunga lo
stesso numero di bits?)
Mi spiego meglio: la suddetta documentazione è "tipicamente
accademica", ovvero carica di speculazioni teoriche e niente che
possa fare qualche esempio pratico, quindi alla fine è lecito avere
dei dubbi. Su RSA si parla di chiavi a 512, 1024 ecc bits facendo
riferimento al *solo* modulo pubblico della chiave, e sembra quasi
che la crittazione del testo avvenga sempre con lo stesso modulo e
relativo esponente pubblico della chiave. Ma se così fosse, fatta
eccezzione per gli enormi calcoli esponenziali, il tutto si
tramuterebbe in una semplicissima sostituzione
carattere<-->carattere.
Per esempio supponiamo che la frase "palla", crittografata anche con
un modulo enorme, diventi un qualcosa simile a "hebbe". Se venisse
impiegato sempre lo stesso modulo e lo stesso esponente pubblico
tutte le "a" nella frase verebbero trasformate in "e", e le "l" in
"b": quindi alla fine ci sarebbe una semplice sostituzione e
basta...........................
Ma come ho già detto la documentazione è poco chiara, e si tratta in
particolar modo di speculazioni matematiche squisitamente teoriche.
Sempre su RSA c'è scritto che per avere un'ottima sicurezza è
necessario usare un modulo pubblico che abbia più di 1024 cifre (e
sembra quasi che qui cifre e bit vengano usati per determinare la
stessa identica cosa). E poi come si gestisce un numero di 1024 cifre
districandosi dall'overflow????? Si potrebbe usare qualche proprietà
della matematica modulare (forse), ma un computer non riuscirebbe mai
a interpretare e manipolare un numero così grande (se non sotto forma
di stringa, e quindi completamente inutile...........), o forse mi
sta sfuggendo qualcosa??!?!? Senza contare che anche se il computer
accettasse un numero così grande, un'esponenziale di quel tipo
porterebbe via diverse ore di elaborazione............
Sicuramente ci sono delle proprietà per allegerire tutti questi
calcoli.................................
Spero che qualcuno sappia darmi una mano e risolvere i miei (tanti)
dubbi sull'argomento.
A quanti risponderanno,
un grazie anticipato

stesso numero di bits?)
Semplcie 8 bit fanno come sai un byte un byte e' anche la lunghezza di
un carattere quindi in generale vale che ad esempio una chiave :
"pippo" sia una chiave lunga 40Bit :-)
Augusto Pucci
Webmaster di Prospektiva On-line
http://www.prospektiva.it

carattere<-->carattere.
Il mio inglese non è corretto, ma ma quello che ho capito leggendo qua
e là l'RSA viene usato solo per crittografare la chiave pubblica, per
il messaggio si usano altri algoritmi, come IDEA, 3DES CAST MD5 Ecc.
IDEA é abbastanza vecchio e collaudato e non si hanno notizie che sia
stato violato, in più è possibile attaccarlo solo a "forza brutta"...
Hai già letto le Faq di 
www.pgpi.com
 ???
Ciao
------------
Beep Bepp
           Roby
Togliere XXX per rispondere via Email
PGP KEY  Disponibile

dubbi sull'argomento.
Spero di averti aiutatop almeno un po'. Il casino è cercare di essere
chiari senza poter usare simboli matematici e disegni, ma solo
scrivendo in formato testo.
Cmq sappi che per "bazzicare" nel mondo della sicurezza occorrono solo
poche regolette di algebra dei campi finiti (che per lo più sono
identiche a quelle dell'algebra classica). Non farti spaventare dai
nomi altisonanti. Algebra dei campi finiti o algebra modulare vuol
dire solo che invece che considerare numeri da -inf a +inf considero
uno spazio dei residui che va per es da 0-187. In questa nuova algebra
mod187 i numeri 0,1,2,....187 valgono 0,1,2,...,187 mentre per es 188
vale 0, 189 vale 1, etc. Lo spazio dei residui è circolare, non
lineare. Tutte le operazioni (tranne inversione e log) sono come
nell'algebra elementare (classica) solo che il risultato va riportato
entro lo spazio 0-187.
PS agli esperti di sicurezza:
scusate il linguaggio altamente semplificativo e poco preciso poco
ricco di terminologia matematica, ma reputo che per spiegare una cosa
semplice si può tentare di adottare all'inizio un linguaggio molto
semplice.
See Ya ;-)
_____________________________________________
Per rispondere via e-mail
togliere "101" dall'indirizzo.
_____________________________________________

stato violato, in più è possibile attaccarlo solo a "forza brutta"...
IDEA è stato l'unico contributo europeo al tema sicurezza, per il
resto esistono solo USA, Israele e Giappone.
Non è poi così vecchio ma in sostanza non è stato un gran successo.
Sul breackaggio di IDEA non so nulla perchè non l'ho mai studiato
seriamente.


Ciao,
prima di tutto lascia che ti ringrazi per la tua risposta abbastanza
esaustiva................
Ma ho ancora qualche dubbio (alcuni sono gli stessi che ho citato in
precedenza ma ai quali non ho avuto una risposta decisa, quindi cercherò di
spiegarmi meglio...........):
Consideriamo per il momento RSA e una chiave da 1024 bit che è un numero da
309 cifre. Ok. Come da mia precedente mail, se io do in pasto all'algoritmo
con questa chiave enorme una frase del tipo "palla", lui mi tirerà fuori una
frase, per esempio, "hebbe", sostituendo cioè ad ogni "a" una "e" e ad ogni
"l" una "b". Questo perchè tutte le "a" hanno un valore x e tutte le "l" un
valore y, e passate all'algoritmo si ottiene un risultato uguale per tutte
le x e uno uguale per tutte le y. Quindi, se le cose fossero come io le ho
appena descritte (e di sicuro in pratica non le sono, ma vorrei capire bene
come funziona) l'algoritmo RSA operando sempre sullo stesso modulo "n" e
sullo stesso esponente "e" per tutti i caratteri del plain text
somiglierebbe molto ad un Cifrario di Vigenère, data la sostituzione
carattere<-->carattere. L'unica differenza sarebbe nei calcoli assurdi che
ci sono in RSA (anche se semplificati dall'algebra lineare), ma alla fine
forzare RSA ottenuto in questo modo sarebbe come forzare il suddetto
Cifrario.............................................
Io pensavo alla lunghezza della chiave come numero di esponente/modulo (nel
senso 1024bit/8=128 esponenti con relativo modulo pubblico), in modo che
venisse usato un esponente/modulo diverso sul plain text, una cosa di questo
genere (non so se hai familiarità con C++/Java..........)
for (int i=0,int j=0;i<plaintext.length();i++,j=(j+1)%chiave.length())
    plaintext[i]=RSA(plaintext[i],chiave[j].esponente,chiave[j].modulo);
dove RSA è un metodo per il calcolo del ciphertext ottenuto semplificando
con l'algebra lineare il ben noto C=M^e mod N
Un ragionamento di questo tipo sarebbe più sensato, il risultato non
somiglierebbe per niente ad un semplice cifrario di Vigenère e sarebbe senza
omba di dubbio più complesso risalire al plain text perchè invece di rompere
un solo modulo o indovinare la sostituzione se ne dovrebbero
rompere/indovinare ben 128..............
Comunque aspetto una tua risposta
sull'argomento..................................
Altro problema: semplificazione dei calcoli con l'algebra modulare.
Avevo già pensato ad una cosa del genere, e ho implementato una soluzione
che se velocizza (e di molto i calcoli) non sempre mi salva dall'overflow.
Si tratta di estrarre uno sviluppo binario dell'esponente e fattorizzare lo
stesso applicando delle formule simili di algebra modulare che ti stesso mi
hai riportato. Il problema è che un numero di 309 cifre (per tornare alla
famosa chiave di 1024 bit che dicevi tu) non posso assegnarlo ad una
variabile! Appena lo faccio scatta l'overflow (come è normale). Ma come
faccio a usare delle regole di algebra modulare se neanche riesco a
manipolare il numero???
Questi sono problemi che sorgono sempre all'atto pratico (quanto implementi
un determinato sistema) e che in teoria non si pongono mai................:(
Sapresti poi indicarmi qualche risorsa online che tratta gli algoritmi CAST,
IDEA, DES, TDES e Diffie-Hellmann facendo anche degli esempi pratici, in
modo che il compito del programmatore (in questo caso io) venga notevolmente
semplificato?
Grazie ancora,
ciao

semplificato?
Hai gia` letto i sorgenti di gnupg? (
http://gnupg.linux.it
)
-- 
ciao, |
Marco | * The Internet is full. Go away.  -- Joel Furr *
      | (Ri)scoprire fidonet: 
http://bbs.mi.linux.it

 Hai gia` letto i sorgenti di gnupg? (
http://gnupg.linux.it
)
No, ma ci vado a fare un salto appena posso.............
Grazie

Ciao,
prima di tutto lascia che ti ringrazi per la tua risposta abbastanza
esaustiva................
Ma ho ancora qualche dubbio (alcuni sono gli stessi che ho citato in
precedenza ma ai quali non ho avuto una risposta decisa, quindi cercherò di
spiegarmi meglio...........):
Consideriamo per il momento RSA e una chiave da 1024 bit che è un numero da
309 cifre. Ok. Come da mia precedente mail, se io do in pasto all'algoritmo
con questa chiave enorme una frase del tipo "palla", lui mi tirerà fuori una
frase, per esempio, "hebbe", sostituendo cioè ad ogni "a" una "e" e ad ogni
"l" una "b". Questo perchè tutte le "a" hanno un valore x e tutte le "l" un
valore y, e passate all'algoritmo si ottiene un risultato uguale per tutte
le x e uno uguale per tutte le y. Quindi, se le cose fossero come io le ho
appena descritte (e di sicuro in pratica non le sono, ma vorrei capire bene
come funziona) l'algoritmo RSA operando sempre sullo stesso modulo "n" e
sullo stesso esponente "e" per tutti i caratteri del plain text
somiglierebbe molto ad un Cifrario di Vigenère, data la sostituzione
carattere<-->carattere. L'unica differenza sarebbe nei calcoli assurdi che
ci sono in RSA (anche se semplificati dall'algebra lineare), ma alla fine
forzare RSA ottenuto in questo modo sarebbe come forzare il suddetto
Cifrario.............................................
Io pensavo alla lunghezza della chiave come numero di esponente/modulo (nel
senso 1024bit/8=128 esponenti con relativo modulo pubblico), in modo che
venisse usato un esponente/modulo diverso sul plain text, una cosa di questo
genere (non so se hai familiarità con C++/Java..........)
for (int i=0,int j=0;i<plaintext.length();i++,j=(j+1)%chiave.length())
    plaintext[i]=RSA(plaintext[i],chiave[j].esponente,chiave[j].modulo);
dove RSA è un metodo per il calcolo del ciphertext ottenuto semplificando
con l'algebra lineare il ben noto C=M^e mod N
Un ragionamento di questo tipo sarebbe più sensato, il risultato non
somiglierebbe per niente ad un semplice cifrario di Vigenère e sarebbe senza
omba di dubbio più complesso risalire al plain text perchè invece di rompere
un solo modulo o indovinare la sostituzione se ne dovrebbero
rompere/indovinare ben 128..............
Comunque aspetto una tua risposta
sull'argomento..................................
Altro problema: semplificazione dei calcoli con l'algebra modulare.
Avevo già pensato ad una cosa del genere, e ho implementato una soluzione
che se velocizza (e di molto i calcoli) non sempre mi salva dall'overflow.
Si tratta di estrarre uno sviluppo binario dell'esponente e fattorizzare lo
stesso applicando delle formule simili di algebra modulare che ti stesso mi
hai riportato. Il problema è che un numero di 309 cifre (per tornare alla
famosa chiave di 1024 bit che dicevi tu) non posso assegnarlo ad una
variabile! Appena lo faccio scatta l'overflow (come è normale). Ma come
faccio a usare delle regole di algebra modulare se neanche riesco a
manipolare il numero???
Questi sono problemi che sorgono sempre all'atto pratico (quanto implementi
un determinato sistema) e che in teoria non si pongono mai................:(
Sapresti poi indicarmi qualche risorsa online che tratta gli algoritmi CAST,
IDEA, DES, TDES e Diffie-Hellmann facendo anche degli esempi pratici, in
modo che il compito del programmatore (in questo caso io) venga notevolmente
semplificato?
Grazie ancora,
ciao

semplificato?
http://www.pgpi.org/dev/
 =>> specifiche per sviluppatori
http://www.pgpi.org/links/www/
 =>> qui trovi i link
e poi basta qualche ricerca ne trovi a chili di roba.
Ti consiglio anche i newsgruop americani.
suca ma di più non so. non mi sono mai posto il problema di sviluppare
queste cose :-)
ciao 


Comunque aspetto una tua risposta sull'argomento......................
Non sono lui, ma spero ti accontenterai :)
Dunque, in pratica stai riscoprendo l'acqua calda: sto' sito elenca i
vari tipi di crittazione, e i vari attacchi possibili.
http://axion.physics.ubc.ca/pgp-attack.html
Quello da te menzionato e' qualcosa di simillimo al ROT13 :) (che fa
uno shift, pero' potrebbe benissimo essere accomunato al Cifrario di
cui parli)

 Oppure Visual Basic???
Ti dedichi all'agricoltura che e` meglio...


 Ti dedichi all'agricoltura che e` meglio...
Beh, il tuo giudizio è un po' di parte.................

Ciao,
grazie della risposta e del link. Avevo già visitato quella pagina, che
espone le debolezze degli algoritmi e le relative tecniche di crittoanalisi
per rompere il codice................
Ma a parte questo (comunque molto interessante) non dice niente di quello
che serve a me. Riassumento a me serve da sapere
1) come si presenta la rappresentazione *fisica* di una qualsiasi chiave di
tot bit, specialmente per i sistemi di crittografia asimmetrica (come RSA)
2) come lavora RSA (non la ben nota formula C=M^e mod n), per essere precisi
come avviene la crittografia RSA su un blocco di bit di 64 (per esempio).
Sotto che forma do in input alla funzione RSA (cioè M) un tot di bit di
plain text??? (domande che non mi fanno dormire la notte!) E come ri
presenta la chiave?? Un solo esponente e un solo modulo pubblico oppure più
esponenti e più moduli pubblici che agiscono separatamente sui diversi
blocchi???

Beh, il tuo giudizio è un po' di parte.................
No. Uno che pensa davvero di implementare algoritmi crittografici in
basic non ha chiaramente capito qualcosa (della vita, credo).


 basic non ha chiaramente capito qualcosa (della vita, credo).
Forse tu sei uno dei fanatici del mondo Unix/Linux, che sono contrari di
natura a qualsiasi linguaggio che non sia C/C++ (è una specie di repulsione
che hanno nel DNA.........) e che vedono Java come una brutta imitazione di
C++ (e non è così, visto che solo la sintassi è simile............).
Permettimi di sollevare l'obiezione che Visual basic non è uguale a QBasic o
a GW-Basic (considerando che tu hai risposto "quelli che usano basic non
hanno capito niente dalla vita"). Con Visual Basic nella sua ultima versione
puoi fare le stesse identiche cose sotto OS Microsoft che con Visual C++
(anche se il codice generato da quest'ultimo risulta essere un po' più
veloce, non necessitando di alcuna Virtual Machine...........)
Non esiste solo C/C++.............................

 - rimuovi XXX x rispondere    ICQ #8814554
Era disposto a dare il suo braccio destro pur di essere ambidestro.

...

Ho un testo bellissimo sull'analisi combintoria e la probabilita': tutti gli
algoritmi che implementano le formule dei teoremi matematici li' esposti
sono in Basic, e per giunta quello vecchio: il quick basic. Penso quindi che
ogni cosa abbia la sua importanza: forse il basic puo' essere usato
rapidamente per vedere se la logica che ci ha guidato ad una conclusione
teorematica, funziona anche quando viene implementata. Se funziona sotto
basic, allora funziona anche sotto fortran, pascal, C, C++ e Java.
Per quanto riguarda le chiavi RSA non vorrei sbagliarmi, ma mi pare che
l'algoritmo di questo cifrario operi soltanto a livello di gruppi di cifre
binarie della lunghezza della chiave. Quindi la cifratura avverrebbe per
blocchi di bit: quelli sottostanti all'effetto (: testo) prodotto dal codice
ASCII che, come si sa, ce li trasforma in gruppi di  7 bit di dati + 1 bit
di controllo al fine di fornirci, tramite scheda video, la visione di uno o
piu' caratteri alfanumerici: a fronte, per esempio, di 1024 cifre binarie,
penso che il codice ASCII, eseguendo 1024:8=128 e poi assegnando ad ogni
gruppo di 8 bit, a partire dall'inizio del flusso cosi' suddiviso in byte,
un preciso simbolo video, associato da un'apposito file di fonts richiamato
dall'applicativo in uso, si comporti proprio come un antico repertorio di
cifratura: assegna ad uno o piu' simboli altri simboli secondo una precisa
convenzione di riferimento.
Ecco perche', dato il caratteristico output testuale del PGP, mi pare che
questo programma, al termine della cifratura, richiami un suo specifico set
di fonts (e che cosi' faccia ogni altro applicativo di cifratura in
commercio, dato che ogni crittogramma ha un suo set di fonts
inconfondibile: cosi', chi deve decrittare, capisce subito che algoritmo
decrittatorio
deve usare!!!).
La forza di una chiave, come e' noto, sta nell'assenza di ripetizioni di
serie di simboli al suo interno: la chiave deve dunque essere un frammento
di caos (o un flusso caotico di cifre in quantita' identica al numero delle
cifre del chiaro nel caso in cui il cifrario, anziche' a blocchi, sia a
flusso). Ma, al di la' di questa osservazione, mi pare che sia sfuggito il
fatto che, anche l'aritmetica binaria, ha il fenomeno del riporto (a meno
che non si operi bit-a-bit), e quindi
l'aumento delle dimensioni del file binario risultante dalla cifratura
rispetto al file binario del chiaro. Dovendo infatti operare nel campo degli
interi positivi, solo alcune operazioni aritmetiche sono possibili:
esattamente quelle rispetto alle quali questo insieme e' chiuso, e quindi
tutte quelle che producono un riporto e, con esso, un accrescimento del
numero di bit dell'originario chiaro. Ecco perche' qualsiasi crittogramma di
PGP (o di altro tipo) ha un numero di simboli superiore al numero dei
simboli del chiaro.
Saranno poi oppurtune operazioni di modulo e di de-modulo, mi pare, a
contenere i valori prodotti entro i limiti del codice ASCII usato,
rispettivamente, per testualizzare il crittogramma binario con i fonts
adatti ed il chiaro binario con i fonts usualmente utilizzati nei word
processors.
Per quanto poi riguarda i criteri di cifratura, al di la' della
trasposizione e della sostituzione (sia quest'ultima o a repertorio o a
cifrario o per compressione dati) mi pare che la matematica non permetta di
concepire altro anche perche', se si passa dalla logica programmata a quella
cablata, oltre P-Boxes ed S-Boxes "tertium non datur". Percio' mi sembra un
po' ingenuo immaginare che il PGP produca una sostituzione monoalfabetica,
com'e' stato ipotizzato con un esempio: basta infatti immaginare come una
serie di operazioni aritmetiche in base 2, in cui uno o + operandi sono
costituiti da una piu' o meno lunga serie caotica di bit, vada a dilatare la
dimensione ed a sconvolgere l'ordine del chiaro/binario per comprendere come
la seconda fase dell'operazione, quella della testualizzazione a partire dal
capo del crittogramma binario, non possa che qualificarsi come realizzarione
di un crittogramma da cifrario sostitutivo polialfabetico. Ma c'e' di piu':
chi ha usato la prima versione del PGP e' al corrente del fatto che,
operando in DOS per ottenere dal crittogramma binario il crittogramma
testuale, bisogna, prima, realizzare il passaggio intermedio della
"armatura" del file crittogrammatico binario (trasformare il file pgp in
armored file). A mio modesto parere qui sta il nocciolo della questione: la
vera natura di questa operazione non e' mai stata veramente rivelata. E'
stato detto soltanto che l'armored file e' piu' stabile e sicuro per la
creazione di datagrammi internet derivanti da posta elettronica. Che cos'e',
dunque, l'armatura dei files pgp? Una codificazione in byte di un flusso
pari ad 8^n bit secondo un codice non ASCII o secondo un codice ASCII
integrato da uno specifico pool di fonts pgp?
Detto questo il problema della crittoresistenza del PGP mi pare si polarizzi
soltanto sulla formula, in aritmetica binaria, ottenuta della formula del
PGP esposta in aritmetica convenzionale.
Il discorso, cioe', dovrebbe diventare molto piu' profondo ed articolato.
Saluti
K

 risposto "quelli che usano basic non hanno capito niente dalla vita").
rileggiti la sua frase; si sta parlando di algoritmi crittografici...
hola
Buttha
-- 
* Per rispondere in email rimuovere una i dall'indirizzo
* 
http://members.xoom.it/buttha/
* Rifiutarsi di amare per paura di soffrire č come rifiutarsi di vivere 
  per paura di morire.

spiegare....................
Per come l'ho studiata io la cosa funziona così:
- chiave da 1024 bit vuol dire che "è un numero da 309 cifre
decimali", chiamiamolo e (come nella tua formula).
- opera su un block cipher di 64 bit vuole dire che se tu hai un testo
in italiano composto da 16 caratteri (in codifica ASCII) questo
plaintext corrisponde a una serie di 128 bit. Scomponi questi 128 bit
in blocchi da 64bit, otterrai due blocchi da 64bit. Con ciascun blocco
da 64bit puoi codificare un numero decimale da 19 cifre, chiamiamolo M
(come nella tua formula).
Ora, da un testo di 16 caratteri abbiamo ottenuto due numeri da 19
cifre decimali M1 e M2 (sempre usando la tua notazione).
Bob volendo spedire il testo crittato prende M1 e M2 e ottiene:
C1=(M1^e) modN
C2=(M2^e) modN
Ora Bob invia a Alice C1 e C2.
Alice sa la trapdoor dell'RSA a conosce quindi l'inverso di "e",
chiamiamolo "a"; Alice esegue dunque:
M1=(C1^a) modM
M2=(C2^a) modM
A questo punto Alice ha in mano due numeri da 19 cifre decimali, li
converte in bit (ovviamente questa operazione è puramente logica, non
fisica) e trova un flusso di 128 bit che codifica in ASCII per
ottenere il testo in chiaro.


prima...................)
Beh, proprio nessuno non è vero, cmq hai perfettamente ragione sul
fatto che a parlare sono capaci tutti, ma quando si tratta di scendere
il campo e realizzare qualcosa di REALE, tutto diventa più difficile e
ci si imbatte in problemi che sulla carta risultavano marginali, di
implementazione appunto.
Anch'io mi metto tra quelli che parlano e basta, sia ben chiaro, dal
momento che non ho implementato un bel cavolo di niente!
Questa discussione mi spinge cmq a riflettare su alcune apparenti
banalità che avevo trascurato in fase di studio ma che, comprendo,
diventano vitali in fase realizzativa.
Mi hai messo in crisi con la "storia della palle tradotta in hebbe"!
Provo a risponderti:
- RSA non è uno stream cipher; come hai visto anche tu, dalla formula
C = P^b mod m
se si inserisce sempre lo stesso P, si otterrà sempre lo stesso C;
tuttavia si può implementare RSA in modalità CBC, CFB, OFB, o ECB (in
particolare CBC e CFB) e allora si ottiene un crittosistema di tipo
stream che non produce più lo stesso output dato il medesimo inpu (do
per scontato, per brevità, che tu sappia cosa sono CBC e CFB ma se non
lo sai dimmelo che te lo spiego!!).
RSA da solo per ogni "palla" ti darà un "hebbe" sempre uguale!
RSA+CBC (ad es)  per ogni "palla" ti darà un "hebbe" sempre diverso!
PS
Un'altra cosa su RSA:
- non si può affermare lapidariamente (non ricordo chi lo disse) che
RSA si usa solo per crittare le chiavi pubbliche!! Così sembra che con
RSA non si possa crittare un testo semplice, il che è assurdo.
Di tutto questo discorso è vero il fatto che RSA, e più in generale
gli algoritmi a chiave pubblica, sono MOLTO lenti in confronto a
quelli a chiave privata e quindi sono molto dispendiosi per crittarte
lunghi file. Da questo fatto nascono soluzioni di crittografia IBRIDA
(pubblica+privata) come PGP in cui si critta in privato il plaintext e
poi si critta la chiave in pubblico (la qual cosa è veloce dato che la
chiave è piccola).


blocchi??
Un solo modulo un solo esponente, altrimenti avrei più chiavi
pubbliche (cosa cmq lecita). Per crittare un testo in RSA uso UNA SOLA
chiave pubblica eventualmente coadiuvata da modalità CBC, CFB,...


calcoli.................................
Infatti.
-- 
Lorenzo
"Given enough eyeballs, all bugs are shallow", Linus'Law
(address rot13 encoded)

Ti ho gia` consigliato di comprare _Applied cryptography_
C'è anche in italiano? Chi è l'autore?
Grazie :)
-- 
Ciao, Massimo
m...@pkri.network (togli 'work' per rispondere in privato)

C'è anche in italiano? Chi è l'autore?
No, non c'e`.
www.counterpane.com
