LA SICUREZZA INFORMATICA - Matematicamente.it
LA SICUREZZA INFORMATICA - Matematicamente.it
LA SICUREZZA INFORMATICA - Matematicamente.it
You also want an ePaper? Increase the reach of your titles
YUMPU automatically turns print PDFs into web optimized ePapers that Google loves.
CASTIGLIONI MARCO<br />
POZZETTI MIRKO<br />
TREVISAN MATTEO<br />
<strong>LA</strong> <strong>SICUREZZA</strong><br />
<strong>INFORMATICA</strong><br />
ANNO SCO<strong>LA</strong>STICO 2001/2002<br />
C<strong>LA</strong>SSE 5IB
SOMMARIO<br />
Introduzione III<br />
Cap<strong>it</strong>olo 1 La storia<br />
1.1 La nasc<strong>it</strong>a dei calcolatori 1<br />
1.1.1 I computer e la seconda guerra mondiale 1<br />
1.1.2 I computer nel dopoguerra 2<br />
1.1.3 I computer moderni 3<br />
1.2 I computer nella seconda guerra mondiale 4<br />
Cap<strong>it</strong>olo 2 Il presente<br />
2.1 Le comunicazioni in Internet 7<br />
2.2 Il protocollo IP 8<br />
2.2.1 Il preambolo IP 8<br />
2.2.2 Struttura dell’indirizzo IP 10<br />
2.3 Il protocollo TCP 11<br />
2.3.1 Il preambolo TCP 12<br />
2.3.2 Gestione delle connessioni TCP 13<br />
2.4 Le porte 15<br />
2.4.1 Esempi di porte 16<br />
2.5 I socket 17<br />
2.6 Esempi 17<br />
2.6.1 Tracert 18<br />
2.6.2 Netstat 18<br />
Cap<strong>it</strong>olo 3 La cr<strong>it</strong>tografia<br />
3.1 La storia 19<br />
3.1.1 Cr<strong>it</strong>tografia antica 21<br />
3.1.2 Cr<strong>it</strong>tografia fino al XVIII secolo 23<br />
3.1.3 Cr<strong>it</strong>tografia moderna 25<br />
3.2 Principali cifrari 28<br />
3.2.1 Cifrari a sost<strong>it</strong>uzione 28<br />
3.2.2 Cifrario affine 28<br />
3.2.3 Cifrario Playfair 30<br />
3.2.4 Stream cypher 31<br />
3.2.5 Cifrario di Vernam 32<br />
3.3 La sicurezza perfetta 33<br />
3.4 Gli algor<strong>it</strong>mi 35<br />
3.4.1 Il DES 35<br />
3.4.2 L’ RSA 45<br />
3.5 Macchine cifranti 46<br />
3.5.1 Enigma 46<br />
3.5.2 La bomba di Turing 52<br />
3.6 Cr<strong>it</strong>toanalisi 57<br />
3.6.1 Cr<strong>it</strong>toanalisi statistica 57<br />
3.6.2 Cr<strong>it</strong>toanalisi lineare 58<br />
3.6.3 Cr<strong>it</strong>toanalisi differenziale 60<br />
3.6.4 Cr<strong>it</strong>toanalisi su polialfabetici 60<br />
3.6.5 Brute force 61<br />
3.7 Curios<strong>it</strong>à e considerazioni 62<br />
Sommario<br />
I
Cap<strong>it</strong>olo 4 Esempi pratici<br />
4.1 L’uso di Winsock 64<br />
4.1.1 Struttura dell’applicazione 64<br />
4.1.2 Implementazione dell’applicazione 66<br />
4.2 Il DES 68<br />
4.2.1 La classe CDes 68<br />
4.3 Scambio di messaggi cr<strong>it</strong>tati 75<br />
4.3.1 Struttura dell’applicazione 76<br />
4.3.2 Implementazione dell’applicazione 76<br />
4.4 L’ analisi di un testo 78<br />
4.4.1 Struttura dell’applicazione 78<br />
4.4.2 Implementazione dell’applicazione 81<br />
4.5 I socket in Linux 88<br />
4.5.1 Implementazione dell’applicazione 88<br />
4.6 PGP 90<br />
Conclusioni 101<br />
Appendice A 105<br />
Appendice B 109<br />
Appendice C 114<br />
Appendice D 120<br />
Appendice E 121<br />
Appendice F 123<br />
Glossario 171<br />
Bibliografia 176<br />
Sommario<br />
II
INTRODUZIONE<br />
L’ argomento trattato nell’ area di progetto, la sicurezza<br />
informatica, è entrato in auge in segu<strong>it</strong>o alla capillare di<br />
diffusione dei PC e di Internet. Con essi sono nati i primi seri<br />
problemi di sicurezza sia per i privati e, soprattutto, per le<br />
grandi aziende.<br />
Nell’area di progetto si è cercato di analizzare questo<br />
problema prendendo in esame sia la parte teorica che quella<br />
pratica.<br />
In particolare l’attenzione è stata focalizzata su i due<br />
grandi temi chiave della sicurezza : gli attacchi via socket e la<br />
cr<strong>it</strong>tografia. Infatti sono questi i due temi che ad oggi<br />
determinano o meno la sicurezza di un sistema. Il primo, cioè i<br />
socket, riguarda la trasmissione delle informazioni, il secondo,<br />
la cr<strong>it</strong>tografia, riguarda la sicurezza intrinseca di esse.<br />
La trattazione di questi argomenti nella parte pratica ha<br />
permesso di realizzare una piccola applicazione che è in grado,<br />
tram<strong>it</strong>e l’uso congiunto di socket e cr<strong>it</strong>tografia, di inviare<br />
messaggi cifrati tra due stazioni.<br />
Inoltre è stata realizzata una piccola applicazione che<br />
permette di cr<strong>it</strong>tare i messaggi attraverso algor<strong>it</strong>mi “storici”<br />
come la scacchiera di Polibio o il cifrario di Cesare.<br />
Come ultimo esempio pratico è stato analizzato l’uso di<br />
PGP. In pratica è stato costru<strong>it</strong>o un piccolo manuale,<br />
contenente le istruzioni più importanti, per usare il programma<br />
di cr<strong>it</strong>tazione più diffuso al mondo.<br />
La seconda parte dell’area di progetto si basa sulle<br />
conseguenze che l’azione congiunta di informatica e cr<strong>it</strong>tografia<br />
hanno portato nella storia. In particolare si analizzeranno le<br />
tecniche usate nella seconda guerra mondiale per cifrare le<br />
informazioni, come la macchina Enigma e quelle per decifrarle,<br />
come la Bomba di Turing.<br />
In particolare lo sviluppo della cr<strong>it</strong>tografia è stato<br />
affrontato fin dai primi algor<strong>it</strong>mi (codice Atbash) fino ad<br />
arrivare ai giorni nostri.<br />
Introduzione<br />
III
Cap<strong>it</strong>olo 1<br />
La storia<br />
1.1 La nasc<strong>it</strong>a dei calcolatori<br />
1.1.1 I computer e la seconda guerra mondiale<br />
1.1.2 I computer nel dopoguerra<br />
1.1.3 I computer moderni<br />
1.2 I computer nella seconda guerra mondiale<br />
1.1 La nasc<strong>it</strong>a dei calcolatori<br />
La parola computer deriva dal latino “computare” che<br />
significa “fare di conto”.<br />
Questo strumento è nato per facil<strong>it</strong>are il calcolo di<br />
funzioni matematiche complesse. Già nel 1642 il matematico<br />
Blaise Pascal inventò e costruì la prima calcolatrice macchina<br />
con riporto automatico con otto cifre. Questa macchina servì<br />
solo a dimostrare che si potevano eseguire calcoli matematici<br />
anche con macchine e non solo con la mente, mentre il vero e<br />
proprio computer nasce solo nel XX secolo. Sempre in questi<br />
anni nasce la scienza dell’informatica, che studia l’elaborazione<br />
dei dati e il trattamento automatico delle informazioni.<br />
1.1.1 I computer e la seconda guerra mondiale<br />
Il secondo confl<strong>it</strong>to mondiale fu la rampa di lancio dei<br />
primi computer, che furono ideati sia dalla parte alleata sia dalla<br />
parte tedesca.<br />
I tedeschi furono i primi a costruire un macchina che fu in<br />
grado di generare un codice cr<strong>it</strong>tato, che era incomprensibile per<br />
gli alleati. Questo codice, creato dai tedeschi per comunicare<br />
strategie di guerra e messaggi, fu incomprensibile per gli alleati<br />
per tutta la prima parte del confl<strong>it</strong>to.<br />
Churchill incaricò il matematico inglese Turing, che fu<br />
l’ideatore della prima macchina, che era in grado di leggere le<br />
informazioni da un nastro e di copiarle su un altro, di dirigere il<br />
centro di studi sulla comunicazione.<br />
Turing formò un gruppo di lavoro per decifrare i codici<br />
cr<strong>it</strong>tati, formato da circa settemila persone, sia mil<strong>it</strong>ari sia<br />
personale civile (si andava da matematici, ad archeologi, a<br />
cr<strong>it</strong>tografici, ad enigmisti, a giocatori d’azzardo e a tante altre<br />
persone).<br />
Ma solo un esperto di centralini telefonici ideò il primo<br />
calcolatore elettromeccanico, che era in grado di trovare in<br />
pochi minuti i codici nazisti: questa macchina prese il nome di<br />
Colossus.<br />
La storia<br />
1
Questo calcolatore cambiò letteralmente le sorti della<br />
guerra, infatti, gli alleati erano in grado di prevedere le mosse<br />
dei tedeschi e la marina <strong>it</strong>aliana ne fece le spese, venendo<br />
sconf<strong>it</strong>ta nel 1941 a Capo Matapan.<br />
Alla fine della seconda guerra mondiale Churchill ordinò<br />
di smantellare tutti gli esemplari di Colossus.<br />
1.1.2 I computer nel dopoguerra<br />
Gli anni del dopoguerra furono fondamentali per la<br />
nasc<strong>it</strong>a di calcolatori più veloci, anche se questi calcolatori<br />
“moderni” erano molto grossi, pesanti e lenti rispetto a<br />
quelli che usiamo ora.<br />
Il primo calcolatore elettromeccanico funzionava<br />
automaticamente con programmi registrati (che sono gli<br />
“antenati” dei primi software).<br />
Il nome di questo calcolatore era Harvard Mark 1 e fu<br />
realizzato nei laboratori dell’IBM, in collaborazione con<br />
l’univers<strong>it</strong>à di Harvard. Con questo calcolatore è nato anche<br />
il termine “bug”, che viene utilizzato dagli specialisti per<br />
definire un errore.<br />
Il calcolatore Bessie che eseguiva operazioni<br />
matematiche come la somma di numeri a 23 cifre in tre<br />
decimi di secondo e una moltiplicazione in 6 secondi, venne<br />
impiegato dalla marina mil<strong>it</strong>are statun<strong>it</strong>ense per studi sulla<br />
balistica e progettazione di navi. Inoltre venne anche usato<br />
dalla commissione dell’energia per ricerche sulla<br />
disintegrazione dell’atomo.<br />
Un altro calcolatore realizzato nel 1946, destinato<br />
solamente ad un uso mil<strong>it</strong>are, chiamato Eniac, costò la<br />
bellezza di mezzo milione di dollari di allora. Questo<br />
calcolatore serviva per il calcolo delle traiettorie dei<br />
proiettili. Esso riusciva a realizzare una tabella balistica in<br />
30 minuti contro le 20 ore impiegate da un uomo. Questo<br />
calcolatore fu tenuto in funzione solo per nove anni, dopo<br />
di che non fu più utilizzato poiché aveva un alto costo di<br />
manutenzione. Esso va ricordato anche per un altro fatto:<br />
durante la sua creazione lo scienziato John Tykey creò il<br />
termine “b<strong>it</strong>”, contrazione delle parole “Binary DigiT”. Esso<br />
rappresenta la più piccola un<strong>it</strong>à di informazione, che<br />
specifica due stati: 1 (acceso) e 0 (spento), che codificano i<br />
dati all’interno di un computer. Una striscia di otto b<strong>it</strong><br />
forma un “byte”, che oggi viene utilizzato per rappresentare<br />
un carattere o un singolo numero.<br />
Nel 1947 fu inventato il transistor, il quale<br />
rivoluzionò completamente il mondo del computer. Questi<br />
dispos<strong>it</strong>ivi erano molto più piccoli (qualche millimetro)<br />
rispetto alle valvole (diversi centimetri), erano molto più<br />
resistenti e consumavano molta meno elettric<strong>it</strong>à.<br />
Fino al 1950 i computer non avevano memoria e quindi<br />
le informazioni non potevano essere salvate. Tra il 1950 e il<br />
La storia<br />
2
1955 i calcolatori vennero dotati di memorie, ma la capac<strong>it</strong>à<br />
di memorizzazione era solo di un b<strong>it</strong> alla volta. Queste<br />
memorie “interne” erano molto ingombranti e siccome i<br />
computer avevano già grandi dimensioni, si decise di<br />
abbandonarle, puntando su memorie ausiliarie o esterne,<br />
come nastri e dischi magnetici.<br />
Negli anni successivi si costruirono calcolatori sempre<br />
più piccoli, arrivando nel 1957 alle dimensioni di un<br />
frigorifero. Questo calcolatore era accessibile solamente<br />
all’eserc<strong>it</strong>o. Ma l’era dei computer domestici era lontana,<br />
poiché il costo era elevato e le dimensioni non certo adatte<br />
per una casa.<br />
Ma la vera rivoluzione avvenne nel 1958, grazie<br />
all’ingegnere americano Kilby che inventò i circu<strong>it</strong>i<br />
integrati.<br />
1.1.3 I computer moderni<br />
Gli integrati rivoluzionarono il mondo del computer:<br />
con questa invenzione i calcolatori potevano avere delle<br />
dimensioni molto ridotte rispetto ai loro predecessori.<br />
Questa invenzione nel campo informatico prese il nome di<br />
chip. I computer ebbero una diffusione maggiore: essi non<br />
solo potevano essere acquistati dai mil<strong>it</strong>ari, ma anche da<br />
industrie. Erano molto veloci, grazie a questi circu<strong>it</strong>i<br />
miniaturizzati, ma il loro costo era molto elevato e ancora<br />
accessibile a pochi.<br />
Questi computer erano prodotti soprattutto in<br />
America, ma nel 1965 anche l’Italia scese in campo, grazie<br />
all’ Olivetti, che costruì un calcolatore chiamato<br />
“Programma 101”, che ebbe grande successo, soprattutto<br />
oltreoceano. Questo calcolatore fu il primo ad avere<br />
memorizzato al suo interno un programma ed un supporto<br />
magnetico, dal quale avrà origine il “floppy disk”.<br />
Nel 1968 l’industria americana prese il sopravvento,<br />
infatti, in questo anno nacque l’Intel, che fu ed è tuttora,<br />
l’azienda leader nella costruzione di processori e chip di<br />
memoria.<br />
Nel 1970 costruì la prima RAM adottata da tutti i<br />
calcolatori al posto delle vecchie memorie a nuclei<br />
magnetici.<br />
Nel 1971 venne costru<strong>it</strong>a la prima cpu che da allora,<br />
cost<strong>it</strong>uisce il cuore del calcolatore. Essa era in grado di<br />
tenere memorizzati i dati, fino a che non veniva a mancare<br />
la corrente.<br />
Per realizzare il computer come lo conosciamo oggi,<br />
mancava ancora un componente, infatti, il vero problema era<br />
memorizzare i dati all’interno del calcolatore, senza perderli<br />
una volta tolta la corrente. Questo problema venne superato<br />
grazie al primo “hard disk”, costru<strong>it</strong>o dall’IBM, che<br />
La storia<br />
3
permetteva di immagazzinare i dati anche in mancanza di<br />
corrente.<br />
La data più importante nella storia dei computer e<br />
dell’informatica fu il 1975, anno in cui, grazie a due studenti<br />
univers<strong>it</strong>ari, William “Bill” Gates e Paul Allen, nacque la<br />
Microsoft, prima azienda specializzata nell’elaborazione di<br />
linguaggi per computer. A questa azienda si opposero altri<br />
due giovani, Stephen Jobs e Stephen Wozniak, che nel<br />
salotto della loro casa, costruirono Apple I e diedero v<strong>it</strong>a<br />
nel 1976 alla Apple azienda, tuttora in competizione con<br />
Microsoft. Nel 1977, Jobs e Wozniak, costruirono Apple II,<br />
che era solo dotato di una tastiera, di un alimentatore e di<br />
prese per il collegamento con le periferiche, già presenti sul<br />
mercato.<br />
Nel 1981 l’IBM, che allora era la maggiore produttrice<br />
di computer, investì sulla produzione dei “Personal<br />
Computer” grazie anche all’aiuto della Microsoft, la quale<br />
ideò e fornì il primo sistema operativo : l’ MS-DOS, che è<br />
tuttora utilizzato.<br />
In questi quarant’ anni il computer si è evoluto<br />
rapidamente, passando dall’essere lento e ingombrante ad<br />
avere dimensioni che siamo ab<strong>it</strong>uati a vedere tutti i giorni e<br />
a veloc<strong>it</strong>à che sono in costante aumento.<br />
Nel futuro i computer saranno sempre più piccoli e<br />
più veloci e faranno sempre più parte della nostra v<strong>it</strong>a<br />
quotidiana.<br />
1.2 I computer nella Seconda Guerra Mondiale<br />
Dopo l’ascesa al potere di H<strong>it</strong>ler, verificatasi in Germania<br />
a partire del 1933, e la costruzione del suo regime d<strong>it</strong>tatoriale, il<br />
nazismo portò prima l’Europa e poi il mondo intero in un nuovo<br />
e spaventoso confl<strong>it</strong>to mondiale.<br />
La guerra iniziò il 1° settembre del 1939 con l’attacco<br />
della Germania alla Polonia che venne conquistata i poche<br />
settimane . Il 3 settembre la Francia e l’Inghilterra dichiararono<br />
guerra alla Germania.<br />
Mentre sul fronte francese non si verificarono inizialmente<br />
combattimenti, la Russia attaccò e conquistò la Finlandia, la<br />
Germania per stringere l’Inghilterra in una morsa attaccò e<br />
conquistò la Danimarca e la Norvegia. Sulla linea di confine tra<br />
Francia e Germania i francesi costruirono una linea difensiva<br />
(Linea Maginot), con trincee e cannoni, che serviva come difesa<br />
in caso di attacco, ma la Germania attaccò, passando per il<br />
Belgio, il 10 maggio del 1940, e dopo poco più di un mese i<br />
tedeschi conquistarono gran parte della Francia.<br />
Il 10 giugno del 1940 entrò in guerra a fianco dei nazisti<br />
l’Italia. Con questo intervento mil<strong>it</strong>are si verificherà la<br />
conquista <strong>it</strong>aliana di terr<strong>it</strong>ori in Africa (Somalia, Sudan) e della<br />
Grecia, mentre perdette l’Etiopia; inoltre subì gravi sconf<strong>it</strong>te<br />
navali a Punta Stilo e a Capo Matapan nel 1941, derivanti dalla<br />
La storia<br />
4
superior<strong>it</strong>à della marina inglese, ottenuta grazie al radar. La<br />
battaglia di Capo Matapan fu persa a causa dell’intercettazione<br />
inglesi delle trasmissione cr<strong>it</strong>tate tra Italiani e tedeschi, grazie al<br />
primo computer COLOSSUS.<br />
Per l’Asse (Germania, Italia, Giappone) fino alla fine del<br />
1941 la guerra portò importanti v<strong>it</strong>torie, che rafforzarono il loro<br />
potere e permisero la conquista di nuovi terr<strong>it</strong>ori e, come<br />
conseguenza, l’allargamento dei propri confini.<br />
I tedeschi ev<strong>it</strong>arono che i paesi alleati ricevessero gli aiuti<br />
dagli Stati Un<strong>it</strong>i; questi ultimi si dichiararono neutrali nel 1939<br />
insieme al Giappone. Ma gli USA, in realtà, fornivano aiuti ai<br />
paesi che non avevano al potere dei regimi total<strong>it</strong>ari filo -<br />
fascisti. I tedeschi cercarono di ev<strong>it</strong>are che gli aiuti statun<strong>it</strong>ensi<br />
raggiungessero l’Europa, usando i sottomarini (U-boat), che<br />
aspettavano le navi al largo dell’Atlantico e le affondavano.<br />
I sottomarini tedeschi, riuscivano a comunicare tra di loro<br />
e con gli alti comandi dell’eserc<strong>it</strong>o tram<strong>it</strong>e l’invio di messaggi.<br />
Questi ultimi per non essere intercettati e cap<strong>it</strong>i dagli Alleati<br />
erano cr<strong>it</strong>tati con la macchina ENIGMA. Per la prima parte della<br />
guerra le potenze dell’Asse riuscirono a comunicare con<br />
sicurezza senza che gli Alleati riuscissero a intercettare e a<br />
comprendere i messaggi mandati.<br />
Con l’attacco della Germania alla Russia, che iniziò nel<br />
giugno del 1941, cominciò il declino delle potenze dell’asse.<br />
Dopo aver riportato v<strong>it</strong>torie schiaccianti in pochi mesi,<br />
l’immenso eserc<strong>it</strong>o arrivò alle porte di Mosca e Stalingrado. Ma<br />
con l’inizio dell’inverno la macchina bellica si inceppò, fermò<br />
la sua marcia verso la conquista dell’intero terr<strong>it</strong>orio e cominciò<br />
una guerra di posizione,. L’eserc<strong>it</strong>o russo si riorganizzò e sferrò<br />
la controffensiva, mentre quello tedesco arretrò per circa 200<br />
chilometri. Come conseguenza H<strong>it</strong>ler ordinò la resistenza a<br />
oltranza e nel giugno del 1942 dispose di radere al suolo<br />
Stalingrado, ma l’eserc<strong>it</strong>o non riuscì nell’impresa; questo fu<br />
l’inizio della fine per le potenze dell’Asse.<br />
Inoltre gli Alleati riuscirono a rompere il codice cr<strong>it</strong>tato<br />
che permetteva ai tedeschi di comunicare segretamente, così da<br />
permettere agli alleati di conoscere in anticipo le mosse del<br />
nemico.<br />
Questa rottura del codice fu effettuata da un gruppo di<br />
persone aiutate da un computer chiamato COLOSSUS. Questo<br />
gruppo fu incaricato da Churchill sotto la supervisione di Alan<br />
Turing.<br />
Anche sul fronte del Pacifico cominciarono a verificarsi le<br />
prime sconf<strong>it</strong>te del Giappone da parte degli americani.<br />
Come già stato detto, sia i giapponesi che gli americani, si<br />
dichiararono neutrali nel 1939, ma dopo l’attacco nipponico a<br />
Pearl Harbor, avvenuto il 7 dicembre 1941, gli USA decideranno<br />
di entrare in guerra. Nel Pacifico la forza americana era<br />
gravemente indebol<strong>it</strong>a, poiché l’attacco a Pearl Harbor riportò<br />
gravi perd<strong>it</strong>e di uomini e mezzi, rendendo le forze giapponesi<br />
superiori. Per avere il predominio nel Pacifico e l’annientamento<br />
La storia<br />
5
della flotta americana, i giapponesi dovettero organizzare un<br />
nuovo attacco.<br />
L’intelligence navale degli Stati Un<strong>it</strong>i aveva sub<strong>it</strong>o un<br />
grave smacco nell’attacco alle Hawaii, ma si misero al lavoro per<br />
cercare d’intercettare e decr<strong>it</strong>tare il messaggi nipponici; fu<br />
formato così un gruppo composto per la maggior parte<br />
d’analisti. In 6 mesi di lavoro furono in grado di decr<strong>it</strong>tare il<br />
codice. Da questo momento, gli americani poterono sapere in<br />
anticipo le mosse del nemico, ma non dove sarebbe avvenuto<br />
l'attacco. Il luogo scelto dai giapponesi furono le isole Midway,<br />
che fu scoperto casualmente in un messaggio cifrato. Il 4 giugno<br />
del 1942 iniziarono le prime schermaglie: sia i giapponesi che gli<br />
americani persero un numero uguale di navi, ma il contrattacco<br />
portato dagli americani fu schiacciante e vennero distrutte la<br />
maggior parte delle portaerei giapponesi, mentre le forze aeree<br />
vennero decimate. Dopo la schiacciante v<strong>it</strong>toria, le forze nel<br />
Pacifico tornarono in par<strong>it</strong>à.<br />
Da questo momento la macchina industriale americana<br />
cominciò a produrre navi e mezzi per combattere il Giappone.<br />
A patire dal 1943 i giapponesi persero la maggior parte dei<br />
terr<strong>it</strong>ori, gli americani si avvicinarono pericolosamente alle<br />
coste del giappone. Nel 1944 cominciarono i bombardamenti su<br />
Tokyo.<br />
Ma la vera forza nipponico era basata sull’eserc<strong>it</strong>o di terra.<br />
Allora Truman decise di sganciare due bombe atomiche sul<br />
Giappone per mettere fine al confl<strong>it</strong>to.<br />
Ne 1943 gli alleati sbarcarono in Italia e Mussolini venne<br />
arrestato e imprigionato. Si ist<strong>it</strong>uì il governo di Badoglio. Il 5<br />
maggio del 1944 gli alleati conquistarono Roma.<br />
Gli alleati e l’Unione Sovietica decisero di aprire un nuovo<br />
fronte di guerra: il luogo scelto fu la Normandia. La sbarco<br />
riuscì con successo e sia l’eserc<strong>it</strong>o alleato, sia i sovietici<br />
marciarono inarrestabili verso la Germania e Berlino. Il 7<br />
maggio i tedeschi firmano la cap<strong>it</strong>olazione.<br />
La storia<br />
6
Cap<strong>it</strong>olo 2<br />
Il presente<br />
2.1 Le comunicazioni in Internet<br />
2.2 Il protocollo IP<br />
2.2.1 Il preambolo IP<br />
2.2.2 Struttura dell’indirizzo IP<br />
2.3 Il protocollo TCP<br />
2.3.1 Il preambolo TCP<br />
2.3.2 Gestione delle connessioni TCP<br />
2.4 Le porte<br />
2.4.1 Esempi di porte<br />
2.5 I socket<br />
2.6 Esempi<br />
2.6.1 Tracert<br />
2.6.2 Netstat<br />
2.1 Le comunicazioni in Internet<br />
La maggior parte delle applicazioni che comunicano via<br />
rete (Internet o <strong>LA</strong>N) utilizzano gli stessi principi.<br />
Vi è una stazione cliente (client) che richiede un servizio<br />
ad una stazione servente (server). Quest’ ultima rimane in<br />
ascolto fino a che il cliente non richiede un servizio. A questo<br />
punto la stazione servente può decidere o meno di esaudire la<br />
richiesta. In caso affermativo le due stazioni cominciano a<br />
scambiarsi informazioni, il canale di comunicazione è<br />
bidirezionale, ovvero entrambe le stazioni possono inviare<br />
informazioni. Quando le due stazioni hanno terminato di<br />
comunicare la comunicazione verrà abbattuta.<br />
Quella appena fatta è una descrizione semplificata del<br />
protocollo TCP/IP (Transfer Control Protocol/Internet<br />
Protocol), il principale protocollo di comunicazione usato in<br />
Internet.<br />
La sua principale funzione è quella di fornire un flusso<br />
affidabile di dati tra due stazioni e permettere l’identificazione<br />
di esse tram<strong>it</strong>e un indirizzo.<br />
Il TCP/IP nasce durante gli anni ’70, congiuntamente con<br />
la versione 3.4 di UNIX. Il progetto fu elaborato dall’univers<strong>it</strong>à<br />
californiana di Berkeley.<br />
Il suo sviluppo è stato reso necessario dalla nasc<strong>it</strong>a delle<br />
prime reti a commutazione di pacchetto, avvenuta durante gli<br />
anni ’60. La prima di esse fu ARPANet, nata da uno studio<br />
finanziato dall’agenzia americana DARPA (Defense Advanced<br />
Research Project Agency) e svolto dall’ARPA (Advanced<br />
Research Project Agency).<br />
Il presente<br />
7
Durante gli anni ’80 con la fusione tra ARPANet e<br />
NSFNET (National Science Foundation NETwork) nasce la rete<br />
mondiale Internet, la quale verrà aperta al pubblico da 1992.<br />
2.2 Il protocollo IP<br />
Il protocollo IP (Internet Protocol) appartiene al livello 3°<br />
(livello di rete) del sistema a strati OSI (Open System<br />
Interconnection, standard internazionale per l’organizzazione di<br />
reti locali) e consente l’implementazione di una rete a<br />
commutazione di pacchetto che può utilizzare qualunque DLC<br />
(Data Link Control). Esso spedisce le informazioni divise in<br />
pacchetti, e ognuno di essi percorre diversi percorsi attraverso<br />
la rete. Quindi non si garantisce che il primo pacchetto inviato<br />
sia anche il primo arrivato al ricev<strong>it</strong>ore. Per compensare questo<br />
difetto si utilizza il protocollo TCP che appartiene al 4° livello<br />
OSI (livello di trasporto) che garantisce l’ordine dei pacchetti<br />
arrivati al terminale attraverso l’IP e assicura l’affidabil<strong>it</strong>à del<br />
protocollo.<br />
Ogni interfaccia su una rete TCP/IP riceve un<br />
identificatore univoco chiamato indirizzo IP. Ad ogni periferica<br />
della rete verrà assegnato un indirizzo IP. Ogni computer<br />
possedente un indirizzo IP e capace di comunicare via TCP/IP<br />
viene chiamato host. Esso possiede almeno una scheda di rete o<br />
un modem. Di conseguenza, se un host possiede più schede di<br />
rete, possiederà anche più indirizzi IP.<br />
Gli indirizzi IP sono formati da due parti : un ID di rete e<br />
un ID dell'host.<br />
L'ID dell'host identifica un singolo host che si trova su un<br />
segmento di rete. L'host può comunicare direttamente solo con<br />
altri host che si trovano sullo stesso segmento di rete, infatti, i<br />
segmenti, sono divisioni logiche di una rete in univoci ID<br />
numerici chiamati subnet.<br />
L'host deve usare, per comunicare con gli host di una diversa<br />
subnet, un router che comunica con entrambe le subnet.<br />
Il successo dell’IP è dovuto alla flessibil<strong>it</strong>à, la quale<br />
permette di connettere reti basate su tecnologie eterogenee.<br />
2.2.1 Il preambolo IP<br />
8 16 24 32<br />
Versione IHL Tipo di servizio Lunghezza del pacchetto<br />
Identificazione DF MF Offset di frammentazione<br />
del pacchetto<br />
Tempo di v<strong>it</strong>a Protocollo Checksum<br />
Indirizzo sorgente<br />
Indirizzo destinazione<br />
Options (lunghezza variabile)<br />
Il presente<br />
8
Version<br />
Descrive la versione del protocollo utilizzato dal datagram<br />
IPv4. La lunghezza è di 4 b<strong>it</strong>.<br />
IHL<br />
Siccome la lunghezza dell'header non è constante in questo<br />
campo è contenuta la lunghezza dell'header in parole di 32 b<strong>it</strong> il<br />
valore minimo è 5 (nessuna opzione header = 20 byte) il<br />
massimo è 15 byte (header uguale a 60 byte). La lunghezza del<br />
campo è di 4 b<strong>it</strong>.<br />
Tipo di servizio<br />
Consente agli host di comunicare alla rete il tipo di<br />
servizio desiderato in base ai parametri: r<strong>it</strong>ardo, capac<strong>it</strong>à di<br />
trasmissione affidabil<strong>it</strong>à. La lunghezza è di 8 b<strong>it</strong>.<br />
Lunghezza del pacchetto<br />
Riguarda l'intero pacchetto la massima lunghezza è di<br />
65.536 byte pari a 16 b<strong>it</strong>.<br />
Identificazione<br />
È necessario per permettere all'host di destinazione di<br />
determinare a quale datagram appartiene un frammento appena<br />
arrivato.Tutti i frammenti di un datagram contengono lo stesso<br />
numero di identificazione. La lunghezza è di 16 b<strong>it</strong>.<br />
Offset di frammentazione del pacchetto<br />
Indica in quale posizione del datagram corrente si trova<br />
questo frammento, tutti i frammenti tranne l'ultimo devono<br />
essere multipli di 8 byte, il campo è di 13 b<strong>it</strong> , avrò quindi un<br />
massimo di 8192 frammenti (8192 x 8 = 65536 byte al<br />
massimo(IP packet).<br />
Tempo di v<strong>it</strong>a<br />
È un contatore utilizzato per lim<strong>it</strong>are il tempo di v<strong>it</strong>a dei<br />
pacchetti sulla rete. Quando il contatore raggiunge lo 0 il<br />
pacchetto viene scartato e viene inviato alla destinazione un<br />
messaggio di avvertimento. Lunghezza pari a 8 b<strong>it</strong>.<br />
Protocollo<br />
Campo che indica il protocollo che viene usato al livello<br />
trasporto (TCP, UDP e altri) la numerazione dei protocolli è<br />
globale ed è descr<strong>it</strong>ta nel RFC 1700. La lunghezza è di 16 b<strong>it</strong>.<br />
Indirizzo sorgente e destinazione<br />
Sono rispettivamente gli indirizzi del m<strong>it</strong>tente e del<br />
destinatario del pacchetto composti da 32 b<strong>it</strong> ognuno.<br />
Checksum<br />
Verifica solamente il preambolo IP. E’ utilizzato per<br />
verificare gli errori generati dai router. L'algor<strong>it</strong>mo consiste nel<br />
sommare tutte le parole di 16 b<strong>it</strong> che arrivano usando<br />
Il presente<br />
9
l'ar<strong>it</strong>metica di complemento a 1 e quindi prendendo il<br />
complemento a 1 del risultato. Il risultato finale deve essere 0.<br />
Da notare che l'algor<strong>it</strong>mo deve essere cambiato ad ogni salto<br />
perchè c'è almeno un campo che cambia il TTL (time to live).<br />
La seconda struttura illustra le opzioni che si possono<br />
aggiungere a un pacchetto IP. Quelle più usate sono descr<strong>it</strong>te di<br />
segu<strong>it</strong>o.<br />
Secur<strong>it</strong>y<br />
Descrive il grado di segretezza delle informazioni, in<br />
teoria un router mil<strong>it</strong>are dovrebbe utilizzare questo campo per<br />
richiedere di non attraversare paesi considerati a rischio.<br />
Strict source routing<br />
Fornisce il percorso completo da seguire.<br />
Loose source routing<br />
Richiede che il pacchetto attraversi una lista di router<br />
specificati nell'ordine specificato ma e' possibile che passi<br />
attraverso altri router lungo il percorso.<br />
Record route<br />
Forza i router lungo il cammino ad aggiungere il loro<br />
indirizzo IP al campo opzione.<br />
Timestamp<br />
È simile all'opzione record route a parte il fatto che oltre<br />
a registare l'indirizzo a 32 b<strong>it</strong> ogni router regista un timestamp<br />
di 32 b<strong>it</strong> (motivi diagnostici).<br />
2.2.2 Struttura dell’indirizzo IP<br />
L’indirizzo IP è composto da 4 byte (1 byte = 0 255<br />
decimale o 0 ff esadecimale) che identificano in modo<br />
univoco un computer, quindi a ogni terminale corrisponde un<br />
solo indirizzo IP.<br />
Esempio 123.1.82.109<br />
In una rete locale (<strong>LA</strong>N, Local Area Network) l’indirizzo<br />
IP è statico. Il primo indirizzo è 192.168.0.1, gli altri indirizzi<br />
crescono in modo sequenziale. Diversamente in Internet (WAN,<br />
World Area Network) l’indirizzo IP è dinamico, quindi ad ogni<br />
nuova connessione si avrà un nuovo IP. Questo avviene per<br />
diversi motivi:<br />
• primo, il totale degli indirizzi che si possono creare con<br />
32b<strong>it</strong> è 4.294.967.296, quindi non è possibile applicare ad ogni<br />
utente un IP fisso poiché gli indirizzi disponibili non sarebbero<br />
sufficienti;<br />
• secondo, un IP statico facil<strong>it</strong>erebbe il comp<strong>it</strong>o ai pirati<br />
informatici<br />
Il presente<br />
10
Poiché esistono “solo” 4,3 miliardi di indirizzi IP gli<br />
sviluppatori hanno deciso di suddividerli in 5 diverse classi,<br />
dalla A alla E. Ognuna di esse ha un funzionamento diverso<br />
dalle altre.<br />
Per identificarle il 1° byte dell’IP ha dei valori diversi :<br />
Classe<br />
Configurazione binaria<br />
del 1° byte Indirizzo Struttura<br />
Classe A 0xxxxxxx 0-127.x.x.x Net_Add 1°byte<br />
Classe B 10xxxxxx 127-191.0-255.x.x Net_Add 1°, 2° byte<br />
Classe C 110xxxxx 192-223.0-255.0-255.x Net_Add 1°, 2°, 3° byte<br />
Classe D 1110xxxx 224-239.x.x.x Flat<br />
Classe E 11110xxx 240-255.x.x.x Usi futuri<br />
Naturalmente le varie classi hanno funzional<strong>it</strong>à diverse.<br />
Le classi A, B, C hanno scopi commerciali ossia sono usate<br />
da società o da privati per connettersi a Internet, mentre la<br />
classe D è usata per impieghi speciali mentre la classe E è<br />
riservata per usi futuri.<br />
Le 3 classi per usi quotidiani hanno delle differenze<br />
sostanziali, poiché hanno tutte un diverso numero di host e un<br />
diverso numero di reti :<br />
Classe Numero di reti Numero di host<br />
Classe A 126 16.777.214<br />
Classe B 16.384 65.534<br />
Classe C 2.097.152 254<br />
Si può notare che la classe A ha un elevato numero di<br />
host, ma un basso numero di reti.<br />
Al contrario la classe C può avere pochi host, ma un<br />
elevato numero di reti.<br />
Classe Indirizzo IP ID di rete ID dell'host<br />
Classe A 10.1.1.10 10 1.01.10<br />
Classe B 172.16.1.10 172.16.00 1.10<br />
Classe C 192.168.1.10 192.168.1 10<br />
La scelta della classe dipende dalla rete che si vuole<br />
effettuare.<br />
2.3 Il protocollo TCP<br />
Il protocollo TCP fa parte del 4° livello dello standard<br />
OSI. Il suo comp<strong>it</strong>o è quello di rendere affidabile il protocollo<br />
IP, fornendo una verifica sulla consegna dei dati. TCP<br />
garantisce una consegna corretta per mezzo della ricevuta<br />
pos<strong>it</strong>iva con r<strong>it</strong>rasmissione (PAR, Pos<strong>it</strong>ive Acknowledgment w<strong>it</strong>h<br />
Retransmission) e assembla nel corretto ordine i datagrammi IP<br />
in cui è stato frazionato il messaggio, all’arrivo di esso al<br />
ricevente.<br />
Il presente<br />
11
TCP<br />
H.L.<br />
Il TCP è diviso in 4 livelli fondamentali :<br />
7 Applicazione<br />
4 Trasporto (TCP)<br />
3 Internet (IP)<br />
1 – 2 Host - rete<br />
Livello di Trasporto<br />
In questo particolare caso il livello di trasporto è<br />
solamente il TCP, ma in generale potrebbe essere anche l’UDP.<br />
Il TCP è un protocollo orientato alla connessione<br />
affidabile, ossia assegna ai livelli superiori l’affidabil<strong>it</strong>à che<br />
invece manca al livello inferiore, ovvero all’IP.<br />
Il protocollo TCP ha il comp<strong>it</strong>o di dividere il messaggio<br />
entrante e passarlo al livello IP. Il datagramma di lunghezza<br />
massima è di 65496 (65536 – 20 per il preambolo TCP – 20 per<br />
il preambolo dell’IP).<br />
Livello Internet<br />
Il livello Internet è il fulcro, insieme al TCP,<br />
dell’arch<strong>it</strong>ettura.<br />
L’indirizzo permette di inserire un pacchetto in una<br />
qualsiasi rete( può essere una <strong>LA</strong>N, una MAN o Internet).<br />
I pacchetti inviati possono arrivare in ordine diverso<br />
rispetto a come sono part<strong>it</strong>i.<br />
Lo scopo del livello Internet è consegnare i pacchetti IP al<br />
luogo di destinazione.<br />
Il presente<br />
2.3.1 Preambolo TCP<br />
8 16 24 32<br />
Source port Destination port<br />
Sequence number<br />
Acknowledgement Number<br />
URG ACK PSH RST SYN FIN Window size<br />
Checksum Urgent pointer<br />
Options (lunghezza variabile)<br />
Data (lunghezza variabile)<br />
Sorgente e destinazione<br />
Rispettivamente porta sorgente e porta destinazione<br />
identificano gli estremi locali di una connessione, ogni host<br />
deve decidere come allocare le proprie porte successive alla 256.<br />
Il punto di accesso del livello trasporto sarà quindi identificato<br />
dall'indirizzo espresso nel seguente formato<br />
ADDRESS IP : PORTA<br />
La lunghezza di ambedue i campi è di 16 b<strong>it</strong>.<br />
Numero di sequenza<br />
Un numero di sequenza viene assegnato ad ogni pacchetto<br />
durante la connessione tra 2 host, il campo è composto da 32<br />
b<strong>it</strong>.<br />
12
Numero Ack<br />
È uguale a 1 per indicare che il numero di ack è valido, se<br />
ack = 0 il segmento non contiene ack e il campo numero di ack<br />
viene ignorato.<br />
PSH<br />
Indica dati di tipo push, in questo modo si richiede al<br />
m<strong>it</strong>tente di consegnare i dati dell'applicazione al momento<br />
dell'arrivo, ev<strong>it</strong>ando che siano salvati in un buffer di attesa.<br />
Lunghezza 1 b<strong>it</strong>.<br />
RST<br />
Viene utilizzato per reinizializzare una connessione che è<br />
diventata instabile a causa del guasto di un host o per qualche<br />
altro motivo. Inoltre viene anche utilizzato per rifiutare<br />
l'apertura di una connessione. Lunghezza 1 b<strong>it</strong>.<br />
SYN<br />
Viene utilizzato per creare una connessione. La richiesta<br />
di connessione è caratterizzata da SYN=1 ACK=0. La risposta<br />
sara' SYN=1 ACK=1. Lunghezza 1 b<strong>it</strong>.<br />
FIN<br />
Viene utilizzato per chiudere una connessione. Specifica<br />
che il m<strong>it</strong>tente non ha altri dati da spedire, tuttavia dopo aver<br />
chiuso una connessione, un processo può continuare a ricevere<br />
dati indefin<strong>it</strong>amente. Lunghezza 1 b<strong>it</strong>.<br />
Window<br />
Il controllo di flusso TCP è gest<strong>it</strong>o utilizzando un<br />
protocollo sliding window a dimensione variabile. Il campo<br />
window specifica quanti byte possono essere sped<strong>it</strong>i a partire dal<br />
byte confermato. Lunghezza 16 b<strong>it</strong>.<br />
Checksum<br />
Per garantire l'affidabil<strong>it</strong>à è presente anche un campo<br />
checksum, che verifica il preambolo i dati e lo<br />
pseudopreambolo. Quando viene esegu<strong>it</strong>o il calcolo, il campo<br />
checksum viene posto uguale a 0, e il campo dati viene<br />
completato con un 0 se la lunghezza è un numero dispari.<br />
L'algor<strong>it</strong>mo di checksum somma tutte le parole di 16 b<strong>it</strong> in<br />
complemento a 1 e quindi prende il complemento a 1 della<br />
somma. Come conseguenza quando il ricevente esegue il calcolo<br />
sull'intero segmento (compreso il checksum) il risultato deve<br />
essere 0.<br />
2.3.2 Gestione delle connessioni TCP<br />
In TCP, per creare una connessione viene usato il<br />
protocollo three-way handshake che consiste, come indicato dal<br />
nome, in tre passi principali :<br />
Il presente<br />
13
1. il client spedisce un pacchetto TCP avente il flag<br />
SYN impostato, il flag ACK non impostato e con<br />
un valore X del sequence number;<br />
2. il server risponde con entrambi i flag SYN e ACK<br />
impostati, con il sequence number con un valore Y<br />
e acknowledgment number con valore X+1;<br />
3. il client risponde con il flag ACK impostato, con il<br />
Sequence number con valore X+1 e<br />
acknowldgement number con valore Y+1.<br />
SYN=1 ACK=0 SEQ-NUM=X<br />
CLIENT --------------------------------------> SERVER<br />
SYN=1 ACK=1 SEQ-NUM=Y ACK-NUM=X+1<br />
CLIENT SERVER<br />
Dopo che la connessione è stata inizializzata si può<br />
procedere al trasferimento dei dati. In segu<strong>it</strong>o verrà indicato<br />
con pacchetto SYN il primo dei tre, con SYN/ACK il secondo e<br />
con ACK il terzo.<br />
Gestione Sequence number e Acknowledgement<br />
number in una connessione<br />
Il TCP realizza una connessione affidabile, è in grado<br />
cioè, di recuperare pacchetti persi, duplicati e fuori ordine.<br />
Tutto questo è possibile grazie all'assegnamento di un numero di<br />
sequenza (sequence number) ad ogni byte trasmesso e alla<br />
richiesta di conferma dei dati ricevuti dal destinatario<br />
(acknowledgement number). All'interno di un pacchetto il<br />
sequence number indica il numero di sequenza del primo byte di<br />
dati contenuto, mentre l'Acknowledgement number indica il<br />
numero del prossimo byte atteso e conferma la ricezione fino al<br />
byte indicato meno 1.<br />
Prendiamo in esame il seguente esempio per capire<br />
meglio.<br />
SEQ-NUM=1000 ACK-NUM=5000 DATI=100 byte<br />
1) A -----------------------------------------> B<br />
SEQ-NUM=5000 ACK-NUM=1100 DATI=250 byte<br />
2) A B<br />
SEQ-NUM=5250 ACK-NUM=1250 DATI=0 byte<br />
4) A
Nel caso 1) A spedisce a B 100 byte il cui primo byte ha<br />
come numero di sequenza 1000. Inoltre conferma la ricezione<br />
dei byte ricevuti in precedenza fino al 4999 ed indica che si<br />
aspetta che il prossimo byte trasmesso sia quello con numero di<br />
sequenza 5000.<br />
Nel caso 2) B spedisce ad A 250 byte il cui primo byte ha<br />
come numero di sequenza 5000. Inoltre conferma la ricezione<br />
dei byte ricevuti in precedenza fino al 1099 ed indica che si<br />
aspetta che il prossimo byte trasmesso sia quello con numero di<br />
sequenza 1100.<br />
Nel caso 3) A spedisce a B 150 byte il cui primo byte ha<br />
come numero di sequenza 1100. Inoltre conferma la ricezione<br />
dei byte ricevuti in precedenza fino al 5249 ed indica che si<br />
aspetta che il prossimo byte trasmesso sia quello con numero di<br />
sequenza 5250.<br />
Nel caso 4) B non ha dati da spedire, si lim<strong>it</strong>a solo a<br />
confermare i dati ricevuti. Questo pacchetto non verrà<br />
confermato in quanto non contiene dati.<br />
Chiusura di una connessione<br />
Sebbene le connessioni TCP siano full duplex, per<br />
comprendere la chiusura di una connessione è meglio pensarle<br />
come una coppia di connessioni simplex.<br />
Ogni connessione simplex viene chiusa<br />
indipendentemente dall'altra. Per chiudere una connessione<br />
entrambe le parti possono spedire un pacchetto TCP contenente<br />
il flag FIN impostato a uno per indicare che non ci sono più<br />
dati da spedire. Quando viene confermata la ricezione del flag<br />
FIN quella connessione viene spenta. Quando entrambe le<br />
direzioni vengono chiuse la connessione viene rilasciata. Quindi<br />
normalmente occorrono 4 passaggi per chiudere una<br />
connessione.<br />
2.4 Le porte<br />
Quando un host si collega ad un server, i due computer<br />
trasmettono continuamente i propri dati attraverso delle porte.<br />
Ogni porta ha un numero associato e compie un servizio<br />
specifico.<br />
Il servizio è compiuto da un programma, chiamato demone<br />
che esegue i comandi necessari per compiere il servizio<br />
richiesto.<br />
Le porte sono suddivise in 2 categorie :<br />
• Da 0 a 255<br />
• Da 255 a 65535<br />
Le prime sono dette well – known port poiché i loro<br />
servizi sono noti e precisati, mentre le altre porte non hanno<br />
tutte un servizio preciso e in alcuni casi sono addir<strong>it</strong>tura dei<br />
doppioni delle porte conosciute.<br />
Il presente<br />
15
Ad esempio la porta 80 svolge il servizio http, ma anche la<br />
porta 8080 svolge la stessa occupazione.<br />
Quando ci si collega ad una rete tra cui anche Internet,<br />
come detto in precedenza, due terminali si scambiano<br />
informazioni attraverso le porte, ma non tutte vengono usate<br />
nello stesso collegamento.<br />
Esse si possono trovare in 4 stati:<br />
• Ascolto<br />
• Comunicazione<br />
• Chiusura<br />
• Attesa<br />
Quando una porta è chiusa, per un hacker è impossibile<br />
tentare di entrarci, quindi ogni tentativo di intrusione fallirà.<br />
2.4.1 Esempi di porte<br />
Legenda<br />
Porta : indica la porta utilizzata<br />
C/S : se il servizio descr<strong>it</strong>to è dalla parte del<br />
server (S), oppure dal lato client (C).<br />
Poss. att. : indica le possibil<strong>it</strong>à di attacco alla porta.<br />
Note : varie ed eventuali, come ad esempio<br />
possibil<strong>it</strong>à di attacco ai servizi presenti su<br />
quella porta, presenza di back door, ecc…<br />
PORTA C/S POSS. ATT. NOTE<br />
ICMP (0) // Ricezione di<br />
pacchetti anomali<br />
per mandare in crash<br />
lo stack TCP/IP<br />
Il presente<br />
Sezione relativa alla manutenzione del<br />
protocollo TCP/IP<br />
FTP (21) S // //<br />
Telnet (23) S // //<br />
SMTP (25) S Bug di Sendmail<br />
(UNIX)<br />
//<br />
DNS (53) S // //<br />
TFTP (69) S // //<br />
Finger (79) S Può essere usato per<br />
un “denial of<br />
service” attack<br />
Disabil<strong>it</strong>are il Finger o montare una<br />
versione aggiornata<br />
WEB (80) S CGI/BIN attacks Utilizzare sempre la versione aggiornata<br />
del server WEB<br />
POP3 (110) S Possibile lettura file<br />
in posta<br />
//<br />
TCP (119) S // //<br />
NetBios<br />
(137)<br />
Proxy<br />
(1080)<br />
S // E’ necessario disattivare NetBios. Oppure<br />
installare WinNuke95<br />
C/S // Chi cerca una connessione sulla 1080<br />
vuole mandare in giro pacchetti a nome<br />
vostro, alcuni ISP mettono a disposizione<br />
un server proxy per velocizzare le<br />
16
Il presente<br />
comunicazioni. L’effetto collaterale è che<br />
tutti i pacchetti in usc<strong>it</strong>a hanno<br />
l’indirizzo IP del proxy server.<br />
5001 C/S // Porta destinazione degli attacchi di<br />
Socket de Trois<br />
IRC (6667) S // //<br />
12345 /<br />
12346<br />
UDP<br />
(31337)<br />
2.5 I socket<br />
C/S // Porte del server NetBus, si possono<br />
ricevere scan alla ricerca di un dato<br />
programma<br />
C/S // E’ la porta standard del server di Back<br />
Orifice<br />
I socket sono i principali oggetti utilizzati dalle<br />
applicazioni per eseguire la maggior parte delle comunicazioni di<br />
rete. Sono stati inizialmente utilizzati per UNIX alla Univers<strong>it</strong>à<br />
di California di Berkeley e sono stati progettati in modo che le<br />
comunicazioni di rete fra applicazioni potessero avvenire nello<br />
stesso modo in cui quelle stesse applicazioni leggevano e<br />
scrivevano i file. Da allora vi è stato un progresso anche per<br />
quanto riguarda i socket ma il funzionamento di base è rimasto<br />
immutato.<br />
La creazione di una connessione via socket richiede due<br />
informazioni principali :<br />
• bisogna sapere il nome del server;<br />
• bisogna conoscere la porta su cui il server è in<br />
ascolto.<br />
Esempio 85.125.255.12 : 80<br />
Indirizzo IP Porta<br />
È possibile riassumere i socket come l’unione<br />
dell’indirizzo IP più la porta.<br />
È importante dire che solo un’applicazione può essere in<br />
ascolto in una determinata porta e su un determinato computer.<br />
Anche se su un computer vi possono essere più applicazioni che<br />
ascoltano più richieste di connessione su un singolo computer,<br />
ognuna di esse deve essere in ascolto su una porta differente.<br />
2.6 Esempi<br />
Il sistema operativo MS – DOS mette a disposizione due<br />
programmi, Netstat e Tracert. Ambedue i programmi servono<br />
per controllare parametri relativi alle connessioni, quali le porte<br />
e i pacchetti TCP/IP.<br />
17
2.6.1 Netsat<br />
La funzione Netstat permette di vedere tutte le porte<br />
aperte del proprio host durante una connessione TCP/IP. Esso,<br />
per ogni porta locale, specifica a quale indirizzo remoto è<br />
connessa e quale porta il remoto sta utilizzando, inoltre<br />
specifica per ogni connessione il protocollo (TCP, UDP) e lo<br />
stato della porta.<br />
Sintassi netstat –sn<br />
Protocollo Indirizzo host Indirizzo server Stato socket<br />
2.6.2 Tracert<br />
La funzione Tracert permette, specificando un s<strong>it</strong>o, di<br />
tenere traccia del percorso che il pacchetto compie per arrivare<br />
dal provider al server in cui è osp<strong>it</strong>ato il s<strong>it</strong>o.<br />
Sintassi tracert (nome s<strong>it</strong>o)<br />
Numero passaggi Tempo passato<br />
nel nodo<br />
Indirizzo del s<strong>it</strong>o<br />
Il presente<br />
18
Cap<strong>it</strong>olo 3<br />
La cr<strong>it</strong>tografia<br />
3.1 La storia<br />
3.1.1 Cr<strong>it</strong>tografia antica<br />
3.1.2 Cr<strong>it</strong>tografia fino al XVIII secolo<br />
3.1.3 Cr<strong>it</strong>tografia moderna<br />
3.2 Principali cifrari<br />
3.2.1 Cifrari a sost<strong>it</strong>uzione<br />
3.2.2 Cifrario affine<br />
3.2.3 Cifrario Playfair<br />
3.2.4 Stream cypher<br />
3.2.5 Cifrario di Vernam<br />
3.3 La sicurezza perfetta<br />
3.4 Gli algor<strong>it</strong>mi<br />
3.4.1 Il DES<br />
3.4.2 L’ RSA<br />
3.5 Macchine cifranti<br />
3.5.1 Enigma<br />
3.5.2 La bomba di Turing<br />
3.6 Cr<strong>it</strong>toanalisi<br />
3.6.1 Cr<strong>it</strong>toanalisi statistica<br />
3.6.2 Cr<strong>it</strong>toanalisi lineare<br />
3.6.3 Cr<strong>it</strong>toanalisi differenziale<br />
3.6.4 Cr<strong>it</strong>toanalisi su polialfabetici<br />
3.6.5 Brute force<br />
3.7 Curios<strong>it</strong>à e considerazioni<br />
3.1 La storia<br />
Per migliaia di anni re, regine e generali hanno avuto il<br />
bisogno di comunicazioni efficienti per governare i loro paesi e<br />
comandare i loro eserc<strong>it</strong>i. Nel contempo, essi compresero quali<br />
conseguenze avrebbe avuto la caduta dei loro messaggi in mano<br />
ostili : informazioni preziose sarebbero state a disposizione<br />
delle nazioni rivali e degli eserc<strong>it</strong>i nemici. Fu il pericolo dell'<br />
intercettazione da parte degli avversari a promuovere lo<br />
sviluppo di codici, tecniche di alterazione del messaggio<br />
destinate a renderlo comprensibile solo alle persone<br />
autorizzate.<br />
Una delle prime tecniche di comunicazione segrete, basata<br />
sull'occultamento del messaggio, si chiama steganografia, dalle<br />
parole greche steganós, che significa coperto, e gráphein, che<br />
significa scrivere. Negli anni sono state impiegate in tutto il<br />
mondo innumerevoli forme di steganografia.<br />
Uno dei metodi più bizzarri per trasmettere le<br />
informazioni segrete era utilizzato nell'antica Persia e viene<br />
La cr<strong>it</strong>tografia<br />
19
La cr<strong>it</strong>tografia<br />
raccontato da Erodoto. Esso consisteva nel rapare i capelli di<br />
uno schiavo e nel scrivergli il messaggio sulla testa. Lo schiavo<br />
si recava poi dal destinatario del messaggio dopo che gli erano<br />
ricresciuti i capelli e il messaggio era recuperato rapandoglieli<br />
nuovamente.<br />
Nell'antica Cina si dipingeva il messaggio su striscioline di<br />
seta finissima, che venivano appallottolate e coperte di cera. Le<br />
palline erano quindi inghiott<strong>it</strong>e dal messaggero. Nel XVI secolo<br />
lo scienziato <strong>it</strong>aliano Giambattista Della Porta spiegò come<br />
comunicare tram<strong>it</strong>e un uovo sodo, preparando un inchiostro con<br />
30 grammi di allume in mezzo l<strong>it</strong>ro d'aceto, e usandolo per<br />
scrivere sul guscio. La soluzione penetra nel guscio, che è<br />
poroso, senza lasciar traccia, e tinge l'albume solidificato;<br />
quest'ultimo potrà essere letto sbucciando l'uovo.<br />
La longev<strong>it</strong>à della steganografia dimostra che essa<br />
garantisce una certa sicurezza, ma il suo punto debole è evidente<br />
: se il latore del messaggio è attentamente perquis<strong>it</strong>o, è<br />
probabile che il messaggio sia scoperto; in tal caso, il nemico<br />
può farne l'uso che crede. In altre parole, la segretezza è<br />
perduta nel momento stesso dell'intercettazione. In tal caso è<br />
inev<strong>it</strong>abile che molti messaggi siano trovati.<br />
Perciò in parallelo con lo sviluppo della steganografia si<br />
assisté all'evoluzione della cr<strong>it</strong>tografia, dal greco kryptós, che<br />
significa nascosto. La cr<strong>it</strong>tografia non mira a nascondere il<br />
messaggio in sé, ma il suo significato. Per rendere<br />
incomprensibile un testo, lo si altera per mezzo di un<br />
procedimento concordato a suo tempo dal m<strong>it</strong>tente e dal<br />
destinatario. Questi può quindi invertire il procedimento, e<br />
ricavare il messaggio originale. Il vantaggio della cr<strong>it</strong>tografia è<br />
che anche se il nemico intercetta il messaggio, esso risulta<br />
incomprensibile e quindi inutilizzabile. Infatti il nemico, non<br />
conoscendo il procedimento di alterazione, dovrebbe trovare<br />
difficile, se non impossibile, ricostruire il significato.<br />
Non tutte le società antiche svilupparono forme di<br />
cr<strong>it</strong>tografia. La Cina, per esempio, l'unica civiltà antica ad usare<br />
una scr<strong>it</strong>tura ideografica, non ne ha mai viste. Le ragioni, a<br />
detta degli storici, sono legate alla natura prevalentemente orale<br />
delle comunicazioni.<br />
In India, invece, forme di cr<strong>it</strong>tografia furono<br />
concretamente praticate. In diversi testi sacri sono presenti<br />
riferimenti a forme di scr<strong>it</strong>ture segrete. Nell'Artha-Sastra, un<br />
testo classico sugli affari di stato, si sottolinea l'importanza<br />
delle scr<strong>it</strong>ture segrete nei servizi di spionaggio. Esempi di<br />
scr<strong>it</strong>ture segrete sono presenti anche nel Latila-Vistara, un<br />
libro che esalta le virtù di Budda.<br />
Anche nelle scr<strong>it</strong>ture cuneiforme sviluppate in<br />
Mesopotamia sono stati r<strong>it</strong>rovati esempi di cr<strong>it</strong>tografia. Sia<br />
presso gli Assiri che i Babilonesi, le due grosse civiltà sorte<br />
sulle sponde del Tigri, è stata rinvenuta l'usanza di sost<strong>it</strong>uire le<br />
parti terminali delle parole con elementi corti e stereotipati detti<br />
colofoni. In Iraq, nel periodo finale delle scr<strong>it</strong>ture cuneiformi, è<br />
presente per la prima volta la sost<strong>it</strong>uzione di nomi con numeri.<br />
20
La cr<strong>it</strong>tografia<br />
Anche se la steganografia e la cr<strong>it</strong>tografia sono discipline<br />
indipendenti, possono essere impiegate per alterare e occultare<br />
il medesimo testo, garantendo un livello di sicurezza molto più<br />
alto. Per esempio, il « microdot », cioè la riduzione di uno scr<strong>it</strong>to<br />
alle dimensioni di un punto, è una forma di steganografia che<br />
ebbe largo impiego durante la seconda guerra mondiale. Tram<strong>it</strong>e<br />
un procedimento fotografico, gli agenti tedeschi in America<br />
latina trasformavano una pagina scr<strong>it</strong>ta, precedentemente<br />
cr<strong>it</strong>tografata, in una macchia con un diametro inferiore al<br />
millimetro, che poteva essere nascosta nel puntino di una « i » in<br />
una comunicazione banale. Il primo microdot fu scoperto dall'<br />
FBI nel 1941 grazie a una soffiata.<br />
3.1.1 Cr<strong>it</strong>tografia antica<br />
Figura 3.1 : Sc<strong>it</strong>ala lacedemonica<br />
Le più antiche notizie sicure sono probabilmente<br />
quelle sulla sc<strong>it</strong>ala lacedemonica , data da Plutarco come<br />
in uso dai tempi di Licurgo (IX sec a.C.) ma più<br />
sicuramente usata ai tempi di Lisandro(verso il 400<br />
a.C.). Consisteva in un bastone su cui si avvolgeva ad<br />
elica un nastro di cuoio; sul nastro si scriveva per<br />
colonne parallele all'asse del bastone, lettera per<br />
lettera, il testo segreto. Tolto il nastro dal bastone, il<br />
testo vi risultava trasposto in modo regolare ma<br />
sufficiente per ev<strong>it</strong>are la comprensione senza un<br />
secondo bastone uguale al primo.<br />
Tra il 390 e il 360 a.C. venne compilato da<br />
Enea il tattico, generale della lega arcadica, il<br />
primo trattato di cifrari il cui XXI cap<strong>it</strong>olo tratta<br />
appunto di messaggi segreti. In questo viene<br />
descr<strong>it</strong>to un disco sulla zona esterna del quale<br />
erano contenuti 24 fori, ciascuno dei quali era<br />
contrassegnato da una lettera disposte in ordine<br />
alfabetico. Un filo, partendo da un foro centrale,<br />
si avvolgeva passando per i fori delle successive Figura 3.2 : Disco di Enea<br />
lettere del testo. Il destinatario del messaggio svolgeva il filo<br />
dal disco segnando le lettere da esso indicate. Il testo si doveva<br />
poi leggere a rovescio.<br />
Nei testi sacri, in particolare nel Vecchio Testamento, si<br />
possono r<strong>it</strong>rovare tre principali scr<strong>it</strong>ture segrete : l’ Atbash, l’<br />
Albam e l’ Atbah. Il primo codice cifrato, l’ Atbash, è stato<br />
ideato dal popolo ebraico. Esso consisteva nel capovolgere<br />
l’alfabeto, di conseguenza la prima lettera diventava l’ultima e<br />
l’ultima la prima e così per tutte le altre lettere dell’alfabeto.<br />
Usando l’ attuale alfabeto ordinario, l’ Atbash può essere<br />
riassunto con la seguente tabella di cifratura :<br />
21
L'Albam richiede che l'alfabeto venga diviso in due parti e<br />
che ogni lettera venga sost<strong>it</strong>u<strong>it</strong>a con la corrispondente dell'altra<br />
metà. Infine, l'Atbah, richiede che la sost<strong>it</strong>uzione soddisfi una<br />
relazione di tipo numerico. Le prime nove lettere dell'alfabeto<br />
vengono sost<strong>it</strong>u<strong>it</strong>e in modo tale che la somma della lettera da<br />
sost<strong>it</strong>uire e della lettera sost<strong>it</strong>uente risulti uguale a dieci. Per le<br />
restanti lettere dell'alfabeto deve valere una regola simile con<br />
somma pari a 28 in decimale.<br />
a b c d e f g h i j k l m n o p q r s t u v w x y z<br />
z y x w v u t s r q p o n m l k j i h g f e d c b a<br />
La cr<strong>it</strong>tografia<br />
Lo storico greco Polibio (200 ca. -118 a.C.), nelle sue<br />
Storie (Libro X) descrive un interessante metodo di cifratura.<br />
L'idea è quella di cifrare una lettera con una coppia di numeri<br />
compresi tra 1 e 5, in base ad una matrice 5x5, contenente le<br />
lettere dell'alfabeto. Ogni lettera viene rappresentata da due<br />
numeri, guardando la riga e la colonna in cui essa si trova. Per<br />
esempio, a=11 e r=42.Inoltre, Polibio, suggeriva di mandare<br />
tanti messaggeri quanti erano i caratteri del messaggio. Questi<br />
portavano nella mano sinistra un numero di torce pari all'indice<br />
di riga e nella mano destra un numero pari all'indice di colonna.<br />
In effetti più che di un codice segreto, si tratta di un sistema di<br />
telecomunicazione, di fatto un telegrafo ottico. Telegrafi a torce<br />
esistevano da molti secoli ed erano stati descr<strong>it</strong>ti da Enea il<br />
tattico intorno al 350 a.C., ma erano basati su un lim<strong>it</strong>ato elenco<br />
di messaggi possibili; quello di Polibio si basa invece sulla<br />
scomposizione del messaggio nelle singole lettere ed è quindi in<br />
grado di trasmettere qualsiasi messaggio.<br />
# 1 2 3 4 5<br />
1 A B C D E<br />
2 F G H I J<br />
3 KQ L M N O<br />
4 P R S T U<br />
5 V W X Y Z<br />
Svetonio nella V<strong>it</strong>a dei dodici Cesari, un'opera del II secolo<br />
d.C., racconta che Giulio Cesare usava per le sue corrispondenze<br />
riservate un codice di sost<strong>it</strong>uzione molto semplice, nel quale<br />
ogni lettera del testo veniva sost<strong>it</strong>u<strong>it</strong>a dalla lettera che la segue<br />
di tre posti nell'alfabeto ( Restano quelle a Cicerone,così come quelle<br />
ai familiari sugli affari domestici, nelle quali, se doveva fare delle<br />
comunicazioni segrete, le scriveva in codice, cioè con l'ordine delle lettere<br />
così disposto che nessuna parola potesse essere ricostru<strong>it</strong>a: se qualcuno<br />
avesse voluto capire il senso e decifrare, avrebbe dovuto cambiare la<br />
quarta lettera degli elementi, cioè D per A e così via per le rimanenti. ).<br />
a b c d e f g h i j k l m n o p q r s t u v w x y z<br />
d e f g h i j k l m n o p q r s t u v w x y z a b c<br />
22
Ad esempio la lettera A è sost<strong>it</strong>u<strong>it</strong>a dalla D, la B dalla E e<br />
così via fino alle ultime lettere che sono cifrate con le prime<br />
come nella tabella che segue (che fa riferimento all'odierno<br />
alfabeto internazionale).<br />
3.1.2 La cr<strong>it</strong>tografia fino al XVIII secolo<br />
Un sistema usato dall'Arcivescovo di Napoli, Pietro di<br />
Grazia, tra il 1363 e il 1365, é quello in cui le lettere sono<br />
cifrate con numeri o simboli speciali. La corrispondenza tra<br />
lettere e simboli o numeri per la sost<strong>it</strong>uzione è fissata da una<br />
tabella. Dagli inizi del XIV secolo, per depistare i tentativi di<br />
analisi statistica delle frequenze, si iniziano ad usare più segni<br />
per cifrare le vocali, dato che queste sono molto ricorrenti in un<br />
testo. Successivamente tale tecnica viene estesa anche alle<br />
consonanti più ricorrenti. Inoltre alcune parole, utilizzate<br />
frequentemente, (Papa, et, con, quo, etc.) sono sost<strong>it</strong>u<strong>it</strong>e con un<br />
solo simbolo. Un primo esempio di questa cifratura fu la lettera<br />
di Michele Steno scr<strong>it</strong>ta nel 1411.<br />
La cr<strong>it</strong>tografia<br />
Figura 3.3 : Lettera di<br />
Michele Steno<br />
Leon Battista Alberti, nel suo Trattato, ha proposto un<br />
disco composto di due cerchi concentrici di rame. Uno esterno<br />
fisso di diametro maggiore sul quale sono riportate le lettere<br />
dell'alfabeto in chiaro e uno interno mobile per le lettere<br />
dell'alfabeto cifrante. Il disco esterno è composto di 24 caselle<br />
contenenti 20 lettere maiuscole in ordine lessicografico, escluse<br />
H, J, K, W, Y, al posto delle quali ci sono i numeri 1, 2, 3, 4.<br />
Il disco interno riporta le 24 lettere minuscole in maniera<br />
disordinata (la u e la v sono collassate) ed un simbolo speciale<br />
&.<br />
23
Fissata una lettera maiuscola come chiave, ad esempio B,<br />
si deve spostare il disco mobile interno in modo da far<br />
corrispondere la B con un simbolo particolare del disco<br />
interno(&). Si stabilisce in tal modo un'associazione tra le<br />
lettere dell'alfabeto in chiaro e quello dell'alfabeto cifrante.<br />
Può anche essere<br />
utilizzata una chiave diversa<br />
per ogni parola del testo in<br />
chiaro. Le lettere che di volta<br />
in volta corrispondono ai<br />
numeri 1 2 3 4 non vengono<br />
usate per la cifratura. Tutte le<br />
lettere del messaggio da<br />
cifrare sono cambiate in base<br />
all'associazione tra le lettere<br />
maiuscole e quelle minuscole.<br />
Tale disco non ottenne<br />
successo anche per la<br />
decisione dell'Alberti di<br />
Figura 3.4 : Disco<br />
dell’Alberti<br />
tenerlo segreto (il suo trattato fu pubblicato solo un secolo più<br />
tardi a Venezia insieme ad altri suoi "opuscoli morali" e passò<br />
quasi inosservato).<br />
La cr<strong>it</strong>tografia<br />
Il bresciano Giovan Battista Bellaso pubblicò tra il 1553 e il<br />
1564 tre opere di cr<strong>it</strong>tologia contenenti alcuni cifrari polialfabetici<br />
di notevole interesse.<br />
L'idea su cui si basa il principale cifrario proposto dal<br />
Bellaso è quella di ricavare cinque alfabeti da una parola segreta<br />
convenuta. Le lettere dell' alfabeto vengono scr<strong>it</strong>te in una<br />
tabella composta da due righe. In particolare quelle della parola<br />
segreta sono inser<strong>it</strong>e nelle prime colonne intercalate sulle due<br />
righe e le rimanenti lettere dell'alfabeto vengono scr<strong>it</strong>te di<br />
segu<strong>it</strong>o. In questo modo si è ottenuto il primo alfabeto derivato.<br />
A partire da questo ricaviamo il secondo spostando<br />
circolarmente verso destra la seconda riga di una posizione.<br />
Applicando lo stesso procedimento al secondo alfabeto, si ricava<br />
il terzo alfabeto derivato e così via fino ad ottenerne cinque,<br />
ognuno dei quali sarà identificato da un gruppo di quattro<br />
lettere. Facendo riferimento sempre al primo alfabeto, le lettere<br />
della prima e della sesta colonna identificano il primo alfabeto<br />
derivato, quelle della seconda e della settima colonna<br />
identificano il secondo alfabeto derivato. In generale le quattro<br />
lettere che identificano l' i-esimo alfabeto sono quelle dell' iesima<br />
e della (i + 5)-esima colonna. A questo punto si deve<br />
convenire una frase segreta; le lettere di quest’ ultima servono a<br />
selezionare l' alfabeto da usare. In particolare, presa l' i-esima<br />
lettera della parola segreta, si controlla quale dei cinque<br />
identificativi degli alfabeti la contiene. Si determina così<br />
l'alfabeto da usare per l' i-esima parola del testo in chiaro. Se il<br />
numero di lettere della frase segreta è minore del numero di<br />
parole del testo da cifrare, la frase segreta viene riapplicata<br />
ciclicamente per la selezione degli alfabeti. La cifratura si<br />
24
effettua sost<strong>it</strong>uendo la lettera del testo in chiaro con la lettera<br />
che si trova sulla stessa colonna nell'alfabeto predeterminato.<br />
La cr<strong>it</strong>tografia<br />
Blaise de Vigenére pubblicò nel 1586 un trattato di cifrari<br />
nel quale proponeva tra gli altri un codice che ebbe grande<br />
fortuna e che è ricordato con il suo nome. Si tratta del più<br />
semplice codice di sost<strong>it</strong>uzione polialfabetica, e proprio per la sua<br />
semplic<strong>it</strong>à ha goduto per secoli di una grossa fama.<br />
La forza del cifrario di Vigenére sta nell'utilizzare non uno<br />
ma 26 alfabeti cifranti per cifrare un solo messaggio. Il metodo<br />
si può considerare una generalizzazione del codice di Cesare;<br />
invece di spostare sempre dello stesso numero di posti la lettera<br />
da cifrare, questa viene spostata di un numero di posti variabile,<br />
determinato dalle lettere della parola chiave, da concordarsi tra<br />
m<strong>it</strong>tente e destinatario. La parola è detta chiave o verme, per il<br />
motivo che, essendo in genere molto più corta del messaggio,<br />
deve essere ripetuta molte volte. Di segu<strong>it</strong>o viene riportata il<br />
cifrario utilizzato nei codici di Vigénère.<br />
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z<br />
B C D E F G H I J K L M N O P Q R S T U V W X Y Z A<br />
C D E F G H I J K L M N O P Q R S T U V W X Y Z A B<br />
D E F G H I J K L M N O P Q R S T U V W X Y Z A B C<br />
E F G H I J K L M N O P Q R S T U V W X Y Z A B C D<br />
F G H I J K L M N O P Q R S T U V W X Y Z A B C D E<br />
G H I J K L M N O P Q R S T U V W X Y Z A B C D E F<br />
H I J K L M N O P Q R S T U V W X Y Z A B C D E F G<br />
I J K L M N O P Q R S T U V W X Y Z A B C D E F G H<br />
J K L M N O P Q R S T U V W X Y Z A B C D E F G H I<br />
K L M N O P Q R S T U V W X Y Z A B C D E F G H I J<br />
L M N O P Q R S T U V W X Y Z A B C D E F G H I J K<br />
M N O P Q R S T U V W X Y Z A B C D E F G H I J K L<br />
N O P Q R S T U V W X Y Z A B C D E F G H I J K L M<br />
O P Q R S T U V W X Y Z A B C D E F G H I J K L M N<br />
P Q R S T U V W X Y Z A B C D E F G H I J K L M N O<br />
Q R S T U V W X Y Z A B C D E F G H I J K L M N O P<br />
R S T U V W X Y Z A B C D E F G H I J K L M N O P Q<br />
S T U V W X Y Z A B C D E F G H I J K L M N O P Q R<br />
T U V W X Y Z A B C D E F G H I J K L M N O P Q R S<br />
U V W X Y Z A B C D E F G H I J K L M N O P Q R S T<br />
V W X Y Z A B C D E F G H I J K L M N O P Q R S T U<br />
W X Y Z A B C D E F G H I J K L M N O P Q R S T U V<br />
X Y Z A B C D E F G H I J K L M N O P Q R S T U V W<br />
Y Z A B C D E F G H I J K L M N O P Q R S T U V W X<br />
Z A B C D E F G H I J K L M N O P Q R S T U V W X Y<br />
3.1.3 La cr<strong>it</strong>tografia moderna<br />
Il cifrario di Jefferson prende il nome dal suo inventore<br />
Thomas Jefferson (1743-1826), uno degli autori della Dichiarazione<br />
d'Indipendenza e Presidente degli USA nel 1801-1804. Jefferson<br />
non lo mise mai in uso e il suo cifrario fu dimenticato fino al<br />
1922, quando fu riscoperto e utilizzato, fino agli anni '50,<br />
dall'eserc<strong>it</strong>o statun<strong>it</strong>ense. E nel 1890 Etienne Bazeries un<br />
25
cr<strong>it</strong>tologo francese propose l' "La<br />
chiffre endecifrable", un cifrario del<br />
tutto equivalente a quello di<br />
Jefferson.<br />
Il codice di Jefferson è un<br />
metodo di cifratura meccanico<br />
basato su un cilindro di circa 15<br />
cm di lunghezza e 4 cm di<br />
larghezza. Il cilindro è cost<strong>it</strong>u<strong>it</strong>o<br />
da 36 dischi, imperniati su di un<br />
asse, in grado di ruotare<br />
liberamente. Ogni disco riporta le<br />
26 lettere dell'alfabeto sul bordo<br />
esterno, in un ordine differente Figura 3.5 : Cifrario di Jefferson<br />
l'uno rispetto all' altro.<br />
Inoltre i dischi possono volta per volta essere inser<strong>it</strong>i sull'asse<br />
in un ordine differente per ogni cifratura, previo accordo tra<br />
m<strong>it</strong>tente e destinatario. La cifratura di un messaggio avviene nel<br />
seguente modo : il messaggio viene prima di tutto diviso in<br />
blocchi di 36 caratteri. Per ogni blocco, i dischi della macchina<br />
vengono ruotati in modo tale da far comparire allineati su una<br />
riga i caratteri del blocco. Una volta effettuata tale operazione,<br />
si sceglie a caso un'altra riga, e si considera la corrispondente<br />
sequenza di 36 lettere come il messaggio cifrato. Il ricevente,<br />
che possiede un cilindro identico a quello del trasm<strong>it</strong>tente, non<br />
deve far altro che ruotare i dischi in modo tale da far comparire<br />
il cifrato allineato su una riga. Compiuta questa operazione,<br />
deve analizzare le restanti righe. Una sola di queste è una frase<br />
di senso compiuto rappresentante il messaggio in chiaro. Una<br />
variante è quella di fissare a priori la riga su cui sarà possibile<br />
trovare il messaggio in chiaro.<br />
Il cilindro di Jefferson è il primo esempio di una serie di<br />
macchine cifranti basate su cilindri e dischi ruotanti intorno ad<br />
un asse, la più celebre di tutte è la cosiddetta Macchina Enigma<br />
usata dai Tedeschi nella Seconda Guerra Mondiale.<br />
La cr<strong>it</strong>tografia<br />
Il Playfair cipher fu inventato dal noto fisico Sir Charles<br />
Wheatstone (1802-1875), ma il nome di Playfair deriva da colui<br />
che ha divulgato nelle alte sfere governative questo metodo di<br />
cifratura. Lyon Playfair, barone di St.Andrews, mostrò per la<br />
prima volta questo sistema nel 1854 durante una cena<br />
organizzata da Lord Granville alla presenza di Lord Palmerton<br />
(1784-1865) allora ministro degli Esteri. La speranza di Playfair<br />
era quella di far utilizzare il Cipher durante la guerra di Crimea<br />
ma il sistema fu effettivamente utilizzato dall'eserc<strong>it</strong>o br<strong>it</strong>annico<br />
solamente a partire dalla guerra Boera. Il Cipher è r<strong>it</strong>enuto<br />
essere il primo metodo di cifratura a bigrammi (coppie di<br />
caratteri). Si usa una matrice di 25 lettere che viene riemp<strong>it</strong>a<br />
nelle prime caselle con la parola chiave, abolendo le eventuali<br />
lettere ripetute, ed è completata con le rimanenti lettere nel loro<br />
ordine alfabetico. Si omette la W che, se necessario, potrà essere<br />
cifrata come una doppia V.<br />
26
La cr<strong>it</strong>tografia<br />
Il testo in chiaro deve essere diviso in bigrammi di due<br />
lettere consecutive. Le due lettere si cercano sul quadrato e si<br />
sost<strong>it</strong>uiscono con altre secondo le seguenti regole: se le due<br />
lettere chiare si trovano su una stessa riga, si prendono le due<br />
lettere che le seguono a destra; se una delle due lettere chiare si<br />
trova sulla quinta colonna a destra, si prenderà la prima lettera a<br />
sinistra della stessa riga. Se le due lettere chiare sono sulla<br />
stessa colonna, si prendono le due lettere sottostanti; se una<br />
lettera è nell'ultima riga, si prenderà la lettera che sta nella<br />
prima riga della stessa colonna; se le due lettere sono in colonne<br />
e righe diverse, si prendono le due che cost<strong>it</strong>uiscono un<br />
rettangolo con esse, cominciando da quella che si trova nella<br />
stessa riga della prima lettera del bigramma in chiaro; qualora il<br />
bigramma chiaro presenti due lettere uguali si cercherà di<br />
eliminare questo raddoppio, oppure di romperlo inserendo una<br />
lettera rara (k, w, x, y).<br />
Dopo che la Gran Bretagna dichiarò guerra alla Germania<br />
il 3 settembre 1939, le operazioni di decifrazione Br<strong>it</strong>anniche<br />
furono spostate da Londra a Bletchley Park. Tra il 4 settembre<br />
1939 e l'estate del 1944, Alan Turing (1912-1954) (uno dei più<br />
famosi matematici di questo secolo, fra i fondatori<br />
dell'informatica teorica) alloggiò al Crown Inn, a Shenley Brook<br />
End, un villaggio vicino Bletchley. Il lavoro esegu<strong>it</strong>o da Alan<br />
Turing e dai suoi colleghi a Bletchley Park poté essere<br />
completamente apprezzato solo molti anni dopo, quando cadde<br />
il segreto mil<strong>it</strong>are sulle tecniche di cr<strong>it</strong>toanalisi durante la<br />
guerra. Quasi tutte le comunicazioni tedesche venivano cifrate<br />
con una macchina chiamata Enigma. Questa macchina è una<br />
nobile rappresentante dei cifrari a rotore, utilizzati fino<br />
all'introduzione di cifrari elettronici e microelettronici che<br />
hanno sconvolto e trasformato il mondo della cr<strong>it</strong>tografia. Per<br />
"rompere" Enigma (alcuni dettagli della soluzione sono tenuti<br />
segreti fino ad oggi) Turing, per conto del governo inglese, si<br />
servì di gigantesche macchine chiamate appunto Colossi, che<br />
possono considerarsi i precursori dei moderni calcolatori<br />
elettronici. Turing è autore di ricerche estremamente importanti<br />
sul concetto logico-matematico di calcolabil<strong>it</strong>à : lo strumento<br />
che egli ha proposto per affrontare il problema è noto oggi col<br />
nome di macchina di Turing. Una delle prime macchine di<br />
cifratura a rotori è stata costru<strong>it</strong>a dal californiano Edward<br />
Hebern, che la brevettò nel 1921. Autentici gioielli della<br />
cr<strong>it</strong>tografia meccanica sono le macchine costru<strong>it</strong>e da Boris<br />
Hangelin; nel 1927 egli aveva rilevato una d<strong>it</strong>ta che produceva<br />
materiale cr<strong>it</strong>tografico e che ancora oggi è prospera e fiorente,<br />
anche se ormai i rotori sono entrati nei musei della scienza. Per<br />
rendersi conto di quanto i tempi siano cambiati basterà<br />
ricordare che l' Enigma aveva un grande inconveniente: era<br />
sprovvisto di stampante. I risultati apparivano illuminati su una<br />
tastiera appos<strong>it</strong>a, lettera dopo lettera, e una persona doveva<br />
provvedere a trascriverli a mano su un foglio di carta. Una<br />
27
stampante elettro-meccanica avrebbe appesant<strong>it</strong>o troppo il<br />
congegno e lo avrebbe reso poco maneggevole.<br />
In un epoca di supercomputer e macchine potentissime il<br />
codice Navajo è un monumento alla più potente e sofisticata<br />
macchina che esista al mondo : la mente umana. Nel tentativo di<br />
ottenere delle comunicazioni vocali "sicure" l'eserc<strong>it</strong>o USA,<br />
prima della seconda guerra mondiale ha sperimentato l'uso della<br />
lingua degli indiani Choctaws per criptare le comunicazioni<br />
vocali, lingua che era già di per se "criptata". Dopo l'entrata in<br />
guerra degli USA, nel 1941, lo studio di questo tipo di<br />
"cr<strong>it</strong>tografia" venne esteso e si sperimentarono i linguaggi di<br />
Commanches, Choctaws, Kiowas, Winnebagos, Seminoles,<br />
Navajos, Hopis e Cherokees. Successivamente la Marina USA ha<br />
prosegu<strong>it</strong>o il lavoro dell'eserc<strong>it</strong>o codificando, espandendo e<br />
perfezionando il metodo, usando esclusivamente il linguaggio<br />
Navajos. Usati con successo su molti fronti i "NAC" (Native<br />
American Codetalkers) non hanno mai visto "infranto" il loro<br />
"codice".<br />
3.2 Principali cifrari<br />
Di segu<strong>it</strong>o verranno analizzati i principali cifrari utilizzati<br />
nella storia.<br />
3.2.1 Cifrari a sost<strong>it</strong>uzione<br />
In questi sistemi di cifratura, ogni simbolo del testo in<br />
chiaro viene trasformato in un simbolo dell'alfabeto del testo<br />
cifrato. I segni di punteggiatura e gli spazi non vengono cifrati,<br />
in modo tale che il testo diventa un'unica stringa di caratteri<br />
alfabetici. Questi cifrari si dividono in due categorie:<br />
monoalfabetici e polialfabetici. Nei monoalfabetici, ogni carattere,<br />
una volta sost<strong>it</strong>u<strong>it</strong>o con un altro carattere, conserverà tale<br />
sost<strong>it</strong>uzione durante tutta la fase di cifratura; per esempio, se la<br />
parola “bacca” sarà cifrata in “efggf”, allora la lettera 'a' sarà<br />
sempre cifrata con la 'f ', la 'c' con la 'g' e così via. Nei sistemi<br />
polialfabetici, invece, lo stesso carattere può essere cifrato con<br />
più caratteri. Un esempio di cifrario a sost<strong>it</strong>uzione<br />
monoalfabetica è quello di Cesare.<br />
3.2.2 Cifrario affine<br />
In questo cifrario la chiave é una coppia di interi in Z 26<br />
K = (a,b) con a,b ∈ Z 26<br />
Dato un messaggio x da cifrare, la funzione di cifratura é<br />
del tipo<br />
e k (x) = (ax + b) mod 26<br />
La cr<strong>it</strong>tografia<br />
28
La cr<strong>it</strong>tografia<br />
Queste funzioni sono dette funzioni affini, da cui il nome<br />
del cifrario.<br />
Una funzione di cifratura deve essere iniettiva; se così non<br />
fosse il ricevente non potrebbe decifrare il messaggio in modo<br />
univoco. Pertanto la chiave (a, b) deve essere scelta in modo<br />
che l'equazione<br />
y = (ax + b) mod 26<br />
abbia un'unica soluzione.<br />
Supponendo di scegliere come chiave la coppia a = 2 e b =<br />
0 e che il messaggio cifrato sia y = 0; allora la funzione di<br />
cifratura sarà<br />
e k (x) = 2x<br />
e quindi per decifrare il messaggio l'equazione da risolvere<br />
sarà<br />
2x = 0 mod 26<br />
Le soluzioni sono x = 0 e x = 13, quindi due messaggi in<br />
chiaro distinti corrispondono allo stesso messaggio cifrato. Di<br />
conseguenza la scelta a = 2 non è ammissibile perché si vuole<br />
che la congruenza<br />
ax = 0 mod 26 (1)<br />
abbia un'unica soluzione per x. Sia d = gcd(a,26). Allora la<br />
congruenza (1) ha almeno due distinte soluzioni in Z 26, cioè x =<br />
0 e x = 26/d. Per avere un'unica soluzione deve essere gcd(a,26)<br />
= 1, cioè a deve essere primo con 26. Tale condizione è<br />
necessaria e sufficiente affinché e k (x) risulti iniettiva.<br />
Teorema<br />
ax=y mod 26 ha un’unica soluzione per ogni y se e solo se gcd (a,<br />
26) = 1.<br />
Dimostrazione<br />
Supponendo che ax = y mod 26 abbia un'unica soluzione<br />
per ogni y e supponendo per assurdo che gcd(a, 26) = d >1.<br />
Risolvendo l'equazione per y = 0 si giunge ad un assurdo; infatti<br />
ax = 0 mod 26 ha due soluzioni distinte in Z 26 : x = 0 e x =<br />
26/d . Quindi è stato provato che esiste un y per cui ax = y mod<br />
26 non ammette soluzione unica.<br />
Sia gcd(a, 26) = 1, siano x 1 e x 2 soluzioni distinte di ax =<br />
y mod 26 quindi<br />
ax 1 = ax 2 mod 26<br />
da cui<br />
a(x 1 - x 2 ) = 0 mod 26<br />
quindi<br />
26 | a( x 1 - x 2 )<br />
dato che gcd(a,26) = 1 si ha 26 | ( x 1 - x 2 ) quindi<br />
x 1 = x 2 mod 26<br />
così x 1 e x 2 sono la stessa soluzione.<br />
Si calcoli la funzione di decifratura d applicata ad un<br />
messaggio cifrato y. Siccome<br />
y = ax + b mod 26<br />
si ha che<br />
y -b = ax mod 26<br />
da cui<br />
29
La cr<strong>it</strong>tografia<br />
a -1 (y-b) mod 26 = x<br />
quindi<br />
d(y) = a -1 (y - b) mod 26.<br />
Il numero di possibili chiavi per il cifrato affine è dato dal<br />
numero di coppie (a,b), tali che b può assumere qualsiasi dei 26<br />
possibili valori mentre a solo i valori tra 0 e 25 primi con 26.<br />
Quindi il numero dei possibili valori che a può assumere è dato<br />
dalla cardinal<strong>it</strong>à di Z *<br />
26, che può essere determinata tram<strong>it</strong>e la<br />
funzione di Eulero:<br />
f(26) = (13-1) (2-1) = 12<br />
Pertanto il numero di possibili chiavi è 26x12 , troppo<br />
basso per scoraggiare una ricerca esaustiva.<br />
3.2.3 Cifrario Playfair<br />
Questo sistema fa uso di una matrice 5 x 5, che<br />
rappresenta la chiave, in cui ci sono 25 lettere distinte<br />
dell'alfabeto disposte in ordine arb<strong>it</strong>rario. L'unica lettera non<br />
presente è la Q, in quanto è la lettera che è quasi sempre segu<strong>it</strong>a<br />
dalla U e quindi facilmente riconoscibile. Ogni lettera individua<br />
ed è individuata dal suo numero di riga e dal suo numero di<br />
colonna. Il testo in chiaro deve essere di lunghezza pari, dovrà<br />
essere diviso in coppie di caratteri e ciascuna coppia deve avere<br />
caratteri distinti. Nel caso in cui il testo sia di lunghezza dispari<br />
si aggiunge un carattere f<strong>it</strong>tizio che non alteri il senso del<br />
messaggio, per ottenere la par<strong>it</strong>à. Analogo stratagemma si<br />
utilizza se una delle coppie ha i due caratteri uguali: si inserisce<br />
come secondo carattere uno che non altera la comprensione del<br />
testo. Con queste caratteristiche ogni coppia di caratteri rientra<br />
sicuramente in uno fra questi tre casi :<br />
1. le due lettere della coppia si trovano sulla stessa<br />
riga;<br />
2. le due lettere si trovano sulla stessa colonna;<br />
3. le due lettere non si trovano né sulla stessa riga né<br />
sulla stessa colonna.<br />
La cifratura è esegu<strong>it</strong>a su una coppia di lettere per volta.<br />
Ogni coppia del testo in chiaro rientra in uno dei tre casi<br />
precedenti, ciascuno dei quali va trattato in modo differente:<br />
1. le lettere della coppia del testo in chiaro vanno<br />
cifrate con le lettere che le seguono sulla stessa riga<br />
(con la convenzione “circolare” che l'ultima lettera<br />
della riga sia segu<strong>it</strong>a dalla prima). Per esempio per<br />
la coppia WI si ha HS, WH diventa HI, ecc…;<br />
2. le lettere della coppia del testo in chiaro vanno<br />
cifrate con le lettere immediatamente sottostanti<br />
30
(sempre con la convezione “circolare”) ; ad<br />
esempio IG diventa BO e VB diventa IG;<br />
La cr<strong>it</strong>tografia<br />
3. in questo caso, che è il più frequente, le due lettere<br />
individuano sulla matrice un “rettangolo” di cui due<br />
vertici rappresentano la coppia di caratteri del<br />
messaggio in chiaro e gli altri due i corrispondenti<br />
caratteri del messaggio cifrato. La convezione che si<br />
utilizza nella cifratura è che la prima lettera del<br />
testo risultante é quella che si trova sulla stessa<br />
riga della prima lettera della coppia in chiaro. Per<br />
esempio, NC diventa PA, mentre CN diventa AP.<br />
3.2.4 Stream cypher<br />
Nei cr<strong>it</strong>tosistemi studiati fino ad ora successivi elementi<br />
del testo in chiaro sono cifrati mediante la stessa chiave k, cioè<br />
la stringa cifrata y è ottenuta nel modo seguente:<br />
y = y 1 y 2 …. = e k (x 1 ) e k (x 2 ) ….<br />
Cr<strong>it</strong>tosistemi di questo tipo sono spesso defin<strong>it</strong>i “cifrari a<br />
blocchi”. Un approccio alternativo consiste nell'utilizzare gli<br />
“stream cipher”. L'idea di base consiste nel generare una<br />
sequenza, detta “keystream”<br />
z = z 1 z 2 .......<br />
e nell'utilizzarla per cifrare la stringa<br />
x = x 1 x 2 ……<br />
del testo in chiaro nel modo seguente<br />
ossia<br />
W H I S K<br />
Y A B C D<br />
E F G J L<br />
M N O P R<br />
T U V X Z<br />
dove<br />
z i = f i ( k, x 1 , …. , x i -1 )<br />
L’elemento z i della sequenza è utilizzato per cifrare x i ,<br />
y i = e zi(x i )<br />
Pertanto per cifrare la stringa x 1 x 2 ….. bisogna calcolare<br />
z 1 , y 1 , z 2 , y 2 …..<br />
Analogamente per decifrare la stringa y 1 y 2 …..bisogna<br />
calcolare<br />
z 1 , x 1 , z 2 , x 2 ......<br />
Per esempio se P = C = K = Z 26 le funzioni di cifratura e<br />
decifratura possono essere le seguenti:<br />
y i = x i + z i mod 26<br />
x i = y i - z i mod 26<br />
Gli stream cipher sono spesso defin<strong>it</strong>i in termini binari,<br />
cioè P = C = K = Z 2 . In tal caso le funzioni di cifratura e<br />
decifratura possono essere le seguenti:<br />
y i = x i + z i mod 2<br />
31
La cr<strong>it</strong>tografia<br />
x i = y i - z i mod 2<br />
Se associamo a "0" il valore booleano "falso", ed a "1" il<br />
valore booleano "vero" allora l'addizione modulo 2 corrisponde<br />
allo XOR, pertanto la cifratura e la decifratura possono essere<br />
implementate molto efficientemente in hardware.<br />
Un metodo per generare la sequenza keystream a partire da<br />
m valori k 1 , . . . . , k m consiste nel fissare i valori per z 1, .….,<br />
z m come z i = k i per ogni i = 1,……, m, e nel calcolare i valori<br />
successivi in base ad una relazione di ricorrenza lineare di<br />
grado m :<br />
dove c 0 ,….,c m-1 ∈ Z 2 sono costanti predeterminate. Tale<br />
ricorrenza è funzione lineare dei termini precedenti, ed ha grado<br />
m perché ciascun termine dipende dagli m precedenti. In tal<br />
caso la chiave consiste dei 2m valori ( k 1 ……k m ; c 0 ......c m-1 ),<br />
dove k i =z i per i = 1,….., m.<br />
3.2.5 Cifrario di Vernam<br />
Nel 1917 Gilbert Vernam, impiegato della compagnia<br />
AT&T, inventò un ingegnosissimo sistema di protezione<br />
cr<strong>it</strong>tografica, per comunicazioni su telegrafo, dei testi codificati<br />
in binario. Egli costruì per prima cosa un dispos<strong>it</strong>ivo in grado di<br />
leggere contemporaneamente due nastri in input e generare a<br />
partire da essi un nastro di output tale che ciascun foro fosse<br />
generato mediante uno XOR dei due corrispondenti fori sui<br />
nastri input. Dopodiché prese un nastro su cui era perforata una<br />
sequenza di caratteri casuale ed un nastro su cui era perforato<br />
un testo reale e li passò nella sua macchina. Il risultato fu un<br />
nastro completamente inintellegibile, ovvero cifrato.<br />
Lo schema di cr<strong>it</strong>tografia di Vernam è uno schema onetime<br />
pad; un tale schema richiede che :<br />
1. la chiave sia usata una sola volta (da qui il nome);<br />
2. deve essere lunga almeno quanto il testo in chiaro;<br />
3. fra i b<strong>it</strong> che compongono la chiave non deve esserci<br />
alcuna relazione;<br />
4. la chiave deve essere generata casualmente.<br />
In pratica se il testo in chiaro è X = 0110 e la chiave è<br />
K = 1100, applicando il metodo di Vernam si ottiene il seguente<br />
testo cifrato :<br />
Y= X ⊕ K = 1010<br />
la decifratura si ottiene nel seguente modo:<br />
X= Y ⊕ K = 0110<br />
Notiamo che è stata applicata la stessa chiave ed è stata<br />
effettuata la stessa operazione sia per la cifratura che per la<br />
decifratura, ciò caratterizza un sistema cr<strong>it</strong>tografico reversibile,<br />
questo è uno dei molti aspetti notevoli del cifrario di Vernam.<br />
Per ciò che concerne la sicurezza, a tutt'oggi, questo è l'unico<br />
32
metodo ad essere perfetto, ossia cost<strong>it</strong>uisce un cifrario<br />
assolutamente indecifrabile in senso stretto.<br />
Un cifrario si dice perfetto se, dati X il testo in chiaro e Y<br />
il cifrato corrispondente, gode della seguente proprietà:<br />
per ogni X’e Y’ risulta :<br />
Pr ( X = X’ ) = Pr (X = X’ | Y = Y’ )<br />
La proprietà di cui sopra si chiama sicurezza perfetta. Per<br />
un cifrario che gode della sicurezza perfetta, l'indecisione nello<br />
stabilire qual è il testo in chiaro X senza conoscere il testo<br />
cifrato Y è la stessa che si ha su X conoscendo il testo cifrato<br />
Y.<br />
Le proprietà che caratterizzano l’one-time pad sono<br />
estremamente restr<strong>it</strong>tive, volendole rispettare si ottiene un<br />
sistema scomodo da usare in pratica, considerando che le<br />
ingombranti chiavi andrebbero generate in anticipo rispetto al<br />
loro uso previsto, e conservate in luogo sicuro. Sono questi i<br />
motivi per cui questo sistema non viene usato che per casi<br />
eccezionali, come la famosa hot-line tra Washington e Mosca.<br />
Un'altro problema è che l’one-time pad è modificabile; un<br />
intruso può cambiare Y così che il messaggio M decifrato sia<br />
differente dal messaggio sped<strong>it</strong>o. Non ci sono modi per il<br />
destinatario di controllare che il m<strong>it</strong>tente abbia sped<strong>it</strong>o proprio<br />
il messaggio ricevuto. Ci sono delle varianti che possono ev<strong>it</strong>are<br />
di utilizzare delle chiavi così grandi, ma che fanno perdere la<br />
perfezione al sistema perché introducono delle dipendenze<br />
statistiche. Un esempio è quello di prendere una chiave in un<br />
grosso testo, come la Bibbia, specificando un punto di inizio<br />
qualunque, tutti i caratteri da quel punto in poi, formeranno la<br />
chiave. La dipendenza statistica è ins<strong>it</strong>a proprio nel fatto che le<br />
parole devono avere senso compiuto. La difficoltà per i<br />
cr<strong>it</strong>toanalisti, oltre alla conoscenza della chiave (punto di inizio<br />
nel testo), sta anche nel capire qual è il testo utilizzato.<br />
Il problema con le chiavi corte, che dunque devono essere<br />
riutilizzate ciclicamente nel corso del messaggio, è che<br />
producono, in usc<strong>it</strong>a, delle regolar<strong>it</strong>à statistiche che possono<br />
essere usate dai cr<strong>it</strong>toanalisti per forzare il cifrario.<br />
3.3 Sicurezza perfetta<br />
Ragionando con i moderni termini della teoria<br />
dell'informazione, si comprende come la “somma” di una chiave<br />
casuale ad un testo in chiaro annulli l'ordine intrinseco nel testo<br />
stesso, producendo un cifrario a sua volta casuale, nel quale<br />
l'entropia H, che rappresenta la quant<strong>it</strong>à di informazione<br />
contenuta in un messaggio X, è massima.<br />
L'entropia H(X) di una variabile aleatoria X con<br />
distribuzione di probabil<strong>it</strong>à p 1 , p 2 , ……, p m , è uguale a<br />
La cr<strong>it</strong>tografia<br />
33
e definisce la quant<strong>it</strong>à di informazione contenuta in X.<br />
In termini di entropia è possibile definire un sistema di<br />
cifratura come segue : sia X la variabile aleatoria associata al<br />
messaggio in chiaro, sia Y la variabile aleatoria associata al<br />
messaggio cifrato e sia K la variabile aleatoria associata alla<br />
chiave, tutte con distribuzione di probabil<strong>it</strong>à arb<strong>it</strong>raria. Con<br />
questa definizione<br />
Pr ( X = X’ ) = Pr (X = X’ | Y = Y’ )<br />
si può scrivere<br />
H ( X ) = H ( X | Y )<br />
Affinché le tre variabili aleatorie X, Y, K realizzino un<br />
sistema cr<strong>it</strong>tografico perfetto si deve avere :<br />
• Cifratura : il testo cifrato è univocamente<br />
determinato dal testo in chiaro e dalla chiave.<br />
Formalmente : H ( Y | XK ) = 0<br />
• Decifratura : il testo in chiaro è univocamente<br />
determinato dal testo cifrato e dalla chiave.<br />
Formalmente : H ( X | YK ) = 0<br />
• Sicurezza perfetta : la conoscenza del testo<br />
cifrato non dà alcuna informazione sul testo in<br />
chiaro. Formalmente : H ( X | Y ) = H ( X )<br />
Teorema<br />
In un sistema cr<strong>it</strong>tografico con sicurezza perfetta, la lunghezza<br />
della chiave deve essere tanto grande quanto quella del messaggio in<br />
chiaro.<br />
Dimostrazione<br />
Supponendo che X sia il messaggio in chiaro,Y il<br />
messaggio cifrato e che la chiave utilizzata sia K.<br />
La mutua informazione I ( KX | Y ) può essere scr<strong>it</strong>ta<br />
come<br />
I ( KX | Y ) = H ( K | Y ) - H ( K | XY )<br />
oppure come<br />
I ( KX | Y ) = H ( X | Y ) - H ( X | YK )<br />
da cui si ottiene<br />
H ( K | Y ) = H ( K | XY ) + H ( X | Y ) - H ( X | YK ) (3)<br />
dato che H ( X | YK ) = 0, si ottiene<br />
H ( K | Y ) = H ( X | Y ) + H ( K | XY ) (4)<br />
In più, dato che l'incertezza sulla chiave è più grande<br />
dell'incertezza che si ha sulla chiave conoscendo anche il<br />
messaggio cifrato Y, cioè H ( K ) ≥ H ( K | Y ), si può scrivere:<br />
H ( K ) ≥ H ( K | Y )<br />
= H ( X | Y ) + H ( K | XY ) per la (4)<br />
= H ( X ) + H ( K | XY ) per la sicurezza perfetta<br />
≥ H ( X ) siccome H ( K | XY ) ≥ 0<br />
Ciò significa che l'incertezza che si ha sulla chiave è<br />
maggiore o uguale della incertezza che si ha sul messaggio X. Se<br />
supponiamo che X sia distribu<strong>it</strong>o uniformemente, allora:<br />
H ( X ) = log |X|<br />
da cui la lunghezza di K è maggiore o uguale della<br />
lunghezza di X, cioè<br />
log |K| ≥ H ( K ) ≥ H ( X ) = log |X|.<br />
La cr<strong>it</strong>tografia<br />
34
3.4 Gli algor<strong>it</strong>mi<br />
In questa sezione verranno esaminati due dei principali<br />
algor<strong>it</strong>mi utilizzati per la cifratura di dati : il DES e l’ RSA.<br />
Prima della trattazione tecnica verrà esaminata la storia dell’<br />
algor<strong>it</strong>mo.<br />
3.4.1 DES<br />
Il DES (Data Encryption Standard) viene adottato dal<br />
governo degli Stati Un<strong>it</strong>i nel 1977 come standard federale. Esso<br />
deriva dall'algor<strong>it</strong>mo Lucifer inventato dall' IBM nei primi anni<br />
'70. Mentre Lucifer era ancora in via di sviluppo il NBS<br />
(National Bureau of Standard), diventato poi NIST (National<br />
Inst<strong>it</strong>ute of Standards and Technology) , sollec<strong>it</strong>ò l'industria<br />
americana alla creazione di un nuovo standard cr<strong>it</strong>tografico per<br />
la protezione di dati riservati ma non classificati come "segreti<br />
mil<strong>it</strong>ari" o di "stato".<br />
L'NBS non fu accontentato molto presto forse perché il governo<br />
degli Stati Un<strong>it</strong>i non ha mai incoraggiato ricerche in questo<br />
campo, comunque nel 1974 l'IBM propose un Lucifer modificato<br />
a cui fu dato il nome di DEA (Data Encryption Algor<strong>it</strong>hm). L’<br />
NBS sceglie il DEA come standard ed è annunciato sul<br />
documento N.46 di Federal Information, col nuovo e defin<strong>it</strong>ivo<br />
nome di DES.<br />
La cr<strong>it</strong>tografia<br />
Tuttavia, se si riuscisse a far lavorare qualche migliaio di<br />
computer del tipo PC simultaneamente, è possibile sperare di<br />
scoprire la chiave in un periodo di tempo ragionevole.<br />
Provando a fare un piccolo conto si ottiene che si hanno 2 56<br />
possibili chiavi.<br />
Supponendo che un PC calcoli un milione di chiavi al secondo,<br />
occorreranno 2 56 /10 6 = 72057594037,9 secondi, che sono<br />
1200959900,63 minuti, che sono 20015998,3439 ore, che sono<br />
833999,930995 giorni, che sono 2284,93 anni.<br />
Quindi, per calcolare tutte le chiavi possibili bisognerà aspettare<br />
circa 2285 anni !<br />
Quindi, se si vuole essere sicuri di trovare la chiave in giornata,<br />
sarà necessario calcolare quanti computer dovrebbero lavorare<br />
simultaneamente. Cioè 2.285 x 365 = 834.025 macchine.<br />
Riassumendo, bisogna far lavorare 834.025 computer<br />
contemporaneamente per 24 ore per testare tutte le chiavi<br />
possibili.<br />
La chiave di cr<strong>it</strong>tografazione è lunga 64 b<strong>it</strong>, ma 8 b<strong>it</strong> sono<br />
di controllo, quindi la chiave effettiva è di 56 b<strong>it</strong>. Questo porta<br />
ad avere 2 56 (circa 72 milioni di miliardi) possibili chiavi in un<br />
tentativo di attacco brute - force. In effetti un supercomputer<br />
potrebbe scoprire la password in un tempo che va dalle 3 alle 10<br />
ore (per quello che è noto a livello non mil<strong>it</strong>are).<br />
35
La cr<strong>it</strong>tografia<br />
Tuttavia, anche senza basarsi sull'attacco di forza bruta,<br />
gli studiosi Biham e Shamir hanno ideato una nuova tecnica di<br />
forzatura detta cr<strong>it</strong>toanalisi differenziale. Questa tecnica<br />
consiste nell'utilizzo dell'algor<strong>it</strong>mo per la cifratura di 247 testi<br />
particolari ed il confronto dei risultati. Ancora in tempi più<br />
recenti, Matsui ha ideato un altro tipo di forzatura a cui è stato<br />
dato il nome di cr<strong>it</strong>toanalisi lineare. Anche in questo caso<br />
vengono cifrati dei testi noti, per la precisione 243, ed analizzati<br />
i risultati con il testo da decifrare. I tempi di decr<strong>it</strong>tazione sono<br />
comunque lunghi: il primo esperimento di Matsui richiese 9735<br />
postazioni di lavoro e 50 giorni e 12 ore di tempo.<br />
Il DES non viene più certificato dal NIST. Ha tuttavia<br />
ancora larghissimo impiego nelle trasmissione audiovisive (è<br />
incluso nello standard IRDETO, usato nelle trasmissioni<br />
svizzere) e nei sistemi di protezione di Bancomat e carte di<br />
cred<strong>it</strong>o, data anche l'elevata veloc<strong>it</strong>à di cr<strong>it</strong>tografazione rispetto<br />
al suo rivale RSA a chiave pubblica. Non può essere tuttavia<br />
utilizzato in quei casi dove il valore dell'informazione da<br />
proteggere superi certe cifre, dato che già tempo fa è stato<br />
dimostrato che in circa 3 ore qualsiasi testo cifrato con DES<br />
può essere riportato in chiaro tram<strong>it</strong>e un computer dal costo di<br />
1 milione di dollari.<br />
E` comunque stata costru<strong>it</strong>a una versione del DES,<br />
chiamata Triplo DES, che utilizza 3 chiavi diverse ad ogni<br />
passaggio di sovracifratura. Nonostante i risultati siano inferiori<br />
alle aspettative, è stato innalzato moltissimo il tempo necessario<br />
per un attacco di brute-force.<br />
Manipolazione della chiave<br />
Adesso verrà affrontato il primo stadio del cryptaggio che<br />
consiste nel manipolare i b<strong>it</strong>s della chiave.<br />
Per prima cosa, bisogna sapere che la chiave si può presentare in<br />
due forme diverse:<br />
- una chiave a 56 b<strong>it</strong>s come indicato precedentemente<br />
- una chiave a 64 b<strong>it</strong>s che non è altro che la stessa chiave<br />
a cui è stata aggiunta una par<strong>it</strong>à.<br />
La par<strong>it</strong>à<br />
La par<strong>it</strong>à è utilizzata durante le trasmissioni di dati binari al fine<br />
di verificarne la corretta ricezione.<br />
Essa consiste nell’aggiungere ad un "codice binario" un b<strong>it</strong><br />
supplementare per fare in modo<br />
che il numero totale degli 1 sia sempre pari o dispari.<br />
Si avranno, quindi, due tipi di par<strong>it</strong>à, pari o dispari.<br />
Esempio<br />
10011000 par<strong>it</strong>à dispari – abbiamo tre 1<br />
10011001 par<strong>it</strong>à pari – abbiamo quattro 1<br />
36
Per lo stesso gruppo di dati (1001100), vengono applicati due<br />
b<strong>it</strong>s diversi per ottenere la par<strong>it</strong>à desiderata.<br />
Per il sistema DES, viene utilizzata la par<strong>it</strong>à dispari.<br />
Ora consideriamo un chiave a 56 b<strong>it</strong>s:<br />
12 34 56 3C F0 12 34<br />
In binario avremo:<br />
00010010001101000101011000111100111100000001001000110100<br />
Applicando una par<strong>it</strong>à dispari su ciascun gruppo di sette<br />
b<strong>it</strong>s si otterrà dunque:<br />
00010011 13<br />
00011010 1A<br />
00010101 15<br />
11000111 C7 Il numero "1" è sempre dispari.<br />
11001110 CE<br />
10000000 80<br />
01001001 49<br />
01101000 68<br />
Quindi la chiave 12 34 56 3C F0 12 34 a 56 b<strong>it</strong>s senza<br />
par<strong>it</strong>à corrisponde alla chiave<br />
13 1A 15 C7 CE 80 49 68 a 64 b<strong>it</strong>s con par<strong>it</strong>à dispari.<br />
Si potrà, quindi, determinare ciascuna delle due chiavi<br />
possedendo l’altra.<br />
Primo stadio<br />
Prendiamo la chiave precedente a 64 b<strong>it</strong>s.<br />
13 1A 15 C7 CE 80 49 68<br />
Verrà attribu<strong>it</strong>o a ciascun b<strong>it</strong> una posizione da 1 a 64,<br />
procedendo da sinistra verso destra.<br />
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16<br />
0 0 0 1 0 0 1 1 0 0 0 1 1 0 1 0<br />
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32<br />
0 0 0 1 0 1 0 1 1 1 0 0 0 1 1 1<br />
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48<br />
1 1 0 0 1 1 1 0 1 0 0 0 0 0 0 0<br />
49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64<br />
0 1 0 0 1 0 0 1 0 1 1 0 1 0 0 0<br />
Si cerca ora di ridurre questa chiave a 56 b<strong>it</strong>s applicando<br />
la seguente tabella di conversione:<br />
57 49 41 33 25 17 09<br />
01 58 50 42 34 26 18<br />
10 02 59 51 43 35 27<br />
19 11 03 60 52 44 36<br />
63 55 47 39 31 23 15<br />
07 62 54 46 38 30 22<br />
14 06 61 53 45 37 29<br />
21 13 05 28 20 12 04<br />
Lim<strong>it</strong>andosi a sost<strong>it</strong>uire i valori indicati nella tabella con i<br />
b<strong>it</strong> corrispondenti, si avrà:<br />
La cr<strong>it</strong>tografia<br />
37
0 0 1 1 1 0 0<br />
0 1 1 0 1 1 0 C(0)<br />
0 0 1 0 0 0 0<br />
0 0 0 0 0 0 0<br />
0 0 0 1 1 0 1<br />
1 0 0 0 1 1 1 D(0)<br />
0 0 1 1 0 1 0<br />
0 1 0 0 1 1 1<br />
I primi 28 b<strong>it</strong>s compongono il gruppo C(0).<br />
Gli ultimi 28 b<strong>it</strong>s compongono il gruppo D(0) .<br />
A questo punto occorre calcolare le sedici chiavi derivanti dalla<br />
prima.<br />
In effetti il sistema DES opera su sedici <strong>it</strong>erazioni e ciascuna di<br />
loro a bisogno della propria chiave.<br />
Il valore I corrisponde alle <strong>it</strong>erazioni e prenderà quindi i valori<br />
1-16.<br />
Inizio del ciclo<br />
I = 1<br />
Per ciascuno dei sedici valori di I , si effettueranno una o<br />
due rotazioni circolari verso sinistra in funzione del valore<br />
indicato nella seguente tabella:<br />
Iterazione 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16<br />
Rotazione 1 1 2 2 2 2 2 2 1 2 2 2 2 2 2 1<br />
In questo momento I=1. Dalla tabella si vede che occorre<br />
effettuare una rotazione a sinistra.<br />
La rotazione si farà su C(I-1) e su D(I-1) dunque per I=1 su<br />
C(0) e su D(0).<br />
Il risultato sarà C(I) e D(I) quindi C(1) e D(1).<br />
C(0) =<br />
MSB LSB<br />
0 0 1 1 1 0 0 0 1 1 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0<br />
Il primo b<strong>it</strong> di sinistra scomparirà per passare a destra ed<br />
il secondo b<strong>it</strong> a sinistra deve diventare il primo per cui si<br />
ottiene:<br />
La cr<strong>it</strong>tografia<br />
MSB LSB<br />
0 1 1 1 0 0 0 1 1 0 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0<br />
C(1)<br />
38
D(0) =<br />
MSB LSB<br />
0 0 0 1 1 0 1 1 0 0 0 1 1 1 0 0 1 1 0 1 0 0 1 0 0 1 1 1<br />
MSB LSB<br />
0 0 1 1 0 1 1 0 0 0 1 1 1 0 0 1 1 0 1 0 0 1 0 0 1 1 1 0<br />
D(1)<br />
A questo punto si opera su C(I) e su D(I) quindi C(1) e<br />
D(1) .<br />
Si comincerà con il riunire i due gruppi da 28 b<strong>it</strong>s per formare<br />
un nuovo gruppo da 56 b<strong>it</strong>s. Ora verrà attribu<strong>it</strong>o una riga a<br />
ciascuno dei 56 b<strong>it</strong>s e verrà applicata, infine, una permutazione<br />
secondo la tavola defin<strong>it</strong>a più avanti.<br />
1 2 3 4 5 6 7 8 9 10 11 12 13 14<br />
0 1 1 1 0 0 0 1 1 0 1 1 0 0<br />
15 16 17 18 19 20 21 22 23 24 25 26 27 28<br />
0 1 0 0 0 0 0 0 0 0 0 0 0 0<br />
29 30 31 32 33 34 35 36 37 38 39 40 41 42<br />
0 0 1 1 0 1 1 0 0 0 1 1 1 0<br />
43 44 45 46 47 48 49 50 51 52 53 54 55 56<br />
0 1 1 0 1 0 0 1 0 0 1 1 1 0<br />
Tavola di permutazione<br />
da cui otteniamo:<br />
14 17 11 24 01 05<br />
03 28 15 06 21 10<br />
23 19 12 04 26 08<br />
16 07 27 20 13 02<br />
41 52 31 37 47 55<br />
30 40 51 45 33 48<br />
44 49 39 56 34 53<br />
46 42 50 36 29 32<br />
0 0 1 0 0 0<br />
1 0 0 0 0 0<br />
0 0 1 1 0 1<br />
1 0 0 0 0 1<br />
1 0 1 0 1 1<br />
0 1 0 1 0 0<br />
1 0 1 0 1 1<br />
0 0 1 0 0 1<br />
A questo punto si ha la chiave K(I) e dunque la chiave<br />
K(1).<br />
001000100000001101100001101011010100101011001001<br />
La chiave è rappresentata sicuramente da 48 b<strong>it</strong>s. Sarà lo stesso<br />
per le sedici chiavi K(1)-K(16).<br />
Di segu<strong>it</strong>o, si passa a I=2 e si calcola la chiave K2.<br />
La cr<strong>it</strong>tografia<br />
39
Si calcoleranno così le sedici chiavi.<br />
Il blocco dei dati<br />
Ora che si hanno le sedici chiavi è possibile lavorare su<br />
un blocco di dati di 64 b<strong>it</strong>s così come è il cryptaggio.<br />
Prendendo come esempio il seguente dato<br />
45 45 15 35 50 11 05 23 in chiaro<br />
In binario, si otterrà :<br />
MSB LSB<br />
0100010101000101 0001010100110101 0101000000010001 0000010100100011<br />
Allora si attribuirà, come fatto in precedenza, ciascun b<strong>it</strong><br />
ad una determinata riga (1-64) e verrà applicata una tavola di<br />
permutazione a tutti i b<strong>it</strong>s.<br />
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16<br />
0 1 0 0 0 1 0 1 0 1 0 0 0 1 0 1<br />
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32<br />
0 0 0 1 0 1 0 1 0 0 1 1 0 1 0 1<br />
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48<br />
0 1 0 1 0 0 0 0 0 0 0 1 0 0 0 1<br />
49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64<br />
0 0 0 0 0 1 0 1 0 0 1 0 0 0 1 1<br />
Tavola di permutazione iniziale (IP)<br />
da cui otteniamo:<br />
58 50 42 34 26 18 10 02<br />
60 52 44 36 28 20 12 04<br />
62 54 46 38 30 22 14 06<br />
64 56 48 40 32 24 16 08<br />
57 49 41 33 25 17 09 01<br />
59 51 43 35 27 19 11 03<br />
61 53 45 37 29 21 13 05<br />
63 55 47 39 31 23 15 07<br />
0 0 0 1 0 0 1 1<br />
0 0 1 1 1 1 0 0 L(0)<br />
0 1 0 0 1 1 1 1<br />
1 1 1 0 1 1 1 1<br />
0 0 0 0 0 0 0 0<br />
1 0 0 0 1 0 0 0 R(0)<br />
0 0 0 0 0 0 0 0<br />
1 0 0 0 0 0 0 0<br />
I primi 32 b<strong>it</strong>s compongono L(0) gli ultimi 32 b<strong>it</strong>s<br />
compongono R(0).<br />
A questo punto verrà applicato alle sedici chiavi.<br />
La cr<strong>it</strong>tografia<br />
40
Inizio del ciclo<br />
I = 1<br />
Prendendo il blocco R(I-1) quindi R(0), si attribuirà<br />
ciascun b<strong>it</strong> ad una riga determinata ed applichiamo la tabella<br />
d’espansione che segue:<br />
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16<br />
0 0 0 0 0 0 0 0 1 0 0 0 1 0 0 0<br />
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32<br />
0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0<br />
Tabella d’espansione<br />
da cui otteniamo:<br />
32 01 02 03 04 05<br />
04 05 06 07 08 09<br />
08 09 10 11 12 13<br />
12 13 14 15 16 17<br />
16 17 18 19 20 21<br />
20 21 22 23 24 25<br />
24 25 26 27 28 29<br />
28 29 30 31 32 01<br />
0 0 0 0 0 0<br />
0 0 0 0 0 1<br />
0 1 0 0 0 1<br />
0 1 0 0 0 0 E(R(0))<br />
0 0 0 0 0 0<br />
0 0 0 0 0 1<br />
0 1 0 0 0 0<br />
0 0 0 0 0 0<br />
Otterremo 48 b<strong>it</strong>s poiché sono stai utilizzati più volte<br />
alcuni b<strong>it</strong>s.<br />
Occorre quindi eseguire la seguente operazione:<br />
E(R(I-1)) Xor K(I)<br />
Per la prima <strong>it</strong>erazione si ottiene :<br />
E(R(0)) Xor K(1)<br />
La cr<strong>it</strong>tografia<br />
Si dovrà quindi effettuare un’ operazione di XOR<br />
esclusivo fra ciascun b<strong>it</strong> di E(R(0)) e ciascun b<strong>it</strong> della chiave K1<br />
trovata precedentemente.<br />
Si otterrà :<br />
000000000001010001010000000000000001010000000000 E(R(0))<br />
XOR<br />
001000100000001101100001101011010100101011001001 K(1)<br />
________________________________________________<br />
001000100001011100110001101011010101111011001001<br />
41
Separando i 48 b<strong>it</strong>s ottenuti in otto gruppi di sei b<strong>it</strong>s :<br />
001000 B(1)<br />
100001 B(2)<br />
011100 B(3)<br />
110001 B(4)<br />
101011 B(5)<br />
010101 B(6)<br />
111011 B(7)<br />
001001 B(8)<br />
Otterremo otto valori B(1)-B(8) e ciascuno di essi sarà<br />
associato ad una delle otto tavole che seguono (S-Box).<br />
S1<br />
14 4 13 1 2 15 11 8 3 10 6 12 5 9 0 7<br />
0 15 7 4 14 2 13 1 10 6 12 11 9 5 3 8<br />
4 1 14 8 13 6 2 11 15 12 9 7 3 10 5 0<br />
15 12 8 2 4 9 1 7 5 11 3 14 10 0 6 13<br />
S2<br />
15 1 8 14 6 11 3 4 9 7 2 13 12 0 5 10<br />
3 13 4 7 15 2 8 14 12 0 1 10 6 9 11 5<br />
0 14 7 11 10 4 13 1 5 8 12 6 9 3 2 15<br />
13 8 10 1 3 15 4 2 11 6 7 12 0 5 14 9<br />
S3<br />
10 0 9 14 6 3 15 5 1 13 12 7 11 4 2 8<br />
13 7 0 9 3 4 6 10 2 8 5 14 12 11 15 1<br />
13 6 4 9 8 15 3 0 11 1 2 12 5 10 14 7<br />
1 10 13 0 6 9 8 7 4 15 14 3 11 5 2 12<br />
S4<br />
7 13 14 3 0 6 9 10 1 2 8 5 11 12 4 15<br />
13 8 11 5 6 15 0 3 4 7 2 12 1 10 14 9<br />
10 6 9 0 12 11 7 13 15 1 3 14 5 2 8 4<br />
3 15 0 6 10 1 13 8 9 4 5 11 12 7 2 14<br />
S5<br />
2 12 4 1 7 10 11 6 8 5 3 15 13 0 14 9<br />
14 11 2 12 4 7 13 1 5 0 15 10 3 9 8 6<br />
4 2 1 11 10 13 7 8 15 9 12 5 6 3 0 14<br />
11 8 12 7 1 14 2 13 6 15 0 9 10 4 5 3<br />
S6<br />
12 1 10 15 9 2 6 8 0 13 3 4 14 7 5 11<br />
10 15 4 2 7 12 9 5 6 1 13 14 0 11 3 8<br />
9 14 15 5 2 8 12 3 7 0 4 10 1 13 11 6<br />
4 3 2 12 9 5 15 10 11 14 1 7 6 0 8 13<br />
La cr<strong>it</strong>tografia<br />
42
S7<br />
4 11 2 14 15 0 8 13 3 12 9 7 5 10 6 1<br />
13 0 11 7 4 9 1 10 14 3 5 12 2 15 8 6<br />
1 4 11 13 12 3 7 14 10 15 6 8 0 5 9 2<br />
6 11 13 8 1 4 10 7 9 5 0 15 14 2 3 12<br />
S8<br />
13 2 8 4 6 15 11 1 10 9 3 14 5 0 12 7<br />
1 15 13 8 10 3 7 4 12 5 6 11 0 14 9 2<br />
7 11 4 1 9 12 14 2 0 6 10 13 15 3 5 8<br />
2 1 14 7 4 10 8 13 15 12 9 0 3 5 6 11<br />
La cr<strong>it</strong>tografia<br />
Prendiamo B(1) . Esso sarà associato alla tavola S1.<br />
1 2 3 4 5 6<br />
B(1)= 0 0 1 0 0 0<br />
I b<strong>it</strong>s 1 e 6 formeranno un codice di due b<strong>it</strong>s che<br />
chiameremo m .<br />
m = 00 che corrisponde a 0 in decimale.<br />
I b<strong>it</strong>s 2-5 formeranno un codice di quattro b<strong>it</strong>s che<br />
chiameremo n.<br />
n = 0100 che corrisponde a 4 in decimale.<br />
Occorre a questo punto r<strong>it</strong>ornare alla tavola S1 .<br />
m indica il numero di linea della tavola, n indica il numero della<br />
colonna.<br />
Dunque bisognerà cercare il valore rappresentato nella linea 0,<br />
colonna 4. Il valore trovato sarà 2 , che in binario viene indicato<br />
0010.<br />
B(1) assume ora questo nuovo valore:<br />
B(1)=0010<br />
La stessa cosa viene fatta da B(2) a B(8) e troveremo i nuovi<br />
valori:<br />
B(2)=1101<br />
B(3)=0010<br />
B(4)=1001<br />
B(5)=1110<br />
B(6)=1101<br />
B(7)=0010<br />
B(8)=1010<br />
Raggruppando da B(1) a B(8) , attribuiamo una riga a<br />
ciascun b<strong>it</strong> e applichiamo la tabella che segue.<br />
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16<br />
0 0 1 0 1 1 0 1 0 0 1 0 1 0 0 1<br />
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32<br />
1 1 1 0 1 1 0 1 0 0 1 0 1 0 1 0<br />
Tabella di permutazione p<br />
16 07 20 21<br />
29 12 28 17<br />
43
da cui otteniamo:<br />
01 15 23 26<br />
05 18 31 10<br />
02 08 24 14<br />
32 27 03 09<br />
19 13 30 06<br />
22 11 04 25<br />
1 0 0 1<br />
1 0 0 1<br />
0 0 0 0<br />
1 1 1 0<br />
0 1 1 0<br />
0 1 1 0<br />
1 1 0 1<br />
1 1 0 0<br />
A questo punto occorre applicare un XOR esclusivo fra i risultati ottenuti<br />
ed i valori di L(I-1) per la prima <strong>it</strong>erazione L(0).<br />
10011001000011100110011011011100<br />
XOR<br />
00010011001111000100111111101111 L(0)<br />
________________________________<br />
10001010001100100010100100110011 R(1)<br />
L(I) = R(I-1) per la prima <strong>it</strong>erazione L(1) = R(0)<br />
Riassumendo:<br />
L(1)=R(0)= 00000000100010000000000010000000<br />
R(1)= 10001010001100100010100100110011<br />
Adesso bisogna r<strong>it</strong>ornare all’inizio del ciclo con I=2 per la<br />
seconda <strong>it</strong>erazione. Per completare la cifratura occorrono sedici<br />
<strong>it</strong>erazioni.<br />
Fine<br />
Appena applicata la sedicesima chiave, è necessario effettuare un’ultima<br />
permutazione nel blocco R(16)-L(16). Questa volta, R(16) si trova davanti a L(16).<br />
Verrà assegnato a ciascun b<strong>it</strong> del blocco il rispettivo posto ed applicata la<br />
permutazione finale con l’aiuto della seguente tabella.<br />
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16<br />
1 1 0 0 0 0 0 0 1 1 0 1 1 0 1 0<br />
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32<br />
0 0 0 1 1 1 1 1 0 1 0 1 1 1 0 1<br />
33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48<br />
1 1 1 1 1 0 1 0 1 0 1 1 0 1 1 1<br />
49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64<br />
1 0 1 1 1 0 0 1 0 1 0 0 1 0 0 0<br />
La cr<strong>it</strong>tografia<br />
44
Tabella di permutazione finale<br />
40 08 48 16 56 24 64 32<br />
39 07 47 15 55 23 63 31<br />
38 06 46 14 54 22 62 30<br />
37 05 45 13 53 21 61 29<br />
36 04 44 12 52 20 60 28<br />
35 03 43 11 51 19 59 27<br />
34 02 42 10 50 18 58 26<br />
33 01 41 09 49 17 57 25<br />
Da cui si ottiene :<br />
0 0 1 0 1 1 0 1<br />
1 0 1 1 0 1 0 0<br />
0 0 1 0 0 1 0 1<br />
1 0 0 1 1 1 1 1<br />
1 0 1 1 1 1 0 1<br />
1 0 1 0 1 0 0 0<br />
1 1 0 1 0 0 1 1<br />
1 1 1 1 1 0 0 0<br />
quindi<br />
00101101 10110100 00100101 10011111 10111101 10101000<br />
11010011 11111000<br />
Convertendo questi valori in esadecimale si otterrà:<br />
2D B4 25 9F BD A8 D3 F8<br />
Che è quindi il valore cryptato di<br />
45 45 15 35 50 11 05 23<br />
con la chiave<br />
13 1A 15 C7 CE 80 49 68<br />
3.4.2 RSA<br />
L’RSA è un algor<strong>it</strong>mo di codifica a chiave pubblica.<br />
Questo algor<strong>it</strong>mo è a stato ideato da tre matematici Ron Rivest,<br />
Adi Shamir e Leonard Adleman nel 1977. Questo algor<strong>it</strong>mo<br />
sviluppa un codice cifrato attraverso un procedimento che<br />
sfrutta le proprietà dei numeri primi.<br />
L’RSA è formato da due chiavi, quella pubblica e quella<br />
segreta. La chiave pubblica è calcolata facendo il prodotto tra<br />
due fattori primi molto grandi, il risultato che troviamo N è un<br />
numero che deve essere difficile da fattorizzare, questa N viene<br />
resa pubblica.<br />
Esempio<br />
n = modulo<br />
p = numero primo<br />
q = numero primo<br />
La cr<strong>it</strong>tografia<br />
45
n = p * q = modulo<br />
La cr<strong>it</strong>tografia<br />
Si sceglie un numero ‘e’ primo rispetto a (p-1) (q-1), in<br />
segu<strong>it</strong>o si prende un numero ‘d’ tale che (e*d-1) sia divisibile<br />
per (p-1) (q-1): il numero ‘e’ viene chiamato esponente<br />
pubblico, il numero ‘d’ è l’esponente privato. Queste due chiavi<br />
concorrono a formare la chiave pubblica, che è formata dalla<br />
coppia (n,e), mentre la chiave privata è formata dai numeri<br />
(n,d). Oggi è molto difficile fattorizzare ‘n’ nei due numeri ‘p’ e<br />
‘q’ in tempi accettabili. Al momento non è possibile pensare ad<br />
una forzatura dell’algor<strong>it</strong>mo RSA, poiché si utilizzano chiavi con<br />
un numero di cifre superiore o uguale a duecento.<br />
3.5 Macchine cifranti<br />
In questa sezione verranno trattate le due macchine che si<br />
sono rese protagoniste nella seconda guerra mondiale : Enigma e<br />
la Bomba di Turing o Colossus.<br />
3.5.1 Enigma<br />
Figura 3.6 : Creazione<br />
di una coppia di chiavi<br />
con RSA<br />
Nel 1918 l'inventore tedesco Arthur Scherbius avendo<br />
studiato ingegneria elettrica ad Hannover e Monaco, mise a<br />
punto un dispos<strong>it</strong>ivo cr<strong>it</strong>tografico che in sostanza era una<br />
versione elettromeccanica del disco cifrante dell'Alberti.<br />
46
La sua invenzione fu chiamata Enigma. Essa consiste di<br />
diversi ingegnosi elementi combinati in un potente e sofisticato<br />
dispos<strong>it</strong>ivo per la produzione di scr<strong>it</strong>ture segrete.<br />
La versione semplificata del congegno di Scherbius<br />
consiste in 3 componenti collegati da fili elettrici: una tastiera<br />
per immettere le lettere del testo in chiaro; un'un<strong>it</strong>à<br />
scambiatrice che cifra la lettera trasformandola nel<br />
corrispondente elemento del cr<strong>it</strong>togramma (testo cifrato); un<br />
visore con varie lampadine, che accendendosi indicano la lettera<br />
da inserire nel testo cifrato.<br />
Per generare il cr<strong>it</strong>togramma, l'operatore preme il tasto<br />
corrispondente alla lettera da cifrare; l'impulso elettrico<br />
raggiunge l'un<strong>it</strong>à scambiatrice, e dopo essere stato elaborato va<br />
ad illuminare il visore in modo da evidenziare la lettera cifrata<br />
corrispondente.<br />
La cr<strong>it</strong>tografia<br />
Figura 3.7 : Versione<br />
semplificata della<br />
macchina Enigma con<br />
un alfabeto di sei<br />
lettere.<br />
Con questo schema di base lo scambiatore in sostanza<br />
definisce una corrispondenza tra le lettere del testo in chiaro e<br />
quelle cifrate, e la macchina può essere usata per realizzare una<br />
semplice cifratura per sost<strong>it</strong>uzione monoalfabetica. Il passo<br />
successivo consiste nel far ruotare automaticamente il disco<br />
scambiatore di un 1/26 di giro dopo la cifratura di ogni lettera.<br />
In altre parole, la corrispondenza tra lettere in chiaro e cifrate<br />
cambia dopo la cifratura di ogni lettera cosicché la cifratura di<br />
una stessa lettera muta continuamente. Con questa disposizione<br />
rotante, lo scambiatore in sostanza definisce 26 diverse<br />
corrispondenze tra lettere in chiaro e cifrate, ed Enigma può<br />
essere usata per effettuare una cifratura polialfabetica. Tuttavia,<br />
così come è il congegno, ha un punto debole evidente; dopo 26<br />
pressioni continue dello stesso tasto, il disco torna alla<br />
posizione iniziale, e se si continuasse a premere lo stesso tasto,<br />
lo schema di cifratura si ripeterebbe tale e quale. Per ridurre il<br />
numero di ripetizioni può essere introdotto un altro<br />
scambiatore. In questo modo, ogni volta che una lettera è<br />
cifrata, il primo disco ruota di un carattere, mentre il secondo<br />
disco invece resta immobile fin quando il primo scambiatore ha<br />
completato un giro, solo a questo punto il secondo scambiatore<br />
avanza di una posizione.<br />
L'aggiunta del secondo scambiatore comporta il vantaggio<br />
che lo schema della cifratura non si ripete finché il secondo<br />
scambiatore non è tornato al punto di partenza, il che richiede<br />
26 giri completi del primo scambiatore, ovvero la cifratura di<br />
26x26=676 lettere. Per una sicurezza ancora maggiore viene<br />
47
aggiunto un terzo rotore, per cui il numero di sost<strong>it</strong>uzioni<br />
diverse è 26x25x26=16.900 (il secondo rotore effettua una<br />
rotazione in meno rispetto agli altri due, poiché dopo aver<br />
effettuato un giro completo rimane fermo una volta per far<br />
ruotare il terzo rotore). Inoltre viene aggiunto un riflessore<br />
molto simile allo scambiatore che consiste in un disco di gomma<br />
con circu<strong>it</strong>i interni che non ruotano e i fili entrano ed escono<br />
dallo stesso lato. Col riflessore installato quando si dig<strong>it</strong>a una<br />
lettera il segnale elettrico attraversa i 3 rotori, raggiunge il<br />
riflessore ed è mandato indietro. Quindi il segnale elettrico<br />
passa di nuovo nei rotori ma lungo un percorso diverso.<br />
La cr<strong>it</strong>tografia<br />
Figura 3.8 : Il progetto<br />
di Scherbius del<br />
modello base di Enigma<br />
includeva un terzo<br />
scambiatore e un<br />
riflessore, che costringe<br />
l'impulso elettrico ad<br />
attraversare di nuovo gli<br />
scambiatori.<br />
Dato che il numero di chiavi è alto ma non abbastanza per<br />
scoraggiare un cr<strong>it</strong>toanalista che può disporre di più macchine e<br />
più aiutanti, per accrescere l'affidabil<strong>it</strong>à si dovrebbe aumentare<br />
il numero di assetti cioè il numero di chiavi. Invece di<br />
aggiungere un altro rotore e aumentare di 26 volte le chiavi sono<br />
state introdotte due nuove caratteristiche. Innanz<strong>it</strong>utto si<br />
possono utilizzare rotori removibili e sost<strong>it</strong>uibili, ad esempio il<br />
primo e il terzo rotore si possono scambiare di posto. Quindi<br />
dati tre elementi intercambiabili essi possono essere permutati<br />
in sei modi differenti; con questo accorgimento il numero di<br />
chiavi aumenta di un fattore pari a sei. La seconda caratteristica<br />
è l'inserimento di un pannello a prese multiple tra la tastiera e il<br />
primo rotore. Il pannello permette al m<strong>it</strong>tente di inserire alcuni<br />
cavi mun<strong>it</strong>i di spinotti, che aveva l'effetto di scambiare due<br />
lettere prima della loro immissione nel rotore. L'operatore di<br />
Enigma dispone di sei cavi che gli danno la possibil<strong>it</strong>à di<br />
scambiare sei coppie di lettere simultaneamente.<br />
48
Calcolo del numero di chiavi possibili<br />
Rotori<br />
I due dischi rotanti più esterni effettuano 26 rotazioni<br />
ognuno, mentre quello centrale ne effettua 25, quindi sono<br />
ammesse 26x25x26=16.900 combinazioni di orientamenti.<br />
Un<strong>it</strong>à cifratrice<br />
I tre rotori (1,2,e 3) possono essere inser<strong>it</strong>i nell'un<strong>it</strong>à<br />
centrale in diverse posizioni reciproche, così riassumibili: 123,<br />
132, 213, 231, 312, 321. Sono quindi ammesse 6 diverse<br />
posizioni reciproche dei rotori.<br />
Pannello a prese multiple<br />
I possibili abbinamenti di 2 x 6 = 12 lettere su 26 sono<br />
moltissime, per l'esattezza 100.391.791.500, che si ottiene dalla<br />
formula seguente dove p, il numero di cavi, è uguale a 6.<br />
Il numero totale di chiavi si ottiene moltiplicando le<br />
suddette possibil<strong>it</strong>à: 16.900 x 6 x 100.391.791.500<br />
La cr<strong>it</strong>tografia<br />
Figura 3.9 : Il pannello<br />
a prese multiple è<br />
interposto tra la tastiera<br />
e gli scambiatori.<br />
Inserendo gli appos<strong>it</strong>i<br />
cavetti è possibile<br />
scambiare due lettere.<br />
49
Figura 3.10 : Pannello a prese multiple<br />
Figura 3.11 : Disco rotante<br />
La cr<strong>it</strong>tografia<br />
50
Figura 3.12 : Macchina Enigma<br />
Figura 3.13 : Scambiatore<br />
La cr<strong>it</strong>tografia<br />
51
3.5.2 La Bomba di Turing<br />
La cr<strong>it</strong>tografia<br />
Nel 1938 Dilly Knox era conoscenza del fatto che i rotori<br />
usati dai tedeschi nella macchina Enigma fossero differenti da<br />
quelli in commercio e, molto probabilmente, non sapeva neanche<br />
il metodo di doppia cifratura del testo in chiaro, vero punto di<br />
forza per i tedeschi.<br />
In quel periodo, Alan Turing, tentò diverse vie per cercare<br />
di forzare il sistema di cifratura dei tedeschi basandosi sulle<br />
uniche informazioni in possesso dell’Inghilterra, ovvero un<br />
“testo piano conosciuto” che in segu<strong>it</strong>o verrà ribattezzato con il<br />
nome di “crib”.<br />
Turing pensò che se l’analisi dei testi cifrati poteva<br />
portare a una parziale decr<strong>it</strong>tazione dello stesso, l’utilizzo di<br />
calcolatori, i quali potevano testare diverse configurazioni di<br />
rotori in poco tempo, poteva portare a buoni risultati.<br />
Inoltre, Turing, attraverso l’uso delle proprie abil<strong>it</strong>à<br />
matematiche, riuscì a dimostrare che una trasformazione da un<br />
testo cifrato al testo in chiaro precludeva un vasto numero di<br />
configurazioni di rotori.<br />
La GC&CS (Governement Codes & Ciphers School), tra gli<br />
anni tra il ’38 e il ’39, riuscì ad intercettare un gran numero di<br />
testi cifrati con la relativa copia in chiaro, grazie anche alla<br />
collaborazione di un impiegato polacco.<br />
Tra le caratteristiche che Turing scovò occasionalmente vi<br />
era quella che la stessa coppia chiaro/cifrato di caratteri<br />
occorreva più volte in differenti punti del medesimo messaggio.<br />
Questa caratteristica venne chiamata “clicks”.<br />
.....JYCQRPWYDEMCJMRSR<br />
.....SPRUCHNUMMERXEINS<br />
.........|…|……....|.|….|...<br />
Questo avveniva perché Enigma era reversibile, ovvero la<br />
coppia chiaro/cifrato di R,C era la stessa C,R e M,E ed E,M.<br />
L’occorrenza di una coppia è determinata dall’ordine del<br />
rotore e dalla posizione iniziale di esso. Turing capì che,<br />
l’ordine attuale dei rotori e la loro posizione di partenza,<br />
potevano essere trovati provando tutte le configurazioni che<br />
soddisfavano la coppia esaminata.<br />
Ovviamente provare tutte le combinazioni possibili su una<br />
sola macchina Enigma una alla volta avrebbe richiesto un tempo<br />
impossibile. Di conseguenza, il passo seguente, fu quello di<br />
considerare come il test poteva essere esegu<strong>it</strong>o simultaneamente<br />
per una particolare configurazione iniziale della macchina.<br />
Il test di ogni coppia di lettere richiedeva un metodo per<br />
determinare rapidamente quale configurazione fosse esatta o<br />
errata. Questo faceva a capo al concetto di collegare insieme più<br />
macchine Enigma per velocizzare le operazioni di decr<strong>it</strong>tazione.<br />
Il risultato fu quello di usare una macchina Enigma “aperta”.<br />
52
A causa della configurazione elettrica di Enigma ciò non<br />
era possibile perché gli ingressi e le usc<strong>it</strong>e che conducevano<br />
corrente erano fissati sul rotore, mentre nella configurazione<br />
aperta studiata da Turing, il riflettore, che nella precedente<br />
configurazione precludeva ogni possibil<strong>it</strong>à di connessione, aveva<br />
due lati. In particolare, quello di usc<strong>it</strong>a era connesso a tre rotori<br />
che rappresentavano i percorsi inversi effettuati dalla corrente<br />
nella configurazione originale della macchina.<br />
Questo metodo dava la possibil<strong>it</strong>à di avere delle<br />
connessioni in input/output separate, permettendo, così, di<br />
avere più macchine Enigma in serie.<br />
La cr<strong>it</strong>tografia<br />
Figura 3.14 : Schema della macchina Enigma<br />
modificata da Turing.<br />
Nella Letchworth Enigma (chiamata così perché la fabbrica<br />
Br<strong>it</strong>ish Tabulating Machine, che l’ha costru<strong>it</strong>a, si trovava a<br />
Letchworth) la cosa intelligente fu quella di includere ambedue i<br />
cablaggi, anteriore e posteriore, dei rotori di Enigma in un unico<br />
tamburo. Le connessioni tra un tamburo e il successivo<br />
avvenivano tram<strong>it</strong>e quattro cerchi composti da 26 contatti fissi<br />
l’uno. I tre set di contatti erano cablati insieme,<br />
permanentemente, ai connettori di input/output. I tre tamburi,<br />
rappresentanti i tre rotori presenti sull’Enigma originale,<br />
potevano essere posizionati sull’albero, formando una macchina<br />
Enigma in configurazione aperta, con i connettori di<br />
input/output separati dagli altri.<br />
R<strong>it</strong>ornando al problema dei clicks, Turing decise di<br />
affrontarlo nel seguente modo :<br />
53
a b c d e f g h i j k l m n o p q<br />
JYCQRPWYDEMCJMRSR<br />
SPRUCHNUMMERXEINS<br />
….|…|……....|.|……|...<br />
La cr<strong>it</strong>tografia<br />
pose un offset, rappresentato dall’alfabeto minuscolo, per<br />
identificare ogni coppia. In questo modo C,R erano<br />
rappresentate dall’offset c e e mentre M,E da j, k e n.<br />
Alla connessione rappresentata dall’offset, in questo caso<br />
la “C”, dell’Enigma a configurazione aperta veniva applicata una<br />
tensione, in questo modo, le 26 lampadine attaccate ad essa<br />
indicavano se la possibile cifratura era esatta. In questo caso si<br />
sarebbe dovuta accendere la lampadina relativa alla lettera R.<br />
Con una singola macchina Enigma questa operazione<br />
avrebbe richiesto un incredibile numero di settaggi.<br />
Figura 3.15 : Schema di risoluzione<br />
del problema dei clicks.<br />
Le macchine Enigma in configurazione aperta erano tutte<br />
settate con lo stesso ordine di tamburi. Tutti i tamburi erano<br />
settati nel medesimo modo, tranne l’ultimo che rappresentava<br />
l’offset della lettera del crib da testare. In questo modo,<br />
attraverso un set di relè era possibile fornire un voltaggio in<br />
ingresso all’ultimo tamburo di tutte le macchine, così facendo<br />
era possibile verificare se il settaggio dei tamburi soddisfava il<br />
crib.<br />
Se il risultato era negativo si procedeva a cambiare<br />
l’ordine dei tamburi attraverso un motore elettrico.<br />
Figura 3.16 : Schema<br />
di settaggio dei<br />
tamburi per la<br />
risoluzione del<br />
problema dei clicks.<br />
54
Un estensione del concetto delle coppie di lettere è il loop<br />
di lettere.<br />
Abc def g hi j k lmnopq<br />
JYCQRPRYDEMCJMRSR<br />
SPRUCHNUMMERXEINS<br />
.............|………….......||<br />
Il primo problema fu quello di trovare le posizioni<br />
principali S1, S2 e S3.<br />
Figura 3.17 : Schema di risoluzione<br />
del problema del loop.<br />
Turing capì che c’era un’altra via per scoprire le<br />
interconnessioni tra le macchine Enigma in configurazione<br />
aperta.<br />
Lo schema rappresenta tre macchine Enigma in<br />
configurazione aperta. I tamburi numero 1 sono settati in<br />
corrispondenza degli offset S1, S2 e S3. I tamburi numero 2 e 3<br />
corrispondono alla configurazione standard dell’Enigma.<br />
A questo punto le posizioni dei rotori corrisponderanno<br />
alla posizione originale presente nella macchina Enigma al<br />
momento della cr<strong>it</strong>tazione.<br />
In questo modo il voltaggio di S1 sarà lo stesso in<br />
ingresso di S2 mentre il voltaggio di S2 sarà l’ingresso di S3.<br />
In questo modo si otterrà la configurazione originale.<br />
La cr<strong>it</strong>tografia<br />
Figura 3.18 : Schema<br />
di settaggio dei<br />
tamburi per la<br />
risoluzione del<br />
problema del loop..<br />
55
Ora il trucco sta nel connettere i terminali di usc<strong>it</strong>a<br />
dall’ultima macchina nell’input della prima. Quest’ultima<br />
operazione porterà ad avere un loop tra le macchine, isolando,<br />
però, le connessioni S1, S2 e S3.<br />
In segu<strong>it</strong>o, Turing pensò che se S1 era sconosciuto e se gli<br />
si applicasse un voltaggio casuale, questo raggiungerebbe tutte<br />
le macchine ma non influenzerebbe gli ingressi S1, S2 e S3<br />
perché essi non erano connessi a nessun terminale.<br />
Il test finale consisteva nello spostare i rotori in modo da<br />
vedere se una o 25 lampadine si accendevano. Se tutte le<br />
lampadine erano accese la posizione era errata. Questo test<br />
avveniva in pochissimo tempo, l’unico accorgimento era quello<br />
di non surriscaldare i motori che muovevano i tamburi.<br />
L’altra idea che ha permesso di perfezionare la Bomba di<br />
Turing venne da Gordon Welchman. Egli pensò di costruire dei<br />
registri, che opportunamente modificati potessero riassumere le<br />
connessioni tra le macchine Enigma in configurazione aperta.<br />
Attraverso la “Diagonal Board” (così fu chiamata) era facile<br />
risalire alla corrispondenza tra le lettere, in particolare risultava<br />
quasi immediata la soluzione nei casi di loop di cifre.<br />
Figura 3.19 :<br />
Diagonal Board.<br />
Figura 3.20 : Vista<br />
frontale della Bomba<br />
di Turing.<br />
La cr<strong>it</strong>tografia<br />
56
3.6 Cr<strong>it</strong>toanalisi<br />
La cr<strong>it</strong>toanalisi è la scienza parallela alla cr<strong>it</strong>tografia,<br />
infatti essa è volta a debellare le protezioni offerte dalla<br />
cr<strong>it</strong>tografia.<br />
Di segu<strong>it</strong>o verranno analizzate alcune delle tecniche usate<br />
dai cr<strong>it</strong>toanalisti per decifrare i più diffusi sistemi di<br />
cr<strong>it</strong>tografia.<br />
3.6.1 Cr<strong>it</strong>toanalisi statistica<br />
Figura 3.22 :<br />
Manopola per il<br />
settaggio dei tamburi.<br />
Figura 3.21 : Vista<br />
posteriore della<br />
Bomba di Turing.<br />
Uno dei sistemi più utilizzati per la cr<strong>it</strong>toanalisi di testi<br />
cifrati, specie quelli della famiglia dei metodi a sost<strong>it</strong>uzione, è<br />
proprio l'analisi della frequenza con cui si ripetono alcune<br />
lettere in una data lingua.<br />
Analizzando come esempio, un testo scr<strong>it</strong>to in <strong>it</strong>aliano,<br />
anche di lunghezza lim<strong>it</strong>ata, si noterà sicuramente che le lettere<br />
che compaiono con più frequenza, sono nell'ordine : e,i,a,o.<br />
Questa caratteristica può essere sfruttata per decr<strong>it</strong>tare cifrati<br />
sconosciuti, o perlomeno come validissima informazione iniziale<br />
per la cr<strong>it</strong>toanalisi.<br />
Analizzando un qualsiasi testo <strong>it</strong>aliano, inglese, ecc. è<br />
possibile stabilire per conto proprio quale sono le frequenze di<br />
La cr<strong>it</strong>tografia<br />
57
ogni lettera dell'alfabeto in tale lingua. Analizzando poi le<br />
frequenze di un testo cifrato, si può capire con quale lettera è<br />
stata sost<strong>it</strong>u<strong>it</strong>a, associando la frequenza di ogni singola lettera<br />
del testo cifrato, con quella dell'alfabeto di tale lingua (che<br />
andrà scoperta per tentativi se non conosciuta). Se ad esempio<br />
in un testo che si sa essere <strong>it</strong>aliano, spicca come lettera a<br />
frequenza più alta la lettera "x", sicuramente tale lettera deve<br />
essere sost<strong>it</strong>u<strong>it</strong>a con la lettera "e". Operando la sost<strong>it</strong>uzione di<br />
tutte le lettere del testo cifrato secondo questo schema, il testo<br />
sarà decr<strong>it</strong>tato come minimo al 60%. Ciò significa che ci si<br />
troverà ad avere un testo con lettere mancanti o errate in ogni<br />
parola, ma facilmente immaginabili.<br />
Ovviamente con gli algor<strong>it</strong>mi polialfabetici, sebbene siano<br />
metodi a sost<strong>it</strong>uzione, le cose si complicano molto rispetto<br />
all'analisi di un monoalfabetico creato, ad esempio, con il<br />
cifrario di Cesare. Con i metodi monoalfabetici questo sistema<br />
di cr<strong>it</strong>toanalisi porta alla soluzione in un batter d'occhio (a<br />
meno che non sia stato utilizzato anche un nomenclatore o un<br />
dizionario), mentre con i polialfabetici si può operare solo a<br />
blocchi di lunghezza pari alla chiave, dato che dopo tale<br />
lunghezza l'alfabeto di sost<strong>it</strong>uzione varia. In questi casi<br />
conviene utilizzare la cr<strong>it</strong>toanalisi lineare o differenziale.<br />
3.6.2 Cr<strong>it</strong>toanalisi lineare<br />
La cr<strong>it</strong>toanalisi lineare è un sistema di cr<strong>it</strong>toanalisi basato<br />
sull'analisi di una coppia cifrato - decifrato intercettata.<br />
L'attacco ha lo scopo di scoprire la chiave utilizzata nei<br />
messaggi. Non è necessario essere in possesso del programma<br />
utilizzato per cifrare/decifrare.<br />
Il metodo è orientato all'analisi tram<strong>it</strong>e<br />
un'approssimazione lineare volta a descrivere il comportamento<br />
del blocco di bytes a partire dal testo in chiaro. Più in<br />
particolare si lavora a livello di b<strong>it</strong> utilizzando un registro a<br />
scorrimento per lo shift dei bytes ed effettuando la somma di<br />
alcuni stadi con l'usc<strong>it</strong>a di sinistra di tale registro. In base ai<br />
dati così raccolti ed attentamente esaminati si può scoprire la<br />
chiave. La probabil<strong>it</strong>à di successo è alta.<br />
Come funziona<br />
Per prima cosa ai ha bisogno di un registro a scorrimento<br />
lineare che sia composto di n elementi di memoria binaria, detti<br />
stadi, il cui contenuto può essere la cifra 0 o la cifra 1; n è la<br />
lunghezza del registro; l'ennupla binaria contenuta nel registro<br />
in un dato momento è lo stato del registro in quel momento<br />
(dunque gli stati possibili di un registro di lunghezza n sono 2 n ).<br />
Ad intervalli di tempo regolari il contenuto di ciascuno stadio<br />
viene trasfer<strong>it</strong>o (scorre) nello stadio di sinistra ed il contenuto<br />
di S 0 "esce" dal registro. Anche il contenuto dello stadio più a<br />
La cr<strong>it</strong>tografia<br />
58
La cr<strong>it</strong>tografia<br />
sinistra, S n-1, va aggiornato : ciò viene effettuato mediante la<br />
funzione di retroazione, detta "feedback" del registro.<br />
Tale funzione consiste in un addizionatore che è collegato<br />
a certi stadi del registro : l'addizionatore somma il contenuto di<br />
tali stadi (prima che il registro venga aggiornato) ed il risultato<br />
viene appunto trasfer<strong>it</strong>o in S n-1; la somma è quella binaria<br />
modulo 2 in cui 1 + 1 = 0. Le usc<strong>it</strong>e del registro sono cost<strong>it</strong>u<strong>it</strong>e<br />
dalle cifre binarie pseudocasuali che via via occupano lo stadio<br />
S 0 .<br />
Chiave pseudocasuale è sinonimo di chiave<br />
"pseudoperfetta" (con riferimento al cifrario perfetto o di<br />
Vernam) e potrebbe sembrare che un simile codice sia<br />
inattaccabile ma non è così.<br />
Si immagini che un cr<strong>it</strong>tanalista possa venire in possesso<br />
della coppia messaggio - cr<strong>it</strong>togramma; tale coppia può<br />
effettivamente essergli sufficiente per capire qual è la chiave che<br />
è stata usata, e dunque per decifrare tutti i cr<strong>it</strong>togrammi futuri<br />
che sarà in grado di intercettare : bastano 2n cifre di messaggio<br />
e le 2n cifre del cr<strong>it</strong>togramma corrispondente perchè il<br />
cr<strong>it</strong>tanalista sia in grado di forzare il cifrario in maniera<br />
completa.<br />
Si supponga che il registro in questione abbia lunghezza 5,<br />
e che il cr<strong>it</strong>tanalista abbia intercettato il messaggio m 12 m 13<br />
m 14...m 20 m 21, ed il cr<strong>it</strong>togramma c 12 c 13 c 14...c 20 c 21 (gli istanti di<br />
tempo sono t=12, 13, 14,...20, 21). Poiché il cr<strong>it</strong>togramma si<br />
calcola sommando la chiave al messaggio cifra per cifra, si ha:<br />
c 12=m 12+S 0 (12)<br />
c 13=m 13+S 0 (13)...<br />
c 21=m 21+S 0 (21)<br />
Ciò consente al cr<strong>it</strong>tanalista di calcolare S 0 (12), S 0 (13),<br />
...S 0 (21) :<br />
S 0 (17)=a 0 S 0 (12)+a 1 S 0 (13)+a 2 S 0 (14)+a 3 S 0 (15)+a 4 S 0 (16)<br />
S 0 (18)=a 0 S 0 (13)+a 1 S 0 (14)+a 2 S 0 (15)+a 3 S 0 (16)+a 4 S 0 (17)<br />
S 0 (19)=a 0 S 0 (14)+...a 4 S 0 (18)<br />
S 0 (20)=a 0 S 0 (15)+...a 4 S 0 (19)<br />
S 0 (21)=a 0 S 0 (16)+...a 4 S 0 (20)<br />
Queste 5 equazioni lineari consentono di trovare i valori<br />
di a 0 , a 1 , a 2 , a 3 e a 4 . Il cr<strong>it</strong>tanalista è ormai in grado di calcolare<br />
anche S 0 (22), S 0 (23), e così via all'infin<strong>it</strong>o : il cifrario è ormai<br />
forzato.<br />
Tale metodo fu per la prima volta usato da Matsui e<br />
Yamagishi in un attacco al FEAL. Successivamente Matsui lo<br />
estese e migliorò per forzare il DES, e da allora fu assai<br />
studiato.<br />
Langford e Hellman introdussero un attacco chiamato<br />
cr<strong>it</strong>tanalisi lineare - differenziale, che combina elementi della<br />
cr<strong>it</strong>tanalisi differenziale con quelli della lineare.<br />
Nello stesso modo sono stati studiati metodi per<br />
proteggere i testi cifrati da tali tipi di attacchi, e tra i maggiori<br />
59
esponenti di tale ricerche, hanno voce in cap<strong>it</strong>olo Nyberg,<br />
Knudsen e O'Conner.<br />
3.6.3 Cr<strong>it</strong>toanalisi differenziale<br />
La cr<strong>it</strong>toanalisi differenziale è un tipo di attacco che può<br />
essere adoperato per forzare dei blocchi di cifre <strong>it</strong>erativi.<br />
Il metodo si basa sull'analisi delle differenze tra due testi<br />
in chiaro cifrati con la stessa chiave.<br />
L'utilizzo di questa tecnica, sebbene con un grande lavoro,<br />
ha portato gli studiosi Biham e Shamir al successo nella<br />
forzatura dell'algor<strong>it</strong>mo DES.<br />
3.6.4 Cr<strong>it</strong>toanalisi su polialfabetici<br />
Il metodo cr<strong>it</strong>tografico cosiddetto "Le Chiffre<br />
Indéciffrable" o meglio conosciuto con il nome di cifrario di<br />
Vigénére è stato utilizzato molto a lungo perché r<strong>it</strong>enuto<br />
inattaccabile (da cui il nome). In effetti è il precursore del<br />
metodo più affidabile in assoluto, l’ one-time pad (o più<br />
propriamente detto cifrario di Vernam), se non fosse che la<br />
chiave di cifratura può essere anche cortissima e non casuale,<br />
cosa che lo trasforma invece in un sistema attaccabile con i<br />
metodi elaborati dal Kasiski.<br />
abcdefghijklmnopqrstuvwxyz<br />
Più in particolare, analizzando una cifratura come la<br />
seguente con chiave "abc", si nota che:<br />
Chiaro: Ciao a tutti<br />
Chiave: abca b cabca<br />
Cifr. : Dldo c wvvwj<br />
La prima e la terza "t" della parola tutti è stata cr<strong>it</strong>tata<br />
con la stessa lettera perchè? Perchè nel testo in chiaro, le due<br />
"t" si sono trovate ad una distanza esatta alla lunghezza della<br />
password. Pensate che un cr<strong>it</strong>toanalista si lasci sfuggire un<br />
simile indizio? Sicuramente no, anzi, prenderebbe tale evento e<br />
lo confronterebbe con altri multipli o sottomultipli<br />
L'attacco alla Kasiski si basa proprio sull'osservazione che<br />
in un dato cifrato polialfabetico di questo tipo, si trovano<br />
spesso questi duplicati di cifratura a distanze precise.<br />
Individuando tutte le sequenze ripetute (e se ce ne sono<br />
già in questa frase di 3 parole possiamo immaginare che in un<br />
testo lungo ve ne saranno moltissime se la chiave è corta), il<br />
massimo comune divisore tra le distanze delle ripetizioni è la<br />
lunghezza della chiave o un suo multiplo. Trovata la lunghezza<br />
della chiave, la decr<strong>it</strong>tazione diventa semplice quanto un sistema<br />
monoalfabetico.<br />
La cr<strong>it</strong>tografia<br />
60
3.6.5 Brute force<br />
Il metodo di attacco Brute force (forza bruta), consiste<br />
nell'effettuazione di una ricerca esaustiva della chiave di<br />
decifrazione.<br />
Questo tipo di attacco è possibile solo oggi, grazie ai<br />
computer : sfruttando le loro caratteristiche di veloc<strong>it</strong>à<br />
nell'effettuazione di operazioni quali la composizione di<br />
stringhe alfanumeriche e la veloc<strong>it</strong>à di test dei risultati, è<br />
possibile provare milioni di combinazioni in qualche minuto e<br />
con macchine potenti ed ancora meglio con macchine<br />
specializzate (la NSA stessa costruisce processori), anche in<br />
frazioni di secondo.<br />
Come si realizza<br />
L'occorrente per un attacco di questo tipo, consiste in :<br />
1. un programma che il destinatario deve usare per<br />
decifrare (generalmente lo stesso programma<br />
utilizzato dal m<strong>it</strong>tente per cifrare);<br />
2. un generatore di password;<br />
3. un programma pilota del programma decifrante;<br />
4. un programma di test con dizionario.<br />
Il punto 1 è facile da realizzare : dall'estensione dei file o<br />
da altre caratteristiche è facile capire con quale dei programmi<br />
in commercio è stato realizzato un determinato file cifrato e<br />
procurarselo. Se non fosse possibile le cose si complicano<br />
notevolmente. Basandosi però sul fatto che anche il governo<br />
americano utilizza un programma con algor<strong>it</strong>mo pubblico, si<br />
presume che sia quasi sempre possibile entrare in possesso del<br />
programma cifrante/decifrante.<br />
I punti 2, 3 e 4, saranno funzioni di un unico programma<br />
che devono essere realizzati da un programmatore.<br />
Nello specifico, il generatore di password può tentare 2<br />
strade :<br />
1. la generazione di tutte le parole di un dato<br />
dizionario, se si presume che la password possa<br />
avere a che fare con qualche parola di senso<br />
compiuto (sebbene l'autore dovrebbe essere andato<br />
contro le regole del buon senso nella scelta della<br />
password);<br />
2. la generazione di password seguendo un ordine<br />
stabil<strong>it</strong>o (es. a, b,...z, aa, ab... az, aaa,aab...aaz, ecc.)<br />
Le password generate saranno introdotte nel programma di<br />
decr<strong>it</strong>tazione (o decifrante, ovvero quello del punto 1), dal<br />
programma pilota, che si occupa di passargli la stringa di<br />
caratteri generalmente chiamata password, come se venisse<br />
inser<strong>it</strong>a manualmente. L'operazione è semplicissima: sotto<br />
Windows, basta sfruttare l'automation, se forn<strong>it</strong>a dal programma<br />
decifratore, oppure l'emulazione di tastiera che è sempre<br />
La cr<strong>it</strong>tografia<br />
61
La cr<strong>it</strong>tografia<br />
effettuabile, via software, o nel peggiore dei casi, via hardware<br />
attraverso altre macchine.<br />
Prima di tentare una nuova password, è necessario avere<br />
un feedback dei risultati, realizzabile dal programma del punto<br />
4, il quale analizzerà il file decifrato per vederne i risultati e<br />
ricercare almeno alcune parole nel dizionario per vedere se sono<br />
di senso compiuto. Dato che la maggior parte dei programmi di<br />
cr<strong>it</strong>tografia non eseguono la decr<strong>it</strong>tazione se la password<br />
inser<strong>it</strong>a non è corretta, il programma di test dovrà dare il<br />
consenso ad un nuovo tentativo di inserimento password qualora<br />
non trovi nessun file decifrato in output. Qualora sia stato<br />
creato dal programma di decifratura, dopo averlo analizzato si<br />
dovranno prendere 2 scelte :<br />
1. se viene trovata una o più parole di senso compiuto,<br />
deve interrompere tutte le operazioni e mostrare<br />
l'ultima password provata.<br />
2. se non viene trovata alcuna parola di senso<br />
compiuto, deve cancellare il file appena esaminato<br />
ed avviare un nuovo tentativo di inserimento<br />
password da parte del programma (o funzione)<br />
pilota.<br />
Il dizionario che viene sfruttato dal programma di test<br />
(quello che genera quindi il feedback per il programma pilota),<br />
dovrà contenere le parole più comuni della lingua che si<br />
presume sia stata utilizzata, e sarà realizzato con un database<br />
indicizzato, oppure da un file di testo da caricare completamente<br />
in memoria per una più veloce operazione di ricerca. Tenere<br />
presente che tale dizionario potrebbe comunque essere<br />
composto anche solo da quelle congiunzioni, preposizioni, verbi<br />
ecc., onnipresenti in un testo. Può quindi essere sufficiente<br />
utilizzare un piccolo dizionario contenente parole formate da un<br />
minimo 3 caratteri (per ev<strong>it</strong>are interpretazioni di successo<br />
errate, dovute al caso), come "dal", "che", "degli", "gli",<br />
"anche", "per", "non", "essere", "avere", "fare", ecc.<br />
Il sistema sopra esposto è specifico per i testi, ma può<br />
andare bene anche per la decr<strong>it</strong>tazione di programmi eseguibili<br />
(software), dato che le interfacce utente dei programmi,<br />
contengono sempre parole del linguaggio parlato.<br />
Per la decr<strong>it</strong>tazione di programmi eseguibili possono<br />
tuttavia essere utilizzati particolari accorgimenti, tanto per<br />
c<strong>it</strong>arne uno, controllare solo i primi due byte del file decifrato,<br />
verificando che contengano il valore esadecimale 4D-5A,<br />
velocizzando le operazioni che in questo modo non necess<strong>it</strong>ano<br />
neanche più del dizionario.<br />
3.7 Curios<strong>it</strong>à e considerazioni<br />
Quanto potente deve essere un metodo cr<strong>it</strong>tografico per<br />
stare tranquilli?<br />
62
A questa domanda si può rispondere in due modi: la<br />
risposta più ovvia sarebbe: "Più si va sul sicuro, meglio è".<br />
D'altro canto, si potrebbe rispondere anche in maniera più<br />
tecnica: "Il fine della cr<strong>it</strong>tografia, non è sempre quello di<br />
rendere assolutamente impossibile la decifrazione, quanto quello<br />
di proteggere nella misura in cui la decifrazione richiede più<br />
tempo e risorse economiche del vantaggio che può portare la<br />
conoscenza delle informazioni protette".<br />
Se qualche secolo fa, un qualsiasi polialfabetico con<br />
chiave di 4 cifre sarebbe stato considerato impossibile da<br />
forzare, oggi c'è invece da preoccuparsi anche dei semplici<br />
attacchi a forza bruta possibili solo grazie ai computer. In altre<br />
parole, la sicurezza di un sistema cr<strong>it</strong>tografico deve aumentare<br />
col passare del tempo. Se oggi utilizzassimo ancora un sistema<br />
come il cifrario di Cesare, anche un ragazzino sarebbe in grado<br />
di decifrare un messaggio ed il più lento dei computers (anche<br />
uno dei primi 8086 o un 286) potrebbe trovare la soluzione in<br />
qualche frazione di millesimo di secondo.<br />
Fra una decina di anni, programmi ed algor<strong>it</strong>mi famosi<br />
potranno essere forzati col semplice brute -force, grazie ai<br />
miliardi di operazioni al secondo che già adesso alcuni PC sono<br />
in grado di compiere. C’è chi dice che in ambiente Echelon la<br />
cr<strong>it</strong>tografia DES ed altre a 64 b<strong>it</strong> siano decr<strong>it</strong>tate in tempo<br />
reale...<br />
La cr<strong>it</strong>tografia<br />
63
Cap<strong>it</strong>olo 4<br />
Esempi pratici<br />
4.1 L’uso di Winsock<br />
4.1.1 Struttura dell’applicazione<br />
4.1.2 Implementazione dell’applicazione<br />
4.2 Il DES<br />
4.2.1 La classe CDes<br />
4.3 Scambio di messaggi cr<strong>it</strong>tati<br />
4.3.1 Struttura dell’applicazione<br />
4.3.2 Implementazione dell’applicazione<br />
4.4 L’ analisi di un testo<br />
4.4.1 Struttura dell’applicazione<br />
4.4.2 Implementazione dell’applicazione<br />
4.5 I socket in Linux<br />
4.5.1 Implementazione dell’applicazione<br />
4.6 PGP<br />
4.1 L’uso di Winsock<br />
Questa applicazione sarà la base per creare un programma<br />
che permetta l’invio di file cr<strong>it</strong>tati tra due terminali.<br />
In particolare verranno usate le librerie Winsock che<br />
forniscono gli strumenti necessarie per creare comunicazioni<br />
tram<strong>it</strong>e il protocollo TCP/IP.<br />
Le API (Application Program Interface) Winsock sono<br />
state programmate per fornire un’interfaccia uniforme per<br />
l’esecuzione delle applicazioni di rete, indipendentemente dal<br />
software di rete utilizzato.<br />
4.1.1 Struttura dell’applicazione<br />
L’applicazione è strutturata a finestre di dialogo. Ovvero<br />
vi è la completa assenza di menu e barre di comando, questo per<br />
rendere più pul<strong>it</strong>a e semplice l’interfaccia e anche perché non se<br />
ne è resa necessaria l’inclusione nel progetto.<br />
L’interfaccia offre la possibil<strong>it</strong>à di dig<strong>it</strong>are l’indirizzo del<br />
server con cui comunicare (può anche essere un server di<br />
loopback, cioè la macchina stessa) e la porta da cui effettuare la<br />
scelta. Fatto questo basta cliccare sul pulsante Connect (Listen<br />
se è un server) per cominciare la comunicazione.<br />
Per quanto riguarda il funzionamento dell’applicazione ci<br />
sono due modi principali : client e server.<br />
Esempi pratici<br />
64
Quando l’applicazione lavora come server essa si mette in<br />
ascolto di eventuali richieste da parte del client, mentre quando<br />
è in modo client l’applicazione dovrà attendere che il server si<br />
metta in ascolto per iniziare a comunicare.<br />
Tipo socket (client,server)<br />
Indirizzo server e n° porta<br />
Testo del<br />
messaggio<br />
Figura 4.1 : Schema dell’applicazione PTerminal.<br />
Messaggi inviati<br />
Messaggi ricevuti<br />
Apertura,<br />
chiusura<br />
connessione<br />
Invia messaggio<br />
Indirizzo server e numero porta<br />
Questi due campi sono riservati all’inserimento<br />
dell’indirizzo del server e il numero della porta a cui ci si vuole<br />
collegare o da cui ci si vuole mettere in ascolto, nel caso si sia<br />
client o server. È indispensabile completare entrambe i campi<br />
per aprire un socket.<br />
Tipo socket<br />
Queste due opzioni servono per scegliere se l’applicazione<br />
deve fare da server o da client. A seconda della scelta il<br />
comportamento dell’applicazione varierà.<br />
Apertura, chiusura connessione<br />
Questi due pulsanti permettono di creare la connessione e<br />
di abbatterla. Nel caso il computer è stato configurato come<br />
server il pulsante Connect diventa Listen, per sottolineare il<br />
fatto che l’applicazione, da quel momento, si metterà in ascolto<br />
di eventuali richieste da parte di un client.<br />
Testo del messaggio<br />
Questo campo è riservato al testo del messaggio. Sia il<br />
client che il server possono ricevere e mandare messaggi.<br />
Esempi pratici<br />
65
Invia messaggio<br />
Questo pulsante permette di inviare il messaggio scr<strong>it</strong>to<br />
nel campo testo del messaggio. Nel caso in cui il campo sia<br />
vuoto non verrà inviato nulla.<br />
Messaggi inviati, messaggi ricevuti<br />
In queste due finestre viene tenuto l’ordine di ricezione e<br />
di spedizione dei messaggi.<br />
4.1.2 Implementazione dell’applicazione<br />
Come accennato in precedenza per la realizzazione<br />
dell’applicazione sono state utilizzate le API Winsock. Di<br />
segu<strong>it</strong>o è riportata una breve descrizione dei metodi e degli<br />
eventi principali.<br />
Metodo Create<br />
Questo metodo prepara il socket per l’uso. La<br />
dichiarazione del metodo cambia a seconda che il computer sia<br />
client o server. Nel caso sia server occorre specificare anche<br />
l’indirizzo della porta in ascolto. Nel caso sia client non occorre<br />
specificare nessun parametro.<br />
Metodo Connect<br />
Questo metodo apre fisicamente la connessione. È<br />
utilizzata solamente dal lato client.<br />
Il client, per aprire la connessione, deve specificare il<br />
l’indirizzo IP del server e il numero della porta.<br />
Metodo Listen<br />
Questo metodo, utilizzato solamente dal lato server,<br />
abil<strong>it</strong>a il server a ricevere chiamate.<br />
Il metodo Listen non ha bisogno di parametri.<br />
Metodo Accept<br />
Questo metodo viene richiamato in segu<strong>it</strong>o all’evento<br />
OnAccept. Il socket in ascolto, all’arrivo della chiamata, creerà<br />
un ulteriore socket connesso all’altra applicazione. Per questo<br />
socket non bisognerà richiamare il metodo Create ma il metodo<br />
Accept.<br />
Il metodo Accept vuole come parametro la variabile<br />
associata all’altra applicazione.<br />
Metodo Send<br />
Questa prim<strong>it</strong>iva permette l’invio dei messaggi attraverso<br />
una connessione via socket. Il metodo è identico per il client e<br />
per il server.<br />
I parametri indispensabili sono un puntatore ad un buffer<br />
generico e la lunghezza dello stesso. Questi parametri sono<br />
indispensabili perché il socket non conosce il tipo di dati da<br />
inviare.<br />
Esempi pratici<br />
66
Metodo Receive<br />
Questa prim<strong>it</strong>iva viene attivata dall’evento OnReceive.<br />
Grazie all’evento il socket sa che ci sono messaggi in coda. I<br />
parametri sono i medesimi del metodo Send, un puntatore ad un<br />
buffer e la sua lunghezza.<br />
Metodo Close<br />
È comune al socket e al client. Non vuole nessun<br />
parametro, inoltre è anche l’unico metodo a non rest<strong>it</strong>uire un<br />
codice di errore.<br />
Esempi pratici<br />
Evento OnAccept<br />
Questo evento viene scatenato all’arrivo di una chiamata al<br />
socket in ascolto.<br />
Evento OnClose<br />
Questo evento viene scatenato all’arrivo di una<br />
segnalazione di chiusura (metodo Close) da parte di una delle<br />
due applicazioni.<br />
Evento OnConnect<br />
Questo evento viene scatenato in un socket per segnalare<br />
l’avvenuta connessione.<br />
Evento OnReceive<br />
Questo evento viene scatenato all’arrivo di un messaggio.<br />
Evento OnSend<br />
Questo evento è richiamato quando il socket è pronto a<br />
inviare dati.<br />
Di segu<strong>it</strong>o verrà descr<strong>it</strong>ta l’implementazione della classe<br />
per la gestione dei socket.<br />
La classe creata è stata derivata dalla classe MFC<br />
CAsyncSocket. In questo modo è possibile ered<strong>it</strong>are la gestione<br />
degli eventi dalla classe MFC personalizzando quelli interessati.<br />
class CMySocket : public CAsyncSocket<br />
{<br />
private:<br />
CDialog* m_pWnd;<br />
public:<br />
CMySocket();<br />
virtual ~CMySocket();<br />
SetParent (CDialog *pWnd);<br />
};<br />
virtual void OnAccept(int nErrorCode);<br />
virtual void OnConnect(int nErrorCode);<br />
virtual void OnReceive(int nErrorCode);<br />
67
Le variabili<br />
La variabile m_pWnd è un puntatore alla finestra di<br />
dialogo corrente.<br />
I metodi<br />
Funzione SetParent<br />
PROTOTIPO<br />
SetParent (CDialog *pWnd)<br />
INPUT<br />
pWnd puntatore ad una finestra di dialogo<br />
DESCRIZIONE<br />
La funzione setta la variabile privata m_pWnd con la<br />
variabile passata come parametro.<br />
Funzioni OnAccept, OnConnect, OnReceive<br />
PROTOTIPO<br />
virtual void Onxxxxx ( int nErrorCode )<br />
INPUT<br />
nErrorCode codice errore<br />
DESCRIZIONE<br />
Queste funzioni rispondo agli eventi di base della<br />
classe. Esse sono state derivate da quelle defin<strong>it</strong>e nella classe<br />
CAsyncSocket. La loro funzione è quella di richiamare i metodi<br />
standard della classe per soddisfare le richieste dei socket.<br />
4.2 Il DES<br />
Il funzionamento del DES è stato ampiamente descr<strong>it</strong>to<br />
nel cap<strong>it</strong>olo precedente, di conseguenza, di segu<strong>it</strong>o, verrà<br />
analizzata l’implementazione in C. In particolare saranno<br />
esaminate le classi e i metodi utilizzati.<br />
Al termine, la classe creata, è stata inser<strong>it</strong>a in una DLL<br />
(Dynamic Linked Library) in modo da permetterne il<br />
funzionamento congiunto con altre applicazioni.<br />
Nel nostro caso, la DLL, sarà usata insieme ad<br />
un’applicazione per l’invio di messaggi attraverso TCP/IP, in<br />
modo da rendere possibile lo scambio di messaggi cr<strong>it</strong>tati.<br />
4.2.1 La classe CDes<br />
La classe CDes contiene i metodi e le variabili che<br />
caratterizzano l’algor<strong>it</strong>mo DES.<br />
class CDes<br />
{<br />
public:<br />
CDes();<br />
virtual ~CDes();<br />
Esempi pratici<br />
68
void Crypt(LPTSTR Key, LPTSTR Data);<br />
void Decrypt(LPTSTR Key, LPTSTR Data);<br />
private:<br />
unsigned _int64 artoi(unsigned int *array,unsigned int length);<br />
void <strong>it</strong>oar(unsigned __int64 int64,unsigned int *array,unsigned int length);<br />
unsigned _int64 stoi(char *string,unsigned int length);<br />
void matoar32(unsigned int matrix[][4],unsigned int array[],unsigned int yStart,unsigned int<br />
xStart,unsigned int yEnd,unsigned int xEnd);<br />
void matoar48(unsigned int matrix[][6],unsigned int array[],unsigned int yStart,unsigned int<br />
xStart,unsigned int yEnd,unsigned int xEnd);<br />
void matoar56(unsigned int matrix[][7],unsigned int array[],unsigned int yStart,unsigned int<br />
xStart,unsigned int yEnd,unsigned int xEnd);<br />
void matoar64(unsigned int matrix[][8],unsigned int array[],unsigned int yStart,unsigned int<br />
xStart,unsigned int yEnd,unsigned int xEnd);<br />
};<br />
Esempi pratici<br />
void _strcat(char *strDest,char *strOr);<br />
void arcat(unsigned int *arrayOr1,unsigned int *arrayOr2,unsigned int *arrayDest,unsigned int<br />
lenDest,unsigned int lenOr);<br />
unsigned _int64 power(unsigned int b,unsigned int e);<br />
void shift(unsigned __int64 &shift,unsigned int nShift);<br />
void Calculate_Keys(unsigned int matrix[][7],unsigned int <strong>it</strong>erations);<br />
unsigned __int64 crypt(unsigned __int64 data,unsigned int <strong>it</strong>erations);<br />
unsigned __int64 crypt(unsigned __int64 data,unsigned int <strong>it</strong>erations);<br />
void Divide(unsigned int *array,unsigned int matrix[][6],unsigned int lenAr,unsigned int<br />
lenGrp);<br />
unsigned int Index(unsigned matDiv[][6],unsigned matrix[][16],unsigned row);<br />
void Group(unsigned int *array,unsigned int *arrGrp,unsigned int lenAr,unsigned int lenGrp);<br />
void Expand(unsigned int *array,unsigned int matrix[][6]);<br />
void Permute_IP(unsigned int *array,unsigned int matrix[][8]);<br />
void Permute_P2(unsigned int *array,unsigned int matrix[][4]);<br />
void Permute_FP(unsigned int *array,unsigned int matrix[][8]);<br />
void Reduce56to48(unsigned int *array,unsigned int matrix[][6]);<br />
void Reduce64to56(unsigned int *array,unsigned int matrix[][7]);<br />
void Set_Key(unsigned __int64 newKey);<br />
unsigned EX[8][6];<br />
unsigned FP[8][8];<br />
unsigned IP[8][8];<br />
unsigned __int64 Keys_Array[16];<br />
unsigned __int64 L[17];<br />
unsigned P1[8][6];<br />
unsigned P2[8][4];<br />
unsigned __int64 R[17];<br />
unsigned Rotation_Array[16];<br />
unsigned R1[8][7];<br />
unsigned S1[4][16];<br />
unsigned S2[4][16];<br />
unsigned S3[4][16];<br />
unsigned S4[4][16];<br />
unsigned S5[4][16];<br />
unsigned S6[4][16];<br />
unsigned S7[4][16];<br />
unsigned S8[4][16];<br />
unsigned _int64 Key;<br />
69
I metodi e le variabili della classe sono dichiarati tutti<br />
privati, ad eccezione dei due metodi che permettono la cifratura<br />
e la decifratura dei dati. Questo è stato fatto per ev<strong>it</strong>are che ci<br />
possa essere un “furto” di dati dall’ esterno.<br />
Le variabili<br />
Le variabili EX, FP, IP, P1, P2, R1 e Sx sono matrici<br />
predefin<strong>it</strong>e che servono nello sviluppo dell’algor<strong>it</strong>mo per<br />
calcolare sia le 16 chiavi che la cifratura del blocco dati.<br />
La variabile Rotation_Array è un array contenente il<br />
numero di rotazioni da effettuare per ogni <strong>it</strong>erazione.<br />
La variabile Keys_Array è un array che contiene le 16<br />
chiavi di sovracifratura da applicare al blocco dati.<br />
Le variabili L e R sono matrici che contengono gli sviluppi<br />
dei 16 passi di cifratura.<br />
La variabile Key contiene la chiave di cifratura.<br />
I metodi<br />
Funzione Calculate_Keys<br />
PROTOTIPO<br />
void Calculate_Keys(unsigned int matrix[][7],<br />
unsigned int <strong>it</strong>erations)<br />
INPUT<br />
matrix[][7] matrice ridotta<br />
<strong>it</strong>erations <strong>it</strong>erazioni<br />
DESCRIZIONE<br />
La funzione calcola le chiavi usate per la cr<strong>it</strong>tazione. Il<br />
numero di chiavi da calcolare è defin<strong>it</strong>o dalla variabile<br />
<strong>it</strong>erations.<br />
Funzione crypt<br />
PROTOTIPO<br />
unsigned __int64 crypt(unsigned __int64 data,<br />
unsigned int <strong>it</strong>erations)<br />
INPUT<br />
data dati da cifrare<br />
<strong>it</strong>erations <strong>it</strong>erazioni<br />
OUTPUT<br />
iRes dati cifrati<br />
DESCRIZIONE<br />
La funzione cr<strong>it</strong>ta il dato passato. La variabile <strong>it</strong>erations<br />
indica, implic<strong>it</strong>amente, il numero di chiavi da usare per la<br />
cifratura.<br />
Funzione decrypt<br />
PROTOTIPO<br />
unsigned __int64 decrypt(unsigned __int64 data,<br />
unsigned int <strong>it</strong>erations)<br />
Esempi pratici<br />
70
INPUT<br />
data dati da decifrare<br />
<strong>it</strong>erations <strong>it</strong>erazioni<br />
OUTPUT<br />
iRes dati decifrati<br />
DESCRIZIONE<br />
La funzione decr<strong>it</strong>ta il dato passato. La variabile<br />
<strong>it</strong>erations indica, implic<strong>it</strong>amente, il numero di chiavi da usare<br />
per la decifratura.<br />
Funzione artoi<br />
PROTOTIPO<br />
unsigned __int64 artoi(unsigned int *array,<br />
unsigned int length)<br />
INPUT<br />
array array da convertire<br />
length lunghezza dell'array<br />
OUTPUT<br />
iRes array convert<strong>it</strong>o<br />
DESCRIZIONE<br />
La funzione converte un array binario (composto da 0 o 1)<br />
in un intero a 64 b<strong>it</strong>. La funzione non effettua nessun controllo<br />
sulla lunghezza dell'array, ma è implic<strong>it</strong>o che esso non debba<br />
superare i 64 byte. Di conseguenza ogni controllo deve essere<br />
effettuato prima della chiamata alla funzione.<br />
Funzione <strong>it</strong>oar<br />
PROTOTIPO<br />
void <strong>it</strong>oar(unsigned __int64 int64, unsigned int *array,<br />
unsigned int length)<br />
INPUT<br />
int64 intero da convetire<br />
array array in cui inserire l'intero convert<strong>it</strong>o<br />
length lunghezza dell'array<br />
DESCRIZIONE<br />
La funzione converte un intero fino a 64 b<strong>it</strong> in un array<br />
binario (composto da 0 e 1). La funzione non effettua nessun<br />
controllo sulla lunghezza dell'array, ma è implic<strong>it</strong>o che esso<br />
debba essere lungo tanto quanto la variabile da convertire e<br />
non più del tipo più grande (unsigned __int64). Di conseguenza<br />
ogni controllo deve essere effettuato prima della chiamata alla<br />
funzione.<br />
Funzione stoi<br />
PROTOTIPO<br />
void stoi(char *string, unsigned int length)<br />
INPUT<br />
string stringa da convertire<br />
length lunghezza della stringa<br />
OUTPUT<br />
iRes stringa convert<strong>it</strong>a<br />
Esempi pratici<br />
71
Esempi pratici<br />
DESCRIZIONE<br />
La funzione converte una stringa in un intero a 64 b<strong>it</strong>. La<br />
funzione non effettua nessun controllo sulla lunghezza della<br />
stringa, ma è implic<strong>it</strong>o che essa non debba superare i 64 byte. Di<br />
conseguenza ogni controllo deve essere effettuato prima della<br />
chiamata alla funzione.<br />
Funzioni matoarXX<br />
PROTOTIPO<br />
void matoarXX(unsigned int matrix[][X],<br />
unsigned int *array,<br />
unsigned int yStart,<br />
unsigned int xStart,<br />
unsigned int yEnd,<br />
unsigned int xEnd)<br />
INPUT<br />
matrix[][x] matrice da convertire<br />
array array risultato<br />
yStart riga di partenza<br />
xStart colonna di partenza<br />
yEnd riga di arrivo<br />
xEnd colonna di arrivo<br />
DESCRIZIONE<br />
Le funzioni convertono una matrice di n righe e m<br />
colonne, in un array pari alla loro dimensione.<br />
I parametri indicano implic<strong>it</strong>amente il numero di elementi<br />
da estrarre dalla matrice.<br />
La funzione non effettua nessun controllo sulla lunghezza<br />
dell' array che deve essere di lunghezza minima pari alla<br />
grandezza della matrice. Di conseguenza ogni controllo deve<br />
essere effettuato prima della chiamata alla funzione.<br />
Funzione power<br />
PROTOTIPO<br />
unsigned __int64 power(unsigned int b, unsigned int e)<br />
INPUT<br />
b base<br />
e esponente<br />
OUTPUT<br />
x risultato<br />
DESCRIZIONE<br />
La funzione calcola l'elevamento a potenza. Sia la base che<br />
l'esponente devono essere non negativi.<br />
Funzione shift<br />
PROTOTIPO<br />
void shift(unsigned __int64 &shift,<br />
unsigned int nShift)<br />
INPUT<br />
Shift valore da shiftare<br />
nShift numero di shift (1 o 2)<br />
72
OUTPUT<br />
shift valore shiftato<br />
DESCRIZIONE<br />
La funzione simula uno shift circolare supponendo che<br />
l'intero passato come parametro sia di soli 6 b<strong>it</strong>.<br />
Funzione arcat<br />
PROTOTIPO<br />
void arcat(unsigned int *arrayOr1,<br />
unsigned int *arrayOr2,<br />
unsigned int *arrayDest,<br />
unsigned int lenOr1, unsigned int lenOr2)<br />
INPUT<br />
arrayOr1 primo array da concatenare<br />
arrayOr2 secondo array da concatenare<br />
arrayDest array risultato<br />
lenOr1 lunghezza del primo array<br />
lenOr2 lunghezza del secondo array<br />
DESCRIZIONE<br />
La funzione concatena due array della lunghezza<br />
specificata dai parametri lenOr1 e lenOr2. La funzione non<br />
effettua il controllo sulla lunghezza degli array, di conseguenza<br />
tutti i controlli devono essere fatti prima della chiamata alla<br />
funzione.<br />
Funzione _strcat<br />
PROTOTIPO<br />
void _strcat(char *strDest, char *strOr)<br />
INPUT<br />
strDest stringa destinazione<br />
strOr stringa d'origine<br />
DESCRIZIONE<br />
La funzione concatena due stringhe. La stringa risultante<br />
sarà contenuta in strDest, inoltre essa sarà del tipo nullterminated.<br />
Funzioni di riduzione, espansione e permutazione<br />
PROTOTIPO<br />
void NOME_FUNZIONE(unsigned int *array,<br />
unsigned int matrix[][x])<br />
INPUT<br />
array array a cui applicare la matrice<br />
matrix[][x] matrice risultante<br />
DESCRIZIONE<br />
Le funzioni applicano la matrice specificata, costruendone<br />
una risultante dall'operazione. Le funzioni seguono lo stesso<br />
principio di funzionamento, cambia solo la matrice applicata (le<br />
matrici si differenziano, oltre che per i valori, anche per la<br />
grandezza).<br />
Di segu<strong>it</strong>o sono riassunte le funzioni con le matrici applicate.<br />
Reduce56to48 P1 = prima matrice di permutazione<br />
Reduce64to56 R1 = matrice di riduzione<br />
Esempi pratici<br />
73
Permute_IP IP = matrice di permutazione iniziale<br />
Permute_P2 P2 = seconda matrice di permutazione<br />
Permute_FP FP = matrice di permutazione finale<br />
Expand EX = matrice di espansione<br />
Funzione Divide<br />
PROTOTIPO<br />
void Divide(unsigned int *array,<br />
unsigned int matrix[][6],<br />
unsigned int lenAr,<br />
unsigned int lenGrp)<br />
INPUT<br />
array array da dividere<br />
matrix matrice risultato<br />
lenAr lunghezza array<br />
lenGrp lunghezza gruppo<br />
DESCRIZIONE<br />
La funzione divide un array in gruppi della lunghezza<br />
specificata dalla variabile lenGrp. La massima grandezza<br />
dell'array è di 48 byte, di conseguenza la grandezza massima<br />
della matrice sarà 8*6. La funzione non effettua nessun<br />
controllo sulla lunghezza dell'array e sulla grandezza della<br />
matrice. Di conseguenza ogni controllo deve essere fatto prima<br />
della chiamata alla funzione.<br />
Funzione Group<br />
PROTOTIPO<br />
void Group(unsigned int *array,<br />
unsigned int *arrayGrp,<br />
unsigned int lenAr,<br />
unsigned int lenGrp)<br />
INPUT<br />
array array da raggruppare<br />
arrayGrp array risultato<br />
lenAr lunghezza array<br />
lenGrp lunghezza dei gruppi<br />
DESCRIZIONE<br />
La funzione unisce un array di interi (NON binario) in un<br />
unico array. La lunghezza dell'array e quella dei gruppi di b<strong>it</strong><br />
viene passata come parametro.<br />
Funzione Index<br />
PROTOTIPO<br />
unsigned Index(unsigned int matDiv[][6],<br />
unsigned int matrix[][6],<br />
unsigned row)<br />
INPUT<br />
matDiv[][6] matrice da indicizzare<br />
matrix matrice da cui estrarre i dati<br />
row riga della matrice da indicizzare<br />
OUTPUT<br />
iRes risultato<br />
Esempi pratici<br />
74
DESCRIZIONE<br />
La funzione preleva dalla matrice matDiv il valore binario<br />
e lo converte in modo da comporre le coordinate di ricerca (m =<br />
colonna, n = riga). L'intero risultato della ricerca verrà<br />
rest<strong>it</strong>u<strong>it</strong>o.<br />
Funzione Set_Key<br />
PROTOTIPO<br />
void Set_Key(unsigned __int64 newKey)<br />
INPUT<br />
newKey nuova chiave<br />
DESCRIZIONE<br />
Funzione di interfaccia che setta la chiave.<br />
Funzioni Crypt e Decrypt<br />
PROTOTIPI<br />
void Crypt(LPTSTR Key, LPTSTR Data)<br />
void Decrypt(LPTSTR Key, LPTSTR Data)<br />
INPUT<br />
key chiave<br />
data dati da elaborare<br />
DESCRIZIONE<br />
Le funzioni sono i metodi principali della classe, servono<br />
per cr<strong>it</strong>tare e decr<strong>it</strong>tare i dati.<br />
Il loro funzionamento è analogo, infatti la funzione<br />
Decrypt non fa che ripercorrere i passi della funzione Crypt al<br />
contrario.<br />
Ambedue le funzioni dividono i dati passati come stringhe<br />
in gruppi di 8 byte, in segu<strong>it</strong>o, il gruppo appena ottenuto, viene<br />
cr<strong>it</strong>tato usando le 16 chavi precedentemente calcolate. I risultati<br />
vengono concatenati in un’ unica stringa e copiati nella stringa<br />
Data.<br />
4.3 Scambio di messaggi cr<strong>it</strong>tati<br />
Esempi pratici<br />
L’applicazione unisce l’uso di WinSock con la DLL<br />
costru<strong>it</strong>a in precedenza per l’uso del DES.<br />
Attraverso questa applicazione sarà possibile mandare dei<br />
messaggi cr<strong>it</strong>tati attraverso l’algor<strong>it</strong>mo DES, tra un client e un<br />
server.<br />
Le finestre di dialogo dell’applicazione sono le medesime<br />
usate per l’applicazione PTerminal. Quindi sarà possibile<br />
scegliere la porta da cui effettuare lo scambio di informazioni e<br />
chi sarà il server e chi il client.<br />
La cr<strong>it</strong>tazione del messaggio avverrà in trasparenza, infatti<br />
il messaggio inser<strong>it</strong>o dall’utente verrà cr<strong>it</strong>tato prima dell’invio e,<br />
di conseguenza, decr<strong>it</strong>tato prima della visualizzazione che<br />
avverrà sul computer del secondo utente.<br />
La chiave dovrà essere già concordata in precedenza tra gli<br />
utenti.<br />
75
4.3.1 Struttura dell’applicazione<br />
La struttura dell’applicazione è identica a quella di<br />
PTerminal.<br />
Figura 4.2 : Schema dell’applicazione.<br />
Come si può notare l’applicazione è strutturata in modo<br />
compatto. Non sono presenti menu ma solo un gruppo di Radio<br />
Button per decidere quale applicazione deve essere il server e<br />
quale il client.<br />
I tre Ed<strong>it</strong> Box servono per inserire l’indirizzo del server e<br />
la porta a cui connettersi, l’ultimo serve per inserire i messaggi<br />
da inviare.<br />
I tre Command Button servono per aprire una<br />
connessione, chiuderla e per mandare il messaggio.<br />
Le due List Box servono per tenere traccia dei messaggi<br />
inviati e ricevuti.<br />
4.3.2 Implementazione dell’applicazione<br />
La realizzazione dell’applicazione ha richiesto<br />
l’implementazione di una sola classe, oltre a quella usata per il<br />
DES. Essa è stata derivata dalla classe CAsyncSocket delle MFC.<br />
Ciò è stato reso necessario per gestire alcuni eventi particolari<br />
all’interno della classe, come l’invio e la ricezione. A questa<br />
classe è stato dato il nome CMySocket.<br />
Esempi pratici<br />
76
Per l’aggiunta delle funzional<strong>it</strong>à di cr<strong>it</strong>tazione e<br />
decr<strong>it</strong>tazione all’applicazione è stata usata la DLL creata in<br />
precedenza. L’aggiunta al progetto della DLL CDes ha richiesto<br />
solamente la dichiarazione, all’interno della classe<br />
CPTerminalDlg, del file header relativo alla DLL e l’aggiunta al<br />
progetto, come nuova risorsa, del file LIB della DLL.<br />
L’unica modifica al codice di PTerminal è stata l’aggiunta<br />
di un oggetto CDes nella classe CPTerminalDlg. Inoltre sia in<br />
ricezione che in invio, la stringa di dati viene passata al metodo<br />
Decrypt o Crypt, in modo da cr<strong>it</strong>tare/decr<strong>it</strong>tare la stringa.<br />
Oggetti, variabili ed eventi<br />
I seguenti oggetti sono defin<strong>it</strong>i nel progetto, alcuni di essi<br />
hanno associata una variabile.<br />
• IDC_RCLTSRV (Radio Button)<br />
VARIABILE int m_iType<br />
• IDC_LSENT (List Box)<br />
VARIABILE CListBox m_ctlSent<br />
• IDC_LRCVD (List Box)<br />
VARIABILE CListBox m_ctlRcvd<br />
• IDC_ESRVPORT (Ed<strong>it</strong> Box)<br />
VARIABILE int m_iPort<br />
• IDC_ESRVNAME (Ed<strong>it</strong> Box)<br />
VARIABILE CString m_strName<br />
• IDC_EMSG (Ed<strong>it</strong> Box)<br />
VARIABILE CString m_strMessage<br />
• IDC_BCONNECT (Command Button)<br />
VARIABILE CButton m_ctlConnect<br />
• IDC_BSEND (Command Button)<br />
• IDC_BCLOSE (Command Button)<br />
I pulsanti IDC_BSEND e ICD_BCONNECT sono collegati<br />
a due eventi della classe CPTerminalDlg, OnBSend e<br />
OnBConnect. Questi due eventi creano la connessione e inviano<br />
i messaggi. Per la ricezione dei messaggi si usa la funzione<br />
Receive che viene richiamata ogniqualvolta viene generato<br />
l’evento OnReceive.<br />
Tutti questi eventi sono stati già defin<strong>it</strong>i nelle classi<br />
CPTerminal e CMySocket nel progetto PTerminal.<br />
Esempi pratici<br />
77
4.4 Analisi di un testo<br />
In questa applicazione si cercherà di analizzare un testo<br />
cifrato e di decifrarlo senza avere la chiave. Per lo scopo si<br />
utilizzeranno tabelle contenenti le frequenze delle lettere della<br />
lingua <strong>it</strong>aliana. Riportando questi valori a quelli relativi alle<br />
lettere contenute nel testo si potrà ricavare il testo in chiaro.<br />
Inoltre l’applicazione, sviluppata in Visual Basic, permetterà<br />
l’uso di algor<strong>it</strong>mi di cifratura di base (cifrario di Cesare,<br />
scacchiera di Polibio, cifrario di Vigénère).<br />
4.4.1 Struttura dell’applicazione<br />
Esempi pratici<br />
L’applicazione è strutturata come una tipica applicazione<br />
MDI (Multiple Document Interface). Vi è una form principale<br />
contenente il menu delle opzioni e la barra di comando, in più vi<br />
sono due form secondarie, una usata per la visualizzazione e<br />
l’ed<strong>it</strong>azione del testo, mentre l’altra per visualizzare attraverso<br />
un grafico le frequenze delle lettere presenti nel testo.<br />
Barra di comando<br />
Barra dei menu<br />
Testo<br />
Grafico delle frequenze<br />
Barra di stato<br />
Figura 4.3 : Schema dell’applicazione cr<strong>it</strong>tografia.<br />
78
La barra dei menu<br />
La barra dei menu è cost<strong>it</strong>u<strong>it</strong>a da quattro voci principali :<br />
• File<br />
• Analizza<br />
• Cr<strong>it</strong>ta<br />
• Decr<strong>it</strong>ta<br />
Attraverso queste voci è possibile effettuare tutte le<br />
operazioni permesse dall’applicazione.<br />
Menu file<br />
Figura 4.4 : Menu file<br />
dell’applicazione Cr<strong>it</strong>tografia.<br />
Esempi pratici<br />
Dal menu file è possibile scegliere le seguenti opzioni :<br />
• Apri file in chiaro<br />
Questa opzione permette di aprire un file di<br />
qualsiasi estensione, visualizzandone il contenuto<br />
nella finestra di visualizzazione dei documenti.<br />
• Salva file in chiaro<br />
Questa opzione permette di salvare un file appena<br />
ed<strong>it</strong>ato senza applicare nessuna cr<strong>it</strong>tografia.<br />
Inoltre, se il file da salvare è un file cr<strong>it</strong>tato,<br />
l’applicazione lo decr<strong>it</strong>ta automaticamente e lo<br />
salva in un formato defin<strong>it</strong>o dall’utente (il formato<br />
di default è il txt).<br />
• Apri file cr<strong>it</strong>tato<br />
Questa opzione permette di aprire un file<br />
precedentemente cr<strong>it</strong>tato. I tre formati disponibili<br />
sono :<br />
o *.csr, cifrario di Cesare;<br />
o *.plb, scacchiera di Polibio;<br />
o *.vgn, cifrario di Vigénère.<br />
Il file decr<strong>it</strong>tato viene automaticamente<br />
visualizzato nella finestra di visualizzazione<br />
documenti.<br />
• Salva file cr<strong>it</strong>tato<br />
Questa opzione permette di salvare un testo<br />
oppure un file aperto in chiaro, usando uno dei tre<br />
algor<strong>it</strong>mi a disposizione (cifrario di Cesare,<br />
scacchiera di Polibio, cifrario di Vigénère).<br />
79
Menu analizza<br />
Questo menu non ha sottomenu. Se non è stato aperto<br />
nessun file, l’applicazione, chiede di aprirne uno e viene<br />
automaticamente visualizzato il grafico delle frequenze delle<br />
lettere. Al contrario, se un file è già stato aperto e nessun<br />
grafico è visualizzato a schermo, viene aperta una nuova finestra<br />
contenente il grafico della frequenza delle lettere.<br />
Menu cr<strong>it</strong>ta<br />
Dal menu cr<strong>it</strong>ta è possibile scegliere uno dei seguenti<br />
algor<strong>it</strong>mi di cr<strong>it</strong>tazione :<br />
• Cifrario di Cesare<br />
• Scacchiera di Polibio<br />
• Cifrario di Vigénère<br />
Scegliendo uno di questi algor<strong>it</strong>mi, il testo contenuto nella<br />
finestra di visualizzazione testo, viene cr<strong>it</strong>tato. Per salvarlo<br />
basta scegliere dal menu File Salva file cr<strong>it</strong>tato. In questo modo<br />
l’applicazione riconoscerà automaticamente l’algor<strong>it</strong>mo di<br />
cr<strong>it</strong>tazione utilizzato e di conseguenza salverà il file con<br />
l’estensione appropriata. L’utente dovrà solamente scegliere il<br />
nome da dare al file.<br />
Menu decr<strong>it</strong>ta<br />
Figura 4.5 : Menu cr<strong>it</strong>ta<br />
dell’applicazione<br />
Cr<strong>it</strong>tografia.<br />
Figura 4.6 : Menu<br />
decr<strong>it</strong>ta<br />
dell’applicazione<br />
Cr<strong>it</strong>tografia.<br />
Dal menu decr<strong>it</strong>ta è possibile scegliere l’algor<strong>it</strong>mo da<br />
utilizzare per decr<strong>it</strong>tare il file :<br />
• Cifrario di Cesare<br />
• Scacchiera di Polibio<br />
• Cifrario di Vigénère<br />
Scegliendo uno di questi algor<strong>it</strong>mi, il testo contenuto nella<br />
finestra di visualizzazione del testo, viene decr<strong>it</strong>tato. Come<br />
succede per la cr<strong>it</strong>tazione, se si vuole salvare il file appena<br />
decr<strong>it</strong>tato, basta selezionare dal menu File Salva file in chiaro.<br />
Così facendo, l’applicazione, salverà automaticamente il file nel<br />
formato prefer<strong>it</strong>o dall’utente.<br />
Esempi pratici<br />
80
La barra di comando<br />
Nuovo documento<br />
Apri file in chiaro<br />
La barra di comando riassume tutte le funzioni principali<br />
contenute nel menu file, con in più un ulteriore opzione, quella<br />
di creare un nuovo documento vuoto.<br />
La barra di stato<br />
La barra di stato contiene il percorso del file<br />
correntemente aperto.<br />
4.4.2 Implementazione dell’applicazione<br />
Le form<br />
Per realizzare l’applicazione sono state utilizzate tre form<br />
principali :<br />
• mdiMain<br />
• frmDoc<br />
• frmGraph<br />
La form principale è una form MDI, che può gestire un<br />
numero elevato di form figlie. In questo modo è possibile<br />
visualizzare più finestre documento o grafico<br />
contemporaneamente.<br />
Le altre due form sono dei modelli. Ogni qualvolta viene<br />
richiesto un nuovo documento o un nuovo grafico ne viene<br />
creata una nuova. Il metodo di creazione è il seguente :<br />
Dim nome_form as frmDoc (o frmGraph)<br />
Form mdiMain<br />
Apri file cr<strong>it</strong>tato<br />
Salva file in chiaro<br />
Salva file cr<strong>it</strong>tato<br />
Figura 4.8 : Barra di stato dell’applicazione Cr<strong>it</strong>tografia.<br />
Figura 4.7 : Barra di<br />
comando<br />
dell’applicazione<br />
Cr<strong>it</strong>tografia.<br />
Come detto in precedenza è la form principale. Essa<br />
contiene il menu, la barra di comando e quella di stato. In più<br />
permette la visualizzazione dei grafici e dei testi.<br />
Gli oggetti utilizzati al suo interno sono i seguenti :<br />
• tlbMain (Toolbar)<br />
Toolbar (barra di comando).<br />
Evento on-click.<br />
Esempi pratici<br />
81
• stbMain (StatusBar)<br />
Statusbar (barra di stato).<br />
• imlTlb (ImageList)<br />
Controllo che contiene le immagini delle icone<br />
presenti sulla barra di comando.<br />
• cdlSaveOpen (CommonDialog)<br />
Controllo che permette l’utilizzo delle finestre<br />
standard per il salvataggio e il caricamento dei<br />
file.<br />
Funzioni<br />
Le funzioni descr<strong>it</strong>te di segu<strong>it</strong>o sono quelle usate per il<br />
salvataggio, l’apertura e il calcolo delle frequenze delle lettere.<br />
Le funzioni relativi agli eventi non saranno descr<strong>it</strong>te.<br />
Funzione Scan<br />
PROTOTIPO<br />
Private Function Scan (strC as String) as Boolean<br />
INPUT<br />
strC carattere da cercare<br />
OUTPUT<br />
vero il carattere è stato trovato<br />
falso il carattere non è stato trovato<br />
DESCRIZIONE<br />
La funzione calcola la frequenza delle lettere nel testo,<br />
che verranno rappresentate nel grafico.<br />
Funzione OpenFile<br />
PROTOTIPO<br />
Private Function OpenFile (strFileToOpen as String)<br />
as String<br />
INPUT<br />
strFileToOpen percorso del file da aprire<br />
OUTPUT<br />
strFileOpen stringa contenente il file aperto<br />
DESCRIZIONE<br />
La funzione apre il file specificato dalla stringa<br />
strFileToOpen. Per gestire i file è stato usato l’oggetto<br />
FileSystemObject, il quale permette di creare dei file di testo. In<br />
questo modo sono disponibili dei metodi di lettura e scr<strong>it</strong>tura<br />
più veloci e più semplici da utilizzare.<br />
Funzione SaveFile<br />
PROTOTIPO<br />
Private Function SaveFile (strFileToSave as String,<br />
strFileSave as string)<br />
as Boolean<br />
INPUT<br />
strFileToSave percorso in cui salvare il file<br />
strFileSave stringa da salvare<br />
Esempi pratici<br />
82
OUTPUT<br />
vero il file è stato salvato<br />
falso il file non è stato salvato<br />
DESCRIZIONE<br />
La funzione salva la stringa passata su file. Anche in<br />
questo caso la gestione del file avviene attraverso l’oggetto<br />
FileSystemObject.<br />
Funzioni menu<br />
Queste funzioni vengono richiamate quando accade<br />
l’evento on_click su uno dei menu. Il loro comp<strong>it</strong>o è quello di<br />
richiamare le funzioni per la gestione dei file e per la cifratura e<br />
decifratura.<br />
Funzioni SaveCyph, OpenCyph, SaveClear, OpenClear<br />
Queste funzioni vengono utilizzate per impostare i filtri<br />
del CommonDialog e per scegliere che modal<strong>it</strong>à utilizzarlo<br />
(Open o Save).<br />
Form frmDoc<br />
Questa form è usata come modello per tutte quelle che<br />
verranno create per la visualizzazione dei documenti.<br />
Gli oggetti utilizzati all’interno sono i seguenti :<br />
• txtText (TextBox)<br />
TextBox utilizzata per la visualizzazione dei<br />
documenti.<br />
All’intero non sono state defin<strong>it</strong>e funzioni.<br />
L’unico evento a cui risponderà la form sarà l’evento<br />
Resize. In questo modo la TextBox manterrà dimensioni costanti<br />
anche dopo il ridimensionamento della form.<br />
Form frmGraph<br />
Questa form è usata come modello per tutti i grafici delle<br />
frequenze.<br />
Gli oggetti utilizzati all’interno sono i seguenti :<br />
• mscGraph (MSChart)<br />
Oggetto utilizzato per la creazione del grafico.<br />
Come nella precedente form, non sono state defin<strong>it</strong>e<br />
funzioni. Anche in questo caso la form risponderà all’evento<br />
Resize, in modo da mantenere la dimensione del grafico<br />
costante.<br />
Esempi pratici<br />
83
Modulo modIn<strong>it</strong><br />
Questo modulo contiene le inizializzazioni delle variabili,<br />
le variabili stesse e altre funzioni per il settaggio del<br />
CommonDialog.<br />
dati.<br />
Variabili<br />
Le variabili globali defin<strong>it</strong>e all’interno del modulo sono :<br />
• Public ALPHA(26) As String<br />
Array contenente le lettere dell’alfabeto più lo<br />
spazio.<br />
• Public ASCII(255, 1) As String<br />
Matrice contenente i 256 caratteri ASCII, ognuno<br />
dei quali associato ad una frequenza.<br />
• Public PLOT(26, 1)<br />
Matrice contenente le lettere dell’alfabeto più lo<br />
spazio. Ad ognuna di esse è associata una<br />
frequenza.<br />
• Public FREQ(26) As String<br />
Array contenente le lettere dell’alfabeto in ordine<br />
di frequenza rispetto alla lingua <strong>it</strong>aliana.<br />
• Public CaesarCyph As New Caesar<br />
• Public PolibioCyph As New Polibio<br />
• Public VigenereCyph As New Vigenere<br />
Oggetti usati per la cr<strong>it</strong>tazione e la decr<strong>it</strong>tazione.<br />
Funzioni<br />
Funzione In<strong>it</strong>VAR<br />
PROTOTIPO<br />
Public Sub In<strong>it</strong>VAR()<br />
DESCRIZIONE<br />
La funzione inizializza tutti gli array e le matrici con i<br />
Funzione Clear<br />
PROTOTIPO<br />
Public Sub Clear()<br />
DESCRIZIONE<br />
Azzerra l’array PLOT.<br />
Funzione In<strong>it</strong>CDL<br />
PROTOTIPO<br />
Public Sub In<strong>it</strong>CDL(CDL as CommonDialog,<br />
strExt as String, strT<strong>it</strong>le as String,<br />
strFilter as String,<br />
strIn<strong>it</strong>Dir as String,<br />
strOpenSave as String)<br />
INPUT<br />
CDL oggetto da settare<br />
Esempi pratici<br />
84
strExt estensione standard da dare ai file<br />
strT<strong>it</strong>le t<strong>it</strong>olo che apparirà nel CommonDialog<br />
strFilter possibili estensioni da dare al file<br />
strIn<strong>it</strong>Dir directory di default<br />
strOpenSave settaggio dei flags.<br />
DESCRIZIONE<br />
La funzione setta con i parametri passati il<br />
CommonDialog, anch’esso passato come parametro.<br />
Funzioni In<strong>it</strong>DOC e In<strong>it</strong>GRAPH<br />
PROTOTIPO<br />
Public Sub In<strong>it</strong>xxx(strFilename as String)<br />
INPUT<br />
strFilename nome del file che apparirà come t<strong>it</strong>olo<br />
della finestra<br />
DESCRIZIONE<br />
Queste due funzioni creano una nuova finestra<br />
documento e una nuova finestra grafico.<br />
Moduli di classe<br />
I moduli di classe contengono le definizioni delle classi<br />
usate per gli algor<strong>it</strong>mi di cr<strong>it</strong>tazione.<br />
Modulo Caesar<br />
Questo modulo contiene le definizioni dei metodi per la<br />
cifratura attraverso il cifrario di Cesare. La cr<strong>it</strong>tazione dei dati<br />
avviene utilizzando il codice ASCII e non l’alfabeto ordinario.<br />
Variabili<br />
L’unica variabile defin<strong>it</strong>a all’interno del modulo è la<br />
seguente :<br />
• Private Alphabet(255) as String<br />
Array contenente il codice ASCII.<br />
Funzioni<br />
Funzioni Crypt e Decrypt<br />
PROTOTIPI<br />
Public Function (De)Crypt(iSph as Integer,<br />
strCrypt as String) as String<br />
INPUT<br />
iSph lettere di sfasamento dell’alfabeto<br />
strCrpyt stringa da cr<strong>it</strong>tare<br />
OUTPUT<br />
strCrypted stringa cr<strong>it</strong>tata<br />
DESCRIZIONE<br />
Queste due funzioni cr<strong>it</strong>tano e decr<strong>it</strong>tano la stringa<br />
passata.<br />
Esempi pratici<br />
85
Funzione Find<br />
PROTOTIPO<br />
Private Function Find(vChar as Variant) as Integer<br />
INPUT<br />
vChar carattere da cercare<br />
OUTPUT<br />
i posizione del carattere nell’array<br />
Alphabet<br />
DESCRIZIONE<br />
Questa funzione cerca nell’array Alphabet il carattere<br />
passato come parametro.<br />
Modulo Polibio<br />
Questo modulo contiene le definizioni dei metodi per<br />
applicare la scacchiera di Polibio. Anche in questo caso la<br />
cr<strong>it</strong>tazione viene effettuata sull’intero codice ASCII.<br />
Variabili<br />
L’unica variabile defin<strong>it</strong>a all’interno del modulo è la<br />
seguente :<br />
• Private Alphabet(15, 15) as String<br />
Matrice contenente il codice ASCII.<br />
Funzioni<br />
Funzioni Crypt e Decrypt<br />
PROTOTIPO<br />
Public Function (De)Crypt(strCrypt as String) as String<br />
INPUT<br />
strCrypt stringa da cr<strong>it</strong>tare<br />
OUTPUT<br />
strCrypted stringa cr<strong>it</strong>tata<br />
DESCRIZIONE<br />
Queste due funzioni cr<strong>it</strong>tano e decr<strong>it</strong>tano la stringa<br />
passata come parametro. In questo caso il risultato della<br />
cr<strong>it</strong>tazione non sarà una stringa alfabetica ma una stringa<br />
alfanumerica. Infatti viene usato il codice esadecimale per<br />
definire le righe e le colonne.<br />
Funzione Find<br />
PROTOTIPO<br />
Private Sub Find(vChar as Variant, ByRef iY as Integer,<br />
ByRef iX as Integer)<br />
INPUT<br />
vChar carattere da cercare<br />
OUTPUT<br />
iY, iX colonna e riga in cui si trova il<br />
carattere<br />
Esempi pratici<br />
86
Esempi pratici<br />
DESCRIZIONE<br />
La funzione cerca nella matrice Alphabet il carattere<br />
passato e r<strong>it</strong>orna il valore di riga e colonna nelle due variabili iY<br />
e iX.<br />
Modulo Vigénère<br />
Questo modulo contiene le definizioni dei metodi per<br />
applicare il cifrario di Vigénère. Anche in questo caso il la<br />
cr<strong>it</strong>tazione è effettuata sull’intero codice ASCII.<br />
Nel cifrario di Vigénère viene utilizzata anche una chiave<br />
che in ogni cr<strong>it</strong>tazione/decr<strong>it</strong>tazione verrà richiesta<br />
dall’applicazione.<br />
Variabili<br />
L’unica variabile defin<strong>it</strong>a all’interno del modulo è la<br />
seguente :<br />
• Private Alphabet(15, 15) as String<br />
Matrice contenente il codice ASCII.<br />
Funzioni<br />
Funzioni Crypt e Decrypt<br />
PROTOTIPI<br />
Private Function (De)Crypt(strCrypt as String,<br />
strKey as String) as String<br />
INPUT<br />
strCrypt stringa da cr<strong>it</strong>tare<br />
strKey chiave<br />
OUTPUT<br />
strCrypted stringa cr<strong>it</strong>tata<br />
DESCRIZIONE<br />
Queste due funzioni cr<strong>it</strong>tano e decr<strong>it</strong>tano la stringa<br />
passata come parametro usando la chiave.<br />
Funzioni FindRow e FindCol<br />
PROTOTIPI<br />
Private Sub Findxxx(vChar as Variant, y as Integer<br />
x as Integer, ByRef iY as Integer<br />
ByRef iX as Integer)<br />
INPUT<br />
vChar carattere da cercare<br />
y,x colonna e riga di partenza<br />
OUTPUT<br />
iY,iX colonna e riga in cui si trova il<br />
carattere<br />
DESCRIZIONE<br />
Queste due funzioni cercano un carattere sulla linea e<br />
sulla colonna passate come parametro.<br />
87
4.5 I socket in Linux<br />
Esempi pratici<br />
Al fine di studiare più approfond<strong>it</strong>amente il protocollo<br />
TCP/IP è stato creato un programma che simula una trama del<br />
protocollo TCP/IP usato per la comunicazione tra le reti, sia<br />
locali che geografiche.<br />
Per poter gestire una trama TCP/IP, non è stato possibile<br />
usare un compilatore di Windows, poiché esso non permette la<br />
gestione a basso livello delle trame. Di conseguenza l’unico<br />
modo per controllare i flag del protocollo TCP/IP è stato creare<br />
un programma in C proprio del sistema operativo Linux. Infatti<br />
esso permette, tram<strong>it</strong>e l’uso dei socket raw, l’uso di funzioni che<br />
permettono la gestione diretta delle trame di ricezione e invio.<br />
Nel programma si è voluto simulare l’invio di una trama di<br />
fine connessione, ossia con il F<strong>LA</strong>G di FIN =1.<br />
All’inizio il programma crea l’header dell’IP ,<br />
successivamente realizza l’header del TCP della trama che si<br />
vuole inviare. Vengono inoltre calcolati i checksum del<br />
pacchetto IP e anche dell’header TCP.<br />
Parametri del programma<br />
Il programma richiede dei parametri in input:<br />
1. porta sorgente<br />
2. indirizzo sorgente<br />
3. porta destinazione<br />
4. indirizzo destinazione<br />
Senza questi parametri il programma non può funzionare,<br />
causando un segnale d’errore :<br />
“usare: porta_sorg. indirizzo sorg. porta dest. indirizzo<br />
sorg.”<br />
4.5.1 Implementazione dell’applicazione<br />
Di segu<strong>it</strong>o verranno descr<strong>it</strong>te le funzioni più importanti<br />
usate nel programma.<br />
Funzioni<br />
Funzione tcp_gen<br />
PROTOTIPO<br />
void tcp_gen(char *packet, unsigned short sport,<br />
unsigned short dport, unsigned long seq,<br />
unsigned long ack)<br />
INPUT<br />
packet puntatore alla struttura IP<br />
sport porta sorgente<br />
dport porta destinazione<br />
seq numero di sequenza<br />
ack acknowledge<br />
88
DESCRIZIONE<br />
È la routine che compone un pacchetto TCP compilando<br />
la struttura tcp contenuta nell'header del programma. Questa<br />
routine setta il b<strong>it</strong> di fin a 1 indicando la chiusura della<br />
connessione. Dopo aver compilato la struttura la routine<br />
calcola il checksum sul pacchetto tcp.<br />
Funzione ip_gen<br />
PROTOTIPO<br />
void ip_gen(char *packet,unsigned char protocol,<br />
struct in_addr saddr,<br />
struct in_addr daddr,<br />
unsigned short length<br />
INPUT<br />
packet pacchetto, rappresentato dal vettore<br />
protocol costante IPPROTO. Indica il<br />
protocollo di livello di trasporto per la<br />
compilazione della struttura IP<br />
saddr indirizzo sorgente<br />
daddr indirizzo destinazione<br />
length dimensione del pacchetto vettore<br />
DESCRIZIONE<br />
È la routine che compone l'header IP compilando la<br />
struttura tcp contenuta nell'header del programma.<br />
Dopo aver compilato la struttura la routine calcola il<br />
cheksum sul pacchetto IP.<br />
Esempi pratici<br />
Funzione trans_check<br />
PROTOTIPO<br />
unsigned short trans_check(unsigned char proto,<br />
char *packet, int length,<br />
struct in_addr source_address,<br />
struct in_addr dest_address)<br />
INPUT<br />
proto protocollo utilizzato<br />
packet puntatore della struttura del TCP<br />
header<br />
length lunghezza dell’header TCP<br />
source_address indirizzo sorgente<br />
dest_address indirizzo destinazione<br />
OUTPUT<br />
La funzione calcola il checksum sul TCP header, che<br />
non segue le gerarchie e sono inser<strong>it</strong>e nel suo calcolo anche<br />
gli indirizzi IP, che in realtà fanno parte del livello 3 (IP).<br />
DESCRIZIONE<br />
È la routine che compone un pacchetto TCP compilando<br />
la struttura tcp contenuta<br />
Funzione in_cksum<br />
PROTOTIPO<br />
unsigned short in_cksum(unsigned short *addr,int len)<br />
89
INPUT<br />
addr struttura su cui eseguire il checksu<br />
len lunghezza di tale struttura<br />
OUTPUT<br />
answer checksum<br />
DESCRIZIONE<br />
È la routine che contiene l'algor<strong>it</strong>mo per il calcolo del<br />
cheksum sui pacchetti TCP/IP. Questo algor<strong>it</strong>mo viene usato<br />
per scoprire errori generati da errori di memoria all'interno<br />
dei router. Per prima cosa il campo checksum viene posto a 0<br />
e il campo dati viene completato con uno 0 addizionale se la<br />
sua lunghezza è un numero dispari poi viene esegu<strong>it</strong>o<br />
l'algor<strong>it</strong>mo che consiste nel sommare tutte le parole di 16 b<strong>it</strong><br />
che arrivano usando l'ar<strong>it</strong>metica del complemento a 1 e quindi<br />
prendendo il complemento a 1 del risultato. Questo algor<strong>it</strong>mo<br />
del checksum è più potente e da quindi maggiore affidabil<strong>it</strong>à<br />
del normale checksum.<br />
4.6 PGP<br />
PGP (Pretty Good Privacy) è un programma di cr<strong>it</strong>tografia<br />
a chiave pubblica, che è diventato lo uno standard per l’utilizzo<br />
della cr<strong>it</strong>tografia nella posta elettronica.<br />
Esso si avvale dell’algor<strong>it</strong>mo RSA (descr<strong>it</strong>to in<br />
precedenza) per cr<strong>it</strong>tare i file.<br />
Con PGP è possibile codificare un messaggio in modo che<br />
solamente il destinatario possa leggerlo ma non una terza<br />
persona. Inoltre, è possibile autenticare il m<strong>it</strong>tente ed il<br />
messaggio.<br />
Questo risponde all’esigenza fondamentale di riservatezza<br />
e sicurezza della corrispondenza privata.<br />
La corrispondenza per posta elettronica ha da un lato<br />
innumerevoli vantaggi ma presenta intrinsecamente un basso<br />
grado di sicurezza. Ė infatti molto semplice per una terza<br />
persona andare a leggere messaggi privati destinati ad altri,<br />
oppure alterare un messaggio inviato da un altro, oppure ancora<br />
inviarne uno con il nome di un altro.<br />
L’utilizzo di PGP nella cr<strong>it</strong>tografia a chiave pubblica<br />
Il problema storico della cr<strong>it</strong>tografia classica si può<br />
riassumere in questo modo : per cifrare un messaggio si deve<br />
utilizzare una chiave (segreta) con cui effettuare la cifratura.<br />
La stessa chiave deve essere usata per decodificare il<br />
messaggio cifrato.<br />
Se ‘A’ vuole inviare il messaggio codificato al destinatario<br />
‘B’, ha il problema di fare avere a quest’ultimo la chiave segreta<br />
con la quale egli potrà decodificare il messaggio.<br />
Esempi pratici<br />
90
Esempi pratici<br />
Se però ‘B’ sta all’altro capo del mondo e non c’è un<br />
canale sicuro per trasmettere la chiave, questo sistema non può<br />
funzionare, perché la chiave può essere intercettata.<br />
Per esempio, se io non voglio che un messaggio e-mail sia<br />
letto da altri, sarebbe inutile codificarlo in modo convenzionale<br />
e poi inviare la chiave usata per la codifica ancora per e-mail.<br />
Il problema viene risolto brillantemente dalla cr<strong>it</strong>tografia a<br />
chiave pubblica, alla cui base sta un’idea semplice e geniale.<br />
Ogni utente genera, mediante una funzione di PGP, una<br />
coppia di chiavi.<br />
L’algor<strong>it</strong>mo matematico che effettua questa operazione è<br />
tale che :<br />
• un messaggio codificato con una chiave della coppia<br />
può essere decodificato solo con l’altra chiave della<br />
stessa coppia;<br />
• non è materialmente possibile, data una chiave della<br />
coppia, ricavare l'altra.<br />
Ogni utente tiene per sé una chiave della propria coppia,<br />
denominata chiave segreta, e diffonde il più possibile l’altra,<br />
denominata chiave pubblica.<br />
Questo risolve tutti i problemi posti sopra.<br />
Privacy<br />
‘A’ vuole inviare un messaggio a ‘B’, e codifica quel<br />
messaggio usando la chiave pubblica di quest’ultimo.<br />
Solo ‘B’, che ha la corrispondente chiave segreta, è in<br />
grado di decodificare e leggere il messaggio.<br />
Autenticazione del m<strong>it</strong>tente<br />
‘A’ codifica il suo messaggio con la propria chiave privata.<br />
Chiunque, avendo accesso alla chiave pubblica di ‘A’, può<br />
decodificare quel messaggio. Se la decodifica riesce, si è allora<br />
sicuri che esso è stato scr<strong>it</strong>to da ‘A’, l’unico a possedere la<br />
corrispondente chiave segreta.<br />
‘A’ ha posto la sua "firma" elettronica sul messaggio.<br />
Autenticazione del m<strong>it</strong>tente e del messaggio<br />
Ė possibile autenticare, facendo un passo in più, oltre al<br />
m<strong>it</strong>tente anche il contenuto del messaggio.<br />
‘A’ effettua un "hashing" del suo messaggio. Si tratta di<br />
una funzione unidirezionale, che a partire da un certo messaggio<br />
ricava un valore di lunghezza fissa, detto hash, che caratterizza<br />
il messaggio: una sorta di "checksum". Se il messaggio viene<br />
alterato, l'hash non corrisponde più.<br />
‘A’ attacca allora in fondo al suo messaggio il<br />
corrispondente hash. ‘A’ può codificare con la propria chiave<br />
privata ("firmare") tutto l'insieme, oppure lasciare il messaggio<br />
vero e proprio in chiaro e firmare solo l'hash.<br />
Chiunque può decodificare l'insieme ricevuto o il solo<br />
hash con la chiave pubblica di ‘A’, ed è così sicuro del fatto che<br />
il messaggio proviene da quel m<strong>it</strong>tente.<br />
91
Se inoltre, una volta effettuata la decodifica, messaggio ed<br />
hash si corrispondono, si è sicuri che nessuno dei due è stato<br />
alterato in qualche maniera.<br />
In pratica, la firma elettronica realizzata dal PGP effettua<br />
sempre l'autenticazione sia del m<strong>it</strong>tente sia del messaggio.<br />
Essa ha dunque le stesse funzioni della firma ordinaria su<br />
un documento cartaceo.<br />
Esempi pratici<br />
Trasmissione della chiave<br />
Col sistema di cr<strong>it</strong>tografia a chiave pubblica non c’è, come<br />
nella cr<strong>it</strong>tografia convenzionale, una sola chiave usata per<br />
entrambe le funzioni di codifica e decodifica, e che deve essere<br />
posseduta solo dal m<strong>it</strong>tente e dal destinatario.<br />
Pertanto non si pone il problema di dover trasmettere in<br />
modo sicuro quella chiave.<br />
Ogni utente deve semplicemente tenere al sicuro la propria<br />
chiave segreta e può diffondere senza alcun problema la propria<br />
chiave pubblica. Anzi, più questa viene diffusa e meglio è.<br />
Il PGP consente di effettuare tutte queste funzioni<br />
mediante semplici comandi. Ė possibile avere varie funzioni<br />
insieme.<br />
Due procedure comuni sono per esempio :<br />
• la corrispondenza privata<br />
firmare un messaggio e contemporaneamente<br />
codificarlo per un certo destinatario;<br />
• per i messaggi pubblici o privati<br />
effettuare l'hash di un messaggio e firmarlo per<br />
autenticarne il m<strong>it</strong>tente ed il contenuto, ma<br />
lasciando il messaggio stesso in chiaro; questa<br />
procedura viene comunemente chiamata firma in<br />
chiaro, ed è quello che io ho fatto per il presente<br />
testo.<br />
Il PGP utilizza in realtà una intera collezione di algor<strong>it</strong>mi,<br />
tra i più sicuri ed internazionalmente conosciuti nel campo della<br />
cr<strong>it</strong>tografia.<br />
Allo scopo di illustrare il processo messo in atto da PGP,<br />
supponiamo di partire da un messaggio che deve essere firmato e<br />
codificato.<br />
La sequenza delle operazioni è la seguente :<br />
A. PGP applica l'algor<strong>it</strong>mo di hashing MD5 per generare<br />
l'hash del messaggio, avente lunghezza fissa pari a 128<br />
b<strong>it</strong>. L'hash viene attaccato al messaggio.<br />
B. PGP applica l'algor<strong>it</strong>mo di compressione dati ZIP per<br />
comprimere l'insieme messaggio più hash ottenuto in A.<br />
C. PGP applica un algor<strong>it</strong>mo di generazione numeri casuali<br />
per generare una sequenza di 128 b<strong>it</strong> casuali.<br />
92
D. PGP applica l'algor<strong>it</strong>mo di cr<strong>it</strong>tografia convenzionale<br />
IDEA per codificare il messaggio compresso ottenuto<br />
in B, usando come chiave ("session key") il numero<br />
casuale generato in C.<br />
E. PGP applica l'algor<strong>it</strong>mo di cr<strong>it</strong>tografia a chiave<br />
pubblica RSA per codificare la session key. Il risultato<br />
viene attaccato al messaggio codificato ottenuto in D.<br />
La cr<strong>it</strong>tografia convenzionale è molto più veloce di<br />
quella a chiave pubblica. PGP unisce i vantaggi della<br />
cr<strong>it</strong>tografia a chiave pubblica e la veloc<strong>it</strong>à di quella<br />
convenzionale.<br />
Il messaggio viene in realtà codificato convenzionalmente,<br />
ed è la session key usata che viene codificata con l'algor<strong>it</strong>mo a<br />
chiave pubblica.<br />
PGP applica l'algor<strong>it</strong>mo ASCII Armor Radix-64 per<br />
trasformare il messaggio ottenuto in E in modo che esso<br />
contenga solo caratteri ASCII bassi.<br />
Questo algor<strong>it</strong>mo trasforma ogni gruppo di tre bytes in un<br />
gruppo di quattro bytes.<br />
Il messaggio ottenuto in F è quello finale, che può essere<br />
inviato per e-mail. Il destinatario esegue la sequenza inversa di<br />
operazioni.<br />
Esempi pratici<br />
Gli algor<strong>it</strong>mi utilizzati da PGP sono considerati<br />
assolutamente sicuri. Per esempio, l'algor<strong>it</strong>mo di cr<strong>it</strong>tografia a<br />
chiave pubblica RSA si basa sul prodotto di due numeri primi.<br />
Per poter ricavare una chiave privata dalla corrispondente<br />
chiave pubblica occorrerebbe fattorizzare questo prodotto.<br />
Nel caso di chiavi a 1024 b<strong>it</strong>, è stato stimato che una rete<br />
di un milione di computers impiegherebbe 10^10 anni a risolvere<br />
il problema, un tempo pari all'età dell'universo!<br />
Poi, ci sarebbe ancora il problema di ricavare la pass<br />
phrase.<br />
E questo per una sola coppia di chiavi tra tutte quelle<br />
esistenti al mondo.<br />
Esempio pratico dell’utilizzo del PGP<br />
La prima cosa da fare è installare il programma, lo si può<br />
trovare su Internet ed è scaricabile gratu<strong>it</strong>amente (per scopi non<br />
commerciali, su www.pgpi.com) .<br />
Dopo aver scaricato il file .zip basta scompattarlo in una<br />
directory a piacimento e settare il parametro path del DOS nel<br />
modo seguente :<br />
• SET PATH = C:\%PATH%<br />
• SET TZ = C:\<br />
93
La prossima operazione sarà la generazione delle chiavi.<br />
Per generare la coppia di chiavi si utilizza il comando:<br />
pgp -kg<br />
PGP chiede di :<br />
1. Scegliere la lunghezza delle chiavi.<br />
Vengono proposte tre possibil<strong>it</strong>à, delle quali la terza<br />
genera chiavi di 1024 b<strong>it</strong>.<br />
Con la versione internazionale 2.6.3i è possibile generare<br />
chiavi della lunghezza di 2048 b<strong>it</strong> dig<strong>it</strong>ando appunto il numero<br />
2048 invece di scegliere una delle tre alternative proposte.<br />
La generazione di chiavi da 2048 b<strong>it</strong>, non è possibile su un<br />
sistema particolarmente lento, in questo caso è preferibile<br />
generare chiavi a 1024 b<strong>it</strong>.<br />
Figura 4.9 : Creazione delle chiavi con PGP (passo 1).<br />
Nell’esempio che stiamo effettuando è stata scelta una<br />
chiave di 1024 b<strong>it</strong>s.<br />
2. Inserire la User ID<br />
In questo passaggio verrà scelto lo "User Name", chiamato<br />
anche "User ID".<br />
Generalmente, si usa nome e cognome segu<strong>it</strong>o<br />
dall'indirizzo e-mail in parentesi angolari :<br />
Castiglioni Marco <br />
(E' possibile assegnare alle chiavi più identificativi, cosa<br />
che si fa quando si hanno più indirizzi e-mail, per esempio.)<br />
Questo è ciò che viene anche sugger<strong>it</strong>o a video dall’help di<br />
PGP, ed è la cosa preferibile.<br />
In alternativa, se è facile che il vostro indirizzo e-mail<br />
cambi, per creare il vostro "User Name" potete far seguire il<br />
vostro nome e cognome, anziché dall'indirizzo e-mail, da un<br />
qualunque altro dato che vi identifichi.<br />
Esempi pratici<br />
94
3. Inserire la pass phrase<br />
E' molto importante, perché si tratta della frase d’accesso<br />
che permette di utilizzare la chiave segreta, senza la pass phrase<br />
la vostra chiave segreta è inutilizzabile.<br />
E' una password estesa : può essere un testo molto lungo<br />
contenente qualunque carattere.<br />
Scegliete una frase lunga che non sia intuibile, ma deve<br />
però trattarsi di una frase costru<strong>it</strong>a in modo che sia facile da<br />
ricordare.<br />
Figura 4.10 : Creazione delle chiavi con PGP (passo 2).<br />
4. Premere dei tasti casualmente<br />
Dovranno essere premuti dei tasti in modo casuale. In<br />
questo modo PGP, in base alla veloc<strong>it</strong>à di pressione dei tasti,<br />
calcolerà un numero casuale di 504 b<strong>it</strong>s.<br />
Figura 4.11 : Creazione delle chiavi con PGP (passo 3).<br />
Esempi pratici<br />
95
Figura 4.12 : Creazione delle chiavi con PGP (passo 4).<br />
A questo punto, PGP genera la vostra coppia di chiavi.<br />
Esse saranno contenute nei file secring.pgp (secret ring)<br />
per quella segreta, pubring.pgp (public ring) per quella pubblica.<br />
In questa versione del PGP non è necessario firmare la<br />
chiave pubblica poiché viene fatto direttamente con<br />
l’inizializzazione della chiave. Nelle vecchie versioni bisogna<br />
utilizzare il comando pgp –ks “ID” dove ID è l’identificativo<br />
dell’utente, per esempio la User Name.<br />
Per visualizzare le chiavi pubblica si utilizza il comando<br />
pgp -kv, così facendo viene visualizzata la chiave il giorno della<br />
sua creazione il tipo di chiave (numero di b<strong>it</strong> utilizzati) e l’user<br />
id.<br />
Figura 4.13 : Visualizzazione della chiave pubblica.<br />
Esempi pratici<br />
96
Utilizzando il comando pgp -ka “ID” si può<br />
vedere la chiave pubblica.<br />
Figura 4.14 : Estrazione della chiave pubblica.<br />
Di segu<strong>it</strong>o è riportata la chiave pubblica.<br />
Type B<strong>it</strong>s/KeyID Date User ID<br />
pub 1024/B1B74DA1 2002/05/19 <br />
Esempi pratici<br />
-----BEGIN PGP PUBLIC KEY BLOCK-----<br />
Version: 2.6.3ia<br />
mQCNAzznyGsAAAEEAPTc2A3d/TbAMJZww89t6Z/qiC/5asH<br />
mH2qgnqnHOtdjUXg9KWAG8wb2a4S4gIbrhpHfy9OtVFxujNgdR<br />
yQ5w8ayBDr6hO5v9gjO4+6qJKLavDqw7fpq0YsKOz++Ts7P4Zq<br />
v9e5EtZHRmKSupR8Tb/7vF14BnVvn5ragcraxt02hAAURtA88Y2<br />
FzdGlAbXNuLmNvbT6JAJUDBRA858hrtqBytrG3TaEBAb5oA/9<br />
rFrqrd4Y62352MrgttlJgh+Ou8xuIG0/HYAoB+M0IlbVXE5vYY9<br />
1RC6KQsTYVgpv/sOd1/flDZMKokDoRq6IElKE3w7EHHn/r3A<br />
CRAYfk9hTkc6PPq0P2IKZ1JzZJHVpslOct9EVtaIwXrClsQXb0K<br />
LbM0FG9g7TpenLgoksKdg===zMPX<br />
-----END PGP PUBLIC KEY BLOCK-----<br />
Dopo di che è possibile cr<strong>it</strong>tare e decr<strong>it</strong>tare un file di<br />
testo. Il comando da utilizzare per cr<strong>it</strong>tare il testo è :<br />
pgp –esta C:\percoso<br />
• Se si omette l'opzione "s" (sign), quindi dig<strong>it</strong>ate<br />
-eta, il file viene codificato, ma non firmato.<br />
• Se si omette l'opzione "e" (encrypt), quindi dig<strong>it</strong>ate<br />
-sta, il file viene firmato in chiaro, ma non<br />
codificato.<br />
97
Non è detto che il file da codificare e/o firmare sia un<br />
testo, bensì può essere indifferentemente un file binario<br />
qualunque.<br />
Esempi pratici<br />
PGP chiede in ogni caso di dig<strong>it</strong>are la vostra pass phrase,<br />
in modo da poter utilizzare la vostra chiave segreta.<br />
Ė importante che il comando per codificare e/o firmare<br />
(nonché quello per estrarre la vostra chiave pubblica) contenga<br />
sempre l'opzione "a" (ASCII Armor), come si vede dal comando<br />
riportato sopra.<br />
Questo perché quando si invia un file per e-mail, esso<br />
passa attraverso e arriva su sistemi di tipo molto diverso.<br />
Qualunque sistema però è in grado di riconoscere e<br />
trattare caratteri ASCII il cui codice decimale è compreso tra 0 e<br />
127 (il cosiddetto ASCII basso). Perciò è indispensabile che un<br />
file inviato per e-mail sia formato esclusivamente da tali<br />
caratteri (file ASCII armored o semplicemente ASCII), e non da<br />
caratteri qualsiasi. PGP trasforma, mediante l’opzione "a", il file<br />
prodotto in modo che sia ASCII armored.<br />
Figura 4.15 : Cr<strong>it</strong>tazione di un file (passo 1).<br />
Dopo di che il PGP chiederà di riscrivere la vostra<br />
password segreta, in segu<strong>it</strong>o viene anche chiesto l’user ID, dopo<br />
di che verrà creato il file cr<strong>it</strong>tato.<br />
98
Figura 4.16 : Cr<strong>it</strong>tazione di un file (passo 2).<br />
Il file di testo cr<strong>it</strong>tato è il seguente:<br />
-----BEGIN PGP MESSAGE-----<br />
Version: 2.6.3ia<br />
Esempi pratici<br />
hIwDtqBytrG3TaEBA/42ma+Cg8giyBNS5hA31/2LHgp8xj0EHv4<br />
PUrFuwlYc4jNCdTQUklqHdhkLh8WSIzx12ps7ucjs18H4+Mn1vY<br />
qOKp4W1pt5OxZ5gD8V0yrFOnhkWzxA+59acHgUAcu<strong>LA</strong>RmTU<br />
gflkmSdDtfaWLKR+ojHDJt8rvevfaroIT2WQsejLKYAAAE3ixIbp<br />
Is10lfjG2Re3XRXKRzwHd/bhpFZIjcU5jv3gJtTnMb8gdj3Kscv8N<br />
UG+l1W2DKNVuCWryoN7+8llHOn9xERkTa5VdnMjaI9jnmgd4c<br />
cOZjaTFonmJEXVkKUGFlH1DasvsHriezxzcsRobg0y1SWl4yHc0<br />
kbkDTEWfgz+GJQO9d+GOy19sxUXy6v/Hi7dQEXr0PhOjBfmx<br />
LW1+3U76ZIejzfX/fr7cPUU4Kin2qv85PUZ5AJMZMLLSVNO3<br />
ObOFqTeweanlaYUTPagFL5IdAC6yU5eZ4eCa/1djFh27IkIxqXIE<br />
b2o+LpvRklKwVlSxJ2sXb/BayQbrHOM5gw0QsyZOhj+CP9NOt<br />
MXD9vsPk+Z526h5l2uU86yapABeJTu7YZBdhgRVAq5KqHYdG<br />
WfdLinPWvtK0==qHft<br />
-----END PGP MESSAGE-----<br />
Per decodificare il file si dovrà utilizzare il seguente<br />
comando:<br />
pgp C:\percoso<br />
99
Figura 4.17 : Decr<strong>it</strong>tazione di un file.<br />
Dopo questa operazione il file viene decodificato e il testo<br />
può comparire in chiaro.<br />
Qui sotto il testo è riportato in chiaro:<br />
Esempi pratici<br />
Questa è la mia area di progetto questo è un file di testo<br />
fatto per provare il programma che cr<strong>it</strong>ta e decr<strong>it</strong>ta i messaggi di<br />
posta elettronica PGP!<br />
Questo comando ha molteplici funzioni, perché agisce<br />
indifferentemente su codifica e firma.<br />
Se il messaggio di partenza era codificato, il comando<br />
c<strong>it</strong>ato lo decodifica.<br />
Se in aggiunta esso era anche firmato, il comando verifica<br />
inoltre la firma (e quindi l’autentic<strong>it</strong>à del m<strong>it</strong>tente e del<br />
messaggio stesso).<br />
Se era solo firmato, viene semplicemente verificata la<br />
firma.<br />
100
CONCLUSIONI<br />
Dr. M : “Che difficoltà avete incontrato nello sviluppare<br />
l’area di progetto?”<br />
Pozzetti : “La difficoltà maggiore incontrata è stata lo sviluppo<br />
del DES. La manipolazione b<strong>it</strong> per b<strong>it</strong> usata dal DES<br />
rendeva più adatto lo sviluppo dell’algor<strong>it</strong>mo in<br />
Assembler.”<br />
Castiglioni : “Per quanto riguarda la parte storica riguardante<br />
la seconda guerra mondiale non ci sono stati<br />
problemi, mentre per quanto riguarda la parte<br />
della storia della cr<strong>it</strong>tografia ho incontrato alcuni<br />
problemi: a causa dell’abbondanza di informazioni<br />
si è dovuto estrapolare solo lo stretto necessario.<br />
Nella prova pratica con il PGP le difficoltà<br />
incontrate riguardano l’applicazione delle<br />
istruzioni, infatti alcune di esse riportate nell’help<br />
erano errate.”<br />
Trevisan : “Ho incontrato difficoltà nel programma in Linux,<br />
legatiall’uso dei socket raw. Studiando la cr<strong>it</strong>tografia<br />
di Outlook Express non è stato possibile verificare<br />
con esempi pratici l’utilizzo della firma elettronica e<br />
degli algor<strong>it</strong>mi cr<strong>it</strong>tografici, poiché non si disponeva<br />
di un ID dig<strong>it</strong>ale.”<br />
Dr. M : “Cosa avete imparato di nuovo durante lo sviluppo<br />
dell’area di progetto?”<br />
Pozzetti. : “Per quanto riguarda la programmazione ho imparato<br />
a programmare utilizzando Visual C++, in<br />
particolare è stato utile l’uso di Winsock. Nel campo<br />
della cr<strong>it</strong>tografia sono venuto a conoscenza degli<br />
algor<strong>it</strong>mi più usati quali il DES e l’RSA e alcune<br />
delle tecniche che nel futuro renderanno sempre più<br />
sicura la comunicazione via Internet.”<br />
Castiglioni: “Nella parte storica, ho scoperto quando è nata<br />
la cr<strong>it</strong>tografia e l’util<strong>it</strong>à che è riusc<strong>it</strong>a a<br />
conquistarsi nel corso degli anni e dei secoli.<br />
Per quanto riguarda la parte applicativa, ho<br />
lavorato con il programma PGP, che permette la<br />
codifica e decodifica dei messaggi.<br />
Mi è serv<strong>it</strong>o per vedere praticamente e non solo<br />
teoricamente come funziona un programma per la<br />
cr<strong>it</strong>tografia.”<br />
Trevisan : “Ho approfond<strong>it</strong>o il protocollo TCP/IP, sia<br />
teoricamente sia praticamente, costruendo un<br />
programma che simulasse una trama TCP/IP.”<br />
Dr. M : “Come ampliereste la vostra area di progetto?”<br />
Pozzetti. : “Nella parte cr<strong>it</strong>tografica sono state tralasciate<br />
importanti parti, come la simulazione delle macchine<br />
cifranti usate durante la seconda guerra mondiale,<br />
Conclusioni<br />
101
oppure lo studio più approfond<strong>it</strong>o di alcuni<br />
algor<strong>it</strong>mi come l’RSA, trattato solo marginalmente.<br />
In particolare mi sarebbe piaciuto realizzare una<br />
simulazione della macchina Enigma e della Bomba di<br />
Turing per rendere meglio l’idea del lavoro<br />
effettuato dagli Alleati e dal’Asse nello sviluppo dell<br />
cr<strong>it</strong>tografia.”<br />
Trevisan : “Nella parte della sicurezza sarebbe stato utile<br />
approfondire ulteriormente i metodi di attacco degli<br />
hacker, poiché solamente in questo modo si possono<br />
migliorare i metodi realativi alla sicurezza. D’altra<br />
parte era impossibile trattare tutti gli argomenti in<br />
modo dettagliato, poiché l’area di progetto<br />
comprendeva argomenti ampio raggio.”<br />
Castiglioni: “Vorrei aggiungere ancora delle parti sulla storia<br />
della cr<strong>it</strong>tografia, sulla util<strong>it</strong>à che ha avuto nella<br />
seconda guerra mondaile e che sta avendo tuttora<br />
in internet.<br />
Vorrei applicare il PGP, nella posta elettronica,<br />
anche se è difficile ottenere il permesso dalla<br />
autor<strong>it</strong>à competenti.”<br />
Dr. M : “Qual è stata la fonte primaria di informazioni?”<br />
C., P., T. : “Internet e relativi manuali.”<br />
Dr. M : “Ognuno commenti il lavoro altrui.”<br />
Pozzetti. : “Il lavoro svolto da Castiglioni relativo alla storia e<br />
alle basi della cr<strong>it</strong>tografia è stato veramente<br />
impegnativo, soprattutto la ricerca di materiale è<br />
stata difficoltosa. Alla fine ci si è r<strong>it</strong>rovati con più<br />
informazioni di quante ne servissero. Inoltre la sua<br />
parte di lavoro mi è serv<strong>it</strong>a per comprendere meglio<br />
il funzionamento di alcuni algor<strong>it</strong>mi cr<strong>it</strong>tografici,<br />
permettendomi di implementarne alcuni nelle<br />
applicazioni sviluppate.<br />
Il lavoro di Trevisan è stata la base per lo sviluppo<br />
dell’applicazione di scambio per i messaggi cr<strong>it</strong>tati,<br />
che è stata integrata con il DES.”<br />
Castiglioni: “ La parte svolta da Trevisan è stata molto utile<br />
per capire come avviene lo scambio dei messaggi<br />
cr<strong>it</strong>tati tra due utenti.<br />
Il lavoro di Pozzetti è stato importatntissimo,<br />
poiché grazie ad esso, si può vedere come vengono<br />
cr<strong>it</strong>tati i messaggi con l’algor<strong>it</strong>mo DES, è stato un<br />
lavoro molto lungo e complesso, ma che è stato<br />
svolto con molta professional<strong>it</strong>à.”<br />
Trevisan : “Entrambi le altri parti sono state molto complete; la<br />
Conclusioni<br />
102
parte di Pozzetti, che comprendeva principalmente<br />
la cr<strong>it</strong>tografia, è stata molto complessa ed è stata<br />
svolta in modo particolareggiato e professionale;<br />
Castiglioni è stato molto preciso e particolareggiato<br />
nella parte storica, mentre la sua descrizione<br />
riguardante il PGP è stata utile ad un suo utilizzo<br />
pratico.”<br />
Dr. M : “Come è stato lavorare in gruppo?”<br />
Pozzetti. : “Lavorando in gruppo la cosa più importante da<br />
tenere in conto è la divisione del lavoro. Se il lavoro<br />
viene diviso in maniera esatta all’ora il tutto fila via<br />
liscio, altrimenti, ci si r<strong>it</strong>rova a sprecare tempo,<br />
tralasciando alcune parti che alla fine ci si r<strong>it</strong>roverà<br />
ad affrontare con l’acqua alla gola.<br />
Un’altra cosa estremamente importante è avere già in<br />
mente il flusso del lavoro, ovvero conoscere<br />
precisamente gli argomenti da affrontare, in modo da<br />
non r<strong>it</strong>rovarsi a metà dello sviluppo con un’idea che<br />
non coincide per nulla con quello che si aveva in<br />
mente all’inizio.”<br />
Castiglioni: “ E’ stata un’esperienza molto utile, ci ha fatto<br />
capire cosa vuol dire lavorare in gruppo.<br />
Con il lavoro di gruppo ci si può confrontare, si<br />
chiedere aiuto ai propri compagni, che ti sanno<br />
aiutare e consigliare. Ed è molto gratificante<br />
mettere a disposizione le proprie conoscenze per<br />
la buona riusc<strong>it</strong>a del lavoro.”<br />
Trevisan : “E’ stata un’esperienza stimolante, poiché si impara<br />
a comunicare con gli altri per suddividere il lavoro e<br />
proporre le proprie idee.”<br />
Dr. M : “Che conclusioni avete tratto dallo sviluppo dell’area di<br />
progetto?”<br />
Pozzetti. : “Personalmente credo che il mondo della cr<strong>it</strong>tografia<br />
sia molto affascinante, sia per quanto riguarda il lato<br />
“buono” sia per quanto riguarda il lato “cattivo”.<br />
Purtroppo la cr<strong>it</strong>toanalisi (lato “cattivo”) non è stata<br />
affrontata nel modo che mer<strong>it</strong>ava, lasciando un po’<br />
di amaro in bocca.<br />
La stessa affermazione può valere per le<br />
comunicazione via socket. Gli argomenti trattati in<br />
questo campo sono stati veramente pochi,<br />
soprattutto a causa del poco tempo a disposizione.”<br />
Castiglioni: “Dall’analisi che abbiamo fatto sulla cr<strong>it</strong>tografia, si<br />
può dire che essa prenderà sempre più parte nel<br />
mondo di internet, questo per avere una maggiore<br />
sicurezza, che permetterà di scambiare<br />
informazioni o di compiere transazioni in tutta<br />
sicurezza.”<br />
Trevisan : “Penso che analizzando la sicurezza informatica, si<br />
Conclusioni<br />
103
possa notare che sia un campo in continua<br />
espansione e sviluppo. Quindi è molto difficile<br />
essere aggiornati, ma risulta interessante e<br />
stimolante.”<br />
Dr. M : “Defin<strong>it</strong>e con poche parole la vostra area di progetto.”<br />
Pozzetti. : “Una base per chi vuole incominciare a conoscere il<br />
mondo della cr<strong>it</strong>tografia.”<br />
Castiglioni: “Può essere una base per chi si vuole avvicinare<br />
al mondo della cr<strong>it</strong>tografia e un aiuto per chi si è<br />
già avvicinato alla cr<strong>it</strong>tografia e ne vuole sapere di<br />
più.<br />
Trevisan : “L’area di progetto è stata sviluppata in varie parti:<br />
storico, gestione di rete e cr<strong>it</strong>tografia. Alla parte<br />
teorica si affianca una parte di programmazione in<br />
vari linguaggi. L’argomento pur risultando molto<br />
ampio e complesso è stato cercato di essere trattato<br />
in modo completo.”<br />
Conclusioni<br />
104
Appendice A<br />
SSL<br />
1 Cos’è l’SSL<br />
2 Creazione di una connessione SSL<br />
1 Cos’è l’SSL<br />
SSL (Secure Socket Layer protocol) è un protocollo aperto<br />
e non proprietario; è stato sottoposto da Netscape<br />
Communications all'Engineering Task Force per la sua<br />
standardizzazione, anche se di fatto è stato accettato come uno<br />
standard da tutta la comun<strong>it</strong>à di Internet ancor prima del<br />
verdetto dell'IETF. La versione 3.0 del protocollo rilasciata nel<br />
novembre 1996, è un'evoluzione della precedente versione del<br />
1994 la SSL v2.0, e rappresenta al momento una delle soluzioni<br />
più utilizzate per lo scambio di informazioni cifrate. Tale<br />
evoluzione introduce un livello di sicurezza superiore rispetto<br />
alla precedente grazie ad una maggiore attenzione nella fase di<br />
autenticazione tra client e server. Il futuro di SSL è<br />
rappresentato dal protocollo TLS v1 (SSL v3.1) sottoposto a<br />
standardizzazione nel novembre 1998.<br />
Il protocollo SSL è nato al fine di garantire la privacy<br />
delle comunicazioni su Internet, infatti permette alle<br />
applicazioni client/server di comunicare in modo da prevenire le<br />
intrusioni, le manomissioni e le falsificazioni dei messaggi. Il<br />
protocollo SSL garantisce la sicurezza del collegamento<br />
mediante tre funzional<strong>it</strong>à fondamentali :<br />
• privatezza del collegamento: per assicurare un<br />
collegamento sicuro tra due utenti coinvolti in una<br />
comunicazione, i dati vengono protetti utilizzando<br />
algor<strong>it</strong>mi di cr<strong>it</strong>tografia a chiave simmetrica (ad es.<br />
DES, RC4, ecc.);<br />
• autenticazione: l'autenticazione dell'ident<strong>it</strong>à nelle<br />
connessioni può essere esegu<strong>it</strong>a usando la<br />
cr<strong>it</strong>tografia a chiave pubblica (per es. RSA, DSS<br />
ecc.). In questo modo i client sono sicuri di<br />
comunicare con il server corretto, prevenendo<br />
eventuali interposizioni. Inoltre è prevista la<br />
certificazione sia del server che del client;<br />
• affidabil<strong>it</strong>à: il livello di trasporto include un<br />
controllo sull'integr<strong>it</strong>à del messaggio basato su un<br />
appos<strong>it</strong>o MAC (Message Authentication Code) che<br />
utilizza funzioni hash sicure (per es. SHA, MD5<br />
ecc.). In tal modo si verifica che i dati sped<strong>it</strong>i tra<br />
client e server non siano stati alterati durante la<br />
trasmissione.<br />
Appendice A<br />
105
Il protocollo SSL è composto da :<br />
• protocollo SSL handshake, permette al server ed al<br />
client di autenticarsi a vicenda e di negoziare un<br />
algor<strong>it</strong>mo di cr<strong>it</strong>tografia e le relative chiavi prima<br />
che il livello di applicazione trasmetta o riceva il suo<br />
primo byte. Un vantaggio di SSL è la sua<br />
indipendenza dal protocollo di applicazione, in tal<br />
modo un protocollo di livello più alto può<br />
interfacciarsi sul protocollo SSL in modo<br />
trasparente;<br />
• protocollo SSL record, è interfacciato su di un<br />
protocollo di trasporto affidabile come il TCP.<br />
Questo protocollo è usato per l'incapsulamento dei<br />
dati provenienti dai protocolli superiori.<br />
Figura 1 : SSL è un<br />
protocollo a due strati, SSL<br />
Record a livello inferiore ed<br />
SSL Handshake a livello<br />
superiore, che si interfaccia<br />
con una applicazione ad<br />
esempio HTTP.<br />
2 Creazione di una connessione SSL<br />
SSL prevede una fase iniziale, detta di handshake, usata<br />
per iniziare una connessione TCP/IP. In particolare il risultato<br />
di tale fase è l'avvio di una nuova sessione che permette la<br />
contrattazione da parte del client e del server del livello di<br />
sicurezza da usare ed il completamento delle autenticazioni<br />
necessarie alla connessione. Quindi SSL procede con la cifratura<br />
(e/o con la messa in chiaro) della sequenza di byte del<br />
protocollo applicazione usato, ad esempio nell'HTTP tutte le<br />
informazioni sia di richiesta che di risposta sono completamente<br />
cifrate, incluso l'URL richiesto dal client, qualsiasi contenuto di<br />
form compilati (quindi anche eventuali numeri di carte di<br />
cred<strong>it</strong>o...), ogni informazione sulle autorizzazioni all'accesso<br />
come username e password, e tutti i dati inviati in risposta dal<br />
server al client.<br />
Il protocollo SSL usa una combinazione di chiavi<br />
pubbliche e chiavi simmetriche. La cifratura a chiave simmetrica<br />
è molto più veloce della cifratura a chiave pubblica, anche se<br />
quest'ultima provvede ad una tecnica di autenticazione migliore.<br />
Una sessione SSL inizia sempre con uno scambio di messaggi<br />
chiamati di SSL handshake. L'handshake consente al server di<br />
autenticarsi al client usando una tecnica a chiave pubblica,<br />
quindi permette al client ed al server di cooperare per la<br />
Appendice A<br />
106
creazione delle chiavi simmetriche usate per una veloce<br />
cifratura, decifratura e controllo delle intrusione durante la<br />
sessione avviata. Eventualmente, l'handshake permette anche al<br />
client di autenticarsi al server.<br />
Nel protocollo SSL Handshake l'avvio di una nuova connessione<br />
può avvenire o da parte del client o da parte del server. Se è il<br />
client ad iniziare, allora questo invierà un messaggio di client<br />
hello, iniziando così la fase di Hello, e si porrà in attesa della<br />
risposta del server che avviene con un messaggio di server hello.<br />
Nel caso in cui sia il server ad iniziare la connessione, questo<br />
invierà un messaggio di hello request per richiedere al client di<br />
iniziare la fase di Hello. Con lo scambio di questi messaggi, il<br />
client ed il server si accorderanno sugli algor<strong>it</strong>mi da usare per la<br />
generazione delle chiavi; in particolare il client ne proporrà una<br />
lista, quindi sarà il server a decidere quale di essi dovrà essere<br />
utilizzato.<br />
A questo punto può iniziare o meno, a seconda del metodo di<br />
autenticazione impiegato (autenticazione di entrambe le parti,<br />
autenticazione del server con client non autenticato, totale<br />
anonimato), uno scambio di certificati tra client e server.<br />
L'autenticazione è un controllo che si può effettuare per provare<br />
l'ident<strong>it</strong>à di un client o di un server. Un client abil<strong>it</strong>ato può<br />
controllare che il certificato del server sia valido e che sia stato<br />
firmato da un'autor<strong>it</strong>à fidata. Questa conferma può essere utile,<br />
per esempio, se un utente invia il numero di carta di cred<strong>it</strong>o e<br />
vuole controllare l'ident<strong>it</strong>à del ricevente.<br />
Allo stesso modo un client può essere autenticato, questo<br />
potrebbe essere utile se il server è ad esempio una banca che<br />
deve inviare dati finanziari confidenziali ad un suo cliente che<br />
necess<strong>it</strong>a quindi di essere autenticato.<br />
E' importante notare che sia l'autenticazione del client che<br />
quella del server implica la cifratura di alcuni dati condivisi con<br />
una chiave pubblica o privata e la decifratura con la chiave<br />
corrispondente. Nel caso dell'autenticazione del server, il client<br />
deve cifrare dei dati segreti con la chiave pubblica del server.<br />
Solo la corrispondente chiave privata può correttamente<br />
decifrare il segreto, così il client ha delle assicurazioni sulla<br />
reale ident<strong>it</strong>à del server poichè solo lui può possedere tale<br />
chiave. Altrimenti il server non potrà generare le chiavi<br />
simmetriche richieste per la sessione, che verrà così terminata.<br />
In caso di autenticazione del client, questi deve cifrare alcuni<br />
valori casuali condivisi con la sua chiave privata, creando in<br />
pratica una firma. La chiave pubblica nel certificato del client<br />
può facilmente convalidare tale firma se il certificato è<br />
autentico, in caso contario la sessione verrà terminata.<br />
Avvenuta l'autenticazione si procede con la generazione delle<br />
chiavi per la cifratura e per l'autenticazione dei dati provenienti<br />
dal livello di applicazione, tutto questo attraverso i messaggi di<br />
server key exchange e client key exchange. Terminata questa<br />
operazione, il server annuncerà la fine della fase di Hello al<br />
client, con l'invio di un messaggio di server hello done, dopodichè<br />
con l'invio di un messaggio di change CipherSpec entrambi<br />
Appendice A<br />
107
controlleranno la correttezza dei dati ricevuti e se tutto è<br />
avvenuto in maniera corretta, da questo punto in poi useranno<br />
gli algor<strong>it</strong>mi di sicurezza concordati. La fase di handshake<br />
terminerà con l'invio, da entrambe le parti, di un messaggio di<br />
finished che sarà il primo dato ad essere cifrato.<br />
Appendice A<br />
108
Appendice B<br />
La firma dig<strong>it</strong>ale<br />
1 Lo standard DSS e l’algor<strong>it</strong>mo DSA<br />
2 Protocolli di sicurezza<br />
3 Sistemi di autenticazione<br />
1 Lo standard DSS e l’algor<strong>it</strong>mo DSA<br />
Il National Inst<strong>it</strong>ute of Standards and Technology (NIST)<br />
ha pubblicato il Dig<strong>it</strong>al Signature Algor<strong>it</strong>hm (DSA) nell'amb<strong>it</strong>o<br />
del Dig<strong>it</strong>al Signature Standard (DSS) che è parte del progetto<br />
Capstone attuato dal Governo degli Stati Un<strong>it</strong>i. DSS è stato<br />
scelto nel maggio 1994 dal NIST in collaborazione con l' NSA<br />
come standard di firma dig<strong>it</strong>ale del Governo degli USA. DSA è<br />
basato sul problema dei logar<strong>it</strong>mi discreti ed è in relazione con<br />
gli schemi di firma proposti da Schnorr ed El Gamal. DSA può<br />
essere utilizzato soltanto per la firma dig<strong>it</strong>ale contrariamente ad<br />
RSA, utilizzabile sia per la dig<strong>it</strong>al signature che per la codifica e<br />
la privacy. Nel DSA la generazione della firma è più veloce della<br />
verifica della stessa, mentre con RSA la verifica è sensibilmente<br />
più veloce della generazione, per via delle diverse dimensioni<br />
degli esponenti pubblico e privato. La scelta di rendere più<br />
veloce la fase di firma o la fase di verifica può essere oggetto di<br />
discussione e di studio, come si può apprezzare nei lavori di<br />
Wiener e Naccache che hanno cercato dei compromessi per<br />
equilibrare la veloc<strong>it</strong>à delle due fasi ed hanno esplorato le<br />
possibil<strong>it</strong>à di miglioramento dell'efficienza di DSA. Anche se<br />
molti degli aspetti peculiari di RSA sono stati cr<strong>it</strong>icati sin dal<br />
momento del suo annuncio, esso è stato incorporato in un<br />
grande numero di sistemi. Le cr<strong>it</strong>iche mosse inizialmente si<br />
focalizzavano su pochi argomenti principali: mancava la<br />
flessibil<strong>it</strong>à dell' algor<strong>it</strong>mo RSA; la verifica delle firme era troppo<br />
lenta; l'esistenza di un algor<strong>it</strong>mo diverso dallo standard RSA<br />
poteva influenzare negativamente il mercato; il procedimento<br />
per cui il NIST sceglieva DSA era poco chiaro, arb<strong>it</strong>rario e<br />
fortemente influenzato dall' NSA.<br />
Un altro argomento scottante è quello della sicurezza<br />
dell'algor<strong>it</strong>mo. Originariamente proposto dal NIST con una<br />
chiave fissa di 512 b<strong>it</strong>s, dopo molte cr<strong>it</strong>iche per l' eventuale<br />
mancanza di sicurezza a lungo termine, dovuta alla lunghezza<br />
troppo ridotta della chiave, il NIST ha rivisto lo standard DSS<br />
ed ha introdotto chiavi della lunghezza di 1024 b<strong>it</strong>s. Oggi DSA è<br />
considerato sicuro con chiavi di 1024 b<strong>it</strong>s. Al giorno d' oggi non<br />
si conoscono attacchi efficienti portati al problema dei logar<strong>it</strong>mi<br />
discreti, che sorregge lo schema cr<strong>it</strong>tografico di DSA.<br />
Appendice B<br />
109
2 Protocolli di sicurezza<br />
Molti protocolli sono stati realizzati per la sicurezza delle<br />
comunicazioni via Internet, alcuni dei quali sono :<br />
• S/MIME<br />
S/MIME (Secure / Multipurpose Internet Mail Extensions)<br />
è un protocollo che aggiunge firma dig<strong>it</strong>ale e cifratura ai<br />
messaggi standard MIME. MIME è lo standard proposto per la<br />
posta elettronica avanzata. I messaggi di posta elettronica<br />
consistono di due parti : un’intestazione, che contiene<br />
informazioni v<strong>it</strong>ali per la spedizione del messaggio e un corpo,<br />
che non ha nessun formato particolare, a meno che il messaggio<br />
non sia nel formato MIME. Questo formato, infatti, fornisce una<br />
struttura anche al corpo, ed è quindi possibile inviare testo,<br />
audio, immagini ed altri elementi multimediali. Lo standard<br />
MIME da solo non è in grado di fornire una sicurezza<br />
sufficiente all' utente e quindi si è creato il protocollo S/MIME<br />
che quindi cripta il corpo della mail rendendola indecifrabile a<br />
terzi.<br />
• S/WA<br />
La S/WAN (Secure Wide Area Network) è un' iniziativa<br />
nata per promuovere lo sviluppo e la diffusione delle VPNs<br />
Virtual Private Networks basate su Internet e su protocollo IP.<br />
Questo risultato è ottenuto adottando lo standard IP/Sec,<br />
l'arch<strong>it</strong>ettura di sicurezza del protocollo IP. In questo modo si<br />
può garantire l'interoperabil<strong>it</strong>à con firewall e prodotti basati su<br />
protocolli TCP/IP. S/WAN supporta la codifica a livello di<br />
protocollo IP, per cui può fornire una sicurezza più a bsso<br />
livello rispetto a protocolli quali SSL. S/WAN utilizza<br />
l'algor<strong>it</strong>mo RC5 con chiavi della lunghezza compresa tra 40 e<br />
128 b<strong>it</strong>s.<br />
• IP/Sec<br />
Il gruppo di lavoro IP Secur<strong>it</strong>y Protocol (IP/Sec), facente<br />
parte dell' Internet Engineering Task Force (IETF), sta<br />
definendo un insieme di specifiche per l' autenticazione basata<br />
sulla cr<strong>it</strong>tografia per introdurre un alto livello di sicurezza e<br />
segretezza al livello di trasmissione datagram su Internet. I<br />
risultati di queste specifiche comprenderanno un elevato livello<br />
di sicurezza delle trasmissioni host-to-host, tunnels incapsulati e<br />
la definizione di Virtual Public Networks (VPNs) che<br />
fornirannosicurezza ai protocolli residenti ai livelli superiori<br />
rispetto al protocollo IP. I formati dei protocolli per l' IP/Sec<br />
Authentication Header (AH) e per IP Encapsulating Secur<strong>it</strong>y<br />
Payload (ESP) sono indipendenti dall'algor<strong>it</strong>mo di codifica<br />
adottato, permettendo quindi una larga interoperabil<strong>it</strong>à.<br />
Appendice B<br />
110
3 Sistemi di autenticazione<br />
In un ambiente di rete in cui molti utenti vogliono<br />
comunicare reciprocamente sono necessari dei protocolli che<br />
garantiscano sicurezza, riservatezza, trasparenza e veloc<strong>it</strong>à nelle<br />
transazioni. Di segu<strong>it</strong>o sono presentate le soluzioni più usate<br />
oggigiorno :<br />
• SSH<br />
SSH (Secure Shell) è un programma che permette di<br />
connettersi ad un altro computer attraverso una rete, eseguire<br />
comandi su una macchina remota e spostare files da una<br />
macchina all'altra il tutto in maniera sicura. Fornisce solide<br />
autenticazioni e comunicazioni sicure su canali insicuri. Può<br />
essere visto come un rimpiazzo delle istruzioni rlogin, rsh, e<br />
rcp. SSH gestisce connessioni di tipo X sicure e si interfaccia a<br />
connessioni TCP già esistenti.<br />
Protezioni forn<strong>it</strong>e da SSH<br />
1. 'IP spoofing' (truffa dell'IP) : quando un host<br />
remoto vuole spedire pacchetti verso un host<br />
autenticato, SSH protegge contro truffatori che,<br />
sulla rete locale, pretendano di essere i router verso<br />
l'esterno;<br />
2. 'IP source routing' : un host può pretendere che un<br />
pacchetto IP arrivi da un host autenticato e ciò deve<br />
essere garant<strong>it</strong>o da SSH;<br />
3. 'DNS spoofing ': un hacker tenta di forzare i record<br />
del name server;<br />
4. Intercettazione di password in chiaro e altri dati non<br />
cr<strong>it</strong>tati da parte di host intermedi;<br />
5. Manipolazione dei dati da parte di persone che<br />
possiedono il controllo di host intermedi;<br />
6. Attacchi basati sull'ascolto di autenticazioni X e<br />
sull'utilizzo successivo di queste ultime per ottenere<br />
false connessioni al server X11.<br />
Protezioni non garant<strong>it</strong>e da SSH<br />
SSH non dà aiuto a fronte di attacchi alla sicurezza del<br />
proprio host di altro genere. Così, se un hacker ha ottenuto<br />
l'accesso alla root della macchina, può sovvertire lo stesso SSH.<br />
Se qualcuno ha accesso alla nostra home directory, la sicurezza<br />
diventa inesistente. Questo può accadere nel caso in cui la<br />
nostra home directory venga esportata via NFS.<br />
Tutte le comunicazioni di SSH usano IDEA o uno degli<br />
altri protocolli simmetrici (three-key triple-DES, DES,<br />
Blowfish). Le chiavi segrete vengono scambiate usando RSA, e i<br />
dati relativi alle chiavi scambiate vengono distrutti ogni ora (le<br />
chiavi non vengono salvate da nessuna parte). Ogni host ha la<br />
propria chiave RSA che viene usata per autenticare l'host stesso<br />
Appendice B<br />
111
(quando si usa un'autenticazione tipo RSA). La codifica è usata<br />
come protezione contro l'IP spoofing; l'autenticazione a chiave<br />
pubblica è usata a fronte del DNS e del routing spoofing.<br />
Appendice B<br />
• NIS+<br />
NIS+ Overview : NIS+, acronimo di Network Information<br />
Service, e' un'evoluzione del servizio NIS entrambi trademark di<br />
Sun Microsystems (quest'ultimo nome sost<strong>it</strong>ui' l'originale YP<br />
(Yellow Pages) per ragioni di copyright).<br />
L'obiettivo di NIS era diminuire l'insieme di informazioni (di<br />
uno stesso cluster) replicate su piu' host, propagandole<br />
sottoforma di tabelle, in modo da ottenere una gestione<br />
centralizzata dei dati. NIS+ evolve questo concetto aggiungendo<br />
un meccanismo di autorizzazzione e autenticazione per tutti i<br />
client richiedenti tali informazioni. La prima differenza tra i due<br />
tipi di servizio e' l'organizzazione dell'insieme di informazioni<br />
riguardanti macchine e utenti, indicato col nome di "namespace"<br />
"flat" con NIS e "hierarchical" con NIS+.<br />
Il namespace puo' essere visto come un albero la cui radice ha<br />
due foglie ed eventuali rami ad ognuno dei quali e' attaccato un nodo<br />
figlio. Ogni nodo figlio (compresa la radice) ha due foglie cost<strong>it</strong>u<strong>it</strong>e<br />
da due sottodirectory virtuali chiamate "groups_dir" e "org_dir"; la<br />
prima contiene eventuali sottogruppi NIS+ e la seconda varie tabelle.<br />
Secondo la definizione un "NIS+ domain" e' l'insieme del nodo figlio<br />
(sia radice o semplice nodo interno), delle due sottodirectory e delle<br />
tabelle. NIS+ rende possibile la creazione di suddivisioni tra loro<br />
indipendenti del namespace, rifer<strong>it</strong>i di sol<strong>it</strong>o col nome di<br />
"subddomain".<br />
NIS+ Secur<strong>it</strong>y : l'accesso al namespace e': consent<strong>it</strong>o ai "NIS+<br />
principals", fatto rispettare dai "NIS+ servers" e soggetto ai<br />
permessi di ciascun object. Un NIS+ principal e' un utente o una<br />
macchina le cui credenziali sono presenti nel namespace.<br />
Quando un client (utente o macchina) manda una richiesta al<br />
server, vi inserisce automaticamente le credenziali di NIS+ principal.<br />
Il server a sua volta accodera' tale richiesta in una delle due<br />
categorie: autenticata o non utenticata, rispettivamente per le<br />
richieste generate da principal per i quali il server ne riconosce<br />
l'ident<strong>it</strong>a', e per le quali il server non riesce (client qualsiasi).<br />
L'accesso ad un NIS+ object differisce a seconda della coda in<br />
cui si trova la richiesta ed avviene in base ai permessi associati alle<br />
quattro azioni possibili divise per categorie. Ognuna di queste<br />
categorie specifica una "authorization category" differente. Per le<br />
richieste nella prima coda si hanno le categorie Owner, Group e<br />
World, mentre per quelle nella seconda la Nobody. I possibili<br />
permessi in ogni categoria sono quattro e indicano rispettivamente la<br />
possibil<strong>it</strong>a' di leggere (r), modificare (m), creare (c) e distruggere (d)<br />
un oggetto; tutto cio' in perfetta simil<strong>it</strong>udine con quanto avviene per<br />
il meccanismo di accesso ai file nel sistema operativo UNIX.<br />
Si noti che oltre ai permessi propri di ogni oggetto (facenti parte<br />
della sua definizione) e' anche possibile specificare altri permessi per<br />
ogni colonna o entry di una tabella NIS+ (con alcune lim<strong>it</strong>azioni).<br />
112
• Kerberos Authentication System<br />
Kerberos e' un servizio di autenticazione distribu<strong>it</strong>o il cui<br />
comp<strong>it</strong>o è permettere ad utenti di workstations l'accesso alle<br />
risorse di rete in modo sicuro. Kerberos deve dunque gestire i<br />
permessi dei vari user inibendo la possibil<strong>it</strong>à che qualcuno riesca<br />
a spacciarsi per qualcun'altro.<br />
Kerberos appartiene alla categoria "authentication for real<br />
- time" intendendo con questo termine che il processo client<br />
rimane in attesa di una risposta in modo da poter dare i risultati<br />
all'utente, questo implica una rapida risoluzione del problema di<br />
autenticazione per ev<strong>it</strong>are lunghe attese. Applicazioni che<br />
richiedono questo tipo di autenticazione sono : rlogin, file<br />
system r/w, information retrieval su Web etc.<br />
Kerberos fu sviluppato a meta' degli anni 80 come parte<br />
del progetto Athena al MIT ma succesivamente furono<br />
necessarie delle modifiche per supportare nuove pol<strong>it</strong>iche e<br />
metodi di utilizzo, attualmente e in fase di sviluppo la versione<br />
5 (V5) che viene considerata essere il "Kerberos standard" anche<br />
se la V4 viene utilizzata in molti s<strong>it</strong>i nel mondo.<br />
Essenzialmente Kerberos si basa sull'utilizzo di chiavi per<br />
criptare le informazioni scambiate tra le ent<strong>it</strong>a' che partecipano<br />
al protocollo di autenticazione. Il metodo di cr<strong>it</strong>tografia<br />
utlizzato da Kerberos V4 e' il DES (Data Encryption Standard)<br />
che ha la caratteristica di avere la stessa chiave sia per<br />
codificare che per decodificare.<br />
Appendice B<br />
113
Appendice C<br />
Cr<strong>it</strong>tografia quantica<br />
1 Fondamenti sui quanti e sui fotoni<br />
2 Cr<strong>it</strong>tografia quantica<br />
1 Fondamenti sui quanti e sui fotoni<br />
Prima di iniziare a parlare della cr<strong>it</strong>tografia quantica è<br />
meglio precisare il termine "quanto" : un osservatore attento<br />
può notare che il termine più vicino alla parola quanto è<br />
quant<strong>it</strong>à. All'inizio del secolo i fisici hanno notato che c'era<br />
qualcosa di sbagliato nella teorica classica, per essere più<br />
precisi, essi hanno notato che la loro prospettiva delle particelle<br />
fondamentali non coincideva con quella rilevata dagli<br />
esperimenti fatti. La conclusione logica fu che c'era qualcosa di<br />
errato nella classica concezione di atomo. Max Planck introdusse<br />
per primo un nuovo approcio al problema. Nella fisica classica,<br />
gli elettroni orb<strong>it</strong>ano attorno al nucleo dell'atomo e possono<br />
avere una qualsiasi energia e di conseguenza orb<strong>it</strong>are a qualsiasi<br />
distanza da esso.<br />
Il problema che generò questa idea è che l'elettrone,<br />
carico negativamente e il nucleo (composto da protoni, carica<br />
pos<strong>it</strong>iva e neutroni, carica neutra) carico pos<strong>it</strong>ivamente,<br />
potessero collassare. Più precisamente si credette che l'elettrone<br />
avrebbe potuto collassare nel nucleo per circa 0.0000000001<br />
secondi, a causa delle cariche opposte assunte da elettrone e<br />
nucleo.<br />
La risposta fu che l'elettrone non avrebbe potuto avere<br />
qualsiasi energia mentre orb<strong>it</strong>a attorno al nucleo. L'energia<br />
dell'elettrone è il quanto. Questo significa che l'elettrone ha<br />
un'energia strettamente defin<strong>it</strong>a e può orb<strong>it</strong>are solamente ad<br />
alcune distanze dal nucleo. Per essere più precisi, tutto questo<br />
non è propriamente vero, l'elettrone non orb<strong>it</strong>a esattamente<br />
nell'orb<strong>it</strong>a, infatti l'orb<strong>it</strong>a indica solamente il posto dove ci sono<br />
più probabil<strong>it</strong>à di localizzare l'elettrone.<br />
Questo discorso ci porterà a parlare della meccanica<br />
quantistica, in cui non si parla di certezza ma solamente di<br />
possibil<strong>it</strong>à.<br />
Le regole espresse in precedenza sono chiamate leggi di<br />
Heisenberg. Esse dicono che è impossibile determinare entrambe<br />
le proprietà di un atomo allo stesso tempo, senza influenzare<br />
una di esse.<br />
Di segu<strong>it</strong>o verranno enunciati alcuni principi di base della<br />
meccanica quantistica.<br />
Appendice C<br />
114
Il fenomeno della materia è che essa è cost<strong>it</strong>u<strong>it</strong>a da piccole<br />
parti. La più piccola serve per costruire le altre costruzioni della<br />
natura, come atomi e molecole, chiamate particelle<br />
fondamentali. Quello che i fisici hanno trovato è che le<br />
particelle non sono particelle nel senso di sfere, come si<br />
potrebbe immaginare, ma esse sono sottoforma di onde.<br />
Figura 1 : Esempio di particelle..<br />
Adesso parleremo di polarizzazione e shift di fase.<br />
Supponiamo di avere due onde della stessa lunghezza che<br />
viaggiano sullo stesso percorso x. Cosa dire degli altri assi E e<br />
B? Un'onda può avere gli assi B ed E alla stessa costante di 90°<br />
e quindi può ruotare attorno ad essi.<br />
Figura 2 : Esempio di polarizzazione.<br />
Dando una posizione casuale a due vettori in un sistema di<br />
assi, è possibile notare che essi appaiono più vicini, essendo<br />
ruotati di 90°.<br />
Dalla figura 2 è possibile dire che che l'onda elettro -<br />
magnetica è polarizzata per 90°. Di conseguenza il fotone,<br />
considerato la particella elementare della luce, può essere<br />
polarizzato, perchè? Perchè, come accennato in precedenza, la<br />
luce è sia particella che onda, e di conseguenza, ogni protone<br />
può essere considerato anche come un'onda.<br />
Appendice C<br />
115
Ora rimane un ultimo termine da definire : shift di fase.<br />
La figura sottostante descrive un'onda elettro - magnetica. Essa<br />
è una funzione seno. Essa è periodica di 360°. Questo significa<br />
che la funzione si ripete dopo alcuni valori di x.<br />
Figura 3 : Esempio di phase shifting.<br />
Dalla figura è possibile notare che le funzione verde e<br />
rossa sono le stesse, ma shiftate sull'asse x. Per essere più<br />
precisi la funzione rossa è sin(x), mentre quella verde è<br />
sin(x+pi/4). Adesso si può dire che quest'ultima è shiftata di<br />
fase pi/4 (45°). La stessa cosa succede per le onde<br />
elettromagnetiche perchè esse sono descr<strong>it</strong>te da un'onda<br />
sinusoidale.<br />
2 Cr<strong>it</strong>tografia quantica<br />
Ora si hanno due possibil<strong>it</strong>à per mandare un messaggio.<br />
Un cifrario a chiave privata, come quello di Vernam, se è<br />
possibile tenere segreta la chiave. E' proprio in questo punto<br />
che entra in gioco la fisica quantistica.<br />
Bob e Alice devono dividere una chiave segreta, la<br />
cr<strong>it</strong>tografia quantistica permette a due parti separate fisicamente<br />
di creare una chiave segreta casuale senza servirsi del servizio di<br />
un corriere. La cosa migliore è che il sistema permette di<br />
verificare se la chiave è stata intercettata. La cr<strong>it</strong>tografia<br />
quantistica non è un sistema cr<strong>it</strong>tografico totalmente nuovo, ma<br />
la procedura di distribuzione della chiave in perfetta discrezione<br />
lo rende sicuro.<br />
Per capire meglio come funziona la cr<strong>it</strong>tografia quantistica<br />
possiamo considerare il protocollo di comunicazione BB84,<br />
introdotto nel 1984 da Charles Bennett dell'IBM e Gilles<br />
Brassard dell'Univers<strong>it</strong>à di Montreal.<br />
Appendice C<br />
116
Alice e Bob sono connessi da un canale quantico e da da<br />
un classico canale pubblico. Se i singoli fotoni sono usati per<br />
trasportare le informazioni il canale quantico è sol<strong>it</strong>amente una<br />
fibra ottica. Il canale pubblico può essere qualsiasi mezzo di<br />
comunicazione, come una linea telefonica.<br />
Ora parliamo per un attimo di informazione. Le<br />
informazioni nel mondo dei computer sono rappresentate da una<br />
serie di 0 e 1 che un<strong>it</strong>i insieme formano l'informazione. Questi 0<br />
e 1 quando viaggiano in una linea telefonica sono rappresentati<br />
da un voltaggio (sol<strong>it</strong>amente 0V e 5V). Nel caso del canale<br />
quantico le portanti sono i fotoni e come possiamo vedere<br />
possono usare sia la polarizzazione che lo shift di fase.<br />
Figura 4 : Trasmissione tra Alice e Bob.<br />
1. Alice ha 4 polarizzatori, che possono trasmettere<br />
singoli fotoni polarizzati sia verticalmente che<br />
orizzontalmente, a 45° o a -45°. Essa manda una<br />
serie di fotoni attraverso il canale quantico, avendo<br />
scelto a caso uno degli stati di polarizzazione per<br />
ogni fotone.<br />
2. Bob ha 4 analizzatori (dispos<strong>it</strong>ivi che possono<br />
analizzare l'angolo di polarizzazione, o più angoli<br />
allo stesso tempo), non due. Un analizzatore<br />
permette a Bob di distinguere tra due fotoni<br />
polarizzati a 45° o a -45°, mentre gli altri gli<br />
permettono di distinguere tra i fotoni polarizzati<br />
verticalmente o orizzontalmente. Si noti che Alice ha<br />
4 polarizzatori e Bob solo due analizzatori. Si noti,<br />
inoltre, come gli 0 e gli 1 sono settati da Alice.<br />
Questo è cruciale. Cosa fa Bob, allora? Egli sceglie<br />
casualmente un analizzatore e lo usa per registrare<br />
ogni protone. In segu<strong>it</strong>o scriverà quale analizzatore<br />
ha usato e cosa ha registrato. Per esempio, Alice<br />
manda un protone polarizzato verticalmente e Bob<br />
sceglie di analizzare solo quelli a +/-45°.<br />
Essenzialmente se Bob sceglie un analizzatore a +/-<br />
45° ci sono il 50% di probabil<strong>it</strong>à che esso registri<br />
qualcosa, mentre se Bob sceglie l'analizzatore<br />
sbagliato, non ha possibil<strong>it</strong>à di trovare che stato di<br />
Appendice C<br />
117
polarizzazione Alice ha inviato. Dopo aver<br />
scambiato abbastanza fotoni, Bob annuncia nel<br />
canale pubblico la sequenza di analizzatori usata, ma<br />
non il risultato ottenuto.<br />
3. Alice compara la sequenza con la lista dei b<strong>it</strong>s<br />
originariamente inviati, e dice a Bob attraverso il<br />
canale pubblico in che occasione il suo analizzatore<br />
è compatibile con la polarizzazione del fotone. Essa<br />
non deve dire che stato di polarizzazione ha usato.<br />
Se Bob ha usato un analizzatore non compatibile con<br />
il fotone di Alice, il b<strong>it</strong> è rifiutato. Per i b<strong>it</strong><br />
rimanenti, Alice e Bob sanno che hanno lo stesso<br />
valore. I b<strong>it</strong>s che rimangono ad Alice e a Bob<br />
possono essere usati per generare una chiave che essi<br />
potranno utilizzare per cr<strong>it</strong>tare il messaggio.<br />
Adesso analizziamo il caso in cui ci sia Eva. Supponiamo<br />
che Eva abbia intercettato entrambi i quanti e l’informazione<br />
inviata attraverso il canale pubblico. Cosa c'è di sbagliato in<br />
quello appena descr<strong>it</strong>to? Ovviamente i b<strong>it</strong>s scoperti non possono<br />
essere usati ancora per la cr<strong>it</strong>tazione. Se Eva intercetta la loro<br />
chiave, la correlazione tra i valori dei b<strong>it</strong>s diminuisce. Per<br />
esempio se Eva ha la stessa attrezzatura di Bob e taglia la fibra<br />
e misura il segnale, essa avrà dei b<strong>it</strong> casuali ogni volta che<br />
sceglierà l'analizzatore sbagliato. Ma avendo intercettato il<br />
segnale, Eva deve mandare un fotone a Bob per coprire le<br />
proprie tracce. Di conseguenza, nel 50% dei casi gli analizzatori<br />
di Alice e Bob coincidono, ma cosa succede nel caso in cui Eva<br />
abbia sbagliato analizzatore? Comunque nella metà dei casi i<br />
fotoni passeranno accidentalmente attraverso l'analizzatore<br />
giusto dalla parte di Bob. Si può vedere ora che la correlazione<br />
tra Alice e Bob scende al 25% in presenza di Eva. In questo caso<br />
Alice e Bob conosceranno l'informazione che è stata<br />
intercettata, quando compareranno le chiavi sul canale pubblico,<br />
notando un grande disaccordo.<br />
Cosa si può ottenere dalla cr<strong>it</strong>tografia in pratica? I fotoni<br />
sono dei buoni candidati per trasportare informazioni; essi sono<br />
semplici da produrre a da misurare. L'esempio fatto per la<br />
polarizzazione può essere valido per lo shift di fase. Infatti, è<br />
più usato della polarizzazione. Cosa migliore, i protoni, possono<br />
essere trasmessi attraverso la fibra ottica e la loro attenuazione<br />
è di circa 25 anni (misura di quanti fotoni vengono persi durante<br />
la trasmissione) a una lunghezza d'onda di 1300nm. Questo<br />
significa che i protoni possono viaggiare per 10Km prima che il<br />
50% di essi venga perso. E' importante notare che i protoni non<br />
possono essere amplificati, perchè gli stati dei quanti non<br />
possono essere duplicati.<br />
Certamente questo non è l'unico problema. Ci sono anche<br />
problemi relativi alla linea. La non correlazione tra b<strong>it</strong> può<br />
anche essere causata da alcune imperefezioni sperimentali. Per<br />
esempio, Alice deve essere sicura di creare fotoni dello stato<br />
scelto.<br />
Appendice C<br />
118
Per superare questi problemi, Alice e Bob devono<br />
applicare un classico algor<strong>it</strong>mo di gestione degli errori, che<br />
riporti le probabil<strong>it</strong>à di errore negli standard telecomunicativi<br />
(10^-9).<br />
C'è una procedura che Alice e Bob possono usare<br />
conosciuta col nome di "amplificazione privata" in cui gruppi di<br />
b<strong>it</strong> sono combinati in uno solo. Questa procedura assicura che i<br />
b<strong>it</strong> combinati coincidano solo se i b<strong>it</strong> iniziali di Alice e Bob<br />
sono gli stessi.<br />
Appendice C<br />
119
Appendice D<br />
Manuale PGP<br />
Gen. nuove chiavi: pgp -kg<br />
Aggiunta di chiavi: pgp -ka file [portachiavi]<br />
Esrazione di chiavi: pgp -kx[a] ID file [portachiavi]<br />
Vedere chiavi: pgp -kv[v] [ID] [portachiavi]<br />
Vedere impronte dig<strong>it</strong>ali: pgp -kvc [ID] [portachiavi]<br />
Vedere in dettaglio: pgp -kc [ID] [portachiavi]<br />
Rimuovere ID o chiavi: pgp -kr ID [portachiavi]<br />
(Ripetere per piu' ID su una chiave)<br />
Aggiungere un ID: pgp -ke ID [portachiavi]<br />
Modifica frase chiave: pgp -ke ID [portachiavi]<br />
Modif. param. affidab.: pgp -kx ID key.tmp [portachiavi]<br />
pgp -kr ID [portachiavi]<br />
pgp -ka key.tmp [portachiavi]<br />
Firmare una chiave: pgp -ks suo_ID [-u mio_ID]<br />
Rimuovere la firma da una<br />
chiave: pgp -krs ID [portachiavi]<br />
Revoca, disabil<strong>it</strong>az.: pgp -kd ID [portachiavi]<br />
Criptare: pgp -e[a] filetesto dest_ID<br />
Firmare: pgp -s[a] filetesto [-u mio_ID]<br />
Firmare e criptare: pgp -se[a] filetesto dest_ID<br />
[dest2_ID...][-u mio_ID]<br />
Certif. separato: pgp -sb[a] [+clearsig=on] file<br />
principale [-u mio_ID]<br />
Criptare solo con IDEA: pgp -c filetesto<br />
Decr<strong>it</strong>tare o controllo<br />
firma: pgp [-d] [-p] filecifrato<br />
(-d per tenere i dati pgp, -p per il nome originale)<br />
Verifica firma separata: pgp filefirma [fileprincipale]<br />
Aggiungere [a] per produrre files ASCII<br />
Aggiungere [-o outfile] per specificare il file di usc<strong>it</strong>a<br />
Aggiungere [+batchmode] per vedere l'usc<strong>it</strong>a errorlevels<br />
Aggiungere [f] per ridirigere i dati ( pgp -f[ARGS] outfile )<br />
Aggiungere [w] per distruggere il file in chiaro (dopo la<br />
cifratura)<br />
Aggiunger [m] per permettere la sola visione del testo in chiaro<br />
senza file di usc<strong>it</strong>a<br />
Aggiungere [t] per usare il terminatore di linea Unix<br />
Usare [-@] per specificare destinatari addizionali quando si cifra<br />
Appendice D<br />
120
Appendice E<br />
Prodotti esistenti<br />
1 Netbus<br />
Sono già in commercio alcuni programmi che svolgono<br />
operazioni simili a quelle che ci siamo proposti di raggiungere,<br />
ossia software che intercettano i messaggi provenienti dalla rete.<br />
Netbus è un dei più famosi ed efficienti.<br />
Inizialmente è stato prodotto come gestore di sistemi in<br />
remoto, infatti Netbus e' un potentissimo strumento, che se<br />
usato in maniera giusta, puo' pilotare completamente un'altro<br />
pc, a migliaia di km di distanza, risolvendo molti inconvenienti.<br />
1 Netbus<br />
NETBUS è un programma di BACKDOOR. Grazie a<br />
questo programma l'hacker può teleguidare il vostro computer.<br />
Netbus ha una interfaccia molto più semplice, bisogna solo<br />
conoscere l'indirizzo IP del computer da colpire, poi basta<br />
premere i pulsanti in dotazione col programma client<br />
(programma dell'hacker) come Open CD-ROM che serve ad aprire<br />
e chiudere il cassettino del CD-ROM o Play sound che serve a<br />
fare suonare una musica al server remoto (il vostro computer<br />
colp<strong>it</strong>o da hacker) e moltissimi altri comandi intu<strong>it</strong>ivi.<br />
Figura 1 : Interfaccia di Netbus.<br />
Appendice E<br />
121
Quando un hacker installa il suo "cavallo di troia" nel<br />
vostro computer mette una password per accedere al vostro<br />
computer, in questo modo solo lui potra accedervi; esiste però<br />
una master password. Ciò che lo rende più evoluto degli altri<br />
programmi di Back door è la possibil<strong>it</strong>à di fare la scansione<br />
automatica degli indirizzi IP e la possibil<strong>it</strong>à di avere più persone<br />
sotto il controllo dell'hacker, in questo modo l'hacker non deve<br />
inserire sequenzialmente ogni indirizzo IP ma sarà il programma<br />
stesso a fare la scansione; per fare la scansione basta mettere<br />
xxx.xxx.xxx.0+255 (dove xxx è un numero compreso tra 0 e 255)<br />
in questo modo Netbus farà la scansione da 0 a 255 dell'ultimo<br />
campo dell'indirizzo IP.<br />
Figura 2 : Gestione remota di file con Netbus.<br />
Il programma comprende due file: il programma server e il<br />
programma client.<br />
Il programma server è il file con dimensione minore ed è il<br />
file che infetta il computer del malcap<strong>it</strong>ato, per infettare il<br />
computer il programma deve essere esegu<strong>it</strong>o, il nome del file<br />
generalmente è PATCH.EXE (ma il nome può essere modificato<br />
a proprio piacimento); il programma è difficilmente visibile e si<br />
carica ogni volta che si avvia il computer<br />
Il programma client è quello che usa l'hacker per spiare (o<br />
distruggere) il vostro computer, ha un interfaccia semplicissima<br />
a pulsanti, bisogna solo inserire l'indirizzo IP del computer<br />
infetto (o la gamma di indirizzi) e premere i pulsanti.<br />
Ogni computer infetto ha una sua password di accesso esclusiva<br />
dell'hacker che vi ha infettato.<br />
Appendice E<br />
122
Appendice F<br />
Listati<br />
1 PTerminal<br />
1 PTerminal<br />
2 DES<br />
3 Cr<strong>it</strong>tografia<br />
4 TCP<br />
class CMySocket : public CAsyncSocket<br />
{<br />
private:<br />
CDialog* m_pWnd;<br />
// Attributes<br />
public:<br />
// Operations<br />
public:<br />
CMySocket();<br />
virtual ~CMySocket();<br />
SetParent (CDialog *pWnd);<br />
// Overrides<br />
public:<br />
// ClassWizard generated virtual function overrides<br />
//{{AFX_VIRTUAL(CMySocket)<br />
public:<br />
virtual void OnAccept(int nErrorCode);<br />
virtual void OnConnect(int nErrorCode);<br />
virtual void OnReceive(int nErrorCode);<br />
//}}AFX_VIRTUAL<br />
// Generated message map functions<br />
//{{AFX_MSG(CMySocket)<br />
// NOTE - the ClassWizard will add and remove member<br />
functions here.<br />
//}}AFX_MSG<br />
// Implementation<br />
protected:<br />
};<br />
CMySocket::CMySocket()<br />
{<br />
}<br />
CMySocket::~CMySocket()<br />
{<br />
}<br />
CMySocket::SetParent (CDialog *pWnd)<br />
{<br />
m_pWnd = pWnd;<br />
}<br />
Appendice F<br />
123
Do not ed<strong>it</strong> the following lines, which are needed by<br />
ClassWizard.<br />
#if 0<br />
BEGIN_MESSAGE_MAP(CMySocket, CAsyncSocket)<br />
//{{AFX_MSG_MAP(CMySocket)<br />
//}}AFX_MSG_MAP<br />
END_MESSAGE_MAP()<br />
#endif // 0<br />
//////////////////////////////////////////////////////////////////<br />
/////CMySocket member functions<br />
void CMySocket::OnAccept(int nErrorCode)<br />
{<br />
if (nErrorCode == 0)<br />
((CPTerminalDlg*)m_pWnd)->OnAccept();<br />
}<br />
void CMySocket::OnConnect(int nErrorCode)<br />
{<br />
if (nErrorCode == 0)<br />
((CPTerminalDlg*)m_pWnd)->OnConnect();<br />
}<br />
void CMySocket::OnReceive(int nErrorCode)<br />
{<br />
if (nErrorCode == 0)<br />
((CPTerminalDlg*)m_pWnd)->OnReceive();<br />
}<br />
class CPTerminalDlg : public CDialog<br />
{<br />
// Construction<br />
private:<br />
CMySocket m_sListenSocket;<br />
CMySocket m_sConnectSocket;<br />
public:<br />
CPTerminalDlg(CWnd* pParent = NULL); // standard<br />
constructor<br />
void OnAccept();<br />
void OnConnect();<br />
void OnSend();<br />
void OnReceive();<br />
void OnClose();<br />
// Dialog Data<br />
//{{AFX_DATA(CPTerminalDlg)<br />
enum { IDD = IDD_PTERMINAL_DIALOG };<br />
CListBox m_ctlSent;<br />
CListBox m_ctlRecvd;<br />
CButton m_ctlConnect;<br />
CString m_strMessage;<br />
CString m_strName;<br />
int m_iPort;<br />
int m_iType;<br />
//}}AFX_DATA<br />
// ClassWizard generated virtual function overrides<br />
//{{AFX_VIRTUAL(CPTerminalDlg)<br />
protected:<br />
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV<br />
support<br />
Appendice F<br />
124
}}AFX_VIRTUAL<br />
// Implementation<br />
protected:<br />
HICON m_hIcon;<br />
// Generated message map functions<br />
//{{AFX_MSG(CPTerminalDlg)<br />
virtual BOOL OnIn<strong>it</strong>Dialog();<br />
afx_msg void OnSysCommand(UINT nID, LPARAM lParam);<br />
afx_msg void OnDestroy();<br />
afx_msg void OnPaint();<br />
afx_msg HCURSOR OnQueryDragIcon();<br />
afx_msg void OnRType();<br />
afx_msg void OnBconnect();<br />
afx_msg void OnBsend();<br />
afx_msg void OnBclose();<br />
//}}AFX_MSG<br />
DEC<strong>LA</strong>RE_MESSAGE_MAP()<br />
};<br />
CPTerminalDlg::CPTerminalDlg(CWnd* pParent /*=NULL*/)<br />
: CDialog(CPTerminalDlg::IDD, pParent)<br />
{<br />
//{{AFX_DATA_INIT(CPTerminalDlg)<br />
m_strMessage = _T("");<br />
m_strName = _T("");<br />
m_iPort = 0;<br />
m_iType = -1;<br />
//}}AFX_DATA_INIT<br />
// Note that LoadIcon does not require a subsequent DestroyIcon<br />
in Win32<br />
m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);<br />
}<br />
void CPTerminalDlg::DoDataExchange(CDataExchange* pDX)<br />
{<br />
CDialog::DoDataExchange(pDX);<br />
//{{AFX_DATA_MAP(CPTerminalDlg)<br />
DDX_Control(pDX, IDC_LSENT, m_ctlSent);<br />
DDX_Control(pDX, IDC_LRECVD, m_ctlRecvd);<br />
DDX_Control(pDX, IDC_BCONNECT, m_ctlConnect);<br />
DDX_Text(pDX, IDC_EMSG, m_strMessage);<br />
DDX_Text(pDX, IDC_ESERVNAME, m_strName);<br />
DDX_Text(pDX, IDC_ESERVPORT, m_iPort);<br />
DDX_Radio(pDX, IDC_RCLIENT, m_iType);<br />
//}}AFX_DATA_MAP<br />
}<br />
BEGIN_MESSAGE_MAP(CPTerminalDlg, CDialog)<br />
//{{AFX_MSG_MAP(CPTerminalDlg)<br />
ON_WM_SYSCOMMAND()<br />
ON_WM_DESTROY()<br />
ON_WM_PAINT()<br />
ON_WM_QUERYDRAGICON()<br />
ON_BN_CLICKED(IDC_RCLIENT, OnRType)<br />
ON_BN_CLICKED(IDC_BCONNECT, OnBconnect)<br />
ON_BN_CLICKED(IDC_BSEND, OnBsend)<br />
ON_BN_CLICKED(IDC_RSERVER, OnRType)<br />
ON_BN_CLICKED(IDC_BCLOSE, OnBclose)<br />
//}}AFX_MSG_MAP<br />
END_MESSAGE_MAP()<br />
Appendice F<br />
125
///////////<br />
// CPTerminalDlg message handlers<br />
BOOL CPTerminalDlg::OnIn<strong>it</strong>Dialog()<br />
{<br />
CDialog::OnIn<strong>it</strong>Dialog();<br />
// Add "About..." menu <strong>it</strong>em to system menu.<br />
SetIcon(m_hIcon,FALSE);<br />
// IDM_ABOUTBOX must be in the system command range.<br />
ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);<br />
ASSERT(IDM_ABOUTBOX < 0xF000);<br />
CMenu* pSysMenu = GetSystemMenu(FALSE);<br />
if (pSysMenu != NULL)<br />
{<br />
CString strAboutMenu;<br />
strAboutMenu.LoadString(IDS_ABOUTBOX);<br />
if (!strAboutMenu.IsEmpty())<br />
{<br />
pSysMenu->AppendMenu(MF_SEPARATOR);<br />
pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX,<br />
strAboutMenu);<br />
}<br />
}<br />
// Set the icon for this dialog. The framework does this<br />
automatically<br />
// when the application's main window is not a dialog<br />
SetIcon(m_hIcon, TRUE); // Set big icon<br />
SetIcon(m_hIcon, FALSE); // Set small icon<br />
m_iType = 0;<br />
m_strName = "loopback";<br />
m_iPort = 4000;<br />
UpdateData(FALSE);<br />
m_sConnectSocket.SetParent (this);<br />
m_sListenSocket.SetParent (this);<br />
return TRUE; // return TRUE unless you set the focus to a<br />
control<br />
}<br />
void CPTerminalDlg::OnSysCommand(UINT nID, LPARAM lParam)<br />
{<br />
if ((nID & 0xFFF0) == IDM_ABOUTBOX)<br />
{<br />
CAboutDlg dlgAbout;<br />
dlgAbout.DoModal();<br />
}<br />
else<br />
{<br />
CDialog::OnSysCommand(nID, lParam);<br />
}<br />
}<br />
void CPTerminalDlg::OnDestroy()<br />
{<br />
WinHelp(0L, HELP_QUIT);<br />
Appendice F<br />
126
}<br />
CDialog::OnDestroy();<br />
// If you add a minimize button to your dialog, you will need the<br />
code below<br />
// to draw the icon. For MFC applications using the<br />
document/view model,<br />
// this is automatically done for you by the framework.<br />
void CPTerminalDlg::OnPaint()<br />
{<br />
if (IsIconic())<br />
{<br />
CPaintDC dc(this); // device context for painting<br />
0);<br />
}<br />
}<br />
else<br />
{<br />
}<br />
SendMessage(WM_ICONERASEBKGND, (WPARAM) dc.GetSafeHdc(),<br />
// Center icon in client rectangle<br />
int cxIcon = GetSystemMetrics(SM_CXICON);<br />
int cyIcon = GetSystemMetrics(SM_CYICON);<br />
CRect rect;<br />
GetClientRect(&rect);<br />
int x = (rect.Width() - cxIcon + 1) / 2;<br />
int y = (rect.Height() - cyIcon + 1) / 2;<br />
// Draw the icon<br />
dc.DrawIcon(x, y, m_hIcon);<br />
CDialog::OnPaint();<br />
// The system calls this to obtain the cursor to display while the<br />
user drags<br />
// the minimized window.<br />
HCURSOR CPTerminalDlg::OnQueryDragIcon()<br />
{<br />
return (HCURSOR) m_hIcon;<br />
}<br />
void CPTerminalDlg::OnRType()<br />
{<br />
}<br />
UpdateData(TRUE);<br />
if (m_iType == 0)<br />
m_ctlConnect.SetWindowText ("C&onnect");<br />
else<br />
m_ctlConnect.SetWindowText ("&Listen");<br />
void CPTerminalDlg::OnBconnect()<br />
{<br />
UpdateData(TRUE);<br />
GetDlgItem(IDC_BCONNECT)->EnableWindow(FALSE);<br />
GetDlgItem(IDC_ESERVNAME)->EnableWindow(FALSE);<br />
GetDlgItem(IDC_ESERVPORT)->EnableWindow(FALSE);<br />
GetDlgItem(IDC_STATICNAME)->EnableWindow(FALSE);<br />
Appendice F<br />
127
}<br />
GetDlgItem(IDC_STATICPORT)->EnableWindow(FALSE);<br />
GetDlgItem(IDC_RCLIENT)->EnableWindow(FALSE);<br />
GetDlgItem(IDC_RSERVER)->EnableWindow(FALSE);<br />
GetDlgItem(IDC_STATICTYPE)->EnableWindow(FALSE);<br />
if (m_iType == 0)<br />
{<br />
// CAsyncSocket *pSock = new CAsyncSocket;<br />
// if (m_sConnectSocket.Accept (*pSock))<br />
// {<br />
// pSock->Create ();<br />
// pSock->Connect (m_strName,m_iPort);<br />
// }<br />
m_sConnectSocket.Create();<br />
m_sConnectSocket.Connect(m_strName,m_iPort);<br />
}<br />
else<br />
{<br />
m_sListenSocket.Create(m_iPort);<br />
m_sListenSocket.Listen();<br />
}<br />
void CPTerminalDlg::OnAccept()<br />
{<br />
CAsyncSocket *pSock = new CAsyncSocket;<br />
if (m_sListenSocket.Accept (*pSock))<br />
{<br />
pSock->Create ();<br />
pSock->Connect (m_strName,m_iPort);<br />
}<br />
else<br />
delete pSock;<br />
//m_sListenSocket.Accept(m_sConnectSocket);<br />
}<br />
GetDlgItem(IDC_EMSG)->EnableWindow(TRUE);<br />
GetDlgItem(IDC_BSEND)->EnableWindow(TRUE);<br />
GetDlgItem(IDC_STATICMSG)->EnableWindow(TRUE);<br />
void CPTerminalDlg::OnConnect()<br />
{<br />
GetDlgItem(IDC_EMSG)->EnableWindow(TRUE);<br />
GetDlgItem(IDC_BSEND)->EnableWindow(TRUE);<br />
GetDlgItem(IDC_STATICMSG)->EnableWindow(TRUE);<br />
GetDlgItem(IDC_BCLOSE)->EnableWindow(TRUE);<br />
}<br />
void CPTerminalDlg::OnReceive()<br />
{<br />
char *pBuf = new char[1025];<br />
int iBufSize = 1024;<br />
int iRcvd;<br />
CString strRecvd;<br />
iRcvd = m_sConnectSocket.Receive(pBuf, iBufSize);<br />
if (iRcvd == SOCKET_ERROR)<br />
{<br />
}<br />
else<br />
Appendice F<br />
128
}<br />
{<br />
}<br />
pBuf[iRcvd] = NULL;<br />
strRecvd = pBuf;<br />
m_ctlRecvd.AddString(strRecvd);<br />
UpdateData(FALSE);<br />
void CPTerminalDlg::OnClose()<br />
{<br />
m_sConnectSocket.Close();<br />
}<br />
GetDlgItem(IDC_EMSG)->EnableWindow(FALSE);<br />
GetDlgItem(IDC_BSEND)->EnableWindow(FALSE);<br />
GetDlgItem(IDC_STATICMSG)->EnableWindow(FALSE);<br />
GetDlgItem(IDC_BCLOSE)->EnableWindow(FALSE);<br />
if (m_iType == 0)<br />
{<br />
GetDlgItem(IDC_BCONNECT)->EnableWindow(TRUE);<br />
GetDlgItem(IDC_ESERVNAME)->EnableWindow(TRUE);<br />
GetDlgItem(IDC_ESERVPORT)->EnableWindow(TRUE);<br />
GetDlgItem(IDC_STATICNAME)->EnableWindow(TRUE);<br />
GetDlgItem(IDC_STATICPORT)->EnableWindow(TRUE);<br />
GetDlgItem(IDC_RCLIENT)->EnableWindow(TRUE);<br />
GetDlgItem(IDC_RSERVER)->EnableWindow(TRUE);<br />
GetDlgItem(IDC_STATICTYPE)->EnableWindow(TRUE);<br />
}<br />
void CPTerminalDlg::OnBsend()<br />
{<br />
int iLen;<br />
int iSent;<br />
UpdateData(TRUE);<br />
if (m_strMessage != "")<br />
{<br />
iLen = m_strMessage.GetLength();<br />
iSent = m_sConnectSocket.Send(LPCSTR(m_strMessage),<br />
iLen);<br />
}<br />
}<br />
if (iSent == SOCKET_ERROR)<br />
{<br />
}<br />
else<br />
{<br />
m_ctlSent.AddString(m_strMessage);<br />
UpdateData(FALSE);<br />
}<br />
void CPTerminalDlg::OnBclose()<br />
{<br />
OnClose();<br />
}<br />
Appendice F<br />
129
2 DES<br />
#if<br />
!defined(AFX_DES_H__7AF11A81_11EF_4947_8738_DF9FABD1DD25__INCLUDE)<br />
#define AFX_DES_H__7AF11A81_11EF_4947_8738_DF9FABD1DD25__INCLUDED_<br />
#if _MSC_VER > 1000<br />
#pragma once<br />
#endif // _MSC_VER > 1000<br />
class AFX_EXT_C<strong>LA</strong>SS CDes<br />
{<br />
public:<br />
void Decrypt(LPTSTR Key,LPTSTR Data);<br />
CDes();<br />
virtual ~CDes();<br />
void Crypt(LPTSTR Key, LPTSTR Data);<br />
private:<br />
unsigned _int64 artoi(unsigned int *array,unsigned int length);<br />
void <strong>it</strong>oar(unsigned __int64 int64,unsigned int *array,<br />
unsigned int length);<br />
unsigned _int64 stoi(char *string,unsigned int length);<br />
void <strong>it</strong>os(char *string,unsigned __int64 int64,<br />
unsigned int length);<br />
void matoar32(unsigned int matrix[][4],unsigned int array[],<br />
unsigned int yStart,unsigned int xStart,<br />
unsigned int yEnd,unsigned int xEnd);<br />
void matoar48(unsigned int matrix[][6],unsigned int array[],<br />
unsigned int yStart,unsigned int xStart,<br />
unsigned int yEnd,unsigned int xEnd);<br />
void matoar56(unsigned int matrix[][7],unsigned int array[],<br />
unsigned int yStart,unsigned int xStart,<br />
unsigned int yEnd,unsigned int xEnd);<br />
void matoar64(unsigned int matrix[][8],unsigned int array[],<br />
unsigned int yStart,unsigned int xStart,<br />
unsigned int yEnd,unsigned int xEnd);<br />
void _strcat(char *strDest,char *strOr);<br />
void arcat(unsigned int *arrayOr1,unsigned int *arrayOr2,<br />
unsigned int *arrayDest,unsigned int lenDest,<br />
unsigned int lenOr);<br />
unsigned _int64 power(unsigned int b,unsigned int e);<br />
void shift(unsigned __int64 &shift,unsigned int nShift);<br />
void Calculate_Keys(unsigned int matrix[][7],<br />
unsigned int <strong>it</strong>erations);<br />
unsigned __int64 crypt(unsigned __int64 data,<br />
unsigned int <strong>it</strong>erations);<br />
unsigned __int64 decrypt(unsigned __int64 data,<br />
unsigned int <strong>it</strong>erations);<br />
void Divide(unsigned int *array,unsigned int matrix[][6],<br />
unsigned int lenAr,unsigned int lenGrp);<br />
unsigned int Index(unsigned matDiv[][6],unsigned matrix[][16],<br />
unsigned row);<br />
void Group(unsigned int *array,unsigned int *arrGrp,<br />
unsigned int lenAr,unsigned int lenGrp);<br />
void Expand(unsigned int *array,unsigned int matrix[][6]);<br />
void Permute_IP(unsigned int *array,unsigned int matrix[][8]);<br />
Appendice F<br />
130
};<br />
void Permute_P2(unsigned int *array,unsigned int matrix[][4]);<br />
void Permute_FP(unsigned int *array,unsigned int matrix[][8]);<br />
void Reduce56to48(unsigned int *array,<br />
unsigned int matrix[][6]);<br />
void Reduce64to56(unsigned int *array,<br />
unsigned int matrix[][7]);<br />
void Set_Key(unsigned __int64 newKey);<br />
unsigned EX[8][6];<br />
unsigned FP[8][8];<br />
unsigned IP[8][8];<br />
unsigned __int64 Keys_Array[16];<br />
unsigned __int64 L[17];<br />
unsigned P1[8][6];<br />
unsigned P2[8][4];<br />
unsigned __int64 R[17];<br />
unsigned Rotation_Array[16];<br />
unsigned R1[8][7];<br />
unsigned S1[4][16];<br />
unsigned S2[4][16];<br />
unsigned S3[4][16];<br />
unsigned S4[4][16];<br />
unsigned S5[4][16];<br />
unsigned S6[4][16];<br />
unsigned S7[4][16];<br />
unsigned S8[4][16];<br />
unsigned _int64 Key;<br />
#endif<br />
#include "stdafx.h"<br />
#include "CDes.h"<br />
#ifdef _DEBUG<br />
#undef THIS_FILE<br />
static char THIS_FILE[]=__FILE__;<br />
#define new DEBUG_NEW<br />
#endif<br />
//////////////////////////////////////////////////////////////////<br />
////<br />
// Construction/Destruction<br />
//////////////////////////////////////////////////////////////////<br />
////<br />
CDes::CDes()<br />
{<br />
//Inizializzazione della prima matrice di riduzione.<br />
R1[0][0] = 57; R1[0][1] = 49; R1[0][2] = 41; R1[0][3] = 33;<br />
R1[0][4] = 25; R1[0][5] = 17; R1[0][6] = 9;<br />
R1[1][0] = 1; R1[1][1] = 58; R1[1][2] = 50; R1[1][3] = 42;<br />
R1[1][4] = 34; R1[1][5] = 26; R1[1][6] = 18;<br />
R1[2][0] = 10; R1[2][1] = 2; R1[2][2] = 59; R1[2][3] = 51;<br />
R1[2][4] = 43; R1[2][5] = 35; R1[2][6] = 27;<br />
R1[3][0] = 19; R1[3][1] = 11; R1[3][2] = 3; R1[3][3] = 60;<br />
R1[3][4] = 52; R1[3][5] = 44; R1[3][6] = 36;<br />
R1[4][0] = 63; R1[4][1] = 55; R1[4][2] = 47; R1[4][3] = 39;<br />
R1[4][4] = 31; R1[4][5] = 23; R1[4][6] = 15;<br />
Appendice F<br />
131
R1[5][0] = 7; R1[5][1] = 62; R1[5][2] = 54; R1[5][3] = 46;<br />
R1[5][4] = 38; R1[5][5] = 30; R1[5][6] = 22;<br />
R1[6][0] = 14; R1[6][1] = 6; R1[6][2] = 61; R1[6][3] = 53;<br />
R1[6][4] = 45; R1[6][5] = 37; R1[6][6] = 29;<br />
R1[7][0] = 21; R1[7][1] = 13; R1[7][2] = 5; R1[7][3] = 28;<br />
R1[7][4] = 20; R1[7][5] = 12; R1[7][6] = 4;<br />
//Inizializzazione della prima matrice di permutazione<br />
P1[0][0] = 14; P1[0][1] = 17; P1[0][2] = 11; P1[0][3] = 24;<br />
P1[0][4] = 1; P1[0][5] = 5;<br />
P1[1][0] = 3; P1[1][1] = 28; P1[1][2] = 15; P1[1][3] = 6;<br />
P1[1][4] = 21; P1[1][5] = 10;<br />
P1[2][0] = 23; P1[2][1] = 19; P1[2][2] = 12; P1[2][3] = 4;<br />
P1[2][4] = 26; P1[2][5] = 8;<br />
P1[3][0] = 16; P1[3][1] = 7; P1[3][2] = 27; P1[3][3] = 20;<br />
P1[3][4] = 13; P1[3][5] = 2;<br />
P1[4][0] = 41; P1[4][1] = 52; P1[4][2] = 31; P1[4][3] = 37;<br />
P1[4][4] = 47; P1[4][5] = 55;<br />
P1[5][0] = 30; P1[5][1] = 40; P1[5][2] = 51; P1[5][3] = 45;<br />
P1[5][4] = 33; P1[5][5] = 48;<br />
P1[6][0] = 44; P1[6][1] = 49; P1[6][2] = 39; P1[6][3] = 56;<br />
P1[6][4] = 34; P1[6][5] = 53;<br />
P1[7][0] = 46; P1[7][1] = 42; P1[7][2] = 50; P1[7][3] = 36;<br />
P1[7][4] = 29; P1[7][5] = 32;<br />
//Inizializzazione della seconda matrice di permutazione<br />
P2[0][0] = 16; P2[0][1] = 7; P2[0][2] = 20; P2[0][3] = 21;<br />
P2[1][0] = 29; P2[1][1] = 12; P2[1][2] = 28; P2[1][3] = 17;<br />
P2[2][0] = 1; P2[2][1] = 15; P2[2][2] = 23; P2[2][3] = 26;<br />
P2[3][0] = 5; P2[3][1] = 18; P2[3][2] = 31; P2[3][3] = 10;<br />
P2[4][0] = 2; P2[4][1] = 8; P2[4][2] = 24; P2[4][3] = 14;<br />
P2[5][0] = 32; P2[5][1] = 27; P2[5][2] = 3; P2[5][3] = 9;<br />
P2[6][0] = 19; P2[6][1] = 13; P2[6][2] = 30; P2[6][3] = 6;<br />
P2[7][0] = 22; P2[7][1] = 11; P2[7][2] = 4; P2[7][3] = 25;<br />
//Inizializzazione della matrice di permutazione iniziale<br />
IP[0][0] = 58; IP[0][1] = 50; IP[0][2] = 42; IP[0][3] = 34;<br />
IP[0][4] = 26; IP[0][5] = 18; IP[0][6] = 10; IP[0][7] = 2;<br />
IP[1][0] = 60; IP[1][1] = 52; IP[1][2] = 44; IP[1][3] = 36;<br />
IP[1][4] = 28; IP[1][5] = 20; IP[1][6] = 12; IP[1][7] = 4;<br />
IP[2][0] = 62; IP[2][1] = 54; IP[2][2] = 46; IP[2][3] = 38;<br />
IP[2][4] = 30; IP[2][5] = 22; IP[2][6] = 14; IP[2][7] = 6;<br />
IP[3][0] = 64; IP[3][1] = 56; IP[3][2] = 48; IP[3][3] = 40;<br />
IP[3][4] = 32; IP[3][5] = 24; IP[3][6] = 16; IP[3][7] = 8;<br />
IP[4][0] = 57; IP[4][1] = 49; IP[4][2] = 41; IP[4][3] = 33;<br />
IP[4][4] = 25; IP[4][5] = 17; IP[4][6] = 9; IP[4][7] = 1;<br />
IP[5][0] = 59; IP[5][1] = 51; IP[5][2] = 43; IP[5][3] = 35;<br />
IP[5][4] = 27; IP[5][5] = 19; IP[5][6] = 11; IP[5][7] = 3;<br />
IP[6][0] = 61; IP[6][1] = 53; IP[6][2] = 45; IP[6][3] = 37;<br />
IP[6][4] = 29; IP[6][5] = 21; IP[6][6] = 13; IP[6][7] = 5;<br />
IP[7][0] = 63; IP[7][1] = 55; IP[7][2] = 47; IP[7][3] = 39;<br />
IP[7][4] = 31; IP[7][5] = 23; IP[7][6] = 15; IP[7][7] = 7;<br />
//Inizializzazione della matrice di permutazione finale<br />
FP[0][0] = 40; FP[0][1] = 8; FP[0][2] = 48; FP[0][3] = 16;<br />
FP[0][4] = 56; FP[0][5] = 24; FP[0][6] = 64; FP[0][7] = 32;<br />
FP[1][0] = 39; FP[1][1] = 7; FP[1][2] = 47; FP[1][3] = 15;<br />
FP[1][4] = 55; FP[1][5] = 23; FP[1][6] = 63; FP[1][7] = 31;<br />
FP[2][0] = 38; FP[2][1] = 6; FP[2][2] = 46; FP[2][3] = 14;<br />
FP[2][4] = 54; FP[2][5] = 22; FP[2][6] = 62; FP[2][7] = 30;<br />
FP[3][0] = 37; FP[3][1] = 5; FP[3][2] = 45; FP[3][3] = 13;<br />
FP[3][4] = 53; FP[3][5] = 21; FP[3][6] = 61; FP[3][7] = 29;<br />
Appendice F<br />
132
FP[4][0] = 36; FP[4][1] = 4; FP[4][2] = 44; FP[4][3] = 12;<br />
FP[4][4] = 52; FP[4][5] = 20; FP[4][6] = 60; FP[4][7] = 28;<br />
FP[5][0] = 35; FP[5][1] = 3; FP[5][2] = 43; FP[5][3] = 11;<br />
FP[5][4] = 51; FP[5][5] = 19; FP[5][6] = 59; FP[5][7] = 27;<br />
FP[6][0] = 34; FP[6][1] = 2; FP[6][2] = 42; FP[6][3] = 10;<br />
FP[6][4] = 50; FP[6][5] = 18; FP[6][6] = 58; FP[6][7] = 26;<br />
FP[7][0] = 33; FP[7][1] = 1; FP[7][2] = 41; FP[7][3] = 9;<br />
FP[7][4] = 49; FP[7][5] = 17; FP[7][6] = 57; FP[7][7] = 25;<br />
//Inizializzazione della prima matrice di permutazione<br />
EX[0][0] = 32; EX[0][1] = 1; EX[0][2] = 2; EX[0][3] = 3;<br />
EX[0][4] = 4; EX[0][5] = 5;<br />
EX[1][0] = 4; EX[1][1] = 5; EX[1][2] = 6; EX[1][3] = 7;<br />
EX[1][4] = 8; EX[1][5] = 9;<br />
EX[2][0] = 8; EX[2][1] = 9; EX[2][2] = 10; EX[2][3] = 11;<br />
EX[2][4] = 12; EX[2][5] = 13;<br />
EX[3][0] = 12; EX[3][1] = 13; EX[3][2] = 14; EX[3][3] = 15;<br />
EX[3][4] = 16; EX[3][5] = 17;<br />
EX[4][0] = 16; EX[4][1] = 17; EX[4][2] = 18; EX[4][3] = 19;<br />
EX[4][4] = 20; EX[4][5] = 21;<br />
EX[5][0] = 20; EX[5][1] = 21; EX[5][2] = 22; EX[5][3] = 23;<br />
EX[5][4] = 24; EX[5][5] = 25;<br />
EX[6][0] = 24; EX[6][1] = 25; EX[6][2] = 26; EX[6][3] = 27;<br />
EX[6][4] = 28; EX[6][5] = 29;<br />
EX[7][0] = 28; EX[7][1] = 29; EX[7][2] = 30; EX[7][3] = 31;<br />
EX[7][4] = 32; EX[7][5] = 1;<br />
//Inizializzazione delle 8 tavole (S-Box)<br />
//1°<br />
S1[0][0] = 14; S1[0][1] = 4; S1[0][2] = 13; S1[0][3] = 1;<br />
S1[0][4] = 2; S1[0][5] = 15; S1[0][6] = 11; S1[0][7] = 8;<br />
S1[0][8] = 3; S1[0][9] = 10; S1[0][10] = 6; S1[0][11] = 12;<br />
S1[0][12] = 5; S1[0][13] = 9; S1[0][14] = 0; S1[0][15] = 7;<br />
S1[1][0] = 0; S1[1][1] = 15; S1[1][2] = 7; S1[1][3] = 4;<br />
S1[1][4] = 14; S1[1][5] = 2; S1[1][6] = 13; S1[1][7] = 1;<br />
S1[1][8] = 10; S1[1][9] = 6; S1[1][10] = 12; S1[1][11] = 11;<br />
S1[1][12] = 9; S1[1][13] = 5; S1[1][14] = 3; S1[1][15] = 8;<br />
S1[2][0] = 4; S1[2][1] = 1; S1[2][2] = 14; S1[2][3] = 8;<br />
S1[2][4] = 13; S1[2][5] = 6; S1[2][6] = 2; S1[2][7] = 11;<br />
S1[2][8] = 15; S1[2][9] = 12; S1[2][10] = 9; S1[2][11] = 7;<br />
S1[2][12] = 3; S1[2][13] = 10; S1[2][14] = 5; S1[2][15] = 0;<br />
S1[3][0] = 15; S1[3][1] = 12; S1[3][2] = 8; S1[3][3] = 2;<br />
S1[3][4] = 4; S1[3][5] = 9; S1[3][6] = 1; S1[3][7] = 7;<br />
S1[3][8] = 5; S1[3][9] = 11; S1[3][10] = 3; S1[3][11] = 14;<br />
S1[3][12] = 10; S1[3][13] = 0; S1[3][14] = 6; S1[3][15] = 13;<br />
//2°<br />
S2[0][0] = 15; S2[0][1] = 1; S2[0][2] = 8; S2[0][3] = 14;<br />
S2[0][4] = 6; S2[0][5] = 11; S2[0][6] = 3; S2[0][7] = 4;<br />
S2[0][8] = 9; S2[0][9] = 7; S2[0][10] = 2; S2[0][11] = 13;<br />
S2[0][12] = 12; S2[0][13] = 0; S2[0][14] = 5; S2[0][15] = 10;<br />
S2[1][0] = 3; S2[1][1] = 13; S2[1][2] = 4; S2[1][3] = 7;<br />
S2[1][4] = 15; S2[1][5] = 2; S2[1][6] = 8; S2[1][7] = 14;<br />
S2[1][8] = 12; S2[1][9] = 0; S2[1][10] = 1; S2[1][11] = 10;<br />
S2[1][12] = 6; S2[1][13] = 9; S2[1][14] = 11; S2[1][15] = 5;<br />
S2[2][0] = 0; S2[2][1] = 14; S2[2][2] = 7; S2[2][3] = 11;<br />
S2[2][4] = 10; S2[2][5] = 4; S2[2][6] = 13; S2[2][7] = 1;<br />
S2[2][8] = 5; S2[2][9] = 8; S2[2][10] = 12; S2[2][11] = 6;<br />
S2[2][12] = 9; S2[2][13] = 3; S2[2][14] = 2; S2[2][15] = 15;<br />
S2[3][0] = 13; S2[3][1] = 8; S2[3][2] = 10; S2[3][3] = 1;<br />
S2[3][4] = 3; S2[3][5] = 15; S2[3][6] = 4; S2[3][7] = 2;<br />
S2[3][8] = 11; S2[3][9] = 6; S2[3][10] = 7; S2[3][11] = 12;<br />
S2[3][12] = 0; S2[3][13] = 5; S2[3][14] = 14; S2[3][15] = 9;<br />
Appendice F<br />
133
3°<br />
S3[0][0] = 10; S3[0][1] = 0; S3[0][2] = 9; S3[0][3] = 14;<br />
S3[0][4] = 6; S3[0][5] = 3; S3[0][6] = 15; S3[0][7] = 5;<br />
S3[0][8] = 1; S3[0][9] = 13; S3[0][10] = 12; S3[0][11] = 7;<br />
S3[0][12] = 11; S3[0][13] = 4; S3[0][14] = 2; S3[0][15] = 8;<br />
S3[1][0] = 13; S3[1][1] = 7; S3[1][2] = 0; S3[1][3] = 9;<br />
S3[1][4] = 3; S3[1][5] = 4; S3[1][6] = 6; S3[1][7] = 10;<br />
S3[1][8] = 2; S3[1][9] = 8; S3[1][10] = 5; S3[1][11] = 14;<br />
S3[1][12] = 12; S3[1][13] = 11; S3[1][14] = 15; S3[1][15] = 1;<br />
S3[2][0] = 13; S3[2][1] = 6; S3[2][2] = 4; S3[2][3] = 9;<br />
S3[2][4] = 8; S3[2][5] = 15; S3[2][6] = 3; S3[2][7] = 0;<br />
S3[2][8] = 11; S3[2][9] = 1; S3[2][10] = 2; S3[2][11] = 12;<br />
S3[2][12] = 5; S3[2][13] = 10; S3[2][14] = 14; S3[2][15] = 7;<br />
S3[3][0] = 1; S3[3][1] = 10; S3[3][2] = 13; S3[3][3] = 0;<br />
S3[3][4] = 6; S3[3][5] = 9; S3[3][6] = 8; S3[3][7] = 7;<br />
S3[3][8] = 4; S3[3][9] = 15; S3[3][10] = 14; S3[3][11] = 3;<br />
S3[3][12] = 11; S3[3][13] = 5; S3[3][14] = 2; S3[3][15] = 12;<br />
//4°<br />
S4[0][0] = 7; S4[0][1] = 13; S4[0][2] = 14; S4[0][3] = 3;<br />
S4[0][4] = 0; S4[0][5] = 6; S4[0][6] = 9; S4[0][7] = 10;<br />
S4[0][8] = 1; S4[0][9] = 2; S4[0][10] = 8; S4[0][11] = 5;<br />
S4[0][12] = 11; S4[0][13] = 12; S4[0][14] = 4; S4[0][15] = 15;<br />
S4[1][0] = 13; S4[1][1] = 8; S4[1][2] = 11; S4[1][3] = 5;<br />
S4[1][4] = 6; S4[1][5] = 15; S4[1][6] = 0; S4[1][7] = 3;<br />
S4[1][8] = 4; S4[1][9] = 7; S4[1][10] = 2; S4[1][11] = 12;<br />
S4[1][12] = 1; S4[1][13] = 10; S4[1][14] = 14; S4[1][15] = 9;<br />
S4[2][0] = 10; S4[2][1] = 6; S4[2][2] = 9; S4[2][3] = 0;<br />
S4[2][4] = 12; S4[2][5] = 11; S4[2][6] = 7; S4[2][7] = 13;<br />
S4[2][8] = 15; S4[2][9] = 1; S4[2][10] = 3; S4[2][11] = 14;<br />
S4[2][12] = 5; S4[2][13] = 2; S4[2][14] = 8; S4[2][15] = 4;<br />
S4[3][0] = 3; S4[3][1] = 15; S4[3][2] = 0; S4[3][3] = 6;<br />
S4[3][4] = 10; S4[3][5] = 1; S4[3][6] = 13; S4[3][7] = 8;<br />
S4[3][8] = 9; S4[3][9] = 4; S4[3][10] = 5; S4[3][11] = 11;<br />
S4[3][12] = 12; S4[3][13] = 7; S4[3][14] = 2; S4[3][15] = 14;<br />
//5°<br />
S5[0][0] = 2; S5[0][1] = 12; S5[0][2] = 4; S5[0][3] = 1;<br />
S5[0][4] = 7; S5[0][5] = 10; S5[0][6] = 11; S5[0][7] = 6;<br />
S5[0][8] = 8; S5[0][9] = 5; S5[0][10] = 3; S5[0][11] = 15;<br />
S5[0][12] = 13; S5[0][13] = 0; S5[0][14] = 14; S5[0][15] = 9;<br />
S5[1][0] = 14; S5[1][1] = 11; S5[1][2] = 2; S5[1][3] = 12;<br />
S5[1][4] = 4; S5[1][5] = 7; S5[1][6] = 13; S5[1][7] = 1;<br />
S5[1][8] = 5; S5[1][9] = 0; S5[1][10] = 15; S5[1][11] = 10;<br />
S5[1][12] = 3; S5[1][13] = 9; S5[1][14] = 8; S5[1][15] = 6;<br />
S5[2][0] = 4; S5[2][1] = 2; S5[2][2] = 1; S5[2][3] = 11;<br />
S5[2][4] = 10; S5[2][5] = 13; S5[2][6] = 7; S5[2][7] = 8;<br />
S5[2][8] = 15; S5[2][9] = 9; S5[2][10] = 12; S5[2][11] = 5;<br />
S5[2][12] = 6; S5[2][13] = 3; S5[2][14] = 0; S5[2][15] = 14;<br />
S5[3][0] = 11; S5[3][1] = 8; S5[3][2] = 12; S5[3][3] = 7;<br />
S5[3][4] = 1; S5[3][5] = 14; S5[3][6] = 2; S5[3][7] = 13;<br />
S5[3][8] = 6; S5[3][9] = 15; S5[3][10] = 0; S5[3][11] = 9;<br />
S5[3][12] = 10; S5[3][13] = 4; S5[3][14] = 5; S5[3][15] = 3;<br />
//6°<br />
S6[0][0] = 12; S6[0][1] = 1; S6[0][2] = 10; S6[0][3] = 15;<br />
S6[0][4] = 9; S6[0][5] = 2; S6[0][6] = 6; S6[0][7] = 8;<br />
S6[0][8] = 0; S6[0][9] = 13; S6[0][10] = 3; S6[0][11] = 4;<br />
S6[0][12] = 14; S6[0][13] = 7; S6[0][14] = 5; S6[0][15] = 11;<br />
Appendice F<br />
134
S6[1][0] = 10; S6[1][1] = 15; S6[1][2] = 4; S6[1][3] = 2;<br />
S6[1][4] = 7; S6[1][5] = 12; S6[1][6] = 9; S6[1][7] = 5;<br />
S6[1][8] = 6; S6[1][9] = 1; S6[1][10] = 13; S6[1][11] = 14;<br />
S6[1][12] = 0; S6[1][13] = 11; S6[1][14] = 3; S6[1][15] = 8;<br />
S6[2][0] = 9; S6[2][1] = 14; S6[2][2] = 15; S6[2][3] = 5;<br />
S6[2][4] = 2; S6[2][5] = 8; S6[2][6] = 12; S6[2][7] = 3;<br />
S6[2][8] = 7; S6[2][9] = 0; S6[2][10] = 4; S6[2][11] = 10;<br />
S6[2][12] = 1; S6[2][13] = 13; S6[2][14] = 11; S6[2][15] = 6;<br />
S6[3][0] = 4; S6[3][1] = 3; S6[3][2] = 2; S6[3][3] = 12;<br />
S6[3][4] = 9; S6[3][5] = 5; S6[3][6] = 15; S6[3][7] = 10;<br />
S6[3][8] = 11; S6[3][9] = 14; S6[3][10] = 1; S6[3][11] = 7;<br />
S6[3][12] = 6; S6[3][13] = 0; S6[3][14] = 8; S6[3][15] = 13;<br />
//7°<br />
S7[0][0] = 4; S7[0][1] = 11; S7[0][2] = 2; S7[0][3] = 14;<br />
S7[0][4] = 15; S7[0][5] = 0; S7[0][6] = 8; S7[0][7] = 13;<br />
S7[0][8] = 3; S7[0][9] = 12; S7[0][10] = 9; S7[0][11] = 7;<br />
S7[0][12] = 5; S7[0][13] = 10; S7[0][14] = 6; S7[0][15] = 1;<br />
S7[1][0] = 13; S7[1][1] = 0; S7[1][2] = 11; S7[1][3] = 7;<br />
S7[1][4] = 4; S7[1][5] = 9; S7[1][6] = 1; S7[1][7] = 10;<br />
S7[1][8] = 14; S7[1][9] = 3; S7[1][10] = 5; S7[1][11] = 12;<br />
S7[1][12] = 2; S7[1][13] = 15; S7[1][14] = 8; S7[1][15] = 6;<br />
S7[2][0] = 1; S7[2][1] = 4; S7[2][2] = 11; S7[2][3] = 13;<br />
S7[2][4] = 12; S7[2][5] = 3; S7[2][6] = 7; S7[2][7] = 14;<br />
S7[2][8] = 10; S7[2][9] = 15; S7[2][10] = 6; S7[2][11] = 8;<br />
S7[2][12] = 0; S7[2][13] = 5; S7[2][14] = 9; S7[2][15] = 2;<br />
S7[3][0] = 6; S7[3][1] = 11; S7[3][2] = 13; S7[3][3] = 8;<br />
S7[3][4] = 1; S7[3][5] = 4; S7[3][6] = 10; S7[3][7] = 7;<br />
S7[3][8] = 9; S7[3][9] = 5; S7[3][10] = 0; S7[3][11] = 15;<br />
S7[3][12] = 14; S7[3][13] = 2; S7[3][14] = 3; S7[3][15] = 12;<br />
//8°<br />
S8[0][0] = 13; S8[0][1] = 2; S8[0][2] = 8; S8[0][3] = 4;<br />
S8[0][4] = 6; S8[0][5] = 15; S8[0][6] = 11; S8[0][7] = 1;<br />
S8[0][8] = 10; S8[0][9] = 9; S8[0][10] = 3; S8[0][11] = 14;<br />
S8[0][12] = 5; S8[0][13] = 0; S8[0][14] = 12; S8[0][15] = 7;<br />
S8[1][0] = 1; S8[1][1] = 15; S8[1][2] = 13; S8[1][3] = 8;<br />
S8[1][4] = 10; S8[1][5] = 3; S8[1][6] = 7; S8[1][7] = 4;<br />
S8[1][8] = 12; S8[1][9] = 5; S8[1][10] = 6; S8[1][11] = 11;<br />
S8[1][12] = 0; S8[1][13] = 14; S8[1][14] = 9; S8[1][15] = 2;<br />
S8[2][0] = 7; S8[2][1] = 11; S8[2][2] = 4; S8[2][3] = 1;<br />
S8[2][4] = 9; S8[2][5] = 12; S8[2][6] = 14; S8[2][7] = 2;<br />
S8[2][8] = 0; S8[2][9] = 6; S8[2][10] = 10; S8[2][11] = 13;<br />
S8[2][12] = 15; S8[2][13] = 3; S8[2][14] = 5; S8[2][15] = 8;<br />
S8[3][0] = 2; S8[3][1] = 1; S8[3][2] = 14; S8[3][3] = 7;<br />
S8[3][4] = 4; S8[3][5] = 10; S8[3][6] = 8; S8[3][7] = 13;<br />
S8[3][8] = 15; S8[3][9] = 12; S8[3][10] = 9; S8[3][11] = 0;<br />
S8[3][12] = 3; S8[3][13] = 5; S8[3][14] = 6; S8[3][15] = 11;<br />
//Inizializzazione dell'array delle rotazioni<br />
Rotation_Array[0] = 1;<br />
Rotation_Array[1] = 1;<br />
Rotation_Array[2] = 2;<br />
Rotation_Array[3] = 2;<br />
Rotation_Array[4] = 2;<br />
Rotation_Array[5] = 2;<br />
Rotation_Array[6] = 2;<br />
Rotation_Array[7] = 2;<br />
Rotation_Array[8] = 1;<br />
Rotation_Array[9] = 2;<br />
Rotation_Array[10] = 2;<br />
Rotation_Array[11] = 2;<br />
Rotation_Array[12] = 2;<br />
Appendice F<br />
135
}<br />
Rotation_Array[13] = 2;<br />
Rotation_Array[14] = 2;<br />
Rotation_Array[15] = 1;<br />
CDes::~CDes()<br />
{<br />
}<br />
void CDes::Crypt(LPTSTR Key, LPTSTR Data)<br />
{<br />
unsigned C[8][7];<br />
unsigned Index_Array[64];<br />
unsigned __int64 iCrypted = 0;<br />
unsigned __int64 iData = 0;<br />
unsigned __int64 iKey = 0;<br />
int k = 0;<br />
int iLen = 0;<br />
int iIter = 0;<br />
int iIter_Mod = 0;<br />
iLen = strlen(Data);<br />
if (iLen < 8) iIter++;<br />
else<br />
{<br />
iIter = iLen / 8;<br />
iIter_Mod = iLen % 8;<br />
if (iIter_Mod != 0) iIter++;<br />
}<br />
char *strData = new char[8];<br />
char *strCrypt = new char[64];<br />
char *strRes = new char[iIter * 8];<br />
unsigned __int64 *arrayCrypt = new unsigned __int64[iIter];<br />
strcpy(strRes," ");<br />
strcpy(strCrypt," ");<br />
iKey = _atoi64(Key);<br />
Set_Key(iKey);<br />
<strong>it</strong>oar(iKey,Index_Array,64);<br />
Reduce64to56(Index_Array,C);<br />
Calculate_Keys(C,16);<br />
for (register int i=0;i
}<br />
}<br />
arrayCrypt[i] = crypt(iData,16);<br />
for (i=0;i
}<br />
}<br />
}<br />
else<br />
{<br />
}<br />
strData[j] = Data[k];<br />
k++;<br />
iData = stoi(strData,iLen);<br />
arrayCrypt[i] = decrypt(iData,16);<br />
for (i=0;i matrice ridotta<br />
// <strong>it</strong>erations -> <strong>it</strong>erazioni<br />
//DESCRIZIONE<br />
// La funzione calcola le chiavi usate per la cr<strong>it</strong>tazione. Il<br />
//numero di chiavi da calcolare è defin<strong>it</strong>o dalla variabile<br />
//<strong>it</strong>erations.<br />
//////////////////////////////////////////////////////////////////<br />
void CDes::Calculate_Keys(unsigned int matrix[][7], unsigned int<br />
<strong>it</strong>erations)<br />
{<br />
unsigned matrixKey[8][6];<br />
unsigned __int64 iMsb = 0;<br />
unsigned __int64 iLsb = 0;<br />
unsigned __int64 iKey = 0;<br />
unsigned *arrayMsb = new unsigned[28];<br />
unsigned *arrayLsb = new unsigned[28];<br />
unsigned *arrayCat = new unsigned[56];<br />
unsigned *arrayKey = new unsigned[48];<br />
//Vengono creati due array, il primo con la parte bassa della<br />
//matrice il secondo con la parte alta. La matrice utilizzata è<br />
//quella contenente la chiave ridotta a 56 b<strong>it</strong>.<br />
matoar56(matrix,arrayLsb,0,0,4,7);<br />
matoar56(matrix,arrayMsb,4,0,8,7);<br />
//Vengono convert<strong>it</strong>i gli array prima calcolati in due interi.<br />
iMsb = artoi(arrayMsb,28); //D(0)<br />
iLsb = artoi(arrayLsb,28); //C(0)<br />
//Ciclo principale che permette il calcolo delle chiavi.<br />
for (register unsigned i=0;i
}<br />
{<br />
}<br />
//Vengono shiftati i valori precedentemente calcolati<br />
//secondo il valore contenuto nel array Rotation_Array.<br />
shift(iMsb,Rotation_Array[i]);<br />
shift(iLsb,Rotation_Array[i]);<br />
//I valori appena calcolati vengono convert<strong>it</strong>i in array.<br />
<strong>it</strong>oar(iMsb,arrayMsb,28);<br />
<strong>it</strong>oar(iLsb,arrayLsb,28);<br />
//Gli array appena calcolati vengono concatenati in uno<br />
//solo.<br />
arcat(arrayLsb,arrayMsb,arrayCat,28,28);<br />
//L'array appena calcolato viene ridotto, e trasformato<br />
//in una matrice.<br />
Reduce56to48(arrayCat,matrixKey);<br />
//La matrice risultante dall'ultima operazione viene<br />
//trasformata in un array.<br />
matoar48(matrixKey,arrayKey,0,0,8,6);<br />
//L'array ottenuto viene trasformato in un intero che<br />
//sarà la chiave.<br />
iKey = artoi(arrayKey,48);<br />
//La chiave viene memorizzata.<br />
Keys_Array[i] = iKey;<br />
delete [] arrayMsb;<br />
delete [] arrayLsb;<br />
delete [] arrayCat;<br />
delete [] arrayKey;<br />
//////////////////////////////////////////////////////////////////<br />
//PROTOTIPO : unsigned __int64 decrypt(unsigned __int64 data,<br />
// unsigned int <strong>it</strong>erations)<br />
//INPUT : data -> dati da decifrare<br />
// <strong>it</strong>erations -> <strong>it</strong>erazioni<br />
//OUTPUT : iRes -> dati cifrati<br />
//DESCRIZIONE<br />
// La funzione decr<strong>it</strong>ta il dato passato. La variabile <strong>it</strong>erations<br />
//indica, implic<strong>it</strong>amente, il numero di chiavi da usare per la<br />
//cifratura.<br />
//////////////////////////////////////////////////////////////////<br />
unsigned __int64 CDes::decrypt(unsigned __int64 data, unsigned int<br />
<strong>it</strong>erations)<br />
{<br />
unsigned matrixData[8][8];<br />
unsigned matrixExp[8][6];<br />
unsigned matrixPer[8][4];<br />
unsigned __int64 iExp = 0;<br />
unsigned __int64 iXor = 0;<br />
unsigned __int64 iRes = 0;<br />
unsigned __int64 iCrypted = 0;<br />
unsigned j = 0;<br />
unsigned x = 16;<br />
Appendice F<br />
139
unsigned *arrayData = new unsigned[64];<br />
unsigned *arrayLR = new unsigned[32];<br />
unsigned *arrayExp = new unsigned[48];<br />
unsigned *arraySBox = new unsigned[8];<br />
//I dati passati vengono convert<strong>it</strong>i in un array.<br />
<strong>it</strong>oar(data,arrayData,64);<br />
//L'array ottenuto viene permutato. Il risultato sarà una<br />
//matrice.<br />
Permute_IP(arrayData,matrixData);<br />
//La parte bassa della matrice viene convert<strong>it</strong>a in un array.<br />
matoar64(matrixData,arrayLR,0,0,4,8);<br />
//L'array risultante viene convert<strong>it</strong>o in un intero. Sarà il<br />
//primo blocco cifrato.<br />
L[0] = artoi(arrayLR,32);<br />
//Vengono effettuate le stesse operazioni precedenti, con<br />
//la parte alta della matrice.<br />
matoar64(matrixData,arrayLR,4,0,8,8);<br />
R[0] = artoi(arrayLR,32);<br />
//Il ciclo applica al blocco dati tutte le chiavi calcolate in<br />
//precedenza.<br />
for (register unsigned i=0;i
}<br />
j = 0;<br />
j++;<br />
arraySBox[j] = Index(matrixExp,S5,j);<br />
j++;<br />
arraySBox[j] = Index(matrixExp,S6,j);<br />
j++;<br />
arraySBox[j] = Index(matrixExp,S7,j);<br />
j++;<br />
arraySBox[j] = Index(matrixExp,S8,j);<br />
j++;<br />
//I coefficienti ricavati dalle S-box vengono<br />
//riun<strong>it</strong>i in un unico array.<br />
Group(arraySBox,arrayLR,32,4);<br />
//L'array ottenuto viene permutato.<br />
Permute_P2(arrayLR,matrixPer);<br />
//La matrice ottenuta viene convert<strong>it</strong>a in un array.<br />
matoar32(matrixPer,arrayLR,0,0,8,4);<br />
//L'array viene convert<strong>it</strong>o in un intero.<br />
iRes = artoi(arrayLR,32);<br />
//Viene fatta una XOR con il blocco dati appena<br />
//cifrato e quello precedente.<br />
L[i] = iRes ^ R[i + 1];<br />
R[i] = L[i + 1];<br />
j = 0;<br />
x--;<br />
//L'ultimo blocco cifrato di R e di L viene convert<strong>it</strong>o in<br />
//un array e concatenato.<br />
<strong>it</strong>oar(R[<strong>it</strong>erations],arrayLR,32);<br />
for (register int k=0;k
}<br />
delete [] arrayData;<br />
delete [] arrayLR;<br />
delete [] arrayExp;<br />
delete [] arraySBox;<br />
return iCrypted;<br />
//////////////////////////////////////////////////////////////////<br />
//PROTOTIPO : unsigned __int64 crypt(unsigned __int64 data,<br />
// unsigned int <strong>it</strong>erations)<br />
//INPUT : data -> dati da cifrare<br />
// <strong>it</strong>erations -> <strong>it</strong>erazioni<br />
//OUTPUT : iRes -> dati cifrati<br />
//DESCRIZIONE<br />
// La funzione cr<strong>it</strong>ta il dato passato. La variabile <strong>it</strong>erations<br />
//indica, implic<strong>it</strong>amente, il numero di chiavi da usare per la<br />
//cifratura.<br />
//////////////////////////////////////////////////////////////////<br />
unsigned __int64 CDes::crypt(unsigned __int64 data, unsigned int<br />
<strong>it</strong>erations)<br />
{<br />
unsigned matrixData[8][8];<br />
unsigned matrixExp[8][6];<br />
unsigned matrixPer[8][4];<br />
unsigned __int64 iExp = 0;<br />
unsigned __int64 iXor = 0;<br />
unsigned __int64 iRes = 0;<br />
unsigned __int64 iCrypted = 0;<br />
unsigned j = 0;<br />
unsigned *arrayData = new unsigned[64];<br />
unsigned *arrayLR = new unsigned[32];<br />
unsigned *arrayExp = new unsigned[48];<br />
unsigned *arraySBox = new unsigned[8];<br />
//I dati passati vengono convert<strong>it</strong>i in un array.<br />
<strong>it</strong>oar(data,arrayData,64);<br />
//L'array ottenuto viene permutato. Il risultato sarà una<br />
//matrice.<br />
Permute_IP(arrayData,matrixData);<br />
//La parte bassa della matrice viene convert<strong>it</strong>a in un array.<br />
matoar64(matrixData,arrayLR,0,0,4,8);<br />
//L'array risultante viene convert<strong>it</strong>o in un intero. Sarà il<br />
//primo blocco cifrato.<br />
L[0] = artoi(arrayLR,32);<br />
//Vengono effettuate le stesse operazioni precedenti, con<br />
//la parte alta della matrice.<br />
matoar64(matrixData,arrayLR,4,0,8,8);<br />
R[0] = artoi(arrayLR,32);<br />
//Il ciclo applica al blocco dati tutte le chiavi calcolate in<br />
//precedenza.<br />
for (register unsigned i=0;i
}<br />
//Il blocco cifrato R[i] viene conver<strong>it</strong>o in un array.<br />
<strong>it</strong>oar(R[i],arrayLR,32);<br />
//All'array risultante viene applicata la matrice di<br />
//espansione.<br />
Expand(arrayLR,matrixExp);<br />
//La matrice ottenuta viene convert<strong>it</strong>a in una array.<br />
matoar48(matrixExp,arrayExp,0,0,8,6);<br />
//L'array ottenuto viene convert<strong>it</strong>o in un intero.<br />
iExp = artoi(arrayExp,48);<br />
//Viene fatta un XOR con il risultato e la chiave<br />
//corrispondente all'<strong>it</strong>erazione.<br />
iXor = iExp ^ Keys_Array[i];<br />
//Il risultato viene convert<strong>it</strong>o in un array.<br />
<strong>it</strong>oar(iXor,arrayExp,48);<br />
//L'array risultante viene diviso in gruppi di 6 b<strong>it</strong>.<br />
Divide(arrayExp,matrixExp,48,6);<br />
//Per ogni gruppo di 6 b<strong>it</strong> (8 in totale), viene<br />
//calcolato il rispettivo coefficiente contenuto<br />
//nella S-box corrispondente.<br />
arraySBox[j] = Index(matrixExp,S1,j);<br />
j++;<br />
arraySBox[j] = Index(matrixExp,S2,j);<br />
j++;<br />
arraySBox[j] = Index(matrixExp,S3,j);<br />
j++;<br />
arraySBox[j] = Index(matrixExp,S4,j);<br />
j++;<br />
arraySBox[j] = Index(matrixExp,S5,j);<br />
j++;<br />
arraySBox[j] = Index(matrixExp,S6,j);<br />
j++;<br />
arraySBox[j] = Index(matrixExp,S7,j);<br />
j++;<br />
arraySBox[j] = Index(matrixExp,S8,j);<br />
j++;<br />
//I coefficienti ricavati dalle S-box vengono<br />
//riun<strong>it</strong>i in un unico array.<br />
Group(arraySBox,arrayLR,32,4);<br />
//L'array ottenuto viene permutato.<br />
Permute_P2(arrayLR,matrixPer);<br />
//La matrice ottenuta viene convert<strong>it</strong>a in un array.<br />
matoar32(matrixPer,arrayLR,0,0,8,4);<br />
//L'array viene convert<strong>it</strong>o in un intero.<br />
iRes = artoi(arrayLR,32);<br />
//Viene fatta una XOR con il blocco dati appena<br />
//cifrato e quello precedente.<br />
R[i + 1] = iRes ^ L[i];<br />
L[i + 1] = R[i];<br />
j = 0;<br />
Appendice F<br />
143
}<br />
j = 0;<br />
//L'ultimo blocco cifrato di R e di L viene convert<strong>it</strong>o in<br />
//un array e concatenato.<br />
<strong>it</strong>oar(R[<strong>it</strong>erations],arrayLR,32);<br />
for (register int k=0;k lunghezza dell'array<br />
//OUTPUT : iRes -> array convert<strong>it</strong>o<br />
//DESCRIZIONE<br />
// La funzione converte un array binario (composto da 0 o 1) in un<br />
//intero a 64 b<strong>it</strong>. La funzione non effettua nessun controllo<br />
// sulla lunghezza dell'array, ma è implic<strong>it</strong>o che esso non debba<br />
//superare i 64 byte. Di conseguenza ogni controllo deve essere<br />
// effettuato prima della chiamata alla funzione.<br />
//////////////////////////////////////////////////////////////////<br />
unsigned _int64 CDes::artoi(unsigned int *array, unsigned int<br />
length)<br />
{<br />
unsigned __int64 iB<strong>it</strong> = 0;<br />
unsigned __int64 iRes = 0;<br />
unsigned j = 0;<br />
for (register int i=length - 1;i>=0;i--)<br />
{<br />
Appendice F<br />
144
}<br />
iB<strong>it</strong> = array[i];<br />
iB<strong>it</strong> = iB<strong>it</strong> intero da convetire<br />
// array -> array in cui inserire l'intero convert<strong>it</strong>o<br />
// length -> lunghezza dell'array<br />
//DESCRIZIONE<br />
// La funzione converte un intero fino a 64 b<strong>it</strong> in un array<br />
//binario (composto da 0 e 1). La funzione non effettua nessun<br />
// controllo sulla lunghezza dell'array, ma è implic<strong>it</strong>o che esso<br />
//debba essere lungo tanto quanto la variabile da convertire e<br />
// non più del tipo più grande (unsigned __int64). Di conseguenza<br />
//ogni controllo deve essere effettuato prima della chiamata alla<br />
// funzione.<br />
//////////////////////////////////////////////////////////////////<br />
void CDes::<strong>it</strong>oar(unsigned __int64 int64, unsigned int *array,<br />
unsigned int length)<br />
{<br />
}<br />
unsigned __int64 iCopy = 0;<br />
unsigned __int64 j = 1;<br />
unsigned k = 0;<br />
for (register int i=length - 1;i>=0;i--)<br />
{<br />
j = power(2,i);<br />
iCopy = int64 & j;<br />
sw<strong>it</strong>ch (iCopy)<br />
{<br />
case 0 : array[k] = 0; k++; break;<br />
default : array[k] = 1; k++;<br />
}<br />
}<br />
//////////////////////////////////////////////////////////////////<br />
//PROTOTIPO : void stoi(char *string, unsigned int length)<br />
//INPUT : string -> stringa da convertire<br />
// length -> lunghezza della stringa<br />
//OUTPUT : iRes -> stringa convert<strong>it</strong>a<br />
//DESCRIZIONE<br />
// La funzione converte una stringa in un intero a 64 b<strong>it</strong>. La<br />
//funzione non effettua nessun controllo sulla lunghezza della<br />
//stringa,ma è implic<strong>it</strong>o che essa non debba superare i 64 byte. Di<br />
//conseguenza ogni controllo deve essere effettuato prima della<br />
// chiamata alla funzione.<br />
//////////////////////////////////////////////////////////////////<br />
unsigned _int64 CDes::stoi(char *string, unsigned int length)<br />
{<br />
unsigned __int64 iRes = 0;<br />
unsigned __int64 x = 0;<br />
Appendice F<br />
145
}<br />
for (register unsigned i=0;i matrice da convertire<br />
// array -> array risultato<br />
// yStart -> linea di partenza<br />
// xStart -> colonna di partenza<br />
// yEnd -> linea di arrivo<br />
// xEnd -> colonna di arrivo<br />
//DESCRIZIONE<br />
// Le funzioni convertono una matrice di n righe e m colonne, in<br />
//un array pari alla loro dimensione. I parametri indicano<br />
// implic<strong>it</strong>amente il numero di elementi da estrarre dalla matrice.<br />
//La funzione non effettua nessun controllo sulla lunghezza<br />
// dell' array che deve essere di lunghezza minima pari alla<br />
//grandezza della matrice. Di conseguenza ogni controllo deve<br />
//essere effettuato prima della chiamata alla funzione.<br />
//////////////////////////////////////////////////////////////////<br />
void CDes::matoar32(unsigned int matrix[][4], unsigned int *array,<br />
unsigned int yStart, unsigned int xStart,<br />
unsigned int yEnd, unsigned int xEnd)<br />
{<br />
register unsigned j = 0;<br />
for (register unsigned y=yStart;y
}<br />
void CDes::matoar48(unsigned int matrix[][6], unsigned int *array,<br />
unsigned int yStart, unsigned int xStart,<br />
unsigned int yEnd, unsigned int xEnd)<br />
{<br />
}<br />
register unsigned j = 0;<br />
for (register unsigned y=yStart;y
}<br />
if (e == 0) return x;<br />
for (register unsigned __int64 i=1;i valore da shiftare<br />
// n_Shift -> numero di shift (1 o 2)<br />
//OUTPUT : shift -> valore shiftato<br />
//DESCRIZIONE<br />
// La funzione simula uno shift circolare supponendo che l'intero<br />
//passato come parametro sia di soli 6 b<strong>it</strong>.<br />
//////////////////////////////////////////////////////////////////<br />
void CDes::shift(unsigned __int64 &shift, unsigned int nShift)<br />
{<br />
}<br />
unsigned __int64 iCopy;<br />
iCopy = shift;<br />
sw<strong>it</strong>ch (nShift)<br />
{<br />
case 1 : if ((shift & 0x8000000) != 0)<br />
{<br />
iCopy &= 0x3ffffff;<br />
iCopy = iCopy
lenOr1 -> lunghezza del primo array<br />
// lenOr2 -> lunghezza del secondo array<br />
//DESCRIZIONE<br />
// La funzione concatena due array della lunghezza specificata dai<br />
//parametri lenOr1 e lenOr2. La funzione non effettua il controllo<br />
//sulla lunghezza degli array, di conseguenza tutti i controlli<br />
//devono essere fatti prima della chiamata alla funzione.<br />
//////////////////////////////////////////////////////////////////<br />
void CDes::arcat(unsigned int *arrayOr1, unsigned int *arrayOr2,<br />
unsigned int *arrayDest, unsigned int lenOr1, unsigned lenOr2)<br />
{<br />
}<br />
register unsigned j = 0;<br />
for (register unsigned i=0;i stringa d'origine<br />
//DESCRIZIONE<br />
// La funzione concatena due stringhe. La stringa risultante sarà<br />
//contenuta in strDest,inoltre essa sarà del tipo null-terminated.<br />
//////////////////////////////////////////////////////////////////<br />
void CDes::_strcat(char *strDest, char *strOr)<br />
{<br />
}<br />
int lenDest, lenOr;<br />
lenDest = strlen(strDest);<br />
lenOr = strlen(strOr);<br />
for (register int i=0;i array a cui applicare la matrice<br />
// matrix[][x] -> matrice risultante<br />
//DESCRIZIONE<br />
// Le funzioni applicano la matrice specificata, costruendone una<br />
Appendice F<br />
149
isultante dall'operazione. Le funzioni seguono lo stesso<br />
// principio di funzionamento, cambia solo la matrice applicata<br />
//(si differenziano, oltre che per i valori, per la grandezza).<br />
// Di segu<strong>it</strong>o sono riassunte le funzioni con le matrici applicate.<br />
// Reduce56to48 -> P1 = prima matrice di permutazione<br />
// Reduce64to56 -> R1 = matrice di riduzione<br />
// Permute_IP -> IP = matrice di permutazione iniziale<br />
// Permute_P2 -> P2 = seconda matrice di permutazione<br />
// Permute_FP -> FP = matrice di permutazione finale<br />
// Expand -> EX = matrice di espansione<br />
//////////////////////////////////////////////////////////////////<br />
void CDes::Reduce56to48(unsigned int *array, unsigned int<br />
matrix[][6])<br />
{<br />
}<br />
for (register int y=0;y
}<br />
for (register int y=0;y matrice risultato<br />
// lenAr -> lunghezza array<br />
// lenGrp -> lunghezza gruppo<br />
//DESCRIZIONE<br />
// La funzione divide un array in gruppi della lunghezza<br />
//specificata dalla variabile lenGrp. La massima grandezza<br />
//dell'array è di 48 byte, di conseguenza la grandezza massima<br />
della matrice sarà 8*6. La funzione non effettua nessun controllo<br />
sulla<br />
// lunghezza dell'array e sulla grandezza della matrice. Di<br />
//conseguenza ogni controllo deve essere fatto prima della<br />
//chiamata alla funzione.<br />
//////////////////////////////////////////////////////////////////<br />
void CDes::Divide(unsigned int *array, unsigned int matrix[][6],<br />
unsigned int lenAr, unsigned int lenGrp)<br />
{<br />
}<br />
register unsigned j = 0;<br />
unsigned y = 0;<br />
while (j < lenAr)<br />
{<br />
for (register unsigned x=0;x array da raggruppare<br />
// arrayGrp -> array risultato<br />
// lenAr -> lunghezza array<br />
// lenGrp -> lunghezza dei gruppi<br />
//DESCRIZIONE<br />
// La funzione unisce un array di interi (NON binario) in un unico<br />
//array. La lunghezza dell'array e quella dei gruppi di b<strong>it</strong><br />
// viene passata come parametro.<br />
//////////////////////////////////////////////////////////////////<br />
void CDes::Group(unsigned int *array, unsigned int *arrayGrp,<br />
unsigned int lenAr, unsigned int lenGrp)<br />
{<br />
Appendice F<br />
151
}<br />
unsigned iCopy = 0;<br />
unsigned j = 1;<br />
register unsigned k = 0;<br />
register unsigned y = 0;<br />
while (k < lenAr)<br />
{<br />
for (register int i=lenGrp - 1;i>=0;i--)<br />
{<br />
j = power(2,i);<br />
iCopy = array[y] & j;<br />
sw<strong>it</strong>ch (iCopy)<br />
{<br />
case 0 : arrayGrp[k] = 0; k++; break;<br />
default : arrayGrp[k] = 1; k++;<br />
}<br />
}<br />
}<br />
y++;<br />
//////////////////////////////////////////////////////////////////<br />
//PROTOTIPO : unsigned Index(unsigned int matDiv[][6], unsigned<br />
// int matrix[][6], unsigned row)<br />
//INPUT : matDiv[][6] -> matrice da indicizzare<br />
// matrix -> matrice da cui estrarre i dati<br />
// row -> riga della matrice da indicizzare<br />
//OUTPUT : iRes -> risultato<br />
//DESCRIZIONE<br />
// La funzione preleva dalla matrice matDiv il valore binario e lo<br />
//converte in modo da comporre le coordinate di ricerca<br />
// (m = colonna, n = riga). L'intero risultato della ricerca verrà<br />
//rest<strong>it</strong>u<strong>it</strong>o.<br />
//////////////////////////////////////////////////////////////////<br />
unsigned CDes::Index(unsigned int matDiv[][6], unsigned int<br />
matrix[][16],unsigned row)<br />
{<br />
}<br />
unsigned m = 0;<br />
unsigned n = 0;<br />
unsigned iRes = 0;<br />
if (matDiv[row][0] != 0) m += 2;<br />
if (matDiv[row][5] != 0) m ++;<br />
if (matDiv[row][1] != 0) n += 8;<br />
if (matDiv[row][2] != 0) n += 4;<br />
if (matDiv[row][3] != 0) n += 2;<br />
if (matDiv[row][4] != 0) n ++;<br />
iRes = matrix[m][n];<br />
return iRes;<br />
//////////////////////////////////////////////////////////////////<br />
//PROTOTIPO : void Set_Key(unsigned __int64 newKey)<br />
//INPUT : newKey -> nuova chiave<br />
//DESCRIZIONE<br />
// Funzione di interfaccia che setta la chiave.<br />
Appendice F<br />
152
void CDes::Set_Key(unsigned __int64 newKey)<br />
{<br />
Key = newKey;<br />
}<br />
3 Cr<strong>it</strong>tografia<br />
Private Function Scan(strC As String) As String<br />
For i = 0 To 26<br />
If (PLOT(i, 0) = strC) Then<br />
PLOT(i, 1) = PLOT(i, 1) + 1<br />
GoTo End_Function<br />
End If<br />
Next i<br />
Scan = False<br />
Ex<strong>it</strong> Function<br />
End_Function:<br />
Scan = True<br />
End Function<br />
Private Function OpenFile(strFileToOpen As String) As String<br />
Dim strFileOpen As String<br />
Dim objFS, txtFile<br />
Set objFS = CreateObject("Scripting.FileSystemObject")<br />
Set txtFile = objFS.OpenTextFile(strFileToOpen)<br />
Do While txtFile.AtEndOfStream True<br />
c = txtFile.Read(1)<br />
Scan (LCase(c))<br />
strFileOpen = strFileOpen & c<br />
Loop<br />
txtFile.Close<br />
OpenFile = strFileOpen<br />
End Function<br />
Private Function SaveFile(strFileToSave As String, strFileSave As<br />
String) As Boolean<br />
On Error GoTo Err_Handler<br />
Dim objFS, txtFile<br />
Set objFS = CreateObject("Scripting.FileSystemObject")<br />
Set txtFile = objFS.CreateTextFile(strFileToSave)<br />
txtFile.Wr<strong>it</strong>e (strFileSave)<br />
txtFile.Close<br />
SaveFile = True<br />
Ex<strong>it</strong> Function<br />
Appendice F<br />
153
Err_Handler:<br />
SaveFile = False<br />
End Function<br />
Private Sub OpenCl()<br />
On Error GoTo Err_Handler<br />
Call In<strong>it</strong>CDL(cdlSaveOpen, "*.txt", "Apri file in chiaro", _<br />
"File di testo (*.txt)|*.txt|Tutti i file (*.*)|*.*|", _<br />
App.Path, "Open")<br />
cdlSaveOpen.ShowOpen<br />
stbMain.Panels(1).Text = cdlSaveOpen.FileName<br />
Err_Handler:<br />
End Sub<br />
Private Sub SaveCl()<br />
On Error GoTo Err_Handler<br />
Call In<strong>it</strong>CDL(cdlSaveOpen, "*.txt", "Salva file in chiaro", _<br />
"File di testo (*.txt)|*.txt|", App.Path, "Save")<br />
cdlSaveOpen.ShowSave<br />
Err_Handler:<br />
End Sub<br />
Private Sub OpenCyph()<br />
On Error GoTo Err_Handler<br />
Dim strFilter As String<br />
strFilter = "Cifrario di Cesare (*.csr)|*.csr|Scacchiera di_<br />
Polibio (*.plb)|*.plb|" & _<br />
"Cifrario di Vigénère (*.vgn)|*.vgn|"<br />
Call In<strong>it</strong>CDL(cdlSaveOpen, "*.csr", "Apri file cr<strong>it</strong>tato",<br />
strFilter, App.Path, "Open")<br />
cdlSaveOpen.ShowOpen<br />
Err_Handler:<br />
End Sub<br />
Private Sub SaveCyph()<br />
On Error GoTo Err_Handler<br />
Dim strFilter As String<br />
strFilter = "Cifrario di Cesare (*.csr)|*.csr|Scacchiera di_<br />
Polibio (*.plb)|*.plb|" & _<br />
"Cifrario di Vigénère (*.vgn)|*.vgn|"<br />
Call In<strong>it</strong>CDL(cdlSaveOpen, "*.csr", "Salva file cr<strong>it</strong>tato",<br />
strFilter, App.Path, "Save")<br />
Appendice F<br />
154
cdlSaveOpen.ShowSave<br />
Err_Handler:<br />
End Sub<br />
Private Sub Analize_Click()<br />
On Error GoTo Err_Handler<br />
If ActiveForm Is Nothing Then In<strong>it</strong>DOC ""<br />
If ActiveForm.txtText.Text = "" Then<br />
Clear<br />
OpenCl<br />
ActiveForm.txtText.Text = OpenFile(cdlSaveOpen.FileName)<br />
ActiveForm.Caption = cdlSaveOpen.FileT<strong>it</strong>le<br />
In<strong>it</strong>GRAPH cdlSaveOpen.FileT<strong>it</strong>le<br />
Else<br />
In<strong>it</strong>GRAPH cdlSaveOpen.FileT<strong>it</strong>le<br />
End If<br />
Err_Handler:<br />
End Sub<br />
Private Sub CaesarCrypt_Click()<br />
End Sub<br />
ActiveForm.txtText.Text = CaesarCyph.Crypt(3, _<br />
ActiveForm.txtText.Text)<br />
Private Sub CaesarDecrypt_Click()<br />
End Sub<br />
ActiveForm.txtText.Text = CaesarCyph.Decrypt(4, _<br />
ActiveForm.txtText.Text)<br />
Private Sub MDIForm_Load()<br />
End Sub<br />
In<strong>it</strong>VAR<br />
In<strong>it</strong>DOC ""<br />
Private Sub OpenClear_Click()<br />
On Error GoTo Err_Handler<br />
If ActiveForm Is Nothing Then In<strong>it</strong>DOC ""<br />
Clear<br />
OpenCl<br />
ActiveForm.txtText.Text = OpenFile(cdlSaveOpen.FileName)<br />
ActiveForm.Caption = cdlSaveOpen.FileT<strong>it</strong>le<br />
Err_Handler:<br />
End Sub<br />
Private Sub OpenCrypt_Click()<br />
Appendice F<br />
155
On Error GoTo Err_Handler<br />
Dim strKey As String<br />
Dim strFile As String<br />
Dim iFil As Integer<br />
Clear<br />
OpenCyph<br />
strFile = OpenFile(cdlSaveOpen.FileName)<br />
If ActiveForm Is Nothing Then In<strong>it</strong>DOC ""<br />
iFil = cdlSaveOpen.FilterIndex<br />
Select Case iFil<br />
Case 1: ActiveForm.txtText.Text = CaesarCyph.Decrypt(4,_<br />
strFile)<br />
ActiveForm.Caption = cdlSaveOpen.FileT<strong>it</strong>le<br />
Case 2: ActiveForm.txtText.Text = _<br />
PolibioCyph.Decrypt(strFile)<br />
ActiveForm.Caption = cdlSaveOpen.FileT<strong>it</strong>le<br />
Case 3: strKey = InputBox("Inserisci la chiave:", _<br />
"Cifrario di Vigénère")<br />
ActiveForm.txtText.Text = _<br />
VigenereCyph.Decrypt(strFile, strKey)<br />
ActiveForm.Caption = cdlSaveOpen.FileT<strong>it</strong>le<br />
End Select<br />
Err_Handler:<br />
End Sub<br />
Private Sub PolibioCrypt_Click()<br />
ActiveForm.txtText.Text = _<br />
PolibioCyph.Crypt(ActiveForm.txtText.Text)<br />
End Sub<br />
Private Sub PolibioDecrypt_Click()<br />
End Sub<br />
ActiveForm.txtText.Text = _<br />
PolibioCyph.Decrypt(ActiveForm.txtText.Text)<br />
Private Sub Qu<strong>it</strong>_Click()<br />
End<br />
End Sub<br />
Private Sub SaveCrypt_Click()<br />
On Error GoTo Err_Handler<br />
Dim strKey As String<br />
Dim strCyph As String<br />
Dim bRet As Boolean<br />
Dim iFil As Integer<br />
If (ActiveForm.txtText.Text = "") Then GoTo Err_Handler<br />
SaveCyph<br />
iFil = cdlSaveOpen.FilterIndex<br />
Select Case iFil<br />
Appendice F<br />
156
Case 1: strCyph = CaesarCyph.Crypt(4, _<br />
ActiveForm.txtText.Text)<br />
bRet = SaveFile(cdlSaveOpen.FileName, strCyph)<br />
If (bRet = False) Then GoTo Err_Handler<br />
Case 2: strCyph = _<br />
PolibioCyph.Crypt(ActiveForm.txtText.Text)<br />
bRet = SaveFile(cdlSaveOpen.FileName, strCyph)<br />
If (bRet = False) Then GoTo Err_Handler<br />
Case 3: strKey = InputBox("Inserisci la chiave:", _<br />
"Cifrario di Vigénère")<br />
strCyph = _<br />
VigenereCyph.Crypt(ActiveForm.txtText.Text, strKey)<br />
bRet = SaveFile(cdlSaveOpen.FileName, strCyph)<br />
If (bRet = False) Then GoTo Err_Handler<br />
End Select<br />
Ex<strong>it</strong> Sub<br />
Err_Handler:<br />
MsgBox "Non è stato possibile salvare il file."<br />
End Sub<br />
Private Sub SaveClear_Click()<br />
On Error GoTo Err_Handler<br />
Dim bRet As Boolean<br />
If (ActiveForm.txtText.Text = "") Then GoTo Err_Handler<br />
SaveCl<br />
bRet = SaveFile(cdlSaveOpen.FileName, ActiveForm.txtText.Text)<br />
If (bRet = False) Then GoTo Err_Handler<br />
Ex<strong>it</strong> Sub<br />
Err_Handler:<br />
MsgBox "Non è stato possibile salvare il file."<br />
End Sub<br />
Private Sub tlbMain_ButtonClick(ByVal Button As<br />
MSComctlLib.Button)<br />
End Sub<br />
Select Case Button.Key<br />
Case "New": If ActiveForm Is Nothing Then In<strong>it</strong>DOC ""<br />
Case "OpenClear": OpenClear_Click<br />
Case "OpenCyph": OpenCrypt_Click<br />
Case "SaveClear": SaveClear_Click<br />
Case "SaveCyph": SaveCrypt_Click<br />
End Select<br />
Private Sub VigenereCrypt_Click()<br />
Dim strKey As String<br />
strKey = InputBox("Inserisci la chiave:", "Cifrario di _<br />
Vigénère")<br />
ActiveForm.txtText.Text = _<br />
VigenereCyph.Crypt(ActiveForm.txtText.Text, strKey)<br />
Appendice F<br />
157
End Sub<br />
Private Sub VigenereDecrypt_Click()<br />
End Sub<br />
Dim strKey As String<br />
strKey = InputBox("Inserisci la chiave:", "Cifrario di _<br />
Vigénère")<br />
ActiveForm.txtText.Text = _<br />
VigenereCyph.Decrypt(ActiveForm.txtText.Text, strKey)<br />
Private Sub Form_Resize()<br />
On Error Resume Next<br />
txtText.Move 100, 100, Me.ScaleWidth - 200, Me.ScaleHeight - 200<br />
End Sub<br />
Private Sub Form_Resize()<br />
On Error Resume Next<br />
mscGraph.Move 100, 100, Me.ScaleWidth - 200, Me.ScaleHeight - 200<br />
End Sub<br />
Public ALPHA(26) As String<br />
Public ASCII(255, 1) As String<br />
Public PLOT(26, 1)<br />
Public FREQ(26) As String<br />
Public CaesarCyph As New Caesar<br />
Public PolibioCyph As New Polibio<br />
Public VigenereCyph As New Vigenere<br />
Public Sub In<strong>it</strong>VAR()<br />
j = 0<br />
For i = 97 To 122<br />
ALPHA(j) = Chr(i)<br />
PLOT(j, 0) = ALPHA(j)<br />
j = j + 1<br />
Next i<br />
ALPHA(j) = " "<br />
PLOT(j, 0) = " "<br />
For i = 0 To 255<br />
ASCII(i, 0) = Chr(i)<br />
Next i<br />
FREQ(0) = " "<br />
FREQ(1) = "e"<br />
FREQ(2) = "a"<br />
FREQ(3) = "i"<br />
FREQ(4) = "o"<br />
FREQ(5) = "n"<br />
FREQ(6) = "r"<br />
Appendice F<br />
158
End Sub<br />
FREQ(7) = "t"<br />
FREQ(8) = "l"<br />
FREQ(9) = "s"<br />
FREQ(10) = "c"<br />
FREQ(11) = "d"<br />
FREQ(12) = "u"<br />
FREQ(13) = "p"<br />
FREQ(14) = "m"<br />
FREQ(15) = "v"<br />
FREQ(16) = "g"<br />
FREQ(17) = "h"<br />
FREQ(18) = "b"<br />
FREQ(19) = "f"<br />
FREQ(20) = "q"<br />
FREQ(21) = "z"<br />
FREQ(22) = "j"<br />
FREQ(23) = "k"<br />
FREQ(24) = "w"<br />
FREQ(25) = "x"<br />
FREQ(26) = "y"<br />
Public Sub Clear()<br />
End Sub<br />
For i = 0 To 26<br />
PLOT(i, 1) = 0<br />
Next i<br />
Public Sub In<strong>it</strong>CDL(CDL As CommonDialog,strExt As String,strT<strong>it</strong>le _<br />
As String, strFilter As String, strIn<strong>it</strong>Dir _<br />
As String, strOpenSave As String)<br />
On Error GoTo Err_Handler<br />
CDL.CancelError = True<br />
CDL.DefaultExt = strExt<br />
CDL.DialogT<strong>it</strong>le = strT<strong>it</strong>le<br />
CDL.Filter = strFilter<br />
CDL.FilterIndex = 1<br />
CDL.In<strong>it</strong>Dir = strIn<strong>it</strong>Dir<br />
Select Case strOpenSave<br />
Case "Save":<br />
CDL.Flags = cdlOFNOverwr<strong>it</strong>ePrompt<br />
Case "Open":<br />
CDL.Flags = cdlOFNFileMustExist<br />
End Select<br />
Err_Handler:<br />
End Sub<br />
Public Sub In<strong>it</strong>DOC(strFilename As String)<br />
Static lDocumentCount As Long<br />
Dim frmD As New frmDoc<br />
lDocumentCount = 1<br />
Appendice F<br />
159
If (strFilename = "") Then strFilename = "Document" &<br />
lDocumentCount<br />
End Sub<br />
frmD.Caption = strFilename<br />
frmD.Show<br />
Public Sub In<strong>it</strong>GRAPH(strFilename As String)<br />
End Sub<br />
Static lChartCount<br />
Dim frmG As New frmGraph<br />
If (strFilename = "") Then strFilename = "Chart" & lChartCount<br />
W<strong>it</strong>h frmG<br />
.Caption = strFilename<br />
.mscGraph = PLOT<br />
.Show<br />
End W<strong>it</strong>h<br />
Private Alphabet(255) As String<br />
Public Function Crypt(iSph As Integer, strCrypt As String) As<br />
String<br />
Dim c As Variant<br />
Dim strCrypted As String<br />
Dim iRes As Integer<br />
For i = 1 To Len(strCrypt)<br />
Next i<br />
c = Mid(strCrypt, i, 1)<br />
iRes = Find(c)<br />
If ((iRes + iSph) > 255) Then<br />
j = (iRes + iSph) - 255<br />
strCrypted = strCrypted & Alphabet(j)<br />
Else<br />
strCrypted = strCrypted & Alphabet(iRes + iSph)<br />
End If<br />
Crypt = strCrypted<br />
End Function<br />
Public Function Decrypt(iSph As Integer, strCrypt As String) As<br />
String<br />
Dim c As Variant<br />
Dim strCrypted As String<br />
Dim iRes As Integer<br />
For i = 1 To Len(strCrypt)<br />
c = Mid(strCrypt, i, 1)<br />
iRes = Find(c)<br />
Appendice F<br />
160
Next i<br />
If ((iRes - iSph) < 0) Then<br />
j = (iRes - iSph) + 255<br />
strCrypted = strCrypted & Alphabet(j)<br />
Else<br />
strCrypted = strCrypted & Alphabet(iRes - iSph)<br />
End If<br />
Decrypt = strCrypted<br />
End Function<br />
Private Function Find(vChar As Variant) As Integer<br />
For i = 0 To 255<br />
If (Alphabet(i) = vChar) Then<br />
Find = i<br />
GoTo End_Function<br />
End If<br />
Next i<br />
End_Function:<br />
End Function<br />
Private Sub In<strong>it</strong>()<br />
End Sub<br />
Dim c As String<br />
Alphabet(0) = " "<br />
For i = 1 To 255<br />
c = Chr(i)<br />
Alphabet(i) = c<br />
Next i<br />
Private Sub Class_In<strong>it</strong>ialize()<br />
In<strong>it</strong><br />
End Sub<br />
Private Alphabet(15, 15) As String<br />
Private Sub Find(vChar As Variant, ByRef iY As Integer, ByRef iX<br />
As Integer)<br />
For i = 0 To 15<br />
For j = 0 To 15<br />
If (Alphabet(i, j) = vChar) Then<br />
iY = i<br />
iX = j<br />
GoTo End_Function<br />
End If<br />
Next j<br />
Next i<br />
End_Function:<br />
End Sub<br />
Appendice F<br />
161
Private Function HexToDec(c As Variant) As Long<br />
Dim lRes As Long<br />
If ((c >= Hex(10)) And (c
Next i<br />
strCrypted = strCrypted & Alphabet(y, x)<br />
Decrypt = strCrypted<br />
End Function<br />
Private Sub In<strong>it</strong>()<br />
Dim c As Integer<br />
c = 0<br />
End Sub<br />
For i = 0 To 15<br />
For j = 0 To 15<br />
Next j<br />
Next i<br />
Alphabet(i, j) = Chr(c)<br />
c = c + 1<br />
Private Sub Class_In<strong>it</strong>ialize()<br />
In<strong>it</strong><br />
End Sub<br />
Private Alphabet(255, 255) As String<br />
Private Sub FindRow(vChar As Variant, y As Integer, x As Integer,<br />
ByRef iY As Integer, ByRef iX As Integer)<br />
On Error GoTo End_Function<br />
For i = y To 255<br />
For j = x To 255<br />
If (Alphabet(i, j) = vChar) Then<br />
iY = i<br />
iX = j<br />
GoTo End_Function<br />
End If<br />
Next j<br />
Next i<br />
End_Function:<br />
End Sub<br />
Private Sub FindCol(vChar As Variant, y As Integer, x As Integer,<br />
ByRef iY As Integer, ByRef iX As Integer)<br />
On Error GoTo End_Function<br />
For j = x To 255<br />
For i = y To 255<br />
If (Alphabet(i, j) = vChar) Then<br />
iY = i<br />
iX = j<br />
GoTo End_Function<br />
Appendice F<br />
163
End If<br />
Next i<br />
Next j<br />
End_Function:<br />
End Sub<br />
Public Function Decrypt(strCrypt As String, strKey As String) As<br />
String<br />
Dim strCrypted As String<br />
Dim j As Integer<br />
Dim cCrypt As String<br />
Dim cKey As String<br />
Dim cRes As String<br />
Dim iYCrypt As Integer<br />
Dim iXCrypt As Integer<br />
Dim iYKey As Integer<br />
Dim iXKey As Integer<br />
j = 1<br />
For i = 1 To Len(strCrypt)<br />
Next i<br />
If (j > Len(strKey)) Then j = 1<br />
cCrypt = Mid(strCrypt, i, 1)<br />
cKey = Mid(strKey, j, 1)<br />
FindCol cKey, 0, 0, iYKey, iXKey<br />
FindRow cCrypt, iYKey, 0, iYCrypt, iXCrypt<br />
cRes = Alphabet(0, iXCrypt)<br />
strCrypted = strCrypted & cRes<br />
j = j + 1<br />
Decrypt = strCrypted<br />
End Function<br />
Public Function Crypt(strCrypt As String, strKey As String) As<br />
String<br />
Dim strCrypted As String<br />
Dim j As Integer<br />
Dim cCrypt As String<br />
Dim cKey As String<br />
Dim cRes As String<br />
Dim iYCrypt As Integer<br />
Dim iXCrypt As Integer<br />
Dim iYKey As Integer<br />
Dim iXKey As Integer<br />
j = 1<br />
For i = 1 To Len(strCrypt)<br />
Appendice F<br />
164
Next i<br />
If (j > Len(strKey)) Then j = 1<br />
cCrypt = Mid(strCrypt, i, 1)<br />
cKey = Mid(strKey, j, 1)<br />
FindRow cCrypt, 0, 0, iYCrypt, iXCrypt<br />
FindCol cKey, 0, 0, iYKey, iXKey<br />
cRes = Alphabet(iYKey, iXCrypt)<br />
strCrypted = strCrypted & cRes<br />
j = j + 1<br />
Crypt = strCrypted<br />
End Function<br />
Private Sub In<strong>it</strong>()<br />
Dim x As Integer<br />
Dim y As Integer<br />
Dim j As Integer<br />
Dim c As Integer<br />
Dim k As Integer<br />
j = 0<br />
c = 0<br />
k = 0<br />
For y = 0 To 255<br />
Next y<br />
End Sub<br />
For x = 0 To (255 - j)<br />
Alphabet(y, x) = Chr(k)<br />
k = k + 1<br />
Next x<br />
If Not (j = 0) Then<br />
For i = (255 - j) + 1 To 255<br />
Alphabet(y, i) = Chr(c)<br />
c = c + 1<br />
Next i<br />
End If<br />
c = 0<br />
j = j + 1<br />
k = j<br />
Private Sub Class_In<strong>it</strong>ialize()<br />
In<strong>it</strong><br />
End Sub<br />
Appendice F<br />
165
4 TCP<br />
/***********GENERATORI DI PACCHETTI TCP*************************/<br />
/* Dichiarazione delle librerie principali usate nel programma */<br />
#include <br />
#include <br />
#include <br />
#include <br />
#include <br />
#include <br />
#include <br />
#include <br />
#include <br />
#include <br />
#include <br />
#include <br />
#include <br />
#include <br />
#include <br />
/* Dichiarazione dei prototipi delle funzioni */<br />
void tcp_gen(char *packet,unsigned short sport,unsigned short<br />
dport,unsigned long seq,unsigned long ack);<br />
void udp_gen(char *packet,unsigned short sport,unsigned short<br />
dport,unsigned short length);<br />
void ip_gen(char *packet,unsigned char protocol,struct in_addr<br />
saddr,struct in_addr daddr,unsigned short length);<br />
unsigned short trans_check(unsigned char proto, char *packet,int<br />
length, struct in_addr source_address,<br />
struct in_addr dest_address);<br />
unsigned short in_cksum(unsigned short *addr,int len);<br />
#define IPVERSION 4 /* versione del pacchetto IP */<br />
#define DEFAULT_TTL 60 // Definizione del tempo di v<strong>it</strong>a dei<br />
pacchetti //<br />
#define TH_OFFSET 5<br />
#define TCP_WINDOW_SIZE 512 /*larghezza della finestra del tcp */<br />
/* struttura per il calcolo del checksum sul pacchetto tcp*/<br />
struct psuedohdr {<br />
struct in_addr source_address;<br />
struct in_addr dest_address;<br />
unsigned char place_holder;<br />
unsigned char protocol;<br />
unsigned short length;<br />
} psuedohdr;<br />
/****** calcolo del checksum sul tcp header *******************/<br />
unsigned short trans_check(unsigned char proto,char *packet,int<br />
length,struct in_addr source_address,<br />
struct in_addr dest_address)<br />
{<br />
char *psuedo_packet;<br />
Appendice F<br />
166
unsigned short answer;<br />
/* compilazione della struttura pseudohdr tcp */<br />
psuedohdr.protocol = proto;<br />
psuedohdr.length = htons(length);<br />
psuedohdr.place_holder = 0;<br />
psuedohdr.source_address = source_address;<br />
psuedohdr.dest_address = dest_address;<br />
/* allocazione della struttura pseudohdr */<br />
if((psuedo_packet = malloc(sizeof(psuedohdr) + length)) == NULL)<br />
{<br />
perror("malloc");<br />
ex<strong>it</strong>(1);<br />
}<br />
/* copia la struttura pseudohdr nella blocco puntato da<br />
pseudo_packet */<br />
memcpy(psuedo_packet,&psuedohdr,sizeof(psuedohdr));<br />
memcpy(psuedo_packet,&psuedohdr,sizeof(psuedohdr,packet,length));/<br />
/memcpy((psuedo_packet + sizeof(psuedohdr,packet,length)));<br />
/* applica l'algor<strong>it</strong>mo del checksum allo pseudo pacchetto*/<br />
answer = (unsigned short)in_cksum((unsigned short*)psuedo_packet,<br />
length + sizeof(psuedohdr)));<br />
free( psuedo_packet ) ;<br />
return answer;<br />
}<br />
/************************* algor<strong>it</strong>mo del checksum **************/<br />
unsigned short in_cksum(unsigned short *addr,int len)<br />
{<br />
register int sum = 0;<br />
u_short answer = 0;<br />
register u_short *w = addr;<br />
register int nleft = len;<br />
/*Questo ciclo somma nel registro accumulatore (sum) 32 b<strong>it</strong> le<br />
parole di 16 b<strong>it</strong> che vengono estratte dalla struttura addr.*/<br />
while (nleft > 1) {<br />
sum += *w++;<br />
nleft -= 2;<br />
}<br />
/* se la lunghezza del campo dati è numero dispari viene<br />
completato */<br />
/* con un 0 addizionale .*/<br />
if (nleft == 1) {<br />
*( u_char * )( &answer ) = *( u_char * )w ;<br />
sum += answer;<br />
}<br />
/* viene calcolato il complemento a 1 della somma delle word */<br />
sum = (sum >> 16) + (sum & 0xffff);<br />
sum += (sum >> 16);<br />
answer = ~sum;<br />
return(answer);<br />
}<br />
/*********************** generatore pacchetto IP ***************/<br />
Appendice F<br />
167
void ip_gen(char *packet,unsigned char protocol,struct in_addr<br />
saddr,struct in_addr daddr,unsigned short length)<br />
{<br />
/* definisco un puntatore alla struttura */<br />
struct iphdr *iphdr;<br />
/* La variabile pacchetto diventa puntatore alla struttura iphdr<br />
*/<br />
iphdr = (struct iphdr *)packet;<br />
memset((char *)iphdr,'\0',sizeof(struct iphdr));<br />
/* compilo la struttura ip */<br />
iphdr->ihl = 5;<br />
iphdr->version = IPVERSION;<br />
/* BIG ENDIAN e LITTLE ENDIAN */<br />
#ifdef IP_LEN_HORDER<br />
iphdr->tot_len = length;<br />
#else<br />
iphdr->tot_len = htons(length);<br />
#endif /* IP_LEN_HORDER */<br />
iphdr->id = htons(getpid());<br />
iphdr->ttl = DEFAULT_TTL;<br />
iphdr->protocol = protocol;<br />
iphdr->saddr = saddr.s_addr;<br />
iphdr->daddr = daddr.s_addr;<br />
/* calcola il checksum del pacchetto*/<br />
iphdr->check = (unsigned short)in_cksum((unsigned short *)iphdr,<br />
sizeof(struct iphdr));<br />
return;<br />
}<br />
/***dichiarazione del prototipo della funzione tcp_gen ********/<br />
void tcp_gen(char *packet,unsigned short sport,unsigned short<br />
dport, unsigned long seq,unsigned long ack)<br />
{<br />
/* puntatore alla struttura tcphdr */<br />
struct tcphdr *tcp;<br />
/* Cast di packet da (char *) a (struct tcphdr*) */<br />
tcp = (struct tcphdr *)packet;<br />
memset((char *)tcp,'\0',sizeof(struct tcphdr));<br />
/* compilazione della struttura tcp */<br />
tcp->source = htons(sport);<br />
tcp->dest = htons(dport);<br />
tcp->seq = htonl(seq);<br />
tcp->ack_seq = htonl(ack);<br />
tcp->res1 = 0;<br />
tcp->doff = TH_OFFSET;<br />
tcp->window = htons(TCP_WINDOW_SIZE);<br />
tcp->fin = 1;<br />
return;<br />
}<br />
/*************** M A I N **************************************/<br />
Appendice F<br />
168
*argv:<br />
1-porta sorgente<br />
2-indirizzo sorgente<br />
3-porta destinazione<br />
4-indirizzo destinazione<br />
*/<br />
int main(int argc,char *argv[])<br />
{<br />
/* vettore pacchetto di lunghezza ip header + tcp header */<br />
unsigned char packet[ sizeof(struct iphdr) + sizeof(struct<br />
tcphdr) ];<br />
/* sockaddr_in struttura della socket */<br />
struct sockaddr_in mysocket;<br />
/* porte sorgenti e destinazioni */<br />
unsigned short sport, dport;<br />
/* struttura per l'indirizzamento ID/RETE ID/HOST */<br />
struct in_addr saddr, daddr;<br />
/* puntatore alla struttura tcphdr */<br />
struct tcphdr *tcp;<br />
unsigned long seq, ack;<br />
int sockd, on = 1;<br />
/* Prelevo gli argomenti dalla riga di comando */<br />
if(argc < 5) {<br />
fprintf(stderr,"usare: %s porta_sorg. indirizzo_sorg. porta_dest.<br />
indirizzo_dest\n", argv[0]);<br />
ex<strong>it</strong>(1);<br />
}<br />
/* Compila la struttura per le socket con porta sorgente e<br />
indirizzo sorgente */<br />
sport = (unsigned short)atoi(argv[1]);<br />
saddr.s_addr = inet_addr(argv[2]);<br />
/* Compila la struttura per le socket con porta destinazione e<br />
indirizzo destinazione */<br />
dport = (unsigned short)atoi(argv[3]);<br />
daddr.s_addr = inet_addr(argv[4]);<br />
/* Creo il socket descriptor con l'opzione socket raw */<br />
if((sockd = socket(AF_INET,SOCK_RAW,IPPROTO_RAW)) < 0) {<br />
perror("socket");<br />
ex<strong>it</strong>(1);<br />
}<br />
/* Setto alcune opzioni inerenti al livello del protocollo IP */<br />
if(setsockopt(sockd,IPPROTO_IP,IP_HDRINCL,(char *)&on,sizeof(on))<br />
< 0) {<br />
perror("setsockopt");<br />
ex<strong>it</strong>(1);<br />
}<br />
/* Genero numero di sequenza ed ack casuali */<br />
srand(getpid());<br />
seq = rand()%time( NULL );<br />
ack = rand()%time( NULL );<br />
/* Genero pacchetto IP */<br />
Appendice F<br />
169
ip_gen(packet,IPPROTO_TCP,saddr,daddr,sizeof(packet));<br />
/* Sposto il puntatore della struttura tcp header della<br />
dimensione del */<br />
/* pacchetto + la struttura ip header */<br />
tcp = (struct tcphdr *)(packet + sizeof(struct iphdr));<br />
/* Genero il pacchetto TCP */<br />
tcp_gen((char *)tcp,sport,dport,seq,ack);<br />
/* checksum calcolato sul pacchetto IP */<br />
tcp->check = trans_check(IPPROTO_TCP,(char *)tcp,<br />
sizeof(struct tcphdr),<br />
saddr,<br />
daddr);<br />
/*inizializza la struttura mysocket */<br />
memset(&mysocket,'\0',sizeof(mysocket));<br />
/*Compilo la struttura mysocket */<br />
mysocket.sin_family = AF_INET;<br />
mysocket.sin_port = htons(dport);<br />
mysocket.sin_addr = daddr;<br />
/* Spedisco il pacchetto da me creato con il flag fin a a 1<br />
secondo i parametri immessi da linea di comando.*/<br />
if(sendto(sockd,&packet,sizeof(packet),0x0,(struct sockaddr<br />
*)&mysocket,<br />
sizeof(mysocket)) != sizeof(packet)) {<br />
perror("sendto");<br />
ex<strong>it</strong>(1);<br />
}<br />
ex<strong>it</strong>(0);<br />
}<br />
/****************************************************************/<br />
Appendice F<br />
170
GLOSSARIO<br />
Albam metodo cr<strong>it</strong>tografico usato dagli ebrei.<br />
Consiste nel dividere in due parti l’alfabeto e<br />
nel sost<strong>it</strong>uire ogni lettera con la<br />
corrispondente nell’altra metà.<br />
ARPA da Advanced Research Project Agency,<br />
Agenzia per progetti di ricerca avanzata.<br />
Agenzia del Dipartimento della Difesa<br />
statun<strong>it</strong>ense, attualmente ribattezzata<br />
DARPA, fondata nel 1958 per il<br />
finanziamento della ricerca mil<strong>it</strong>are.<br />
ARPANet da Advance Research Project Agency<br />
Network, rete dell’Agenzia per progetti di<br />
ricerca avanzata. Rete a lunga distanza creata<br />
nel 1969 dell’Agenzia per progetti di ricerca<br />
avanzata (ARPA) statun<strong>it</strong>ense, in<br />
collaborazione con le principali univers<strong>it</strong>à e<br />
centri di ricerca, con il fine di utilizzare la<br />
comunicazione di dati ad alta veloc<strong>it</strong>à per la<br />
collaborazione scientifica e le operazioni<br />
mil<strong>it</strong>ari.<br />
Atbash dall’unione delle prime e dalle ultime due<br />
lettere dell’alfabeto ebraico, Aleph Taw Beth<br />
Shin. Codice di cifratura usato nel Vecchio<br />
Testamento dal profeta Geremia, consiste<br />
nel sost<strong>it</strong>uire la prima lettera dell’alfabeto<br />
con l’ultima la seconda con la penultima e<br />
così via.<br />
Brute force nella cr<strong>it</strong>tografia e in altri campi matematici,<br />
tecnica di risoluzione dei problemi che<br />
impiega un computer programmato per<br />
eseguire ripetutamente un comp<strong>it</strong>o semplice,<br />
nella speranza di trovare la risposta.<br />
Checksum somma di controllo. Tecnica di rilevazione<br />
di errori che verifica la corretta ricezione di<br />
un blocco dati. Consiste nell’eseguire la<br />
somma dei valori dei b<strong>it</strong> contenuti nel<br />
blocco dati trasmesso e nel confrontarla con<br />
la somma analoga esegu<strong>it</strong>a in ricezione.<br />
DARPA da Defense Advanced Research Project<br />
Agency, Agenzia della Difesa per progetti di<br />
ricerca avanzata. Attuale denominazione<br />
dell’Agenzia per progetti di ricerca avanzata<br />
del Dipartimento della Difesa Statun<strong>it</strong>ense.<br />
Glossario<br />
171
DES da Data Encryption Standard, standard di<br />
cifratura dati. Metodo di cifratura sviluppato<br />
da IBM e certificata nel 1977 dal governo<br />
USA come tecnica ufficiale di cifratura per<br />
informazioni non classificate; sebbene abbia<br />
perso la certificazione nel 1998, è ancora<br />
ampiamente usato.<br />
DLL da Dynamic Link Library, libreria di<br />
collegamento dinamico. Modulo software<br />
dell’ambiente Windows contenente codice<br />
eseguibile e dati che possono essere<br />
richiamati e usati da applicazioni Windows e<br />
da altre DLL. Funzioni e dati in una DLL<br />
sono caricati e linkati durante l’esecuzione,<br />
quando sono richiamati da un’applicazione o<br />
altre DLL.<br />
FTP da File Transfer Protocol, protocollo di<br />
trasferimento file. Protocollo Internet per lo<br />
scambio di file con computer osp<strong>it</strong>i remoti,<br />
basato sul modello client/server. FTP può<br />
copiare dall’osp<strong>it</strong>e uno o più file e fornisce<br />
gli strumenti necessari per identificare la<br />
directory corrente sull’osp<strong>it</strong>e remoto,<br />
elencare i suoi file, cambiare directory e<br />
rinominare i file o cancellarli.<br />
Hash funzione che, dato un numero in ingresso, ne<br />
genera un altro dal numero di cifre<br />
prestabil<strong>it</strong>e. Da quest’ultimo non è possibile<br />
ricavare il numero che l’ha generato.<br />
Host computer usato da più di un utente come<br />
mezzo di accesso a Internet, di cui funge da<br />
punto terminale di trasferimenti dati.<br />
HTTP da HyperText Transport Protocol, protocollo<br />
per trasferimento di ipertesti. Protocollo e<br />
software serv<strong>it</strong>ore che lo implementa per la<br />
navigazione di ipertesti usato da World Wide<br />
Web.<br />
ICMP da Internet Control Message Protocol,<br />
protocollo di controllo dei messaggi in<br />
Internet. Protocollo standard che gestisce la<br />
s<strong>it</strong>uazione in cui un instradatore sia<br />
congestionato o comunque non in grado<br />
d’inviare a destinazione un datagramma.<br />
Glossario<br />
172
<strong>LA</strong>N da Local Area Network, rete locale.<br />
Collegamento di computer di vario tipo<br />
entro un’area lim<strong>it</strong>ata (10 m – 10 Km) per<br />
mezzo di un canale fisico cost<strong>it</strong>u<strong>it</strong>o da cavo<br />
coassiale, doppino telefonico o fibra ottica.<br />
MFC da Microsoft Foundation Classes, classi<br />
fondate da Mircrosoft. Insieme di librerie<br />
DLL, che forniscono numerose funzioni,<br />
come l’uso dei socket e la gestione delle<br />
finestre.<br />
NETBIOS da NETwork Basic Input/Output System,<br />
sistema di base di ingresso/usc<strong>it</strong>a di rete.<br />
Gruppo di funzioni di servizio, residenti in<br />
memoria di sola lettura, che favoriscono la<br />
trasmissione e la ricezione di dati fra un<br />
computer e la scheda di collegamento a una<br />
rete locale.<br />
NIST da National Inst<strong>it</strong>ute for Standards and<br />
Technology, Ist<strong>it</strong>uto nazionale per gli<br />
standard e la tecnologia. Ist<strong>it</strong>uto erede del<br />
National Bureau of Standards (NBS) e<br />
riconosciuto dall’ANSI, che definisce le<br />
specifiche per gli appalti pubblici.<br />
NNTP da Network News Transfer Protocol,<br />
protocollo di trasferimento delle notizie di<br />
rete. Nella rete Usenet, protocollo standard<br />
che regola la diffusione dei messaggi ai s<strong>it</strong>i<br />
che si siano accordati per ricevere le notizie<br />
di rete.<br />
NSF da National Science Foundation, Fondazione<br />
nazionale per la scienza. Agenzia<br />
indipendente del governo statun<strong>it</strong>ense,<br />
fondata nel 1950 per promuovere la scienza e<br />
la tecnologia attraverso la sponsorizzazione<br />
di ricerche scientifiche, ingegneristiche ed<br />
educative.<br />
NSFNet rete a commutazione di pacchetto ad alta<br />
veloc<strong>it</strong>à basata sui protocolli TCP/IP, che<br />
cost<strong>it</strong>uisce una delle dorsali di Internet e<br />
gestisce i dati prodotti da reti regionali.<br />
Glossario<br />
173
OSI da Open System Interconnection,<br />
interconnessione di sistemi aperti. Standard<br />
internazionale per l’organizzazione di reti<br />
locali, defin<strong>it</strong>o dall’Organizzazione<br />
internazionale per gli standard (ISO) e<br />
dall’Ist<strong>it</strong>uto di ingegneri elettrici ed<br />
elettronici (IEEE) nei primi anni ’80.<br />
PGP da Pretty Good Privacy, riservatezza molto<br />
buona. Software di cifratura di pubblico<br />
dominio sviluppato da Phil Zimmerman.<br />
POP3 da Post Office Protocol 3, protocollo<br />
postale. Protocollo che specifica gli scambi<br />
di posta elettronica tra un PC e un provider.<br />
Router apparato che esegue l’interconnessione di<br />
reti locali multiprotocollo. Opera allo strato<br />
3 del modello OSI e utilizza l’indirizzo<br />
logico contenuto in un pacchetto di dati per<br />
decidere il percorso da utilizzare per<br />
l’instradamento all’utente di destinazione; in<br />
presenza di più percorsi tra due <strong>LA</strong>N, li può<br />
utilizzare tutti in modo ottimizzato.<br />
SMTP da Simple Mail Transfer Protocol, protocollo<br />
semplice per il trasporto di posta. Nello<br />
strato di applicazione di Internet, protocollo<br />
che regola il formato dei messaggi di posta<br />
elettronica. Sviluppato inizialmente da<br />
ARPANet, è diventato il protocollo mondiale<br />
di fatto per i messaggi di posta elettronica.<br />
Socket nell’indirizzamento di Internet,<br />
combinazione di un indirizzo IP, che<br />
identifica un computer osp<strong>it</strong>e, con un<br />
indirizzo di porta, che identifica<br />
un’applicazione in funzione sull’osp<strong>it</strong>e.<br />
Steganografia deriva dalle parole greche steganòs, coperto e<br />
gràphein, scrivere. Tecnica di comunicazione<br />
segreta basata sull’occultamento del<br />
messaggio.<br />
Subnet nell’indirizzamento di Internet, subun<strong>it</strong>à<br />
nella rete di un’organizzazione, che è stata<br />
identificata come ent<strong>it</strong>à distinta ai fini<br />
dell’instradamento di datagrammi,<br />
modificando la struttura degli indirizzi IP.<br />
Glossario<br />
174
TCP/IP da Transmission Control Protocol/Internet<br />
Protocol, protocollo di controllo di<br />
trasmissione/protocollo Internet. Sigla che<br />
indica propriamente i due protocolli<br />
principali di Internet, il protocollo di<br />
controllo di trasmissione e il protocollo<br />
Internet, progettati alla fine degli anni ’70<br />
da Bobert E. Kahn e Vinton G. Cerf a<br />
Berkeley.<br />
Telnet nome di un protocollo e del software che lo<br />
implementa, che definisce un terminale<br />
virtuale di rete e permette a un utente di<br />
entrare in un computer osp<strong>it</strong>e remoto.<br />
UDP da User Datagram Protocol, protocollo di<br />
datagramma di utente. Nello strato di<br />
trasporto di Internet, protocollo non<br />
affidabile e senza collegamento che non<br />
tenta di verificare se un messaggio sia stato<br />
ricevuto.<br />
Unix sistema operativo multiutente/mult<strong>it</strong>ask<br />
sviluppato a partire dal 1969 da Ken<br />
Thompson nel Bell Telephone Labs. Scr<strong>it</strong>to<br />
originariamente nel linguaggio assembly, è<br />
stato presto tradotto in C, potendo così<br />
essere trasportato su numerosi sistemi.<br />
WAN da Wide – Area Network, rete ad ampio<br />
raggio. Rete dati pubblica, con topologia di<br />
sol<strong>it</strong>o a maglia o ibrida, che impiega linee<br />
telefoniche dedicate o satell<strong>it</strong>i per collegare<br />
più reti locali (<strong>LA</strong>N), estendendosi su una<br />
regione geografica più estesa di un’area<br />
metropol<strong>it</strong>ana.<br />
Winsock nell’ambiente Microsoft Windows, file di una<br />
libreria DLL che contiene le informazioni e<br />
le procedure necessarie a Windows per<br />
interfacciarsi con i protocolli TCP/IP.<br />
Glossario<br />
175
Visual C++ 6 Guida completa<br />
Davis Chapman<br />
Apogeo<br />
Dizionario di informatica<br />
Angelo Gallippi<br />
Tecniche nuove<br />
The Alan Turing home page<br />
www.turing.org.uk/turing<br />
Eli Biham’s home page<br />
www.cs.technion.ac.il/~biham/<br />
BIBLIOGRAFIA<br />
MAW 97 CIPHERS The Enigma machine<br />
www.math.arizona.edu/~dsl/enigma.htm<br />
Riksoft – Software – Protezione – Servizi<br />
www.riksoft.com/indexok.asp?Goto=cr<strong>it</strong>logia.htm<br />
Sockaddr.com<br />
www.sockaddr.com/<br />
MSDN Library<br />
www.microsoft.com<br />
Manuali.<strong>it</strong><br />
www.manuali.<strong>it</strong><br />
WWII Codes and cyphers<br />
www.codesandciphers.org.uk<br />
Bibliografia<br />
176