Crittografia: da Cesare ai quanti

 Workshop@UniNA 2014
12/05/2014
Crittografia: da Cesare ai quanti
a cura di Mario Rossano aka Anak
con il patrocinio del Preside della Scuola Politecnica e delle Scienze di Base
dell'Università degli Studi di Napoli Federico II
Prof. Piero Salatino
e con il sostegno del Prof. Antonio Pescapè
Workshop@UniNA 2014
•
•
•
•
Crittografia: Arte, Scienza e Tecnologia
Algoritmi simmetrici
• Cifrario di Cesare
• Polialfabetico di Vigenère
• WW2 – Macchina Enigma
• AES
Algoritmi digest
• MD5
• SHA
Algoritmi asimmetrici
• Scambio di chiavi DH
• Chiave pubblica/privata RSA
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
•
•
•
Crittografia: Arte, Scienza e Tecnologia
Algoritmi simmetrici
• Cifrario di Cesare
• Polialfabetico di Vigenère
• WW2 – Macchina Enigma
• AES
•
•
Algoritmi digest
• MD5
• SHA
Algoritmi asimmetrici
• Scambio di chiavi DH
• Chiave pubblica/privata RSA
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
La summa: PGP
Le nuove strade
• Geometria Frattale
• FNA
• Meccanica Quantistica
• BB84
Workshop@UniNA 2014
•
Crittografia: Arte, Scienza e Tecnologia
Codice
sostituzione al
livello delle
parole
Steganografia
occultamento del messaggio
Scritture segrete
Sostituzione
Crittografia
alterazione del
messaggio
Trasposizione
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Cifratura
sostituzione al
livello delle
lettere
Workshop@UniNA 2014
•
Crittografia: Arte, Scienza e Tecnologia
Arte
Fantasia
Creatività
Intuito
Bellezza
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia: Arte, Scienza e Tecnologia
Arte
Scienza
Fantasia
Creatività
Intuito
Bellezza
Logica
Matematica
Fisica
Informatica
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia: Arte, Scienza e Tecnologia
Arte
Scienza
Tecnologia
Fantasia
Creatività
Intuito
Bellezza
Logica
Matematica
Fisica
Informatica
Computers
Storage
Reti
Laser
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia: Arte, Scienza e Tecnologia
Arte
Scienza
Tecnologia
Fantasia
Creatività
Intuito
Bellezza
Logica
Matematica
Fisica
Informatica
Computers
Storage
Reti
Laser
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
COM
UNIC
AZIO
NE
SICU
RA
Workshop@UniNA 2014
•
Algoritmi simmetrici
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi simmetrici
●
Alice e Bob condividono una chiave segreta
●
La chiave segreta è usata per cifrare
●
La chiave segreta è usata per decifrare
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi simmetrici: Cifrario di Cesare – I a.C.
●
Cifrario a sostituzione monoalfabetica
Ogni carattere è sostituito da quello che si trova dopo un
determinato numero di posizioni nell'alfabeto
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi simmetrici: Cifrario di Cesare
●
Cifrario a sostituzione monoalfabetica
Ogni carattere è sostituito da quello che si trova dopo un
determinato numero di posizioni nell'alfabeto
Alfabeto in chiaro:
abcdefghijklmnopqrstuvwxyz
Spostamento di 3:
defghijklmnopqrstuvwxyzabc
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi simmetrici: Cifrario di Cesare
●
Cifrario a sostituzione monoalfabetica
La chiave segreta è data dal numero di traslazioni
Alfabeto in chiaro:
abcdefghijklmnopqrstuvwxyz
Chiave 3:
defghijklmnopqrstuvwxyzabc
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi simmetrici: Cifrario di Cesare
3
Alfabeto in chiaro:
abcdefghijklmnopqrstuvwxyz
Chiave 3:
defghijklmnopqrstuvwxyzabc
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi simmetrici: Cifrario di Cesare ./caesar.pl
use Crypt::CaesarCipher;
my $shiftValue='3';
my $plainText;
switch (defined($ARGV[0])) {
case '' {
$plainText='workshop at unina mmxiv'
}
else {
$plainText=$ARGV[0]
}
}
say '--> Testo in chiaro: '.$plainText;
my $caesarCipher=Crypt::CaesarCipher->new({setShift => $shiftValue});
my $encrypted=$caesarCipher->encrypt($plainText);
say '--> Messaggio criptato '.$encrypted;
my $decrypted=$caesarCipher->decrypt($encrypted);
say '--> Messaggio decriptato '.$decrypted;
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
3
Workshop@UniNA 2014
•
Algoritmi simmetrici: Cifrario di Cesare ./caesar.pm
sub encrypt {
my ($self,$plainText)=@_;
my $encryptedText;
foreach my $plainChar(split //,$plainText) {
my $ordCharShifted=ord($plainChar)+$self->setShift;
if ($ordCharShifted > 122) {
$encryptedText.=chr($ordCharShifted - 122 + 96)
} else {
$encryptedText.=chr($ordCharShifted)
}
}
return $encryptedText
}
sub decrypt {
my ($self,$encryptedText)=@_;
my $plainText;
foreach my $encryptedChar(split //,$encryptedText) {
my $ordCharShifted=ord($encryptedChar)-$self->setShift;
if ($ordCharShifted < 97) {
$plainText.=chr(122 - $ordCharShifted + 96)
} else {
$plainText.=chr($ordCharShifted)
}
}
return $plainText
}
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
3
Workshop@UniNA 2014
•
Algoritmi simmetrici: Cifrario di Cesare
Script e codice completo della classe Crypt::CaesarCipher
http://pastebin.com/etDnzB5z
Coming soon su CPAN //metacpan.org
Per installarla su qualunque pc di questo pianeta ed in orbita...
$ sudo cpan install Crypt::CaesarCipher
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi simmetrici: Vigenère, la Chiffre indécifrable
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi simmetrici: Vigenère, la Chiffre indécifrable – XVI sec.
●
Cifrario a sostituzione polialfabetica
Più alfabeti cifranti utilizzati in sequenza
Ogni carattere è sostituito da quello che si trova dopo un
determinato numero di posizioni nell'alfabeto cifrante di turno
Dopo ogni cifratura si passa all'alfabeto successivo
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi simmetrici: Vigenère
chiaro:
abcdefghijklmnopqrstuvwxyz
------------------------------------------------------------------------1:
bcdefghijklmnopqrstuvwxyza
2:
cdefghijklmnopqrstuvwxyzab
3:
defghijklmnopqrstuvwxyzabc
4:
efghijklmnopqrstuvwxyzabcd
5:
fghijklmnopqrstuvwxyzabcde
6:
ghijklmnopqrstuvwxyzabcdef
7:
hijklmnopqrstuvwxyzabcdefg
8:
ijklmnopqrstuvwxyzabcdefgh
9:
jklmnopqrstuvwxyzabcdefghi
10:
klmnopqrstuvwxyzabcdefghij
11:
lmnopqrstuvwxyzabcdefghijk
12:
mnopqrstuvwxyzabcdefghijkl
13:
nopqrstuvwxyzabcdefghijklm
14:
opqrstuvwxyzabcdefghijklmn
15:
pqrstuvwxyzabcdefghijklmno
16:
qrstuvwxyzabcdefghijklmnop
17:
rstuvwxyzabcdefghijklmnopq
18:
stuvwxyzabcdefghijklmnopqr
19:
tuvwxyzabcdefghijklmnopqrs
20:
uvwxyzabcdefghijklmnopqrst
21:
vwxyzabcdefghijklmnopqrstu
22:
wxyzabcdefghijklmnopqrstuv
23:
xyzabcdefghijklmnopqrstuvw
24:
yzabcdefghijklmnopqrstuvwx
25:
zabcdefghijklmnopqrstuvwxy
26:
abcdefghijklmnopqrstuvwxyz
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Più alfabeti cifranti
Workshop@UniNA 2014
•
Algoritmi simmetrici: Vigenère
chiaro:
abcdefghijklmnopqrstuvwxyz
------------------------------------------------------------------------1:
bcdefghijklmnopqrstuvwxyza
2:
cdefghijklmnopqrstuvwxyzab
3:
defghijklmnopqrstuvwxyzabc
4:
efghijklmnopqrstuvwxyzabcd
5:
fghijklmnopqrstuvwxyzabcde
6:
ghijklmnopqrstuvwxyzabcdef
7:
hijklmnopqrstuvwxyzabcdefg
8:
ijklmnopqrstuvwxyzabcdefgh
9:
jklmnopqrstuvwxyzabcdefghi
10:
klmnopqrstuvwxyzabcdefghij
11:
lmnopqrstuvwxyzabcdefghijk
12:
mnopqrstuvwxyzabcdefghijkl
13:
nopqrstuvwxyzabcdefghijklm
14:
opqrstuvwxyzabcdefghijklmn
15:
pqrstuvwxyzabcdefghijklmno
16:
qrstuvwxyzabcdefghijklmnop
17:
rstuvwxyzabcdefghijklmnopq
18:
stuvwxyzabcdefghijklmnopqr
19:
tuvwxyzabcdefghijklmnopqrs
20:
uvwxyzabcdefghijklmnopqrst
21:
vwxyzabcdefghijklmnopqrstu
22:
wxyzabcdefghijklmnopqrstuv
23:
xyzabcdefghijklmnopqrstuvw
24:
yzabcdefghijklmnopqrstuvwx
25:
zabcdefghijklmnopqrstuvwxy
26:
abcdefghijklmnopqrstuvwxyz
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Esempio: scelta della chiave
bruto
Workshop@UniNA 2014
•
Esempio: scelta della chiave
Algoritmi simmetrici: Vigenère
chiaro:
abcdefghijklmnopqrstuvwxyz
------------------------------------------------------------------------1:
bcdefghijklmnopqrstuvwxyza
2:
cdefghijklmnopqrstuvwxyzab
3:
defghijklmnopqrstuvwxyzabc
4:
efghijklmnopqrstuvwxyzabcd
5:
fghijklmnopqrstuvwxyzabcde
6:
ghijklmnopqrstuvwxyzabcdef
7:
hijklmnopqrstuvwxyzabcdefg
8:
ijklmnopqrstuvwxyzabcdefgh
9:
jklmnopqrstuvwxyzabcdefghi
10:
klmnopqrstuvwxyzabcdefghij
11:
lmnopqrstuvwxyzabcdefghijk
12:
mnopqrstuvwxyzabcdefghijkl
13:
nopqrstuvwxyzabcdefghijklm
14:
opqrstuvwxyzabcdefghijklmn
15:
pqrstuvwxyzabcdefghijklmno
16:
qrstuvwxyzabcdefghijklmnop
17:
rstuvwxyzabcdefghijklmnopq
18:
stuvwxyzabcdefghijklmnopqr
19:
tuvwxyzabcdefghijklmnopqrs
20:
uvwxyzabcdefghijklmnopqrst
21:
vwxyzabcdefghijklmnopqrstu
22:
wxyzabcdefghijklmnopqrstuv
23:
xyzabcdefghijklmnopqrstuvw
24:
yzabcdefghijklmnopqrstuvwx
25:
zabcdefghijklmnopqrstuvwxy
26:
abcdefghijklmnopqrstuvwxyz
bruto
Messaggio: Anak va in campagna
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Esempio: scelta della chiave
Algoritmi simmetrici: Vigenère
chiaro:
abcdefghijklmnopqrstuvwxyz
------------------------------------------------------------------------1:
bcdefghijklmnopqrstuvwxyza
2:
cdefghijklmnopqrstuvwxyzab
3:
defghijklmnopqrstuvwxyzabc
4:
efghijklmnopqrstuvwxyzabcd
5:
fghijklmnopqrstuvwxyzabcde
6:
ghijklmnopqrstuvwxyzabcdef
7:
hijklmnopqrstuvwxyzabcdefg
8:
ijklmnopqrstuvwxyzabcdefgh
9:
jklmnopqrstuvwxyzabcdefghi
10:
klmnopqrstuvwxyzabcdefghij
11:
lmnopqrstuvwxyzabcdefghijk
12:
mnopqrstuvwxyzabcdefghijkl
13:
nopqrstuvwxyzabcdefghijklm
14:
opqrstuvwxyzabcdefghijklmn
15:
pqrstuvwxyzabcdefghijklmno
16:
qrstuvwxyzabcdefghijklmnop
17:
rstuvwxyzabcdefghijklmnopq
18:
stuvwxyzabcdefghijklmnopqr
19:
tuvwxyzabcdefghijklmnopqrs
20:
uvwxyzabcdefghijklmnopqrst
21:
vwxyzabcdefghijklmnopqrstu
22:
wxyzabcdefghijklmnopqrstuv
23:
xyzabcdefghijklmnopqrstuvw
24:
yzabcdefghijklmnopqrstuvwx
25:
zabcdefghijklmnopqrstuvwxy
26:
abcdefghijklmnopqrstuvwxyz
bruto
Messaggio: Anak va in campagna
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
b rut obru tob r u tob
anakvai ncampagna
beuc jbzovon guzbb
Workshop@UniNA 2014
•
Algoritmi simmetrici: Vigenère
chiaro:
abcdefghijklmnopqrstuvwxyz
------------------------------------------------------------------------1:
bcdefghijklmnopqrstuvwxyza
2:
cdefghijklmnopqrstuvwxyzab
3:
defghijklmnopqrstuvwxyzabc
4:
efghijklmnopqrstuvwxyzabcd
5:
fghijklmnopqrstuvwxyzabcde
6:
ghijklmnopqrstuvwxyzabcdef
7:
hijklmnopqrstuvwxyzabcdefg
8:
ijklmnopqrstuvwxyzabcdefgh
9:
jklmnopqrstuvwxyzabcdefghi
10:
klmnopqrstuvwxyzabcdefghij
11:
lmnopqrstuvwxyzabcdefghijk
12:
mnopqrstuvwxyzabcdefghijkl
13:
nopqrstuvwxyzabcdefghijklm
14:
opqrstuvwxyzabcdefghijklmn
15:
pqrstuvwxyzabcdefghijklmno
16:
qrstuvwxyzabcdefghijklmnop
17:
rstuvwxyzabcdefghijklmnopq
18:
stuvwxyzabcdefghijklmnopqr
19:
tuvwxyzabcdefghijklmnopqrs
20:
uvwxyzabcdefghijklmnopqrst
21:
vwxyzabcdefghijklmnopqrstu
22:
wxyzabcdefghijklmnopqrstuv
23:
xyzabcdefghijklmnopqrstuvw
24:
yzabcdefghijklmnopqrstuvwx
25:
zabcdefghijklmnopqrstuvwxy
26:
abcdefghijklmnopqrstuvwxyz
Il primo carattere da cifrare è la "a".
Corrisponde all'alfabeto 1, che inizia per "b".
Secondo questo alfabeto, il crittogramma di
"a" è "b".
Il secondo carattere da cifrare è "n". Questo
corrisponde all'alfabeto che inizia per "r". In
questo alfabeto il crittogramma di "n" è "e".
Proseguendo e scegliendo sempre l'alfabeto
corrispondente (in base alla chiave scelta,
utilizziamo l'alfabeto che inizia per quella
lettera), otteniamo il crittogramma di "Anak
va in campagna", secondo il polialfabetico di
Vigenére in chiave "bruto" che è:
"beucjbzovonguzbb"
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi simmetrici: Vigenère
use Crypt::Vigenere;
my $keyWord='bruto';
my $vigenere = Crypt::Vigenere->new($keyWord);
bruto
# cripta stringa
my $plainText='anakvaincampagna';
my $encryptedText = $vigenere->encodeMessage($plainText);
# decripta stringa
my $decryptedText = $vigenere->decodeMessage($encryptedText);
say '-> Vigenere - testo in chiaro: '.$plainText;
say '-> Vigenere - testo criptato: '.$encryptedText;
say '-> Vigenere - testo decriptato: '.$decryptedText;
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi simmetrici: Vigenère
Script vigenere.pl
http://pastebin.com/KacV76Ed
Classe Crypt::Vigenere su CPAN //metacpan.org
Per installarla su qualunque pc di questo pianeta ed in orbita...
$ sudo cpan install Crypt::Vigenere
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi simmetrici: La macchina ENIGMA WW2
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi simmetrici: La macchina ENIGMA WW2
●
Cifrario a sostituzione polialfabetica
Più alfabeti cifranti derivanti dalla posizione di 3 dischi
scambiatori connessi in cascata. Sui dischi sono riportati i 26
caratteri (6 caratteri nella fig. seguente riportante un singolo disco).
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi simmetrici: ENIGMA WW2
●
Cifrario a sostituzione polialfabetica
Dopo ogni cifratura il disco
(A) ruota di una posizione.
Quando torna alla posizione
iniziale, ruota di una
posizione il disco (B).
Quando anche questo torna
alla posizione iniziale, il disco
(C) analogamente ruota di
una posizione.
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi simmetrici: La macchina ENIGMA WW2
●
Cifrario a sostituzione polialfabetica
Chiave di Enigma
1. selezione di 3 tra 5 scambiatori
2. loro posizione iniziale (26 pos)
...e non è finita qui...
m!
5!
Permutazioni = ------- ; ------- = 60
(m-n)! (5-3)!
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Combinazioni = p*p*p = 26^3 = 17756
Workshop@UniNA 2014
•
Algoritmi simmetrici: La macchina ENIGMA WW2
●
Cifrario a sostituzione polialfabetica
Chiave di Enigma
Inoltre ogni scambiatore può avere 26^2
(676) accoppiamenti di lettere sulle due
facce.
Era anche presente una ulteriore
sezione di collegamenti che aumentava
le combinazioni fino ad oltre 158 milioni
di milioni di milioni.
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi simmetrici: La macchina Enigma
use Crypt::Enigma;
my $enigma = Crypt::Enigma->new();
# Selezione dei rotori - cablaggio interno dello scambiatore - posizione iniziale rotore
$enigma->setup('312', 'ABC', 'ERZ');
# Scambio a to b, b to a - plugboard di Enigma, come se fosse un ulteriore rotore
$enigma->stekker('a', 'b');
my $plainText='workshop at unina mmxiv';
$plainText =~ s/[^\w]|[^\D]//g;
my $encryptedText;
foreach my $character (split (//,$plainText)) {
$encryptedText.=$enigma->input($character)
}
say '--> Testo criptato: '.$encryptedText;
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi simmetrici: La macchina Enigma
Script enigma.pl
http://pastebin.com/1s7A6v06
Classe Crypt::Enigma su CPAN //metacpan.org
Per installarla su qualunque pc di questo pianeta ed in orbita...
$ sudo cpan install Crypt::Enigma
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi simmetrici: AES - Advanced Encryption Standard
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi simmetrici: AES - Advanced Encryption Standard
●
Cifrario a blocchi
Viene processato un intero blocco di informazione anziché un
elemento alla volta.
Il testo in chiaro arriva al limite a blocchi di 16 byte (128 bit)
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi simmetrici: AES - Advanced Encryption Standard
1. XOR sul testo in chiaro con 16 byte di chiave di ciclo
2. Ognuno dei 16 byte è utilizzato come come indice in una
tabella S-Box (matrice di sostituzione)
3. La S-Box mappa input di 8 bit in output di 8 bit
4. Riposizionamento dei byte secondo uno schema
deterministico ma di elevata entropia
5. Rimescolamento dei byte a gruppi di 4. Ogni bit di output è
ottenuto dallo XOR con diversi bit di input
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi simmetrici: AES - Advanced Encryption Standard
I punti da 1..5 corrispondono ad un singolo ciclo
Vengono ripetuti dai 10 ai 14 cicli in funzione della lunghezza
della chiave
AES 128 → 10 cicli
AES 192 → 12 cicli
AES 256 → 14 cicli
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi simmetrici: AES - Advanced Encryption Standard
use Crypt::AES::CTR;
my $key='01234567890abcdef';
my $bit=256;
my $aes = Crypt::AES::CTR->new(
key =>$key,
nbits=>$bit
);
my $plainText='AES on Workshop@UNINA2014';
say '-> stringa in chiaro: '.$plainText."\n";
my $encryptedText=$aes->encrypt($plainText);
say '-> stringa criptata con AES: '.$encryptedText;
my $decryptedText=$aes->decrypt($encryptedText);
say '-> stringa decriptata con AES: '.$decryptedText;
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi simmetrici: AES - Advanced Encryption Standard
Script aes.pl
http://pastebin.com/shqQs9ja
Classe Crypt::AES::CTR su CPAN //metacpan.org
Per installarla su qualunque pc di questo pianeta ed in orbita...
$ sudo cpan install Crypt::AES::CTR
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi digest: MD5 e SHA
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi digest: MD5 e SHA
Trasformano una sequenza di bit (o byte) in una stringa di
lunghezza arbitraria detta hash
Irreversibilità: non è noto alcun algoritmo che dato un hash
riproduca l'informazione da cui è stato tratto
Sono usati tipicamente come ausilio per le firme digitali
(computazionalmente esose) cui viene passato l'hash del
messaggio (o del file) in luogo del messaggio o del file
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi digest: MD5 e SHA
MD5 → funzione di hash a 128 bit
Brute force: 2^64 calcoli di MD5
SHA → funzione di hash a 160, 224, 256, 384, 512 bit
Brute force: 2^256 calcoli di SHA512
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi digest: MD5 e SHA
Use Digest::MD5;
my $digest=Digest::MD5->new();
$digest->add($data);
$digest->add($fileHandle);
my $hashData=$digest->digest;
my $hashData=$digest->hexdigest;
my $hashData=$digest->b64digest;
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi digest: MD5 e SHA
Use Digest::SHA;
#algorithm 'sha-1' | 'sha-224' | 'sha-256'...
my $digest=Digest::SHA->new($algorithm);
$digest->add($data);
$digest->addfile($filename);
my $hashData=$digest->digest;
my $hashData=$digest->hexdigest;
my $hashData=$digest->b64digest;
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi digest: MD5 e SHA
Classe Digest::MD5 su CPAN //metacpan.org
Classe Digest::SHA su CPAN //metacpan.org
Per installarle su qualunque pc di questo pianeta ed in orbita...
$ sudo cpan install Digest::MD5
$ sudo cpan install Digest::SHA
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici
●
Alice e Bob NON condividono una chiave segreta
●
Alice ha 2 chiavi, una pubblica e l'altra privata (segreta)
●
Bob ha la chiave pubblica
●
La chiave segreta è usata per decifrare
●
La chiave pubblica è usata per cifrare
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici
Alice comunica a Bob la sua
chiave pubblica
Bob usa la chiave pubblica per
cifrare il messaggio
Alice riceve il messaggio e lo
decifra con la sua chiave
privata
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: protocollo Diffie-Helmann
Il protocollo permette di condividere su un canale in chiaro
una chiave in modo sicuro
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: protocollo Diffie-Helmann
Il protocollo permette di condividere su un canale in chiaro
una chiave in modo sicuro
Alice e Bob scelgono un numero primo p molto grande
ed un altro numero g (generatore), solitamente piccolo
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: protocollo Diffie-Helmann
p e g sono la chiave pubblica.
Alice e Bob scelgono un numero primo p molto grande
ed un altro numero g (generatore), solitamente piccolo
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: protocollo Diffie-Helmann
p e g sono la chiave pubblica.
Alice e Bob scelgono un numero primo p molto grande
ed un altro numero g (generatore), solitamente piccolo
Anche Eve, un eventuale attaccante,
può conoscere p e g
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: protocollo Diffie-Helmann
Alice sceglie un intero x
casuale ed inferiore a p
x è la chiave privata
di Alice
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: protocollo Diffie-Helmann
Alice sceglie un intero x
casuale ed inferiore a p
Alice calcola A=g**x mod(p)
x è la chiave privata
di Alice
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: protocollo Diffie-Helmann
Bob sceglie un intero y
casuale ed inferiore a p
Alice calcola A=g**x mod(p)
y è la chiave privata
di Bob
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: protocollo Diffie-Helmann
Bob sceglie un intero y
casuale ed inferiore a p
Alice calcola A=g**x mod(p)
Bob calcola B=g**y mod(p)
y è la chiave privata
di Bob
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: protocollo Diffie-Helmann
Alice calcola A=g**x mod(p)
Bob calcola B=g**y mod(p)
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: protocollo Diffie-Helmann
Alice calcola Ka=B**x mod(p)
Bob calcola Kb=A**y mod(p)
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: protocollo Diffie-Helmann
Alice calcola Ka=B**x mod(p)
Ka=Kb
È la chiave segreta comune
per le proprietà del logaritmo discreto
Bob calcola Kb=A**y mod(p)
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: protocollo Diffie-Helmann
use Crypt::DH;
# parametri pubblici
my $bigPrimeNumber='32416190071';
my $generator='4';
# parametri privati
my $privateKeyAlice='4';
my $privateKeyBob='5';
# istanza DH di Alice
my $dhAlice=Crypt::DH->new();
$dhAlice->p($bigPrimeNumber);
$dhAlice->g($generator);
$dhAlice->priv_key($privateKeyAlice);
my $publicKeyAlice=$dhAlice->generate_keys;
say '-> Chiave pubblica Alice: '.$publicKeyAlice;
# istanza DH di Bob
my $dhBob=Crypt::DH->new();
$dhBob->p($bigPrimeNumber);
$dhBob->g($generator);
$dhBob->priv_key($privateKeyBob);
my $publicKeyBob=$dhBob->generate_keys;
say '-> Chiave pubblica Bob: '.$publicKeyBob;
# Alice calcola la chiave condivisa
my $secretKeyAlice=$dhAlice->compute_secret($publicKeyBob);
# Bob calcola la chiave condivisa
my $secretKeyBob=$dhBob->compute_secret($publicKeyAlice);
# le due chiavi sono uguali
say '-> Chiave segreta calcolata da Alice: '.$secretKeyAlice;
say '-> Chiave segreta calcolata da Bob: '.$secretKeyBob;
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: protocollo Diffie-Helmann
Script dh.pl
http://pastebin.com/qwLJiCnP
Classe Crypt::DH su CPAN //metacpan.org
Per installarla su qualunque pc di questo pianeta ed in orbita...
$ sudo cpan install Crypt::DH
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: RSA
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: RSA
E' il sistema a chiave pubblica più diffuso al mondo
E' versatile: usato per firme digitali e cifratura a chiave pubblica
E' basato sulla difficoltà di fattorializzare numeri grandi
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: RSA
Alice sceglie due numeri primi, p e q e ne calcola il
prodotto N. Inoltre sceglie un numero e che sia
primo rispetto a (p-1)x(q-1)
p=17
q=11
N=p x q=187
e=7
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: RSA
Alice sceglie due numeri primi, p e q e ne calcola il
prodotto N. Inoltre sceglie un numero e che sia
primo rispetto a (p-1)x(q-1)
p=17
q=11
N=p x q=187
e=7
N ed e sono la chiave pubblica di Alice
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: RSA
Bob vuole inviare ad Alice un messaggio, ad es. la
lettera X. Il codice ASCII di X è 88.
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: RSA
Bob vuole inviare ad Alice un messaggio, ad es. la
lettera X. Il codice ASCII di X è 88.
M=88
Bob calcola C=M**e mod(N)
C=88**7 mod(187)=11
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: RSA
Alice, tramite la sua chiave privata, decifra il
messaggio di Bob.
La chiave privata è calcolata dall'equazione:
e x d = 1 mod ((p-1) x (q-1))
d=23
d è la chiave privata di Alice
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: RSA
Alice, tramite la sua chiave privata, decifra il
messaggio di Bob.
M=C**d mod (N)
M=11**23 mod (187) = 88
Messaggio=X
Ciò è garantito dal Piccolo Teorema di Fermat
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: RSA
Riepilogo 1/2:
si scelgono a caso due numeri primi, p e q abbastanza grandi da garantire la
sicurezza dell'algoritmo
si calcola il prodotto n = pq , chiamato modulo e il prodotto f(n) = (p-1)(q-1)
si sceglie poi un numero e (chiamato esponente pubblico), coprimo con f(n) e più
piccolo di f(n)
si calcola il numero d (chiamato esponente privato) tale che il suo prodotto con e
sia congruo ad 1 modulo f(n)
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: RSA
Riepilogo 2/2:
Un messaggio m viene cifrato attraverso l'operazione c = m^e mod{n}
Una volta trasmesso, c viene decifrato con c^d mod{n} = m.
Il procedimento funziona solo se la chiave e utilizzata per cifrare e la chiave d
utilizzata per decifrare sono legate tra loro dalla relazione ed = 1 mod{f(n)}
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: RSA
Firma digitale
La firma digitale è l'applicazione inversa
Il messaggio viene crittografato con la chiave privata, in modo
che chiunque possa decifrarlo con la chiave pubblica, potendo
essere certo che il messaggio è stato mandato dal possessore
della chiave privata che è l'unica chiave a poter ”funzionare”
con la chiave pubblica.
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: RSA
#!/usr/bin/perl -w
use strict;
use warnings;
use feature 'say';
use Crypt::RSA;
# istanza oggetto Crypt::RSA
my $rsa=Crypt::RSA->new();
# Alice produce la sua chiave privata per decifrare e la chiave pubblica da distribuire per cifrare
my ($public, $private) = $rsa->keygen (
Size
=> 1024,
Verbosity => 1
) or die $rsa->errstr();
say '-> Chiavi privata e pubblica OK';
my $plainText='RSA al WORKSHOP@UNINA2014';
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: RSA
# Bob cripta il suo messaggio per Alice con la chiave pubblica che ha ricevuto
say '-->Cifratura RSA in corso...';
my $encryptedText = $rsa->encrypt (
Message => $plainText,
Key => $public
) or die $rsa->errstr();
say '-->Cifratura RSA completata';
# Alice con la sua chiave privata è la sola che può decriptare il messaggio che Bob le ha inviato
say '-->Decifratura RSA in corso...';
my $decryptedText = $rsa->decrypt (
Cyphertext => $encryptedText,
Key => $private
) or die $rsa->errstr();
say '-->Decifratura RSA completata';
say $decryptedText;
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Algoritmi asimmetrici: RSA
Script rsa.pl
http://pastebin.com/0t9Q6zvd
Classe Crypt::RSA su CPAN //metacpan.org
Per installarla su qualunque pc di questo pianeta ed in orbita...
$ sudo cpan install Crypt::RSA
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
La summa: il software PGP
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
La summa: il software PGP
Pretty Good Privacy, la crittografia alla portata di tutti
PGP usa RSA | DH per inviare la chiave di un cifrario
simmetrico(più veloce), ad es. AES, con cui proseguire la
Comunicazione
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
La summa: il software PGP
Alice sceglie una chiave AES con cui cifra il messaggio.
Invia a Bob due dati:
1. messaggio cifrato con AES
2. chiave di AES cifrata con la chiave pubblica RSA di Bob
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
La summa: il software PGP
Bob effettua due operazioni:
1. usa la chiave privata RSA per prelevare la chiave AES
2. usa la chiave AES per leggere il messaggio
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
La summa: il software PGP
# genera chiavi pubblica e privata di Crypt::OpenPGP
# cifrare dati e decifrare dati
use Crypt::OpenPGP;
my $size = '1024';
my $ident = 'Mario Rossano <[email protected]>';
my $pass = 'pippo';
my $public_file = 'public.pgp';
my $private_file = 'private.pgp';
my $plainText='test';
my $keychain = Crypt::OpenPGP->new();
my ($public, $private) = $keychain->keygen (
Type => 'RSA',
Identity => $ident,
Size
=> $size,
Passphrase => $pass,
Verbosity => 1,
) or die $keychain->errstr();
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
La summa: il software PGP
my $public_str = $public->save;
my $private_str = $private->save;
print "Public encrypting_key: ".$public->encrypting_key ."\n";
print "Private encrypting_key: ".$private->encrypting_key ."\n";
open my $fh,'>',$public_file or die $!;
print $fh $public_str;
close $fh;
open $fh, '>', $private_file or die $!;
print $fh $private_str;
close $fh;
my $pgp = Crypt::OpenPGP->new(
PubRing => $public_file,
SecRing => $private_file
);
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
La summa: il software PGP
my $cyphertext = $pgp->encrypt (
Data => $plainText,
Recipients => $ident
) or die $pgp->errstr();
print "testo criptato: ".$cyphertext;
my $decryptedText = $pgp->decrypt (
Data => $cyphertext,
Passphrase => $pass
) || die $pgp->errstr();
print "testo decriptato: ".$decryptedText."\n";
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
La summa: il software PGP
Script openpgp.pl
http://pastebin.com/6wYMxphm
Classe Crypt::OpenPGP su CPAN //metacpan.org
Per installarla su qualunque pc di questo pianeta ed in orbita...
$ sudo cpan install Crypt::OpenPGP
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Le nuove strade della Crittografia
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Le nuove strade della Crittografia
A differenza dei sistemi basati sui numeri interi fattorializzazione e problema del logaritmo discreto le nuove strade esplorano:
. Geometria Frattale
. Fisica Quantistica
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Le nuove strade della Crittografia
A differenza dei sistemi basati sui numeri interi fattorializzazione e problema del logaritmo discreto le nuove strade esplorano:
. Geometria Frattale
Proprietà del caos deterministico
. Meccanica Quantistica
Principio di indeterminazione di Heisenberg
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia frattale: algoritmo FNA
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia frattale: algoritmo FNA
Basata sulle proprietà del caos deterministico
E' un polialfabetico che rispetta i requisiti dimostrati da
Claude Shannon in Teoria dell'Informazione per cui un
sistema inviolabile è del tipo one time pad
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia frattale: algoritmo FNA
Basata sulle proprietà del caos deterministico
E' un polialfabetico che rispetta i requisiti dimostrati da
Claude Shannon in Teoria dell'Informazione per cui un
sistema inviolabile è del tipo one time pad
Il caso migliore si ha quando la chiave è lunga come il
Messaggio (il dato) da cifrare, il che equivale a dire che si
cifra con un numero di alfabeti pari al numero di caratteri
del messaggio da cifrare.
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia frattale: algoritmo FNA
Basata sulle proprietà del caos deterministico
Ogni cifratura influenza le successive seguendo l'effetto
farfalla.
Il caso migliore si ha quando la chiave è lunga come il
Messaggio (il dato) da cifrare, il che equivale a dire che si
cifra con un numero di alfabeti pari al numero di caratteri
del messaggio da cifrare.
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia frattale: algoritmo FNA
Cifratura
Ogni byte viene crittografato mediante le coordinate del
vertice della curva frattale, ottenuto partendo dal
successivo a quello precedentemente valutato, saltando
di un numero ulteriore di vertici stabilito dalla chiave.
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia frattale: algoritmo FNA
Decifratura
Si segue la curva frattale verificando, di vertice in vertice,
che le coordinate corrispondano a quelle del crittogramma.
Il valore del byte originale viene ricostruito avendo contato
quanti vertici si sono succeduti per arrivare all’uguaglianza
dei due valori, dall’ultima uguaglianza incontrata. Il numero
di vertici, ridotto di un predefinito valore stabilito dalla chiave
e sommato all’unità, rappresenta il valore del byte n-esimo.
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia frattale: algoritmo FNA
Metodi della classe Perl
Crypt::FNA->new
Crypt::FNA->make_fract
Crypt::FNA->encrypt_file
Crypt::FNA->decrypt_file
Crypt::FNA->encrypt_scalar
Crypt::FNA->decrypt_scalar
Crypt::FNA->mac
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia frattale: algoritmo FNA
Metodo “encrypt_file”
L’aspetto di un file cifrato è simile al seguente:
-806.16701617 4296.950584 -1163.3897453 4378.30613408 -1253.81513894 4361.33265404 -1502.80711437
4636.89514523 -1371.10557976 4745.56050632 -1230.07749379 4968.48069209 -1338.39851924 5248.88785964
-917.21821497 5429.36645491 -773.44592091 5696.62911696 -692.72801005 5885.46154004 -988.27897105
5885.418198 -1248.99379997 6171.71101067 -830.48330143 6377.55135044 -768.07453852 6493.40995382
-290.38619797 6703.79926248 -101.38261857 6641.39653224 329.01095794 6547.35282987 491.23460593
6672.15350589 682.15153937 6767.07332641 951.17643798 7125.45527124 844.47157379 7301.13742586
616.45930112 7293.99200882 844.26353513 7262.78340711 1211.3200562 7315.25004987 1474.41515451
7121.21394711 1951.75973992 7224.47233263 2176.20365976 6962.04147204 2547.88708591 6998.13655185
2781.82594976 6972.85084038 3056.52905252 7371.28466715 3037.53030053 7569.06437014 3048.49593738
7320.32093005 3389.66342779 7357.81470144 3676.23526579 7708.87987244 3755.43863759 7814.8354795
3435.5290489 8296.58426972 3441.10117125 8627.97877198 3412.2773365 8623.6058585 3362.87465115
8767.32280898 3260.65143202 8583.97947961 2890.71868372 8474.68032897 2726.83436885 8650.05588533
2718.8481018 9045.95222039 2669.00976899 9254.66114943 2644.06562016 9103.68182141 3127.66020707
9113.43039278 3191.47856428 9188.88465234 3207.82184971 9202.57034881 3478.33454467 8945.6121183
3832.00806714 8945.62804071 4080.86384299 9320.62189286 4289.2595779 9439.78195562 4021.13116501
9644.36385638 4311.34336432 9554.3477728
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia frattale: algoritmo FNA
Metodo “encrypt_file”
Il file viene “frullato” in
una ragnatela simile alla
seguente.
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia frattale: algoritmo FNA
use Crypt::FNA;
my $krypto=Crypt::FNA->new(
{
r=> 4,
angle => [42,123,-50],
square => 2048,
background => [255,255,255],
foreground => [0,0,0],
magic => 1,
salted => 'false'
}
);
print "Cifratura di pong.swf in corso...\n";
my $startTime=time();
$krypto->encrypt_file('pong.swf','pong.fna');
my $timeInterval=time()-$startTime;
print 'criptato pong.swf in pong.fna ('.$timeInterval." sec.)\n";
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia frattale: algoritmo FNA
Script fna.pl
http://pastebin.com/5EJGdPRu
Classe Crypt::FNA su CPAN //metacpan.org
Per installarla su qualunque pc di questo pianeta ed in orbita...
$ sudo cpan install Crypt::FNA
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia quantistica: protocollo BB84
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia quantistica: protocollo BB84
Permette lo scambio della chiave
Il protocollo evidenzia un attacco ”man in the middle”
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia quantistica: protocollo BB84
Alice invia un messaggio a Bob
Il messaggio è costituito da una sequenza di 0 ed 1
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia quantistica: protocollo BB84
Alice invia un messaggio a Bob
Il messaggio è costituito da una sequenza di 0 ed 1
I valori 0 ed 1 sono prodotti dalla polarizzazione dei fotoni
che viaggiano sul canale quantistico.
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia quantistica: protocollo BB84
Alice invia un messaggio a Bob
Il messaggio è costituito da una sequenza di 0 ed 1
I valori 0 ed 1 sono prodotti dalla polarizzazione dei fotoni
che viaggiano sul canale quantistico.
Alice usa due schemi per rappresentare gli 0 ed 1 del
messaggio
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia quantistica: protocollo BB84
Base (filtri di polarizzazione)
condivisa da Alice e Bob
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia quantistica: protocollo BB84
Bob legge la sequenza inviata da Alice
Scegliendo arbitrariamente il filtro +
Oppure x per effettuare la misura poiché
ignora il filtro usato da Alice.
Bob effettua delle misure, alcune corrette ed altre no,
in modo casuale
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia quantistica: protocollo BB84
Alice, su un canale in chiaro, comunica a Bob la
sequenza degli schemi di polarizzazione
MA NON LA POLARIZZAZIONE
Bob comunica ad Alice quando ha indovinato ignorando
gli altri casi.
Ora potranno utilizzare la sequenza di 0 1 relativa alle
misure corrette come chiave
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia quantistica: protocollo BB84
Eve potrebbe tentare di leggere le sequenza ma non
saprebbe che filtro polarizzatore utilizzare, sarebbe
nella condizione di Bob.
Se intercettasse il canale in chiaro non le sarebbe
utile poiché avrebbe assegnato un valore errato a
parte della chiave e modificato le letture di Bob.
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
•
Crittografia quantistica: protocollo BB84
?
?
In questo caso le chiavi di Alice e Bob differirebbero
e quindi si renderebbe chiaro che c'è stata un intromissione
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014
The End!
Ringrazio il NaLUG,
gli amici della community Perl italiana //perl.it,
l'Università Federico II di Napoli
...e soprattutto voi che con pazienza e curiosità avete fatto con me questo
piccolo ma intenso percorso lungo 2000 anni di storia dell'intelletto umano.
Grazie :)
Crittografia: da Cesare ai quanti
di Mario Rossano aka Anak – [email protected]
Workshop@UniNA 2014­>NEXT();
19.05.2014
La complessità del malware
Analisi strutturale e ambienti di sviluppo
di Marco Ferrigno
STAY TUNED #WUNINA14