INDICE GENERALE - matteotirelli.com · matteo tirelli appunti del corso di sicurezza 2007/2008...

Matteo Tirelli Appunti del corso di SICUREZZA 2007/2008

INDICE GENERALE

LEZIONE 1:Introduzione alla sicurezza informatica........................................................................7

• Complessità dei sistemi e rischi dal punto di vista della sicurezza:non composizionalità della sicurezza, della tolleranza ai guasti e delle prestazioni. 7

• Le varie facce della medaglia:disponibilità, affidabilità, segretezza/riservatezza, integrità ......................................8

• Classificazione degli attacchi: worm e virus, denial of service, attacchi all'integrità, riservatezza e reputazione . .10

• Strategie di sicurezza: prevenzione, reazione (immediata) e rappresaglia.............11• Misure di sicurezza: fisiche, software e organizzative.............................................11

LEZIONE 2:Sicurezza a livello di sistema.......................................................................................12

• Modello generale di controllo degli accessi: utenti, risorse e nucleo di sicurezza; sistemi aperti e chiusi ..............................................................................................12

• Matrice degli accessi, access list e capability list; sistemi aperti dinamici e politiche di default...................................................................................................................13

• Mediazione del nucleo mediante identificazione/autenticazione degli utenti e autorizzazione degli accessi....................................................................................14

• Principi di Denning...................................................................................................15Ridondanza/economia di controllo.......................................................................................15Minimo privilegio e cambio di contesto...............................................................................15Anello debole e stratificazione senza incapsulamento di macchine virtuali........................16

LEZIONE 3:Controllo degli accessi.................................................................................................18

• Modelli mandatori per garantire segretezza oppure integrità. Problema dei "canali coperti" (o nascosti). Accettabilità da parte degli utenti dei modelli mandatori.......18

• Modello discrezionale: esempio del file system Unix/Linux.....................................19• proprietario del file, amministratore di sistema, e gli altri.........................................19• privilegi di accesso a discrezione del proprietario (o di root)...................................20• privilegi non discrezionali.........................................................................................20• implementazione/approssimazione del principio di minimo privilegio e cambio di

contesto: "su", "sudo", "set UID", "set GID".............................................................21

1 / 86


LEZIONE 4:Memoria sicura...............................................................................................................22

• Memoria RAM di un sistema di calcolo; come realizzare integrità, affidabilità e disponibilità a livello hardware e di nucleo del sistema operativo ..........................24

• Problemi di segretezza derivanti dalla condivisione della memoria: cancellazione/deallocazione lazy, garbage collection, caching ..............................24

• Cancellazione della memoria secondaria (dischi, flash) .........................................24• Cancellazione a livello di file system e journaling ...................................................24• Cancellazione a livello applicativo (esempio del word processor) .........................24

LEZIONE 5:Sicurezza dei processi..................................................................................................25

• Sicurezza dei processi.............................................................................................25• meccanismi hardware a supporto del confinamento dei processi da parte del

processore: modi di esecuzione user/system, trap, memoria virtuale a segmentazione.........................................................................................................26

• Struttura del kernel del sistema operativo per l'esecuzione dei processi; punti deboli dal bootstrap fino all'attivazione dei processi utente.....................................26

• Processi "privilegiati" (con UID=0) e processi "normali" in Unix/Linux....................27• Attacchi di tipo "Buffer Overflow" per far eseguire codice malizioso a processi

privilegiati.................................................................................................................28

LEZIONE 6:Firewall............................................................................................................................30

• Definizione di Firewall e possibili implementazioni a seconda dei requisiti:............30• licenza proprietaria o libera......................................................................................30• sistema operativo.....................................................................................................30• architettura hardware...............................................................................................30• costi economici.........................................................................................................30• Flessibilità................................................................................................................30• situazione in cui ci si trova.......................................................................................30• Accenni agli application firewall...............................................................................30• Accenno al ping e al filtering icmp...........................................................................30• Filtering a livello 3 e 4..............................................................................................31• Cosa può fare e cosa non può fare un firewall........................................................31

LEZIONE 7Introduzione alla Crittografia........................................................................................32

• Alice, Bob e Devil; luoghi fisicamente sicuri, canali di comunicazione soggetti ad attacchi; attacchi di tipo attivo e passivo ad integrità, segretezza, ecc...................32

• Tecniche semplici di cifratura: testo in chiaro, testo cifrato, sostituzione di caratteri, permutazione di caratteri, chiave di cifratura...........................................................33

• Sicurezza computazionale e sicurezza incondizionata...........................................34• Idea di cripto-analisi ed effetto della ridondanza del testo in chiaro........................34

2 / 86


LEZIONE 8Sicurezza di rete............................................................................................................37

• Uso e abuso della rete wireless da parte degli utenti telelavoratori (tratto da punto informatico)..............................................................................................................37

• Esempi di phishing del sito ebay e di paypal. Uso del software wireshark per l'intercettazione del traffico TCP/IP e la ricostruzione delle sessioni......................37

• Firewall: politiche di default permit e default deny...................................................37

LEZIONE 9Principi della Crittografia moderna..............................................................................38

• Sicurezza incondizionata, cifrario di Vernam (One Time Pad) e problemi pratici legati alla lunghezza della chiave............................................................................38

• Necessità di cifrari basati su chiave di lunghezza predeterminata. Principi di Shannon...................................................................................................................39

• Confusione: modifica di un solo bit di chiave cambia ogni bit del codice cifrato con probabilità ½.............................................................................................................39

• Diffusione: modifica di un solo bit del messaggio in chiaro cambia ogni bit del codice cifrato con probabilità ½...............................................................................40

• Codici di tipo Stream o a Blocchi (necessità di padding).........................................40• Modi di uso dei codici a blocchi: Electronic Codebook (ECB) oppure Cipher Block

Chaining (CBC)........................................................................................................41

LEZIONE 10Virus................................................................................................................................43

• Definizione di virus...................................................................................................43• Storia dei Virus (Darwin, Pervade, Elk Cloner, Definizione di Cohen, Brain, Virdem)

.................................................................................................................................43• Meccanismi di infezione: file eseguibili (companion, overwriting, prepending,

appending, boot sector[michelangelo]), macro virus (Melissa, Laroux, tristate e mutazioni involontarie), multipartite virus (Navrhar), Scripting virus, Source Code Virus.........................................................................................................................43

• Meccanismi di propagazione: periferiche rimuovibili, e-mail, download (Melissa), directory condivise...................................................................................................43

• Difese: antivirus (aggiornamenti, signature e anomaly detection, verifica integrità), configuration hardening (POLP etc.), educazione utenti.........................................43

LEZIONE 11Cifratura e chiavi condivise..........................................................................................44

• Esempio di algoritmo di cifratura DES.....................................................................44• Apertura/Segretezza degli algoritmi.........................................................................45• Crittografia forte e debole........................................................................................45• Brevetti.....................................................................................................................45• Problema del Logaritmo Discreto e protocollo Diffie-Hellman.................................46

LEZIONE 12WORM.............................................................................................................................48

3 / 86


LEZIONE 13Diffie-Hellman e RSA.....................................................................................................49

• Attacchi attivi (man-in-the-middle) al protocollo Diffie-Hellman...............................49• Introduzione ai sistemi a chiave asimmetrica..........................................................50• Crittosistema RSA (Rivest, Shamir, Adleman)........................................................51• idea di cifratura e decifratura con due chiavi diverse..............................................51• le formule di cifratura, decifratura e calcolo delle due chiavi...................................51• uso per firmare documenti integri/autentici..............................................................52• uso per cifrare documenti segreti............................................................................52• caratteristiche di sicurezza del crittosistema...........................................................52• confronto coi crittosistemi a chiave simmetrica.......................................................53

LEZIONE 14Prof. Aiello, in preparazione ... ....................................................................................54

LEZIONE 15Funzioni Hash Crittografiche.......................................................................................55

• Tabelle Hash e e Funzioni Hash Perfette................................................................55• Ridondanza dei documenti......................................................................................56• Paradosso del Compleanno.....................................................................................57• Realizzazione di Funzioni Hash Crittografiche........................................................58

LEZIONE 16Applicazioni delle Funzioni Hash.................................................................................59

• Verifica di Integrità dei documenti............................................................................59• Firma Digitale...........................................................................................................60• Autorità di certificazione e Certificati........................................................................61• Certificati Digitali X509.V3.......................................................................................62

LEZIONE 17Altre applicazioni delle Funzioni Hash........................................................................64

• Il gioco del "pari o dispari" O “testa e croce” via rete...............................................65• "cifratura" delle password........................................................................................65• One-time Password..................................................................................................67

LEZIONE 18Firewall............................................................................................................................68

• Consigli pratici per l'implementazione di un firewall................................................68• Firewall UTM e classici (layer 3-4)...........................................................................68• Esempi di firewall commerciali.................................................................................68• Iptables su Linux......................................................................................................68• Logging.....................................................................................................................68• Firewall stateful e non..............................................................................................68

4 / 86


LEZIONE 19Meccanismi di Autenticazione e Certificati Digitali...................................................69

• Cosa sa l'utente? Login e Password........................................................................69• Cosa possiede l'utente? Chiavi di cifratura, schede magnetiche, smart-card.........70• Com'è fatto l'utente? Metodi biometrici....................................................................70• Ancora firme digitali e certificati: verifica on-line e off-line.......................................71• Marche temporali e validità nel tempo della firma digitale.......................................73

LEZIONE 20Intrusion Detection........................................................................................................74

• Host Intrusion Detection e Network Intrusion Detection..........................................74• ESEMPI DI DUMP TRAFFICO INTERNET E ANALISI DI TRAFFICO NORMALE75• Differenze tra anomaly e misuse detection..............................................................76• Port scanning (FIN scan, half connect scan, ACK scan).........................................76• Three-way handshake.............................................................................................78• OS Fingerprinting.....................................................................................................78

LEZIONE 21Steganografia e Watermarking.....................................................................................79

• Idea generale di Steganografia: contenitore e contenuto; ridondanza....................79• Contenitori testuali...................................................................................................79• Contenitori audio (tecnica del bit meno significativo)..............................................80• Contenitori immagini (pixmap e formati compressi)................................................80• Le strutture dati non canoniche come contenitore...................................................80• Cenni alle differenze tra Steganografia e Watermarking.........................................81

LEZIONE 22Attacchi in rete...............................................................................................................82

• IP fragmentation allo scopo di effettuare firewall bypassing...................................82• Man-in-the-Middle....................................................................................................82• Attacco di Mitnick (ip spoofing alla cieca)................................................................82• ARP Cache Poisoning.............................................................................................82

LEZIONE 23Sniffing............................................................................................................................83

• NIC in modalità promiscua.......................................................................................83• sniffing detection su host.........................................................................................84• sniffing detection via rete.........................................................................................84

risposta a stimoli...................................................................................................................84test di latenza al variare del traffico di rete..........................................................................85DNS query (reverse lookup).................................................................................................85

• anti-anti sniffing........................................................................................................86• Ethernet bus, hub e switch: sniffing su switch.........................................................86

5 / 86


6 / 86


LEZIONE 1:INTRODUZIONE ALLA SICUREZZA INFORMATICA

COMPLESSITÀ DEI SISTEMI E RISCHI DAL PUNTO DI VISTA DELLA SICUREZZA:NON COMPOSIZIONALITÀ DELLA SICUREZZA, DELLA TOLLERANZA AI GUASTI E DELLE PRESTAZIONI

Per considerare un sistema sicuro bisogna considerare l'unione di tre componenti: Hardware, Software e Utenti. Il corretto funzionamento non e' quindi legato ad una singola componente, ma a tutte e tre. Per realizzare un sistema sicuro occorre quindi analizzare e capire quali sono i punti deboli di ognuna delle singole componenti.

I sistemi sono estremamente complessi, tuttavia la complessità e' uno dei maggiori nemici della sicurezza.

Il metodo comune per rendere sicuro un sistema e' quello di partire da un sistema completamente insicuro ed aggiungere software, tuttavia questo non fa altro che aumentare la complessità del sistema, e come abbiamo detto precedentemente questo e' un problema.

L'approccio da seguire e' invece esattamente l'opposto, ovvero ridurre al minimo le funzionalità del sistema. Tuttavia questo è un approccio di tipo ideale e difficilmente perseguibile soprattutto in sistemi di tipo general porpouse.

CAUSE DELLA COMPLESSITA':

● L'uso del layering

● L'uso delle componenti (intese come porzioni distinte di sistema ognuna delle quali caratterizzata da minor complessità rispetto al sistema nella sua interezza).

● ...

L'uso di componenti ci porta tuttavia a dover introdurre il concetto di composizionalità:nello sviluppo di una componente infatti è necessario tener conto di tutte le possibili interazioni con altre componenti. Questo tuttavia non è possibile. Si possono prevedere innumerevoli situazioni e combinazioni, ma esisterà sempre un caso non previsto.

La sicurezza, le elevate prestazioni e la fault tollerance sono proprietà che non possono essere garantite nel momento in cui più componenti vengono composte/integrate, nemmeno se tutte le singole componenti prese in isolamento godono di tali proprietà.

In conclusione possiamo quindi dire che la sicurezza NON gode della proprietà di composizionalità

7 / 86


LE VARIE FACCE DELLA MEDAGLIA:DISPONIBILITÀ, AFFIDABILITÀ, SEGRETEZZA/RISERVATEZZA, INTEGRITÀ

Sicurezza è un termine vago. Per definirla dobbiamo considerare le seguenti caratteristiche:

DISPONIBILITA' ( di un sistema, di un apparato dati, .... ). Dobbiamo garantire che il sistema risponda immediatamente alle interrogazioni e permetta quindi di ottenere i dati o i servizi richiesti nel momento in cui vengono richiesti. Si può avere mancanza di disponibilità per diversi motivi, quali la rete momentaneamente in down, la macchina spenta, il DB server down, ecc...

La disponibilità è una caratteristica che viene normalmente valutata a livello temporale (tempo di disponibilità / uptime)

Ci sono chiaramente casi in cui la disponibilità non è una caratteristica essenziale.

INTEGRITA': Dobbiamo garantire che i dati memorizzati non vengano alterati o corrotti. Quali sono le cause della corruzione dei dati?

• L'utilizzatore dei dati commette degli errori• Un attacco volontario esterno• Un guasto del dispositivo di memorizzazione

L'integrità è estremamente importante ad esempio in applicazioni quali un database contenente dati importanti. Invece in casi come le comunicazioni in VOIP l'integrità non è una caratteristica essenziale, poiché la perdita di alcuni bit durante una conversazione è trascurabile e si può quindi sacrificarla dedicando maggiore attenzione in favore di altre caratteristiche.

PRIVATEZZA:Dobbiamo garantire che i dati memorizzati rimangano riservati. Ad esempio voglio che dati personali che ho scritto io rimangano accessibili solo a me. La privatezza è una caratteristica essenziale ovunque ci siano dati sensibili e/o riservati.

AFFIDABILITA':E' una caratteristica strettamente imparentata con la disponibilità. La differenza tra affidabilità e disponibilità consiste nell'arco di tempo che consideriamo. In questo caso non desideriamo avere un accesso immediato alle funzionalità offerte dal sistema, ma vogliamo che sia possibile “prima o poi” accedervi. Dobbiamo quindi garantire che “prima o poi” il sistema risponda.

La sicurezza è una qualunque combinazione delle quattro caratteristiche precedenti. La distribuzione delle singole caratteristiche all'interno di tale combinazione dipende dallo scopo per il quale il sistema viene predisposto.

8 / 86


Bisogna quindi chiedersi sempre come prima cosa quali sono le caratteristiche che è necessario garantire e successivamente determinare a quali invece si è disposti a rinunciare (o tenere in minor considerazione). Questo perché alcune caratteristiche sono conflittuali tra loro.

es. Privatezza – DisponibilitàPer ottenere disponibilità dovrei introdurre un sistema di ridondanza, ma questo provoca un aumento del flusso di dati sulla rete. Questo tuttavia favorisce l'intercettabilità delle comunicazioni e quindi riduce la privatezza dei dati

E' necessario quindi stabilire sempre un ordine di importanza delle caratteristiche (una gerarchia che si adatti alle esigenze del sistema che stiamo sviluppando)

Un punto di partenza è la CORRETTEZZA della realizzazione, seguendo delle specifiche che prendano in considerazione gli aspetti di sicurezza. I bug infatti possono avere effetti negativi sulla sicurezza. Tuttavia la correttezza da sola non è sufficiente.

Un altro aspetto importante è la ROBUSTEZZA. Un sistema robusto è un sistema che in qualunque situazione (prevista e / o imprevista) fa quello che deve. La robustezza è necessaria poiché dobbiamo sempre assumere di essere immersi in un ambiente ostile

Per ambiente ostile si intende un ambiente soggetto a guasti, danni involontari, attacchi deliberati, ecc...

La robustezza è estremamente correlata alla fault tollerance: quando avviene un guasto dobbiamo sempre chiederci quali possono essere gli effetti del guasto sulla sicurezza del sistema

perdo la disponibilitàes. rottura di un disco: conservo la privatezza dei dati

conservo l'affidabilità – solo se ho i backup

posso allora introdurre ridondanza: sia fisica che software

● fisica: posizionando le macchine in ambienti differenti, con impianti elettrici e contatori separati, ecc...

● software: utilizzo parallelamente sistemi differenti, sviluppati da team distinti. In questo modo le probabilità che i due team abbiano introdotto lo stesso bug si riducono notevolmente

9 / 86


CLASSIFICAZIONE DEGLI ATTACCHI: WORM E VIRUS, DENIAL OF SERVICE, ATTACCHI ALL'INTEGRITÀ, RISERVATEZZA E REPUTAZIONE

Non pensiamo tanto ai guasti quanto ad azione e attacchi deliberati. Inizialmente i sistemi operativi ed i protocolli di comunicazione sono stati sviluppati e progettati senza considerare la possibilità di attacchi.

1988: Worm di Morris (primo attacco)

Morris prese un'idea (pubblicata nell'82) di calcolo distribuito che prevedeva l'utilizzo della cpu di altre macchine, senza alcun intervento da parte dell'operatore, nel momento in cui la cpu della macchina su cui era stato lanciato il processo originale era satura.

L'attacco di Morris ha di fatto sfruttato una leggerezza dei protocolli di rete. Il suo worm saturava i processi eseguiti in remoto per potersi così diffondere a cascata su altre macchine.

I Worm: hanno un comportamento di tipo attivo e si diffondono autonomamente

I virus e i trojan: invece hanno bisogno dell'intervento di un utente sprovveduto o abilmente ingannato.

Attacchi DoS – Denial of Service: l'obbiettivo di un attacco DoS è quello di monopolizzare le risorse di un sistema in modo che questi diventi indisponibile agli utenti legittimi

Attacchi all'integrità: l'attaccante modifica deliberatamente i dati o le applicazioni di un sistema (ad esempio per violare l'accesso e poter accedere al sistema senza credenziali, o per spiare)

Attacchi alla privatezza dei dati: l'attaccante sfrutta debolezze del sistema o bug per accedere a dati riservati

Attacchi alla reputazione: ad es. un defacement del sito di un'azienda rivale per sminuirne la reputazione

10 / 86


STRATEGIE DI SICUREZZA: PREVENZIONE, REAZIONE (IMMEDIATA) E RAPPRESAGLIA

● PREVENZIONE: progettare un sistema robusto

● REAZIONE IMMEDIATA: è necessaria l'osservazione continua del sistema per capire se si è sotto attacco. La reazione dipende ovviamente dalla tipologia di attacco al quale siamo sottoposti:

○ nel caso di un DoS potremmo iniziare a scartare pacchetti per uscire dalla situazione di DoS

○ nel caso di un worm dovremmo interrompere il processo, cancellarne i file e ripulire il sistema

● RAPPRESAGLIE: l'attacco è stato ormai subito allora indago su chi è stato e... o gli mando la polizia postale o gli restituisco il favore

○ la minaccia di una rappresaglia talvolta può essere un'ottima misura di prevenzione

○ raccolta informazioni, non in tempo reale. L'analisi dei log è più approfondita rispetto a quella utilizzata durante la reazione immediata (dove l'analisi è più superficiale), ma è costante

MISURE DI SICUREZZA: FISICHE, SOFTWARE E ORGANIZZATIVE

Dal punto di vista operativo invece dobbiamo considerare le misure di sicurezza su tre distinti livelli di egual importanza:

● Fisico: ad esempio un pc posizionato in una stanza chiusa, la cui chiave è affidata a persone fidate ed autorizzate all'uso della macchina

● Software: difese di tipo logico, ad esempio un firewall

● Organizzativo: implica il coinvolgimento, l'informazione e l'addestramento degli utenti che interagiscono con il sistema

Occorre ricordare che un attaccante non cercherà mai di violare il livello più difficile, ma sceglierò sempre quello più facilmente violabile. E' quindi opportuno suddividere le risorse economiche destinate alla messa in sicurezza di un servizio/sistema in maniera quanto più possibile paritetica rendendo in egual misura sicuri i tre livelli.

Se noi ci limitassimo a proteggere un sistema tramite firewall e lasciassimo la macchina che lo ospita liberamente accessibile e posizionata in un ambiente ostile il firewall potrebbe essere inutile. Eviterebbe attacchi remoti ma non garantirebbe alcuna protezione da attacchi diretti (anche solo ad un DoS perpetrato spegnendo la macchina)

11 / 86


LEZIONE 2:SICUREZZA A LIVELLO DI SISTEMA

MODELLO GENERALE DI CONTROLLO DEGLI ACCESSI: UTENTI, RISORSE E NUCLEO DI SICUREZZA; SISTEMI APERTI E CHIUSI

Abbiamo delle risorse di tipo hardware e software e degli utenti (persone / processi) che le vogliono utilizzare. Come dobbiamo allora organizzare il sistema?

Dobbiamo impedire quindi l'accesso diretto alle risorse.

Per fare questo, interponiamo una barriera detta “nucleo di sicurezza” (kernel) che faccia da mediatore tra gli utenti e le risorse.

Potremmo però avere alcuni problemi utilizzando questa tecnica:

● problemi di efficienza (rapidità dei tempi di risposta): si aggiunge latenza nel passaggio attraverso il kernel (e sono necessarie ulteriori risorse per la gestione del kernel)

● garantire accessi contemporanei da parte di più utenti alla medesima risorsa

● quanti utenti possiamo gestire?

● quante risorse possiamo gestire?

● risorse e utenti possono variare di volta in volta o devono essere predeterminati?

Un sistema aperto permette la variazione nel tempo della quantità di utenti e risorse, viceversa un sistema che non offra queste possibilità è detto sistema chiuso.

L'introduzione di un sistema di controllo in grado di mediare tra utenti e risorse porta ad avere una centralizzazione.

Un approccio differente è invece quello di isolare ogni utente ed ogni risorsa in modo tale da garantire che non possano esserci interferenze tra utenti e risorse.

Lo scopo del kernel diventa quindi quello di discriminare quello che è lecito da quello che non lo è.

Una soluzione perseguibile potrebbe essere quella di predisporre una matrice di accesso dove vengono memorizzati per ogni utente i diritti di accesso in rapporto ad ogni risorsa.

12 / 86


Problema: chi definisce questa matrice?

Bisogna innanzitutto considerare che le operazioni su una singola risorsa non sono semplicemente liquidabili con un si/no, ma occorre specificare i permessi per ogni operazione possibile. A seconda del tipo di risorsa infatti potrei avere da una ad n modalità di accesso.

In un sistema chiuso, avendo una conoscenza pregressa di tutti gli utenti autorizzati su quel sistema e di tutte le risorse in esso disponibili, questa matrice è definita una volta per tutte. Valutare quindi se un utente può accedere in una data modalità ad una data risorsa significa semplicemente consultare tale matrice.

MATRICE DEGLI ACCESSI, ACCESS LIST E CAPABILITY LIST; SISTEMI APERTI DINAMICI E POLITICHE DI DEFAULT

In un sistema aperto invece la matrice è soggetta a continui cambiamenti; ho quindi due possibili alternative su cui operare:

● pensare alle colonne . In questo modo determino per ogni risorsa quali operazioni ogni utente può compiere su tale risorsa. Definisco quindi una lista di accesso (access list) che indica chi può accedere. Se aggiungo una nuova risorsa dovrò espandere la matrice aggiungendo una colonna caratterizzata da una nuova access list.

● pensare alle righe focalizzando il ragionamento sugli utenti. Questa modalità è detta capability list. Per ogni utente definisco quindi quali risorse egli può utilizzare.

Problemi della gestione dinamica:Gli utenti e le risorse possono cambiare frequentemente, quindi i valori delle matrici devono essere costantemente aggiornati.

A tale proposito introduco allora il concetto di default che indica il permesso di accesso

13 / 86


predefinito. Si può quindi parlare di:

● default grant: se nella matrice non ho indicazioni specifiche allora acconsento l'accesso alla risorsa.

● Default deny: se nella matrice non ho indicazioni specifiche allora nego l'accesso alla risorsa.

Quale politica è più sicura? La risposta a questa domanda dipende dal tipo di sicurezza che è di primaria importanza per il sistema:

● integrità: DENY

● privacy: DENY

● affidabilità: GRANT

Che cosa scegliere invece tra access list e capability list? Dipende da che cosa valuto possa cambiare con maggior frequenza. Se penso di variare frequentemente le risorse utilizzerò le access list, in caso contrario le capability list. Ad ogni modo devo sempre far uso delle politiche di default quando varia il parametro opposto a quello fissato.

MEDIAZIONE DEL NUCLEO MEDIANTE IDENTIFICAZIONE/AUTENTICAZIONE DEGLI UTENTI E AUTORIZZAZIONE DEGLI ACCESSI

Consideriamo le risorse come entità passive e gli utenti come entità attive. Il Kernel diventa così scomponibile in 2 fasi:

● identificazione mediante accesso alla matrice, access list, capability list: si cerca nella struttura dati scelta la posizione indicizzata da processo e risorsa

● autorizzazione: si legge il permesso e si concede / nega l'operazione

Cosa può rendere più o meno sicuro il controllo degli accessi?

● Devo essere sicuro di aver identificato correttamente l'utente

● Devo essere sicuro che l'utente esegua solo le operazioni per cui è stato autorizzato

14 / 86


PRINCIPI DI DENNING

Si tratta di una lista di preoccupazioni da tenere a mente durante la realizzazione di un sistema sicuro.

RIDONDANZA/ECONOMIA DI CONTROLLO

E' necessario trovare un compromesso ragionevole tra economia di controllo e ridondanza.

La ridondanza di controllo dovrebbe contribuire a garantire la robustezza del kernel. Implica quindi il dover passare attraverso una sequenza di controlli e non uno solo prima di poter acconsentire l'accesso ad una risorsa.

In pratica devo assumere sempre che il kernel possa fallire, quindi eseguendo molteplici controlli e verificando che tutti i risultati siano coerenti posso avere maggiori garanzie.

Se uno dei controlli della sequenza dovesse fallire allora verrebbe negato l'accesso alla risorsa. Ciononostante se non avessimo introdotto ulteriori controlli ed il kernel avesse risposto positivamente al primo ed unico controllo, l'utente avrebbe avuto accesso alla risorsa. Quindi la ridondanza di controllo ha aumentato la complessità del kernel ed ha conseguentemente ridotto la robustezza.

Il principio di economia di controllo invece mi dice che il tempo destinato a sviluppare controlli equivalenti se fosse destinato a sviluppare un singolo controllo renderebbe quest'ultimo più solido e sicuro.

Entrambi i ragionamenti sono convincenti, per questa ragione il principio richiede di valutare un giusto compromesso.

Per quanto riguarda l'efficienza è meglio basarsi sul principio di economia.Per la fault-tollerance la ridondanza aiuta, tuttavia la probabilità che su molteplici controlli uno si “guasti” è maggiore della probabilità di guasto di un singolo controllo.Per quanto riguarda invece l'accettazione da parte degli utenti e l'usabilità di un sistema sarebbe preferibile la presenza del minor numero di controlli possibili.

MINIMO PRIVILEGIO E CAMBIO DI CONTESTO

Il concetto di minimo privilegio è strettamente legato all'attribuzione dei permessi nelle matrici di controllo. Il concetto base è quello di concedere il livello minore possibile di privilegio necessario affinché l'utente possa portare a termine i propri compiti.

15 / 86


Minimo privilegio : dare lo stretto necessario numero di privilegi ad ogni utente

● Scrittura : un ridotto numero di permessi preserva l'integrità

● Lettura : un ridotto numero di permessi preserva la privatezza

Questo comporta l'applicazione di una politica di tipo default deny. Tuttavia nel momento in cui varia l'esigenza di un utente dovrei aggiornare i permessi assegnati ad esso.

Per questa ragione adotto il meccanismo del cambio di contesto.

In questo modo ho una gestione dinamica delle risorse. Non associo le modalità di accesso in modo statico ad ogni utente, ma solo quando l'utente ne ha una reale necessità di utilizzo. In pratica viene concesso l'uso della risorsa solo quando serve, al termine del suo utilizzo il permesso viene revocato.

Come posso passare da un contesto ad un altro? Deve esistere una fase di negoziazione delle risorse. Ogni sessione di utilizzo delle risorse deve essere quanto più possibile limitata nel tempo. Tuttavia occorre fare alcune considerazioni:

● se le sessioni fossero troppo corte un utente impiegherebbe più tempo a negoziare le risorse piuttosto che ad utilizzarle effettivamente.

● se le sessioni fossero invece lunghe il minimo privilegio legato ad un utente rischierebbe di essere un po' troppo esteso.

Bisogna quindi trovare il giusto compromesso: sessioni quindi brevi, ma non troppo.

ANELLO DEBOLE E STRATIFICAZIONE SENZA INCAPSULAMENTO DI MACCHINE VIRTUALI

Devo organizzare le risorse e garantirne sicurezza in maniera equa. Ogni componente deve essere sicura quanto le altre componenti che costituiscono il sistema. E' necessario quindi bilanciare lo sforzo dedicato ad ogni componente del sistema per evitare componenti deboli che compromettono la sicurezza totale.

16 / 86


In un sistema incapsulato se lo strato esterno è sicuro allora l'intero sistema è sicuro. Un attacco infatti potrebbe essere diretto solo al livello più esterno del sistema.

In sistemi a strati invece è spesso possibile accedere direttamente agli strati inferiori. Ne consegue quindi che è necessario proteggere tutti gli strati.

Esempi:

Anche se rendessi un sistema sicurissimo, ma lo lasciassi privo di password di bios la sicurezza implementata potrebbe risultare inutile.

Se si realizza un nuovo protocollo di comunicazione sicuro, ma lo si estende in modo da essere retro compatibile, questi sarebbe soggetto a tutte le vulnerabilità precedenti.

17 / 86


LEZIONE 3:CONTROLLO DEGLI ACCESSI

MODELLI MANDATORI PER GARANTIRE SEGRETEZZA OPPURE INTEGRITÀ. PROBLEMA DEI "CANALI COPERTI" (O NASCOSTI). ACCETTABILITÀ DA PARTE DEGLI UTENTI DEI MODELLI MANDATORI

Si distinguono due modelli : mandatorio e discrezionale.

○ Mandatorio : L'uso delle risorse viene codificato da un'entità superiore in modo da dare garanzie dal punto di vista della sicurezza.Consideriamo due aspetti principali:

■ Privatezza : Definiamo delle classi di segretezza organizzate gerarchicamente ( Esempio Top Secret > Riservato > Pubblico ). Usiamo quindi queste classi per classificare utenti e risorse in modo da poter

discriminare gli accessi per appartenenza.Nc = non classificata,generica.Per la lettura gli utenti possono accedere anche alle classi inferiori ma in scrittura gli utenti non possono accedere a risorse di classe inferiore

( Altrimenti un processo top secret potrebbe scrivere su file pubblici!! ).Questo si spiega semplicemente perchè in questo momento ci stiamo occupando del fattore privatezza e non di quello dell'integrità. Per cui per la privatezza dei dati è perfettamente legittimo per un processo qualsiasi scrivere su una risorsa top secret.Come vedremo in seguito, i due modelli non possono essere applicati in maniera concorrente poiché sono mutualmente esclusivi. E' necessario individuare quale requisito sia considerato più importante e scegliere il modello opportuno.

■ Integrità : Classifichiamo risorse e utenti in due modi possibili (Integre – Non integre)

a seconda della (non) affidabilità che si attribuisce alla risorsa e all'utente.

18 / 86


■ Privatezza – Problema : Anche se assicuriamo la privatezza dei dati e l'impossibilità di comunicazione di un processo top secret con processi di classe inferiore, non è detto che non si possa riuscire a trasmettere dati sensibili fuori controllo. Immaginiamo un processo top secret e un processo pubblico con una risorsa condivisa. Anche se il modello della privatezza impedisce la trasmissione di dati sensibili verso il processo pubblico, il processo top secret può codificare informazioni attraverso fenomeni esterni ( Ad esempio la latenza delle operazioni – fattore influenzabile dal processo top secret e rilevabile dal processo pubblico )

MODELLO DISCREZIONALE: ESEMPIO DEL FILE SYSTEM UNIX/LINUX

Discrezionale : Il controllo viene delegato agli utenti ( Ed è bene tenere in mente che gli utenti non amano negarsi le risorse --> classi di utenti in conflitto )Un esempio di modello discrezionale è il filesystem Unix :Discriminiamo innanzitutto un utente in particolare : il proprietario del file ( Di default viene impostato l'id utente del processo che genera il file ).Questa situazione tuttavia si presta poco a una gestione più raffinata dei permessi.Consideriamo anche il gruppo : un insieme di utenti che condividono gli stessi permessi.Assegnami quindi i permessi (Read,Write,Execute,Set) per utente,gruppo e tutti gli altriUn file quindi conterrà un bit vector per user,group e other per i permessi e due campi per l'Uid ( User Indentifier ) e il Gid ( Group Identifier ). Sia il proprietario che l'amministratore del sistema possono variare i permessi di accesso come pure l'owner o il group del file.Tuttavia perchè tenere bit per i permessi dell'owner dato che questi può modificarli a piacere?Avere bit in più è indubbiamente uno spreco, ma assicura il minimo privilegio unito al cambio di contesto (Vd Lez.2). Permette infatti di mantenere i permessi al minimo e di variarli solo nel momento in cui richiede una risorsa ( resettandoli dopo l'uso ).

PROPRIETARIO DEL FILE, AMMINISTRATORE DI SISTEMA, E GLI ALTRI

● Fase di Autenticazione delle risorseSi confronta l'Uid del processo con l'Uid dell'owner nel file. Se corrispondono si applicano i permessi registrati per l'owner. Se non c'è corrispondenza si cerca di verificare il gruppo:si confronta il Gid indicizzato nel file passwd dal Uid del processo e lo si confronta con il Gid registrato nel file. Si controlla quindi il file dei gruppi nella posizione indicizzata dal Gid del file e si guarda se nella lista degli utenti appartenenti al gruppo c'è corrispondenza con l'Uid del processo. Se una di queste due verifiche ha successo si assegnano i permessi del gruppo registrati nel file. Se le verifiche dell'owner e del gruppo falliscono allora si assegnano i permessi registrati per tutti gli altri.

19 / 86


PRIVILEGI DI ACCESSO A DISCREZIONE DEL PROPRIETARIO (O DI ROOT)

PRIVILEGI NON DISCREZIONALI

Minimo privilegio e cambio di contesto Per il principio del minimo privilegio si assegnano permessi minimi agli utenti e quando c'è la necessità di usare una risorsa si scatena un cambio di contesto per l'utente atto a garantirgli i privilegi necessari ( E non più di questi ) riportando i privilegi allo stato originale non appena termina l'utilizzo della risorsa da parte del processo. E' necessario poter effettuare questa operazione senza dover passare per l'amministratore di sistema altrimenti è molto facile che al processo vengano assegnate tutte le risorse disponibili per evitare lunghe fasi di negoziazione ( Vedere Sessioni Lunghe/Corte e relative conseguenze – Lez. 2 ). A questo scopo in ambiente unix esistono due strumenti a disposizione dell'utente: su e sudo

Su : Apre una nuova sessione con privilegi da amministratore di sistema in cui l'utente può eseguire i propri programmi. Autentica l'utente attraverso la password del super user. Poiché i privilegi durano per la durata della sessione che dipende solo dalla volontà dell'utente questa scelta risulta più delicata di sudo. Inoltre non permette di raffinare la concessione dei permessi: l'utente li riceve direttamente tutti.

Sudo : Esegue un comando con privilegi da amministratore, dopodiché l'utente è di nuovo nel suo contesto. Sudo autentica usando la password dell'utente, così da non dover rivelare quella del super user.Questa autenticazione ha due significati: in primo luogo ricorda all'utente (e lo avverte dei possibili rischi ) che sta per eseguire un'azione in un contesto tale da poter fare danni; in secondo luogo per confermate l'identità e la presenza dello stesso utente per la sessione. Sudo permette una gestione più raffinata dei permessi poiché è possibile definire quali

20 / 86


programmi ogni utente può eseguire attraverso sudo e da quali postazioni ( locale o postazioni remote ).

IMPLEMENTAZIONE/APPROSSIMAZIONE DEL PRINCIPIO DI MINIMO PRIVILEGIO E CAMBIO DI CONTESTO: "SU", "SUDO", "SET UID", "SET GID"

Permessi Set ( SetUid e SetGid )Tra i pemessi definibili per utente,gruppo e altri figurano anche due opzioni di tipo set.Hanno senso solo per file eseguibili.SetUid : Se il bit è a 1 il processo viene eseguito con l'Uid dell'owner ottenendo l'accesso a tutte le risorse previste per l'owner. SetGid : Se il bit è a 1 il processo viene eseguito col Gid dell'owner ottenendo l'accesso a tutte le risorse previste per il gruppo dell'owner.Questi due permessi usati opportunamente permettono un accesso controllato alle risorse molto efficace poiché l'owner può mettere a disposizione le sue risorse attraverso programmi che verifichino tutti i controlli necessari e che vincolino l'utente a passare attraverso l'interfaccia fornita senza avere accesso diretto alle risorse. E' fondamentale che tutti gli altri utenti a parte l'owner non abbiano altri permessi sul file eseguibile se non quello di esecuzione altrimenti l'interfaccia sulle risorse rischia di essere compromessa.In generale comunque si preferisce usare il bit set per il gruppo, in quanto l'owner ha il controllo totale dei permessi e dell'apparteneza del file ( owner,group ) mentre il gruppo ottiene solo dei permessi speciali ma non può alterare l'appartenenza del file né i suoi permessi.

21 / 86


LEZIONE 4:MEMORIA SICURA

Considerando gli aspetti della sicurezza presi in esame fino ad ora ( Privatezza , Integrità, Disponibilità e Affidabilità ) si può osservare che il vero punto debole risulta essere proprio la privatezza. Questo è dovuto alla politica di realizzazione delle memorie in generale, che si basa sul principio di efficienza, andando così contro i principi di sicurezza. Per quanto riguarda gli altri aspetti, alcuni accorgimenti possono essere applicati per ottenere un risultato soddisfacente.

● Disponibilità : Memorie ECCLe RAM con ECC (acronimo di Error Correction Code) hanno dei sistemi utili a rintracciare eventuali errori contenuti nell'informazione memorizzata e dei meccanismi capaci di correggere l'errore riscontrato. Questo è possibile registrando informazioni aggiuntive che rendono queste memorie più costose e poco più lente delle rispettive RAM non dotate di ECC. Gli eventuali bit che presentano errori vengono individuati e corretti all'istante senza influire con le applicazioni in esecuzione.A causa del loro costo,le RAM ECC stanno finendo in disuso.

● Integrità : per proteggere la memoria si introduce la memory management unit (MMU) per gestire la traduzione fisica degli indirizzi dalla memoria virtuale. Utilizzando la segmentazione e assegnando opportunamente i permessi si può assicurare la mutua esclusione per l'accesso in scrittura a parti critiche dei programmi. Rimane il problema della protezione verso se stessi: se un programma scrive nel suo spazio di indirizzi è autorizzato a fare qualsiasi cosa.Il sistema operativo alloca sezioni di memoria distinta per processi distinti. Tuttavia il kernel è in grado di vedere tutta la memoria. L'intervento del kernel può essere problematico in alcuni casi ( Swap,Input/Output,Shared Memory) poiché in molti di questi casi non si può sepaare del tutto i processi. Il problema principale rimane comunque il fatto che la memoria viene gestita col principio di efficienza poiché è un punto critico del sistema. Una gestione della memoria dinamica dei segmenti introdurrebbe un overhead inaccettabile. La gestione della memoria va contro al principio del minimo privilegio.

● Affidabilità: Un sistema non affidabile non è necessariamente un sistema che perde dati regolarmente ( che invece è considerato affidabile ) bensì un sistema che può o non può funzionare, in modo del tutto aleatorio.Un memory failure comporta la perdita di tutto il lavoro svolto non salvato su memoria secondaria. Nel caso in cui i dati provengano da memoria secondaria, è sufficiente riprendere l'elaborazione daccapo, mentre nel caso in cui i dati provengano da fonti non replicabili il problema diventa serio. Una possibile soluzione prevede un meccanismo di swap per la duplicazione dei dati utilizzando un sistema a checkpoint ( si swappa l'immagine del processo ad intervalli di tempo regolari per ripristinare in caso di memory failure) .

22 / 86


● Segretezza : Si può usare la mmu per vincolare la richiesta di lettura di un segmento solo ad un processo negandolo agli altri. Finchè il segmento è controllato da un processo autorizzato non ci sono problemi. Tuttavia quando un processo libera un segmento, se questo non viene azzerato ( e non viene fatto per evitare

overhead --> Principio di efficienza ) il processo a cui viene assegnato il

segmento successivamente può ancora leggere i dati.

Dram ( Ram Dinamica ) : Viene inserita una carica elettrica in un condensatore e questa carica permane fino a quando non si attenua ( di tanto in tanto si refresha --> si legge le informzioni e si riscrive ). In mancanza di corrente il refresh viene a mancare e i dati si perdono ( dipende però dalla temperatura --> con l'azoto liquido si può mantenere i dati per ore )

Anche sulle Ram rimane il problema dei canali coperti. Poiché la latenza trasmissiva è bassa, questo sistema è applicabile solo per traferire piccola quantità di dati sensibili ( Chiavi di criptatura )

Oltre alle politiche lazy a sfavore della segretezza vengono anche le memorie cache ( memorie veloci e di capacità ridotta interposte tra due dispositivi per velocizzare le operazioni più frequenti).A seconda della politica di caching ( write-through e write-back) il rischio di compromettere la segretezza varia --> il write-back è più pericoloso.I controller dei dischi possiedono anch'essi una cache per cui permane il rischio dovuto alle cache.In più non vi è la certezza dell'effettiva scrittura ( e cancellazione ) poiché finchè la cache non è piena non viene effettuata nessuna operazione reale sul disco. Si può ovviare a questo problema bombardando la cache forzando così le operazioni di scrittura in sospeso.In generale tutti i dispositivi di memoria condividono il problema della cache.

Nel caso particolare della memoria secondaria, alcuni filesystem e alcuni formati di file implementano la funzione del journaling : viene tenuta traccia delle modifiche effettuate al flesystem o al fle. Una cancellazione senza modifica al journal permette quindi di poter recuparare ancora le informazioni attraverso il journal

Es. MSOffice usa il journaling per i suoi documenti. Ad ogni richiesta di salvataggio

23 / 86


corrisponde quindi solo un'append poiché il journal contiene già tutte le modifiche effettuate al file.

In generale anche sul piano applicativo si usano tecniche di caching e journaling.

MEMORIA RAM DI UN SISTEMA DI CALCOLO; COME REALIZZARE INTEGRITÀ, AFFIDABILITÀ E DISPONIBILITÀ A LIVELLO HARDWARE E DI NUCLEO DEL SISTEMA OPERATIVO

PROBLEMI DI SEGRETEZZA DERIVANTI DALLA CONDIVISIONE DELLA MEMORIA: CANCELLAZIONE/DEALLOCAZIONE LAZY, GARBAGE COLLECTION, CACHING

CANCELLAZIONE DELLA MEMORIA SECONDARIA (DISCHI, FLASH)

CANCELLAZIONE A LIVELLO DI FILE SYSTEM E JOURNALING

CANCELLAZIONE A LIVELLO APPLICATIVO (ESEMPIO DEL WORD PROCESSOR)

24 / 86


LEZIONE 5:SICUREZZA DEI PROCESSI

SICUREZZA DEI PROCESSI

In un'architettura di tipo Von Neumann il processore esegue indiscriminatamente e ciecamente tutte le istruzioni contenute nel programma che è in esecuzione. Non ci sono quindi vincoli di alcun tipo sulle operazioni ( sono disponibili tutte quelle previste dal processore ) né sulla memoria utilizzabile da un processo.

Devo quindi trovare un modo di limitare questa obbedienza totale.

Architettura Dual Mode:Il processore viene diviso in due parti, una parte system destinata all'esecuzione dei programmi di sistema ed una parte user destinata all'esecuzione dei programmi utente.

La parte destinata allo spazio utente può eseguire un insieme limitato di operazioni considerate safe (un sottoinsieme delle operazioni fornite dal processore) e non consente l'accesso diretto alle risorse del sistema. In modalità system invece si avrà accesso diretto alle risorse ed alla totalità delle operazioni fornite dal processore.

Mediante l'uso di un bit di modo (o di stato) si può sapere in ogni istante in quale modalità ci si trova e, modificando il valore di tale bit, si può agevolmente passare da una modalità ad un'altra.

Quando devo eseguire un “programma non fidato” utilizzo la modalità completa per preparare le risorse del job. Una volta predisposto il sistema tornerò in modalità utente per l'esecuzione vera e propria.

Come eseguo il cambio di modalità?

● da modalità system a modalità user non è un'operazione rischiosa poiché consiste semplicemente nel porre un limite sui permessi di lettura, scrittura ed esecuzione. Posso quindi eseguire il passaggio con una singola istruzione.

● da modalità user a modalità system invece è un'operazione più complicata poiché se assegnassi permessi maggiori ad un utente senza eseguire precedentemente alcuni controlli farei crollare le considerazioni precedenti e ridurrei il livello di sicurezza del sistema.

25 / 86


MECCANISMI HARDWARE A SUPPORTO DEL CONFINAMENTO DEI PROCESSI DA PARTE DEL PROCESSORE: MODI DI ESECUZIONE USER/SYSTEM, TRAP, MEMORIA VIRTUALE A SEGMENTAZIONE

Il cambio di modalità avviene mediante l'esecuzione di una trap apposita. Durante l'esecuzione della trap, il processore interrompe l'esecuzione (non riceve più ordini dal programma) ma esegue autonomamente un trap-handler memorizzato in ram ad un indirizzo specifico.

L'esecuzione di una trap può essere determinata da: - esecuzione esplicita di un'istruzione che la genera - generazione di un qualche errore rilevato da qualche componente hardware

Un programma “malizioso” per poter eseguire istruzioni privilegiate dovrebbe poter modificare il contenuto del trap-handler. Tuttavia l'uso della memoria virtuale ed il meccanismo della segmentazione impediscono al programma di poter accedere alla memoria riservata al sistema ed impediscono quindi che il programma modifichi aree riservate contenenti codice di sistema.

● Funzionameno in dual mode del processore

● Uso di tecniche di memoria virtuale

● Meccanismi di trap

Anche in presenza di queste caratteristiche hardware, se il sistema operativo non le sfrutta adeguatamente si ritorna ad avere un sistema non sicuro.

STRUTTURA DEL KERNEL DEL SISTEMA OPERATIVO PER L'ESECUZIONE DEI PROCESSI; PUNTI DEBOLI DAL BOOTSTRAP FINO ALL'ATTIVAZIONE DEI PROCESSI UTENTE

Dove si può sbagliare nella realizzazione di un Sistema Operativo? La fase più delicata è quella di bootstrap, quindi il caricamento del sistema operativo e la sua inizializzazione.

In fase di boot devo partire con un programma fidato che esegua correttamente queste prime fasi nel minor tempo possibile.

Non ho inizialmente alcun meccanismo di protezione (e quindi il sistema è altamente vulnerabile) poiché la memoria virtuale non è inizializzata, ho il massimo livello di privilegio (devo ridurre i privilegi il prima possibile) e non ho ancora a disposizione il meccanismo delle trap.

Un processo in modalità utente ha la visione della memoria composta da un segmento dati, un segmento codice ed un segmento stack.

26 / 86


Quando un processo deve ad esempio scrivere un file effettua una syscall che genera una trap. A questo punto vede anche il codice del kernel, vede il codice del trap-handler. A questo punto devo capire perché è stata invocata una trap e quale funzione quindi invocare.

Al termine ripristino la modalità utente e riprendo l'esecuzione del programma.

Il codice di un processo dovrebbe essere eseguito il più possibile in modalità utente.

Questo si traduce nel dover realizzare system call il più possibile implementati in librerie che operino in user mode. Il passaggio in system mode dovrebbe invece avvenire solo quando c'è bisogno di accedere alle risorse e alle strutture dati del kernel.

Occorre notare che anche l'utente root è vincolato ad operare in user mode, ma esso ha il diritto di invocare tutte le system call.

PROCESSI "PRIVILEGIATI" (CON UID=0) E PROCESSI "NORMALI" IN UNIX/LINUX

Nel kernel (in un'apposita variabile in modo tale da impedirne modifiche da parte degli utenti) conservo le UID del proprietario di ogni processo.

Il controllo dei permessi è eseguito dal nucleo sulla base dell'Uid : se incontra 0 ( Root o superuser) permette, altrimenti esegue dei controlli sull'owner/group della risorsa richiesta per quel particolare Uid.

I processi possono avere UID=0 o maggiore di 0. Quelli con UID=0 sono gestiti direttamente dal sistema; il sistema dunque rinuncerà a difendersi da problemi che dovessero insorgere. Quelli con UID>0 sono eseguiti in modalità utente, pertanto, in caso di problemi, potranno eventualmente danneggiare i file di proprietà dell'utente proprietario del processo.

Questa è la ragione principale per cui tutti (compreso l'amministratore) dovrebbero autenticarsi in un sistema come semplici utenti ed utilizzare l'account di root solo per operazioni di sistema che richiedono i massimi privilegi.

Quest'ultima osservazione ci porta a dire che è di fondamentale importanza l'autodisciplina degli utenti che conoscono la password di root.

27 / 86


ATTACCHI DI TIPO "BUFFER OVERFLOW" PER FAR ESEGUIRE CODICE MALIZIOSO A PROCESSI PRIVILEGIATI

Prendiamo ad esempio il questo semplice programma in C:

int answerYes(void){ char c, buffer[4]; int i; for( i=0; c=getchar() ; ) c != '\n'; #vers. corretta: c!='\n' && i<3; c = getchar()); buffer[i++]=c; buffer[i]='\0'; return strcmp(buffer, “yes”);}

Problemi la mancanza del controllo porta ad un buffer overflow. Un errore di questo tipo è molto frequente ed è spesso difficile da individuare anche in fase di debugging.

Se l'utente scrive yes oppure no non me ne accorgo poiché il programma ed il sistema non genera alcuna anomalia, ma se scrivo “I don't know” me ne accorgo.

Cosa succede dunque eseguendo il programma sopra riportato?

Le variabili automatiche sono allocate nello stack.La variabile i conterrà il valore ascii di T e le successive posizioni di memoria conterranno le successive lettere.

La funzione eseguita quindi ha l'effetto di alterare lo stato della memoria. Non è possibile prevedere a priori le posizioni in cui questa andrà a scrivere, né l'effetto che questo avrà sul sistema.Se la zona in cui il programma tenta di scrivere appartiene allo stack ottengo un errore di tipo segmentation fault, se invece il programma tentasse di scrivere in aree dello stack potrei non accorgermi dell'errore finché quelle celle non verranno lette.

BUFFER OVERFLOWNello stack oltre alle variabili automatiche vengono salvati i registri del processore nel momento in cui viene interrotta l'esecuzione di un processo.

Il modo in cui vengono memorizzati varia da processore a processore, ma conoscendo il tipo di processore montato sulla macchina potrei fare alcune previsioni.

Sicuramente verranno memorizzati il BasePointer e lo StackPointer.Il BasePointer permette di ripristinare lo stack al termine di una procedura (BP=BPold, SP=BP) mentre lo StackPointer indica la successiva istruzione da eseguire.

Se un programma continuasse a scrivere sulle celle successive, riuscirebbe prima o poi a sovrascrivere le celle che contengono i due puntatori (bp e sp). Quindi inserendo vaolri appropriati nelle celle del bp e dell'sp si può forzare il processore ad andare ad eseguire

28 / 86


(dopo il return della funzione) le istruzioni “malevoli” poste in celle a cui base e stack pointer si riferiscono.

Il concetto è quindi quello di andare a posizionare nello StackPointer e nel BasePointer gli indirizzi di memoria che servono per eseguire il codice dannoso e nelle celle precedenti le istruzioni del programma maligno.

Perché questo sia possibile occorre tuttavia un'ottima conoscenza del sistema.Come è protetto il segmento stack? Se il segmento possiede i permessi di esecuzione allora si potrebbe eseguire qualunque nefandezza.

Se il programma è lanciato da root e volessi sfruttare il buffer overflow per ottenere una shell di root dovrei introdurre come istruzioni il codice della syscall “exec /bin/bash”.Come posso trovarlo?

Condizioni necessarie per l'attacco:- programma buggato- il ciclo incrementa nella direzione di SPold e BPold- devo conoscere i dettagli del supporto a tempo di esecuzione (se un sistema operativo è utilizzato dal 90% degli utenti, allora noti i dettagli di quel sistema saranno noti i dettagli del 90% dei sistemi)- se lo stack ha i permessi di esecuzione è peggio, ma anche se non li avesse l'attacco sarebbe comunque possibile (anche se in modo più complicato poiché dovrei conoscere a priori l'indirizzo di una cella che contiene l'istruzione desiderata)

29 / 86


LEZIONE 6:FIREWALL

DEFINIZIONE DI FIREWALL E POSSIBILI IMPLEMENTAZIONI A SECONDA DEI REQUISITI:

LICENZA PROPRIETARIA O LIBERA

SISTEMA OPERATIVO

ARCHITETTURA HARDWARE

COSTI ECONOMICI

FLESSIBILITÀ

SITUAZIONE IN CUI CI SI TROVA

ACCENNI AGLI APPLICATION FIREWALL

ACCENNO AL PING E AL FILTERING ICMP

30 / 86


FILTERING A LIVELLO 3 E 4

COSA PUÒ FARE E COSA NON PUÒ FARE UN FIREWALL

31 / 86


LEZIONE 7INTRODUZIONE ALLA CRITTOGRAFIA

La crittografia viene utilizzata sia in ambito locale per fornire un ulteriore livello di sicurezza, sia in ambito di rete per proteggere le comunicazioni in rete.

ALICE, BOB E DEVIL; LUOGHI FISICAMENTE SICURI, CANALI DI COMUNICAZIONE SOGGETTI AD ATTACCHI; ATTACCHI DI TIPO ATTIVO E PASSIVO AD INTEGRITÀ, SEGRETEZZA, ECC.

Supponiamo uno scenario in cui Alice e Bob vogliono scambiarsi messaggi attraverso un canale di comunicazione sicuro. In questo scenario dobbiamo assumere che Alice e Bob riescano a garantire la segretezza dei messaggi all'interno dei loro sistemi. Ipotizziamo inoltre la presenza di un ascoltatore che si inserisce nel canale di comunicazione ad intercettando la conversazione.

Allora è necessario cifrare il messaggio M ed inviarlo sul canale di comunicazione. Una volta che Bob riceve il messaggio cifrato lo decifra ed ottiene il messaggio originale. Lo scopo della cifratura è quello di garantire la segretezza del messaggio durante la comunicazione sul canale che non è in grado di garantire la sicurezza a livello fisico.

La cifratura tuttavia non è in grado di garantire da sola la segretezza se i sistemi di Alice e Bob non sono in grado di farlo.

Funzione di cifratura: E(M) = C Funzione di decifratura: D(C) = M

Cosa può fare allora Devil? Può compiere un attacco di tipo attivo o passivo.

Un attacco di tipo passivo consente a Devil di intercettare i messaggi e leggerli

Un attacco di tipo attivo consente a Devil di interferire nella comunicazione permettendogli quindi di intraprendere azioni come:

● eliminare il messaggio: compromettendo quindi disponibilità ed affidabilità

● modificare il messaggio: compromettendo quindi l'integrità

● creare messaggi che non sono stati mai inseriti nel canale di comunicazione (spoofing)

La cifratura può risolvere problemi derivanti da attacchi di tipo passivo, ma non è efficace in caso di attacchi di tipo attivo. Se il canale infatti è soggetto ad intercettazione non si potranno garantire affidabilità, disponibilità ed integrità

32 / 86

Alice

Devil

Bob

C=>MM=>C


TECNICHE SEMPLICI DI CIFRATURA: TESTO IN CHIARO, TESTO CIFRATO, SOSTITUZIONE DI CARATTERI, PERMUTAZIONE DI CARATTERI, CHIAVE DI CIFRATURA

Come trovare funzioni utilizzabili per la cifratura e la decifratura? Per fare ciò occorre trovare funzioni invertibili, altrimenti potrei cifrare, ma non più decifrare. Dobbiamo supporre che se B conosce la funzione di decifratura allora potrebbe riuscire a calcolarla anche Devil.

L'obbiettivo è quindi quello di assicurarci che Devil sia in condizioni inferiori a quelle di B.

Possiamo spiegare come funziona solo a Bob, ma Alice non ha alcun controllo su Devil, quindi non possiamo garantire che Devil non conosca il meccanismo di cifratura/decifratura.

Un'idea è quella che Alice e Bob da soli studino un algoritmo complicato e non lo comunichino a nessuno. Tuttavia gli algoritmi molto complicati sono difficili da sviluppare. Inoltre se l'algoritmo dovesse essere scoperto allora Alice e Bob non avrebbero soluzioni alternative se non quella di individuare un ulteriore algoritmo.

Col tempo si è capito che è meglio utilizzare pochi algoritmi ben collaudati (non nascosti, anzi pubblicati) ai quali aggiungere un parametro chiave.

funzione di cifratura: C(M, K)=C funzione di decifratura: D(C,K)=M

La chiave K dev'essere un valore numerico impredicibile scelto in un insieme N di valori molto grande.

A titolo esemplificativo supponiamo di avere N=[0-3]. Per scegliere K in modo tale che sia impredicibile dobbiamo fare in modo che tutti i valori di N siano equiprobabili, altrimenti se Devil dovesse avere indizi sulla disposizione di probabilità sarebbe agevolato nell'identificare la chiave.Supponiamo che la chiave sia 2, allora C=E(M,2) , viceversa D(C,2)=M

A questo punto Devil per individuare la chiave dovrebbe provare le differenti combinazioni:D( C , 0 ) = M0D( C , 1 ) = M1D( C , 2 ) = M2D( C , 3 ) = M3

Analizzando successivamente i quattro messaggi ottenuti individuerebbe facilmente la chiave utilizzata da Alice e Bob.

Devil ha impiegato quindi poco tempo ad individuare la chiave poiché la cardinalità di N era bassa (quindi il sistema non è stato in grado di proteggere la comunicazione), ma se si aumenta il valore di N a 10^100 allora Devil impiegherà circa 10^99 minuti

33 / 86


SICUREZZA COMPUTAZIONALE E SICUREZZA INCONDIZIONATA

Si parla quindi di sicurezza computazionale quando ciò che ci difende da un attacco non è una matematica certezza, bensì l'incapacità dell'attaccante di poter decifrare i messaggi in un tempo ragionevole. Il tempo ragionevole viene valutato sulla base del tempo minimo per il quale il messaggio non deve essere violato. Se il segreto che si intende proteggere deve essere mantenuto fino al primo weekend e il sistema di protezione utilizzato mi garantisce che questo non è violabile in meno di un anno allora possiamo parlare di sicurezza computazionale.

Se invece voglio che un segreto possa essere conservato per i prossimi 10000 anni non potrò avere una sicurezza computazionale, poiché non posso fare alcuna assunzione sulle tecnologie future e sui tempi che queste impiegheranno a violare il mio sistema.

Si parla quindi di sicurezza incondizionata quando è formalmente dimostrato che il sistema non può essere violato. Questo tuttavia non è possibile, quindi ci si riduce quasi sempre ad affidarsi ad una sicurezza di tipo computazionale.

IDEA DI CRIPTO-ANALISI ED EFFETTO DELLA RIDONDANZA DEL TESTO IN CHIARO

Come posso organizzare un cifrario? Si possono utilizzare algoritmi che agiscono per sostituzione o per permutazione.

Supponiamo che il messaggio da inviare sia M=”Attaccare frontalmente”

● Sostituzione:sostituisco i caratteri del testo originale con i caratteri corrispondenti secondo una tabella di cifratura appositamente predisposta. In questo caso la chiave di cifratura è rappresentata dalla tabella stessa.

es. A=B B=Z C=L T=H ecc...

il messaggio cifrato diventerà quindi: C=”BHHBLLB...................”

● Permutazione:si basa sullo spostamento dei caratteri che compongono il messaggio originale in base alla loro posizione.

M=A T T A C C A ...... supponiamo 0=5, 1=8, 2=0, ecc ecc 0 1 2 3 4 5 6 7 8 ...........

C=T..........A........T

In questo caso la chiave di cifratura è rappresentata dalla tabella di corrispondenza in cui vengono definite le nuove posizioni.

34 / 86


● Sostituzione con permutazione:in questo caso sostituiamo una lettera con quella che alfabeticamente si trova x posizioni più avanti o indietro.

M=”Attaccare frontalmente” supponiamo A=D, B=E, C=F , D=G , E=H, ecc.C=”Dzzdffduh iur................”

In questo caso la chiave potrebbe non essere la tabella di sostituzione, bensì il numero di posizioni alfabetiche di cui avanzare. L'attaccante provando le 21 possibili chiavi potrebbe tuttavia comprendere il messaggio in breve tempo.

Problemi:le regole viste non impongono alcun criterio sugli spazi o sulla punteggiatura, quindi l'attaccante potrebbe facilmente desumere le dimensioni delle parole del messaggio in chiaro anche solo analizzando il messaggio cifrato poiché le parole dei due messagi sono di pari lunghezza.

Per studiare un sistema di cifratura dobbiamo quindi sempre analizzare il testo cifrato per capire quali informazioni possono essere dedotte (numero di parole, lunghezza delle parole, ripetizioni, ecc ecc). Dobbiamo anche supporre che un attaccante conosca la lingua in cui stiamo scrivendo il messaggio e che quindi possa sfruttare le informazioni apprese per confrontarle con le regole della lingua, riuscendo così a restringere maggiormente l'insieme delle decifrature possibili.

Ciò che ci espone ad attacchi di tipo brute-force è la ridondanza del linguaggio. Nella lingua italiana ad esempio ci sono molti elementi che introducono ridondanza.

- Supponiamo che esistano 100.000 parole di 9 caratteri pari a 10^3. - La totalità delle stringhe di 9 caratteri componibili sarebbe tuttavia di 21^9. - Ne deriva quindi che un coefficiente di ridondanza pari a 21^9/10^3.

Se io nel processo di cifratura riuscissi a passare da parole valide ad altre parole valide ridurrei la ridondanza ad un coefficiente 1 riuscendo a confondere l'attaccante.

Supponiamo un generale che intenda dare un ordine alle sue truppe.0 = ritirarsi1 = attaccare frontalmente2 = attendere rinforzi 3 = attuare manovra a tenaglia

C = (M+K) mod 4 con K appartenente all'intervallo [0,3]

Supponiamo che il generale voglia dare l'ordine di attacco frontale utilizzando la chiave 2. Egli allora userebbe:

C = (1+2) mod 4 = 3

35 / 86


L'attaccante che dovesse intercettare il messaggio potrebbe solo dedurre che il messaggio originale poteva essere 0, 1, 2 o 3, ma non può sapere quale sia il messaggio reale, poiché una qualunque delle combinazioni porterebbe ad un messaggio valido e soprattutto equiprobabile.

In questo caso un attacco di tipo brute-force sarebbe inutile. In questo caso si parlerebbe quindi di SICUREZZA ASSOLUTA poiché il tempo necessario alla decifratura non è legato al tempo o alle risorse computazionali da impiegare.

36 / 86


LEZIONE 8SICUREZZA DI RETE

USO E ABUSO DELLA RETE WIRELESS DA PARTE DEGLI UTENTI TELELAVORATORI (TRATTO DA PUNTO INFORMATICO)

ESEMPI DI PHISHING DEL SITO EBAY E DI PAYPAL. USO DEL SOFTWARE WIRESHARK PER L'INTERCETTAZIONE DEL TRAFFICO TCP/IP E LA RICOSTRUZIONE DELLE SESSIONI

FIREWALL: POLITICHE DI DEFAULT PERMIT E DEFAULT DENY

37 / 86


LEZIONE 9PRINCIPI DELLA CRITTOGRAFIA MODERNA

SICUREZZA INCONDIZIONATA, CIFRARIO DI VERNAM (ONE TIME PAD) E PROBLEMI PRATICI LEGATI ALLA LUNGHEZZA DELLA CHIAVE

Come possiamo fare per ottenere un livello di sicurezza incondizionata?

Algoritmo di Vernam (o One Time Pad)consente di ottenere un livello di sicurezza incondizionata. Per poter astrarre dal contenuto del messaggio ed evitare che analizzando il testo cifrato si possano desumere informazioni occorre agire non sul testo in chiaro, ma sulla sua rappresentazione binaria.

M=01101110100010.............. K=00010011101100..............

Per eseguire la cifratura utilizzo la funzione logica XOR, quindi le funzioni di cifratura e decifratura saranno:

E(M) = M xor K = C (cifratura) D(C) = C xor K = M (decifratura)

La funzione XOR è l'inversa di sé stessa. Inoltre è un'istruzione elementare semplicemente realizzabile in hardware e molto efficiente poiché viene eseguita in un singolo colpo di clock.

Il problema dell'algoritmo di Vernam è che per poter applicare la funzione XOR bisogna avere una chiave di dimensione pari a quella del messaggio originale. Inoltre la chiave deve essere impredicibile, quindi deve essere generata in maniera completamente casuale.

M = 0 1 1 0 1 1 1 0 1 0 ...K = 0 1 0 1 1 1 0 1 1 1 ...C = 0 0 1 1 0 0 1 1 0 1 ...

Per quali ragioni ottengo un livello di sicurezza incondizionata?

Non ho alcuna ridondanza poichè non faccio alcuna assunzione sulla rappresentazione letterale del messaggio, ma ne considero solamente la traduzione in binario.

Inoltre per ogni bit del testo in chiaro posso scegliere tra due soli valori ottenendo così probabilità ½ di ottenere un valore diverso e ½ di ottenere un valore invariato.

38 / 86


Riuso della chiave:Teoricamente è possibile riutilizzare la chiave, tuttavia facendolo potrei inserire delle falle nel mio sistema di cifratura. Questo perché l'attaccante che dovesse intercettare i messaggi potrebbe successivamente capire a cosa corrispondono analizzando la reazione a quel messaggio da parte del destinatario.

Ad esempio se un generale invia il messaggio “attaccare frontalmente” il nemico non riuscirebbe a decifrare il messaggio in tempo, tuttavia vedendo la reazione dell'esercito a quell'ordine potrebbe ricavare la chiave utilizzata dal generale semplicemente calcolando

M xor C = K

e potrebbe quindi decifrare i successivi ordini. La chiave quindi deve essere cambiata costantemente.

DIFETTO: espone la chiave all'attaccante se questi ha la conoscenza del messaggio M.

NECESSITÀ DI CIFRARI BASATI SU CHIAVE DI LUNGHEZZA PREDETERMINATA. PRINCIPI DI SHANNON

In tutte le situazioni normali in cui non è pensabile e/o conveniente utilizzare chiavi di dimensioni spropositate bisogna rassegnarsi ad avere un livello di sicurezza di tipo computazionale.

Ho quindi bisogno di individuare algoritmi che permettano il riuso della chiave anche qualora il nemico venisse a conoscenza del messaggio in chiaro e del messaggio cifrato e che, una volta definita la chiave k, con questa si possa cifrare un numero arbitrario di bit.

CONFUSIONE: MODIFICA DI UN SOLO BIT DI CHIAVE CAMBIA OGNI BIT DEL CODICE CIFRATO CON PROBABILITÀ ½

se prendo K=[01110001110] ed applico E(M,K) ottengo un messaggio Csupponiamo di modificare di un solo bit la chiave:se prendo K'=[01110101110] ed applico E(M,K') ottengo quindi un messaggio C'

E' meglio che K' e K siano quanto più possibile differenti ed avere quindi una distanza di Hamming elevata poiché vogliamo confondere le idee al potenziale nemico.

Statisticamente mi vorrei che il valore medio della distanza di Hamming tra C e M sia ½, quindi su 500 bit vorrei 250 bit di differenza.

Perché non 500? Se avessimo 500 bit di differenza vorrebbe dire che il messaggio cifrato sarebbe la negazione del messaggio originale e questo sarebbe troppo semplice da individuare. Analogamente 490 bit di differenza corrisponderebbero a 10 bit di differenza rispetto al messaggio originale negato.

39 / 86


DIFFUSIONE: MODIFICA DI UN SOLO BIT DEL MESSAGGIO IN CHIARO CAMBIA OGNI BIT DEL CODICE CIFRATO CON PROBABILITÀ ½

agisce sul messaggio in chiaro:M =[ 0 1 1 1 0 0 0 1 0 1 1 1 1 0 1 ..... ] E(M , K) = CM'=[ 0 1 1 0 0 0 0 1 0 1 1 1 1 0 1 ..... ] E(M', K) = C'

Come prima mi aspetto di avere una distanza di Hamming elevata con probabilità di variazione pari a ½, tanto che i due testi cifrati sembreranno essere completamente privi di correlazione tra di loro.

Conseguenze:se realizzo un algoritmo che abbia queste caratteristiche che cosa potrebbe fare l'attaccante?

La proprietà di diffusione permette di impedire all'attaccante di identificare la chiaveLa proprietà di confusione complica invece un possibile attacco di tipo brute-force.

Se non valesse il principio di confusione l'attaccante potrebbe capire quando si sta avvicinando alla chiave. L'attaccante infatti potrebbe notare che parte della chiave è corretta e quindi limiterebbe i bit da cercare. Quindi se l'attaccante non sa quando si sta avvicinando, l'unica soluzione sarebbe quella di individuare tutti i bit della chiave.

CODICI DI TIPO STREAM O A BLOCCHI (NECESSITÀ DI PADDING)

I codici di cifratura a stream si applicano a qualsiasi sequenza di bit a lunghezza arbitraria

I codici di cifratura a blocchi si applicano invece a quantità fissate e multipli di queste. Nel caso in cui l'ultimo blocco non sia completo compio un'operazione di padding aggiungendo bit arbitrari per completare il blocco. Poi cifro blocco per blocco. Ogni blocco viene trattato separatamente.

I codici di cifratura a stream hanno il vantaggio di non perdere in efficienza poiché non devo occuparmi del padding.

M=10 Stream=10 bitBlocchi=64 bit se utilizziamo blocchi da 64 bit

Per messaggi di piccole dimensioni è più conveniente utilizzare codici streamPer messaggi di grosse dimensioni invece il padding diventa ininfluente

Tuttavia un vantaggio dei blocchi è proprio il padding perché permette di nascondere la reale quantità di bit del messaggio originale.

Sono differenze poco rilevanti.Quasi tutti gli algoritmi di cifratura odierni sono a blocchi poiché più facili da implementare e poi partendo da codici a blocchi posso sempre costruire codici di tipo stream.

40 / 86


MODI DI USO DEI CODICI A BLOCCHI: ELECTRONIC CODEBOOK (ECB) OPPURE CIPHER BLOCK CHAINING (CBC)

Tecnica di cifratura ECB

M =

E( Mi , K ) = Ci D( Ci , K ) = Mi

C =

Supponiamo che l'attaccante scopra che C2 sia uguale a C5, riuscirebbe a capire qualcosa del testo in chiaro? Si, capirebbe che M2 è uguale ad M5

Non so che cosa i blocchi in chiaro contengano, ma so che sono uguali.

Allora posso pensare di complicare l'algoritmo

Introduco la tecnica di cifratura CBC che implica la concatenazione dei blocchi successivi.

E(Moi xor Ci-1 , K) = Ci

Gioco sul fatto di conoscere le dimensioni del blocco.L'operazione di xor inoltre mi permette di ottenere dati che sembrano ricondursi all'uso di chiavi casuali come per il one time pad.

Inoltre la codifica di un blocco dipende strettamente da quella dei blocchi precedenti. Cifrando così due blocchi identici posti in posizioni differenti ottengo risultati differenti e non dovrò più preoccuparmi che l'attaccante possa scoprire uguaglianze tra i blocchi.

Mi = Ci-1 xor D(Ci, K)

Guadagno quindi la capacità di nascondere all'attaccante la presenza di blocchi uguali, tuttavia perdo la capacità di decifrare blocchi singoli.

Il problema della funzione E è la cifratura del primo blocco poiché questo non ha predecessori. Quindi dovrò comunicare al mio interlocutore sia la chiave sia il blocco C_zero utilizzato come predecessore del primo blocco.

La cifratura separata dei blocchi (senza concatenazione) è detta ECB

41 / 86

M1 | M2 | M3 | M4 | M5 | M6padding

C1 | C2 | C3 | C4 | C5 | C6padding


Generazione di codici a blocchi

Abbiamo visto finora:

● XOR: i vantaggio sono legati alla semplicità e all'efficienza, tuttavia ha lo svantaggio di richiedere l'uso di una chiave di dimensione pari a quella del testo da cifrare, inoltre non rispetta i principi di Shannon poiché la modifica di un bit del testo in chiaro porta alla modifica di un bit nel testo cifrato.

● PERMUTAZIONE: la modifica di un bit del messaggio originale porta alla modifica di un bit del messaggio cifrato anche se non ne conosco la posizione, poiché dipende dalla chiave.

● SOSTITUZIONE: se ragioniamo in termini di rappresentazione binaria del testo in chiaro, si riconduce ad una negazione del messaggio originale. Molto imparentato con lo xor

Cosa succede se ripeto più volte la cifratura?

● XOR: per un numero pari di cifrature ottengo il testo in chiaro, per un numero dispari ottengo il testo cifrato una singola volta

● PERMUTAZIONE: non ottengo alcuna differenza poiché rimanendo invariata la chiave, rimane invariato anche il risultato delle permutazioni

Se invece utilizzo in sequenza sistemi di cifratura diversi riesco ad ottenere risultati migliori.

42 / 86

Messaggioin chiaro

permutazione(M) sostituzione(permutazione(M)) permutazione(sost...


LEZIONE 10VIRUS

DEFINIZIONE DI VIRUS

STORIA DEI VIRUS (DARWIN, PERVADE, ELK CLONER, DEFINIZIONE DI COHEN, BRAIN, VIRDEM)

MECCANISMI DI INFEZIONE: FILE ESEGUIBILI (COMPANION, OVERWRITING, PREPENDING, APPENDING, BOOT SECTOR[MICHELANGELO]), MACRO VIRUS (MELISSA, LAROUX, TRISTATE E MUTAZIONI INVOLONTARIE), MULTIPARTITE VIRUS (NAVRHAR), SCRIPTING VIRUS, SOURCE CODE VIRUS

MECCANISMI DI PROPAGAZIONE: PERIFERICHE RIMUOVIBILI, E-MAIL, DOWNLOAD (MELISSA), DIRECTORY CONDIVISE

DIFESE: ANTIVIRUS (AGGIORNAMENTI, SIGNATURE E ANOMALY DETECTION, VERIFICA INTEGRITÀ), CONFIGURATION HARDENING (POLP ETC.), EDUCAZIONE UTENTI

43 / 86


LEZIONE 11CIFRATURA E CHIAVI CONDIVISE

ESEMPIO DI ALGORITMO DI CIFRATURA DES

DES è un algoritmo di cifratura a blocchi di 64 bit. I singoli bit vengono trattati puramente a livello sintattico senza basarsi sul loro significato concreto. L'obbiettivo del DES è quello di avvicinarsi quanto più possibile ai principi di Shannon (confusione e diffusione)

Struttura di un round

Il blocco viene splittato in due parti da 32 bit.

Il primo semiblocco viene mescolato con una serie di permutazioni e successivamente viene messo al posto del secondo semiblocco. Analogo trattamento viene effettuato sul secondo semiblocco, il quale dopo analoghe permutazioni verrà messo al posto del primo.

Viene fatto lo XOR tra il secondo semiblocco originale ed il primo semiblocco trasformato.

La chiave utilizzata è di 64 bit, anche se 56 sono i bit realmente usati come chiave, gli altri 8 bit sono utilizzati come bit di parità.

Da questa chiave viene estratta una sottochiave formata da 48 bit da utilizzare per cifrare il primo semiblocco. Tuttavia la chiave estratta è lunga 48 bit, mentre il semiblocco è lungo solo 32 bit. Allora il semiblocco viene espanso fino a 48 bit, si effettua quindi lo XOR con la sottochiave ed infine si trasforma il blocchetto da 48 bit appena cifrato in un semiblocco da 32 bit

Ripetizione dei round

Le operazioni che costituiscono un round vengono ripetute per 16 volte. Ad ogni round viene variata la sottochiave in modo tale che alla fine dei 16 round saranno stati utilizzati tutti i 56 bit della vera chiave.

Tutte queste ripetizioni hanno lo scopo di ottenere confusione. Con un solo round infatti potrei riuscire a desumere informazioni sulla composizione della chiave partendo dall'analisi dei testi cifrato e in chiaro.

I round forniscono quindi una difesa da attacchi basati sulla conoscenza simultanea di testo cifrato e testo in chiaro, permettendo così il riuso della chiave

44 / 86

(I) 32 bit (II) 32 bit

(II) 32 bit (I) 32 bit

Perm.S BOX

Perm.S BOX


APERTURA/SEGRETEZZA DEGLI ALGORITMI

L'implementazione delle S-BOX è mantenuta segreta, principalmente per ragioni economiche e per lasciare solo a poche persone la possibilità di decifrare qualunque conversazione (tipicamente governo USA)

Chi utilizza un algoritmo di cifratura di questo tipo deve quindi fidarsi di quell'algoritmo e di chi lo ha sviluppato. Ma come ci si può fidare di qualcosa che non si conosce?

Per questa ragione l'algoritmo di cifratura è stato pubblicato ed è perciò noto a tutti, quello che invece è mantenuto segreto è la prova formale del suo corretto funzionamento. Non esiste dunque alcuna prova formale pubblica che ne giustifichi l'adozione, tuttavia anni di sperimentazione, testing e tentativi di violarlo sono stati finora inefficaci.

L'algoritmo non è quindi rompibile, ma non vale la stessa proprietà per il testo cifrato.. Sfruttando infatti la limitatezza della chiave (56 bit) un testo cifrato DES è soggetto ad attacchi di tipo brute-force.

Tuttavia il DES garantisce sicurezza computazionale e per questa ragione è stato adottato come Data Encryption Standard

CRITTOGRAFIA FORTE E DEBOLE

La scelta della ridotta dimensione della chiave è stata intrapresa volontariamente al fine di creare un sistema di crittografia debole. Un sistema di crittografia debole è un sistema violabile solo con le risorse a disposizione di pochi (tipicamente enti governativi – ad esempio la CIA è in grado di decifrarlo)

DES è quindi un sistema di crittografia utile per il normale uso pubblico, non per chi ha necessità di segretezza più robusta.

Un sistema di crittografia forte invece è un sistema non rompibile con le risorse attualmente disponibili.

BREVETTI

Restrizioni all'uso di un sistema crittografico possono sorgere per problemi di tipo:

● legale : le normative nazionali possono vietare o regolamentare l'uso di sistemi crittografici

45 / 86


● brevetti : ad esempio in USA un algoritmo è considerato come un'opera manifatturiera e quindi brevettabile, mentre in EU viene considerata un'opera dell'ingegno e per tanto non è brevettabile

Negli Stati Uniti quindi devo ottenere una licenza di utilizzo. Normalmente i brevetti dei sistemi crittografici sono brevettati dalla NSA. Invece i principali algoritmi non soggetti a brevetti e sicuri sono principalmente sviluppati fuori dagli Stati Uniti.

Un modo per ovviare alla debolezza del DES è quello di cifrare una seconda volta e con una chiave diversa il testo precedentemente cifrato. Questo migliora la situazione, ma non rende inattaccabile il testo così trattato.

Le chiavi usate in sistemi di crittografia forte sono attualmente da 128 a 256 bit. L'algoritmo AES ad esempio permette l'uso di chiavi a 256 bit.

L'incognita è sempre quella di sapere se esistono modi non ancora pubblicati di violare gli algoritmi. E' quindi sempre una questione di fiducia.

PROBLEMA DEL LOGARITMO DISCRETO E PROTOCOLLO DIFFIE-HELLMAN

La cifratura permette di mantenere la segretezza attraverso un canale di comunicazione non sicuro. Ma come posso fare per scambiare la chiave con il mio interlocutore?

Il problema è stato risolto per la prima volta con l'algoritmo di Diffie-Hellman per la condivisione di una chiave. L'idea alla base di questo algoritmo proviene dall'algebra:

si usa una funzione f x =g xmod k dove g e k sono costanti predefinite che soddisfano alcuni requisiti (devono generare un campo finito).

Prendiamo ad esempio g=3 e k=5 (entrambi numeri primi)

f 0=30mod 5=1f 1=31mod 5=3f 2=32mod 5=4 Tutti i numeri generati sonof 3=33mod 5=2 diversi da zero e minori di kf 4=34mod 5=1f 5=35mod 5=3

Questa funzione genera numeri in modo periodico al variare di x. g=generatoreAbbiamo così definito un campo finito.

La funzione è invertibile in una restrizione del dominio per valori minori di k-1

f −1 y=log g y ma come calcolo k?

46 / 86


E' possibile scrivere un semplice programma che lo calcoli, ma non esiste una soluzione furba. Non esiste infatti una forma chiusa della funzione inversa. Si parla quindi di logaritmo discreto.

La soluzione astuta ci servirebbe per valori elevati dei parametri g e k.

Prendendo ad esempio 2180 riusciremmo a memorizzare l'array del nostro programmino nel processore? La risposta è no... quindi per valori grandi possiamo dire che riusciamo a calcolare la funzione f, ma la funzione è computazionalmente non invertibile.

Per poter scegliere i valori di g e di k devo individuare coppie di numeri primi che generino un campo

Alice genera un numero casuale a e successivamente calcola A= gamod kBob genera un numero casuale b e successivamente calcola B=gbmod k

I valori a e b devono essere mantenuti segreti, mentre A e B possono essere liberamente inviati sul canale di comunicazione. Alice ottiene così B, mentre Bob ottiene A.

Alice può calcolare Bamod k sono lo stesso valore g abmod k

Bob può calcolare Abmod k

Allora questo valore può essere utilizzato come chiave di cifratura per creare tra di loro un canale di comunicazione sicuro

47 / 86


LEZIONE 12WORM

48 / 86


LEZIONE 13DIFFIE-HELLMAN E RSA

ATTACCHI ATTIVI (MAN-IN-THE-MIDDLE) AL PROTOCOLLO DIFFIE-HELLMAN

L'algoritmo di Diffie-Helman si basa sull'ipotesi di resistere ad un attacco di tipo passivo (l'attaccante può solo leggere i dati, ma non manipolarli).Supponiamo ora che l'attaccante abbia i mezzi per manipolare il traffico che viaggia sul canale di comunicazione e realizzi un attacco di tipo Man In the Middle.

Devil si pone tra Alice e Bob, riceve i messaggi diretti da Alice e li inoltra a Bob e viceversa. Un attacco di tipo MiM si può verificare quando l'attaccante si impossessa di pezzi della rete di comunicazione (es. router, pc di Alice, pc di Bob, mail server, ....)

Come si comporta l'algoritmo Diffie-Hellman in caso di attacco di tipo MiM?

Alice genera un numero casuale a e successivamente calcola A=gamod k e lo inviaBob genera un numero casuale b e successivamente calcola B=gbmod k e lo invia

Devil riceve entrambi i numeri e e può quindi utilizzare il D-H.Devil genera quindi un numero casuale d e successivamente calcola D=gdmod k e lo invia ad Alice e Bob.

Alice e Bob ricevono quindi il numero D ignorando il fatto che avrebbero dovuto rispettivamente ricevere B ed A.

49 / 86

Devil BobAlice

A D

D BBobAlice Devil


A questo punto Alice e Bob hanno aperto un canale di comunicazione sicuro, ma non con Bob bensì con il nemico. Se il nemico non vuole farsi individuare deve solamente leggere le comunicazioni senza alterarle.

● Devil riceve da Alice e decodifica il messaggio

● legge il messaggio appena decodificato

● lo codifica con chiave D e lo invia a Bob

Devil procederà poi in maniera analoga per le comunicazioni nel verso opposto.

Come difendersi?

Per potersi difendere servirebbe la capacità di identificare correttamente il mittente dal quale si riceve un messaggio. Serva quindi di introdurre il concetto di firma digitale.

Il D-H è quindi in grado di resistere ad attacchi di tipo passivo, mentre necessita di alcune integrazioni per poter resistere ad attacchi di tipo attivo.

Quanto visto finora rientra nella categoria delle tecniche di cifratura a chiave simmetrica.

INTRODUZIONE AI SISTEMI A CHIAVE ASIMMETRICA

Per cifrare uso la chiave k1, per decifrare uso invece una chiave diversa k2. Questo complica notevolmente la gestione del crittosistema, ma introduce una grossa miglioria poiché separa le chiavi necessarie. Il ricevente di un messaggio cifrato non dovrà quindi essere a conoscenza della chiave di cifratura e si risolve quindi il problema della comunicazione della chiave attraverso un canale di comunicazione non sicuro.

cifratura: C = E(M,K1) decifratura: M = D(C,K2)

Abbiamo visto che utilizzando l'algoritmo DES forniamo al nostro interlocutore una chiave che è in grado sia di cifrare che di decifrare. Utilizzando invece il meccanismo della doppia chiave possiamo garantire una corretta applicazione del principio di minimo privilegio.

Chiaramente deve esistere un legame tra le chiavi k1 e k2.

Il concetto alla base della generazione delle chiavi è legato alla difficoltà di calcolo della funzione inversa e sfrutta un principio simile a quello del logaritmo discreto..

Dal punto di vista matematico è enormemente complicato.

50 / 86


CRITTOSISTEMA RSA (RIVEST, SHAMIR, ADLEMAN)

C=M emod N d≠e K1 = (e , N)M=C dmod N K2 = (d , N)

Come facciamo ad impedire che, data K1 si possa ricavare k2? Si sfruttano notevolmente alcune proprietà algebriche.N non è un numero scelto in maniera casuale, ma è il prodotto di due numeri primi:

N=P∗Q con e primo rispetto a P−1∗Q−1

una volta fatta questa scelta possiamo calcolare d:

d∗e mod P−1∗Q−1=1

Si può dimostrare formalmente che esiste un unico valore d tale da soddisfare l'equazione.Se conosco k1, allora conosco anche i numeri e ed N dove N=P*QSarebbe quindi possibile fattorizzare N per ricavare P e Q, ma se si prendono valori molto grandi per i numeri P e Q otteniamo con certezza un livello di sicurezza computazionale poiché attualmente non esistono risorse sufficienti per calcolare la fattorizzazione del prodotto.

K1 = chiave pubblica K2 = chiave privata

IDEA DI CIFRATURA E DECIFRATURA CON DUE CHIAVI DIVERSE

Un'entità genera la sua coppia di chiavi. Una volta generate le chiavi può buttar via i numeri P e Q e basarsi solamente sulle chiavi generate.

La chiave privata deve essere nascosta, la chiave pubblica può invece essere inviata e diffusa liberamente senza alcun pericolo.

LE FORMULE DI CIFRATURA, DECIFRATURA E CALCOLO DELLE DUE CHIAVI

Prendiamo a titolo esemplificativo: P=11, Q=13, N=143, (P-1)*(Q-1)=120Ci serve un numero e tale che e sia primo rispetto a 120, quindi e=7

K1=(7,143)

per calcolare K2 devo soddisfare l'equazione:

d∗7mod 120=1 d=103 quindi K2=(103,143)

51 / 86


Ora possiamo cifrare e decifrare:

M=”CIAO” M=99,105,97,111997mod 143=441057mod 143=118

....C=44,118,59,45

USO PER FIRMARE DOCUMENTI INTEGRI/AUTENTICI

Bob vuole garantire l'integrità di un messaggio (non necessariamente da tenere segreto). Osservando le funzioni noto che cambia solamente l'esponente, quindi possiamo invertire d con e. Le funzioni diventano quindi:

C=M d mod NM=C emod N

Ottengo così la garanzia che chi invia il documento sia l'unico a poter eseguire l'operazione di cifratura e che tutti i destinatari siano in grado di decifrare il documento. In questo modo posso quindi garantire l'integrità del documento inviato, poiché nessun altro avrebbe potuto cifrare il documento con la chiave privata di Bob.

Il destinatario invece, poiché ha la conoscenza della chiave pubblica, è in grado di verificare che il mittente del documento è realmente Bob

USO PER CIFRARE DOCUMENTI SEGRETI

Se intendo utilizzare RSA per mantenere la segretezza di un documento dovrò invece cifrare con la chiave pubblica e decifrare con la chiave privata.

CARATTERISTICHE DI SICUREZZA DEL CRITTOSISTEMA

A questo punto possiamo irrobustire il Dieffie-Hellman utilizzando un meccanismo di firma digitale.

Possibili punti deboli sfruttabili per un attacco:

● un punto debole potrebbe essere l'operazione di cifratura:

C=M amod N se qualcuno conosce C, M ed N può essere in grado dicalcolare il numero d?

Chiunque può ricavare N dalla chiave pubblica, generarsi M e cifrarlo per ottenere C, tuttavia la formula è un logaritmo discreto.

52 / 86


● un altro punto debole è rappresentato dal numero N:questo poiché lo si potrebbe fattorizzare e quindi ricavarne P e Q. Ma quanto tempo occorrerebbe per fattorizzare numeri elevati?Occorre notare che gli algoritmi di fattorizzazione sono stati notevolmente migliorati, tuttavia è sufficiente utilizzare numeri maggiori di qualche ordine di grandezza rispetto a quelli che si suppone possano essere attualmente calcolati per ottenere un livello di sicurezza computazionale.

RSA è molto più complicato da calcolare rispetto ad DES a 256 bit poiché RSA si basa sull'uso di funzioni esponenziali, mentre AES si basa sull'uso di XOR e permutazioni.

CONFRONTO COI CRITTOSISTEMI A CHIAVE SIMMETRICA

RSA:

● è pesante

● è attaccabile su due fronti: logaritmo discreto (solo a livello teorico) e fattorizzazione (non è chiaro quanto sia computazionalmente sicuro)

● risolve il problema dello scambio delle chiavi

● permette la firma digitale per la garanzia di autenticità

DES:

● è attaccabile mediante brute-force

● è più leggero di RSA

● chiavi da 1024, 2048, 4096

E' quindi opportuno usare algoritmi a chiave asimmetrica solo dove è indispensabile; algoritmi a chiave simmetrica sono invece impiegabili in un maggior numero di situazioni avendo cura di utilizzare chiavi tra i 1024 e i 4096 bit.

Un possibile scenario di impiego potrebbe essere il seguente:- uso un algoritmo a chiave simmetrica per lo scambio della chiave- uso poi la chiave scambiata tramite RSA come chiave di un sistema di comunicazione cifrato a chiave simmetrica

Gli algoritmi a chiave simmetrica sono quindi più efficienti

Quindi se prevedo attacchi di tipo MiM devo utilizzare un crittosistema a chiave asimmetrica + Diffie Hellman + chiave simmetrica per stabilire un canale, poi utilizzo invece solo la chiave simmetrica per la comunicazione.

53 / 86


LEZIONE 14PROF. AIELLO, IN PREPARAZIONE ...

54 / 86


LEZIONE 15FUNZIONI HASH CRITTOGRAFICHE

TABELLE HASH E E FUNZIONI HASH PERFETTE

Una hash table è una tabella indicizzata mediante una funzione che determina la posizione in cui inserire ogni valore.

I problemi legati all'uso delle tabelle hash risiedono principalmente nella generazione di collisioni. Si ha una collisione quando h(e) è uguale ad h(f). I valori calcolati dalla funzione di indicizzazione indicherebbero che e ed f debbano essere inseriti nella medesima posizione, tuttavia ciò non è possibile, quindi dobbiamo studiare come gestire queste situazioni anomale.

● Ingrandire la tabella in modo da ridurre le collisioni: questo è tuttavia un metodo inefficiente poiché devo aumentare le dimensioni della memoria che contiene la tabella.

● Agire sulla funzione di indicizzazione h() in modo da renderla iniettiva e fare quindi in modo che la funzione non generi collisioni. Tuttavia è complicato trovare funzioni di hashing iniettive senza la conoscenza a priori del contenuto da indicizzare.

Occorre, come sempre, trovare un compromesso tra le due soluzioni.

Nell'uso normale delle hash table le collisioni sono un evento accettato e previsto. A tale ragione si utilizzano normalmente funzioni di ricalcolo che permettano di posizionare elementi che hanno generato collisioni:

- rehashing: h2(f)- uso di liste per ogni cella della tabella: se un dato deve essere posizionato in una cella occupata, verrà messo in coda alla lista di tale cella.- incrementare l'indice finchè non si trova una cella libera

Un altro modo di agire è quello di lavorare sulla funzione di hashing. Sperimentalmente si può fare un'analisi comparativa tra diverse funzioni e scegliere poi la funzione che genera il minor numero di collisioni

55 / 86

e

e

f


Perfect hash: intendiamo con perfect hash la funzione di indicizzazione che non genera mai collisioni fino a quando la tabella non è piena. E' possibile realizzare una simile funzione, solo a patto di conoscere in anticipo l'insieme degli elementi da inserire.

Nella pratica tuttavia non si conoscono quasi mai in anticipo i dati da inserire, quindi una simile funzione non è realizzabile e bisogna occuparsi delle collisioni.

Lasciamo un attimo in sospeso la gestione delle collisioni...

RIDONDANZA DEI DOCUMENTI

Un testo codificato in Ascii è composto da caratteri esprimibili in 7 / 8 bit.

In un testo in lingua inglese utiliziamo circa 70 caratteri differenti (minuscole, maiuscole, punteggiatura, cifre numeriche).

Ho un coefficiente di ridondanza di 25670

≈4

In italiano la lunghezza media di una parola è di 6 caratteri, quindi le parole che sarei in grado di esprimere sono 526 (ovvero caratteri alfabetici elevati alla lunghezza media).

Avrei quindi un fattore di ridondanza di 526

105

Se passiamo ad analizzare l'aspetto sintattico possiamo osservare che non tutte le parole componibili hanno un reale senso nella lingua utilizzata.

Algoritmi quali ZIP riducono le dimensioni di un file di testo di circa l'80%, ma un coefficiente di questo tipo è comunque ancora lontano da quello che realmente si potrebbe fare.

Quanti sono i documenti possibili?La dimensione della tabella varia al crescere dei documenti, ma nell'ipotesi di utilizzo di una funzione di hashing perfetta la tabella dovrebbe essere di dimensione pari al numero dei documenti.

Supponiamo che un uomo possa produrre al massimo 100 documenti al giorno, stimiamo quindi che i documenti che possono essere quotidianamente prodotti al mondo siano 10102=1012 , allora la produzione annuale su scala mondiale ammonterà a P.M.A.≈4∗1014 . Stimiamo quindi per eccesso di dover gestire 1018 documenti da

gestire, avrei quindi bisogno di 1018bit pari a 260

56 / 86


Immaginando quindi di avere una funzione di hashing perfetta dovremmo indicizzarci su 60 bit, quindi la nostra funzione di hashing dovrebbe apparire approssimativamente come:

H doc =x∨ x sia un numerodi 60bit

Questo vale però nell'ipotesi di saper costruire una funzione perfetta, ma poiché abbiamo capito che ciò non è realizzabile occorre tornare sull'idea di espandere la tabella hash a seconda delle necessità.

PARADOSSO DEL COMPLEANNO

Supponiamo di voler scommettere sulla presenza di almeno due persone in una stanza che abbiano il compleanno nella stessa data. Come possiamo decidere se scommettere o no? La nostra valutazione potrà basarsi solamente su dati statistici.

Ipotizziamo che la distribuzione di probabilità di nascita sia uniforme per ogni giorno dell'anno (è puramente un'ipotesi accademica poiché è dimostrato non essere vero).

All'aumentare del numero di persone presenti nella stanza aumentano le probabilità:

- 0 persone => probabilità 0- 1 persona => probabilità 0- 2 persone => probabilità 1/365- ......

Se non si analizza approfonditamente il problema ci si aspetterebbe una curva lenta con crescita lineare.

n≈365≈20 Questo mi permette di identificare quando la probabilità è maggiore di ½

Il paradosso del compleanno è concettualmente uguale alla valutazione statistica della probabilità di collisione, quindi seguirà la stessa curva. Per ridurre le collisioni dovrei quindi indicizzare al massimo 260

La funzione di hashing deve quindi tornare un valore maggiore di 120 bit pari a 2602

Se però la distribuzione dei valori hash (analogamente a quella della probabilità di nascita per ogni giorno) non fosse uniforme io avrei una curva analoga, ma molto anticipata.

Statisticamente dobbiamo quindi utilizzare una funzione con distribuzione uniforme

57 / 86


REALIZZAZIONE DI FUNZIONI HASH CRITTOGRAFICHE

Sono funzione non invertibili poiché la stringa arbitraria può essere di dimensione molto superiore ai bit in cui la si vuole mappare.

H : stringa di bit (lunghezza arbitraria) ==> 128, 160, 256 bit

Può tornare valori compresi tra 0 e 2160 −1 oppure 2128−1 o 2256 −1 con probabilità uniforme.

Pur essendo non invertibile la probabilità di collisione sono statisticamente prossime a zero, quindi in pratica pur essendo una funzione non invertibile si comporta come se lo fosse.

Posso quindi riconoscere un documento sulla base di un impronta hash.

Come la si può realizzare?

Se pensiamo ai principi di Shannon e alla cifratura a blocchi possiamo individuare una strada, tuttavia abbiamo bisogno che la funzione sia invertibile.

Posso quindi usare la stessa tecnica con maggiore libertà (Xor, permutazioni, ...)

Esistono quindi molte funzioni hash crittografiche che variano in base alla dimensione del codominio.

Applicazioni: verifica d'integritàPer verificare l'integrità di un file a distanza di tempo devo poter confrontare due impronte generate applicando una funzione di hashing crittografica al file.

fingerprint f = H(F) con F di dimensione arbitraria ed f di dimensione 160, 128 0 256 bit

Dopo aver calcolato il valore f lo memorizzo.Se a distanza di tempo voglio verificare che il file non abbia subito modifiche calcolerò:

f' = H(F')

Chiamo il file F' e non più F poiché lo considero come fosse un file differente.Sarà quindi sufficiente verificare l'ugualianza tra il valore f ed f'

Uso la verifica d'integrità per stabilire se sono avvenute modifiche a file importanti di cui ho precedentemente calcolato il fingerprint.Se un attaccante dovesse violare la macchina potrebbe però non solo manipolare i file, ma ricalcolare anche il loro fingerprint. Ci serve allora introdurre il concetto di firma digitale.

58 / 86


LEZIONE 16APPLICAZIONI DELLE FUNZIONI HASH

VERIFICA DI INTEGRITÀ DEI DOCUMENTI

Abbiamo visto che tramite l'uso di funzioni di hashing possiamo garantire l'integrità dei file, tuttavia è necessario garantire anche l'integrità delle impronte hash per garantire successive verifiche accurate. Un'opzione potrebbe essere quella di memorizzale su supporti di memorizzazione sicuri.

Tuttavia è possibile dover lasciare le impronte calcolate sullo stesso dispositivo fisico che memorizza i file, quindi avrò bisogno di un sistema di firma digitale. Devo avere una persona che garantisce l'integrità del nostro sistema. Il garante d'integrità, per fare ciò, utilizza un sistema di cifratura (public/private key)

In questo modo ottengo una quantità di bit pari a quella dell'impronta del file. Una volta concluso il processo di firma, posso eliminare i risultati delle fasi precedenti e conservare esclusivamente la firma.

Per verificare dopo un po' di tempo l'integrità del mio file dovrò confrontare:

● file ==> H(file) = impronta

● firma ==> decRSA(firma, kpubb)

59 / 86

prendo il fileapplico H(file) e ottengo l'impronta

cifro l'impronta (es.RSA)utilizzando la k-priv del garante

ottengo lafirma

File

H(file)

digest

digest RSA firma

firma k-pubbRSA

k-privata

verifica


Potrei avere un risultato falso dell'operazione di verifica (il file è cambiato ma la verifica ha successo) solo se:

● c'è stata una collisione nella generazione dell'impronta

● c'è stata una collisione in fase di decifratura

Motivi di fallimento invece possono essere:

● il file è stato modificato, ma la firma è rimasta immutata

● la firma è cambiata, ma il file è rimasto inalterato

● è stata utilizzata una chiave pubblica sbagliata

Perché possiamo fidarci di questo meccanismo? Quali sono le condizioni necessarie affinché il processo abbia successo?

Il fatto di possedere ed utilizzare una chiave privata implica la necessità di garantirne la sicurezza. In caso contrario, se l'attaccante fosse in possesso della mia chiave, potrebbe alterare i miei file e rigenerare le nuove impronte. In questo modo, ad una mia successiva verifica, non mi accorgerei delle alterazioni poiché il processo di controllo sarebbe positivo.

L'utilizzo di questo sistema implica però una riduzione della disponibilità poiché ho bisogno di coinvolgere un maggior numero di componenti. Un attaccante che volesse violare la disponibilità dei miei dati avrebbe maggiori possibilità poiché per renderli totalmente invalidi potrebbe limitarsi ad alterare la mia firma.

E' consigliato l'uso di questo sistema solo nei casi in cui è più importante l'affidabilità rispetto all'integrità. In pratica se abbiamo l'informazione bene, in caso contrario non è un problema insormontabile. La cosa importante è che quando un'informazione è presente questa sia corretta.

FIRMA DIGITALE

La firma digitale nasce dalla necessità di attribuire la paternità di un documento in maniera certa. Il meccanismo utilizzato è analogo a quello visto in precedenza per la verifica dell'integrità.

Alice ha bisogno di sapere che il documento che ha appena ricevuto da Bob sia stato effettivamente scritto da lui.Bob allora invierà il documento firmato utilizzando la sua chiave privata. Alice invece decifrerà la firma con la chiave pubblica di Bob

La firma digitale quindi ha una duplice funzione: la verifica di integrità dei file e la verifica della loro autenticità.

60 / 86


La firma autografa (nella vita reale, es. per firmare una lettera) invece garantisce l'autenticità di un documento, tuttavia non ne può garantire l'integrità, poiché il testo riportato in calce alla firma potrebbe essere stato alterato.

Valore legale della firma digitaleTeoricamente la firma digitale potrebbe implicare un riconoscimento legale del contenuto da essa siglato. Sfortunatamente questo è solo uno scenario ideale a causa di problemi normativi.

La legislazione europea infatti non impone vincoli restrittivi sui metodi di generazione, protezione e conservazione delle chiavi. In assenza di tali vincoli non è quindi possibile attribuire un valore legale ai documenti in maniera diretta, ma occorre sempre passare attraverso la consulenza di periti ed esperti che verifichino e stabiliscano la reale paternità del documento.

La legislazione italiana invece è molto più restrittiva ed ha introdotto norme per le quali il riconoscimento di paternità di un documento ed il suo conseguente valore legale potrebbe essere più immediato.

Il sistema ideato è stato sviluppato in maniera tale da impedire errori da parte di un utente. La sicurezza è quindi interamente demandata al sistema. La conservazione delle chiavi può avvenire solo su smart card di tipo tamper-proof e l'attribuzione di una coppia di chiavi ad un utente può essere fatta solo previa verifica della reale identità della persona che la richiede.

AUTORITÀ DI CERTIFICAZIONE E CERTIFICATI

Occorre allora introdurre il concetto di autorità di certificazione (Certification Authority) per stabilire una relazione biunivoca tra coppie di chiavi pubblica e privata e l'identità della persona. L'idea alla base è quella del notaio, da intendersi come terza parte fidata. Si usa quindi un meccanismo di firma digitale per la produzione di certificati.

Un certificato è formato da: [ ( identità della persona + chiave pubblica ) + firma della CA ]

Quindi per verificare che la firma apposta sia corretta si procede come prima, poi esaminiamo il certificato verificando la firma del certificato con la chiave pubblica della certification authority.

61 / 86

Dati identificatividi Bob

Chiave pubblicadi Bob

FIRMA DELLACERT AUTH

Digest RSA K pubbCAVerifico se

corrispondono


Rimane un ultimo problema. Sapere se la chiave pubblica è realmente quella della certification authority. Allora si utilizza una sola CA centralizzata e la sua chiave pubblica viene pubblicata ufficialmente (es. in gazzetta ufficiale).

PROBLEMI PRATICI (prettamente di tipo logistico, gestionale e amministrativo).

● In primo luogo devo verificare l'identità della persona: il modo più facile è quello si delegare il compito ai comuni, poiché questa è una pratica svolta quotidianamente da un ufficio anagrafe.

● Poi occorre verificare l'univocità della chiave pubblica. Per fare questo una soluzione potrebbe essere quella di gestire il problema secondo un approccio di tipo centralizzato. In realtà però il problema viene risolto semplicemente sulla base della probabilità tendente a zero che due persone diverse generino la stessa chiave.

● Un altro problema consiste nel verificare che esista una reale corrispondenza tra la chiave pubblica e quella privata. Le due chiavi potrebbero non corrispondere a causa di un errore involontario o di una scelta deliberata.

○ O la cartification authority genera la coppia di chiavi al posto dell'utente (però così la CA conoscerebbe le chiavi private di tutti)

○ Oppure la CA propone una sfida (challenge): sostanzialmente la CA chiede all'utente di dimostrare di saper usare la propria chiave. Quindi la CA genera un numero casuale. L'utente cifra quel numero, poi prende il numero cifrato e lo decifra utilizzando la chiave pubblica dell'utente. Dopo aver verificato se il risultato è corretto produce il certificato.

La produzione di questi certificati dovrebbe quindi essere fatta di persona, quindi la CA dovrebbe essere ben distribuita sul territorio.

Poiché in Italia l'apparato statale non è in grado di gestire una simile procedura, la generazione dei certificati è stata appaltata a ditte private. Chiaramente, vista la riservatezza dei dati da conservare, sono stati imposti requisiti molto restrittivi (del tutto analoghi a quelli richiesti per le banche). Questo da un lato restringe le aziende che possono mettersi sul mercato, da un altro porta al rilascio di certificati a pagamento. I certificati vengono rilasciati con una durata limitata nel tempo (ad esempio con scadenza annuale) anche per ovviare a possibili perdite o danneggiamenti delle smartcard che conservano le chiavi.Tutte queste limitazioni quindi portano ad una minore accettabilità da parte degli utenti da parte del grande pubblico.

CERTIFICATI DIGITALI X509.V3

Lo standard usato per i certificati è lo x509.v.3 che ha la particolarità di avere campi customizzabili oltre a quelli di default e quindi permette di adattarsi a piacimento a

62 / 86


qualunque esigenza. E' uno standard un po' datato, i campi di default non rispondono più alle esigenze attuali, quindi le informazioni importanti vengono inserite nei campi opzionali. Lo standard quindi non è più utilizzato in maniera standard.

Nella pratica corrente si ragiona nell'ottica della normativa europea che è di tipo lassista.

Ognuno può creare una propria certification authority, ad esempio per un uso locale all'interno di un'azienda. Questo tuttavia è un metodo un po' anomalo di applicare il concetto di CA poiché ogni singolo utente potrebbe essere una CA.

Creazione di una certification authorityCreo allora una coppia di chiavi per la mia CA, poi creo gli utenti di cui ho bisogno e abbino un certificato alle coppie di chiavi degli utenti. Se ho intenzione che una parte esterna al mio contesto (in questo caso l'azienda) possa verificare le chiavi pubbliche dei miei utenti dovrò allora comunicare ad essa la chiave pubblica della mia CA.

Comunicazione della chiave pubblica di una CAPer comunicare la chiave pubblica della certification authority appena creata, dovrò produrre un certificato autofirmato dalla CA stessa.

La creazione e distribuzione di tale certificato corrisponde concettualmente all'idea di challenge. In pratica la certification authority dimostra di saper utilizzare la propria chiave.

CA di tipo gerarchicoLa prima CA creata viene definita ROOT AUTH. ed essa certifica sé stessa. Essa può tuttavia certificare non solo le chiavi di utenti, ma anche quelle di altre CA. In questo caso si crea quindi una relazione padre-figlio dando vita ad una struttura gerarchica ad albero.

Tra i vari campi previsti in un certificato x509.v.3 è presente un campo per indicare la validità delle applicazioni lecite all'entità certificata. Una certification authority potrebbe quindi essere autorizzata solamente alla certificazione di utenti, un'altra potrebbe invece certifica sia utenti che nuove CA. Un certificato potrebbe quindi avere solo il potere di firma, quello di rilascio di nuovi certificati o entrambi i permessi.

Se due ROOT CA si certificano l'una con l'altra allora utenti appartenenti ad alberi diversi (i due alberi coinvolti nella reciproca certificazione) possono comunicare e riconoscersi.

63 / 86

Dati identificatividella Cert. Auth.

Chiave pubblicadella Cert. Auth.

FIRMA DELLACERT AUTH

RootCA

ca ca ca

ca

caca

u

u

u

u

u


LEZIONE 17ALTRE APPLICAZIONI DELLE FUNZIONI HASH

Riepilogo dei concetti legati alla firma digitale:

● prevede l'uso di funzioni hash più crittografia a chiave pubblica

● sintetizza in pochi bit file di dimensioni arbitrarie

● permette la verifica di integrità

● permette di verificare l'autenticità

● permette una separazione tra verifica di autenticità e crittografia

Se non abbiamo la necessità di mantenere una separazione tra la fase di verifica e quella di produzione della firma allora possiamo usare un sistema di crittografia a chiave simmetrica in cui la stessa chiave serve sia per verificare l'integrità, sia per cifrare e decifrare un documento.

Posso così verificare costantemente l'integrità del sistema

Un meccanismo per verificare l'integrità in modo ancora più semplice fa uso solamente di funzioni hash sfruttandone la loro non invertibilità e non compie alcuna operazione di cifratura. Se noi calcoliamo l'impronta di un file, da questa non riusciremo a risalire al contenuto originale del file.

Allora prendiamo un file, concateniamo ad esso una password e calcoliamo H(file+pwd). Possiamo così conservare il file originale e l'impronta appena calcolata. Qualora volessi verificare l'integrità del mio file dovrei semplicemente rieseguire la concatenazione tra file e password, ricalcolarne l'impronta e confrontarla con quella precedentemente generata.

Il vantaggio di questo sistema risiede nel fatto che un attaccante per poter riprodurre l'impronta dovrebbe conoscere la password utilizzata.

64 / 86


IL GIOCO DEL "PARI O DISPARI" O “TESTA E CROCE” VIA RETE

Dobbiamo ovviamente partire dal presupposto di non fidarci dell'avversario, poiché questi potrebbe essere uno sconosciuto o comunque potrebbe barare.

Giocatore A: genera un numero casuale R∈[0, 2k−1]Giocatore B: richiede l'impronta hash di RGiocatore A: invia h=H RGiocatore B: non può calcolare il valore di R partendo da h

risponde pari o dispariGiocatore A: invia il numero RGiocatore B: verifica se ha vinto o perso calcolando h=H R e confrontandolo

con l'impronta precedentemente inviatagli dal giocatore A

"CIFRATURA" DELLE PASSWORD

Questo metodo può essere utilizzato per il sistema di autenticazione all'interno di un sistema. Perché questo? Perché se utilizzassi algoritmi come il DES sarei costretto a memorizzare all'interno del sistema anche la chiave privata in chiaro, ma questa sarebbe una soluzione inattuabile. Inoltre non posso utilizzare alcun algoritmo reversibile.

L'unica soluzione è quindi quella di utilizzare password “cifrate” che in realtà non sono cifrata, ma sono semplicemente impronte hash.

Nel file delle password di un sistema Unix-like ( /etc/passwd ) vengono infatti conservate le impronte hash delle password degli utenti. La verifica della password all'atto dell'autenticazione di un utente viene fatta calcolando l'impronta hash della password digitata dall'utente e confrontandola con quella presente in passwd.

Problematiche:

● Si usano normalmente funzioni hash vecchie (risalenti approssimativamente agli anni '50) che potrebbero generare collisioni, a differenza delle nuove funzioni hash a 256 bit che generano collisioni con probabilità prossima a zero.

● /etc/passwd deve essere protetto in modo tale da impedire il processo di scrittura da parte di qualunque utente e restringere dunque i privilegi di scrittura solo all'utente root

● è violabile tramite attacchi di tipo brute-force soprattutto poiché all'attaccante non interessa trovare la reale password di un utente, ma gli è sufficiente individuare una collisione.

65 / 86


Caratteristiche delle password difficilmente individuabili:

● non deve essere o contenere il nome utente

● deve essere di lunghezza superiore ad 8 caratteristiche

● non deve contenere parole di senso compiuto

● deve contenere caratteri speciali

● non deve contenere parole o numeri riconducibili all'utente

Maggiore è la lunghezza di una password, maggiore sarà il livello di sicurezza computazionale di tale password.

Per proteggere il sistema da un attacco di tipo brute-force alle password posso agire su due fronti:

● limitare il numero massimo di tentativi:potrebbe essere una buona soluzione, tuttavia può portare ad una perdita di disponibilità. Se dopo x tentativi errati da parte dell'attaccante il sistema bloccasse l'account allora l'utente legittimo si troverebbe nelle condizioni di non poter accedere al sistema

● Modificare frequentemente la password:è una buona soluzione, ma porta ad inimicarsi gli utenti del sistema poiché li forzerebbe a memorizzare frequentemente nuove password

● agire sul tempo necessario all'operazione di autenticazione: Se infatti imponiamo un intervallo di attesa tra un tentativo di autenticazione ed il successivo possiamo aumentare notevolmente il tempo necessario ad un attacco brute-force. Il tempo predefinito per un login si aggira intorno a poche frazioni di secondo. Se impostassimo un intervallo di 5 secondi tra un tentativo e l'altro il tempo necessario a migliaia di tentativi ci garantirebbe un ottimo livello di sicurezza computazionale.E' tuttavia necessario che il file delle password non sia visibile pubblicamente.

● Agire sul numero di tentativi da fare :devo elevare quanto più possibile il numero di alternative possibili per la scelta delle password e fare in modo che tutte le possibili alternative siano equiprobabili (proprietà uniforme).E' bene quindi scegliere password che non facciano parte del linguaggio corrente poiché queste sono soggette ad attacchi a dizionario ovvero continui confronti tra le impronte delle password salvate nel file passwd e le impronte calcolate di parole d'uso comune. Normalmente in fase di cracking di una password si effettua come prima operazione un attacco a dizionario e solo al termine di questa fase si prova con un attacco a forza bruta..

66 / 86


E' quindi evidente che è buona norma testare sempre le password dei propri sistemi dal punto di vista dell'attaccante e richiedere la modifica della password ad utenti che le hanno generate in maniera troppo predicibile o violabile.

ONE-TIME PASSWORD

Un problema dell'uso delle password è che queste potrebbero essere carpite dal nemico. Se riduciamo il tempo di validità di una password al minimo indispensabile riusciamo a fare in modo che anche se questa venisse scoperta, non potrebbe essere utilizzata dall'attaccante. Ovviamente la soluzione migliore è quella di avere un sistema di password utilizzabili una sola volta.

Questo meccanismo però ha il difetto di essere difficilmente accettabile da parte degli utenti, poiché li costringerebbe a dover ricordare ogni volta una password differente. Per risolvere questo inconveniente devo fornirgli un dispositivo in grado di memorizzare la sequenza di password che dovranno essere utilizzate.

Per ovvie ragioni il sistema sul quale occorre autenticarsi ed il dispositivo che fornisce le password devono essere costantemente sincronizzati

Una soluzione potrebbe essere quella di utilizzare un array di password indicizzato e predisporre il sistema per fornire all'utente l'indice della password da utilizzare per ogni singola autenticazione. Ogni volta che viene richiesto un indice, questo deve essere memorizzato sia sul sistema sia sul dispositivo, in modo tale da impedire nuove richieste di una password già utilizzata. Quando le password dovessero finire dovrebbe poi essere possibile ricevere un nuovo array di password mediante un canale di comunicazione cifrato.

Un'alternativa migliore è invece quella di impiegare un generatore di password basato su un orologio atomico e funzioni hash.

Prendiamo un numero casuale R non predicibile da un attaccante.Dal numero R appena generato calcoliamo:

pwd1 = H(R)pwd2 = H(H(R)) dalle successive non possiamo risalirepwd3 = H(H(H(R))) alle password precedenti per il principiopwd4 = H(H(H(H(R)))) della non invertibilità.........................

Una volta che sono state generate n password le inserisco nel dispositivo generatore in ordine inverso. Quindi la prima password sarà pwdN, mentre l'ultima sarà pwd1.

Il sistema conserverà solamente l'ultimo valore. Per verificare se la password inserita è corretta il sistema calcola H(password fornita) e la confronta con la password memorizzata. Una volta che una password viene utilizzata il sistema memorizzerà l'ultima password che è stata inserita dall'utente.

67 / 86


LEZIONE 18FIREWALL

CONSIGLI PRATICI PER L'IMPLEMENTAZIONE DI UN FIREWALL

FIREWALL UTM E CLASSICI (LAYER 3-4)

ESEMPI DI FIREWALL COMMERCIALI

IPTABLES SU LINUX

LOGGING

FIREWALL STATEFUL E NON

68 / 86


LEZIONE 19MECCANISMI DI AUTENTICAZIONE E CERTIFICATI DIGITALI

Come fa il sistema a riconoscere gli utenti? Sostanzialmente si pone delle domande...

COSA SA L'UTENTE? LOGIN E PASSWORD

Il punto debole del sistema di login e password è che si basa su un segreto. Un segreto può essere carpito in diversi modi da un utente non legittimo. Uno dei casi in cui il segreto può essere carpito più frequentemente è quando l'utente si sta autenticando. (tramite intercettazione o osservazione diretta dei tasti premuti)

Posso allora cercare di ridurre le autenticazioni richieste al minor numero possibile e possibilmente effettuare le autenticazioni in luoghi in cui non sia possibile l'osservazione diretta da parte di malintenzionati. Tuttavia non è sempre disponibile un luogo isolato e limitare le autenticazioni contrasta con il principio di minimo privilegio e cambio di contesto.

Un altro metodo efficace è l'uso delle one-time password

Un'altra strada percorribile è invece quella di implementare un meccanismo di challenge basato su un crittosistema a chiave asimmetrica in cui il sistema propone ogni volta una sfida differente.

Gli ultimi due meccanismi proposti permettono quindi di non far circolare il segreto sul mezzo di comunicazione non sicuro, tuttavia devono essere memorizzati e/o implementati su un dispositivo fisico. Questo ci porta dunque al punto seguente...

69 / 86


COSA POSSIEDE L'UTENTE? CHIAVI DI CIFRATURA, SCHEDE MAGNETICHE, SMART-CARD

Questo meccanismo è molto più robusto allo spionaggio, ma è soggetto al furto materiale del dispositivo.

I dati ed il dispositivo garantiscono però una sicurezza maggiore poiché non sono intercettabili e soprattutto sono difficilmente manipolabili. Se utilizziamo ad esempio delle smart card di tipo tamper proof e proviamo ad “aprirle” il dispositivo diventerà inutilizzabile. Riusciremmo quindi ad individuare tentativi di manomissione.

Potrei alternativamente utilizzare un dispositivo USB, tuttavia sarebbe facilmente riproducibile e potrei non accorgermi di un'eventuale manomissione o copia.

Il punto debole di questo sistema di autenticazione risiede nella debolezza ad attacchi che combinano Man In the Middle e Phishing.

Per difendersi occorre quindi evitare che l'attaccante riesca ad interporsi tra l'utente ed il sistema.

COM'È FATTO L'UTENTE? METODI BIOMETRICI

Un altro metodo di autenticazione è quello di basarsi su dati fisici caratteristici dell'utente come il timbro di voce, le impronte digitali, la retina, la frequenza di digitazione dei tasti, ecc...

I problemi di questo tipo di controlli è legato a tre fattori: i costi, la sensibilità e la precisione dei sensori e la possibilità che i dati biometrici dell'utente mutino nel tempo (ad esempio in seguito a traumi fisici).

I sistemi biometrici possono essere molto sicuri, ma devono essere usati in modo sicuro. E' inutile infatti utilizzare un sistema di controllo delle impronte o della retina se non mettiamo una guardia che verifichi il corretto utilizzo degli scanner.

Se ho la necessità di garantire un elevatissimo livello di sicurezza devo utilizzare combinazioni dei vari sistemi di autenticazione. Ad esempio potrei utilizzare un challenge

70 / 86

chiude la connessione comunica con la banca

richiede challenge inoltra il challenge

risponde al challenge risponde al challengeuser

Attaccanteche replica

il sistema di auth

banca


al quale sommare una password (che agisca come il pin dei bancomat) ed integrarlo con la rilevazione delle impronte digitali.

Possibili attacchi:

● In un contesto di autenticazione biometrica via rete (lo scanner è posto in prossimità dell'utente, ma il sistema è acceduto in remoto) un attaccante potrebbe intercettare la scansione della retina o delle impronte ed utilizzarla in seguito per autenticarsi.

● L'attaccante potrebbe autenticarsi ponendo sullo scanner di impronte digitali una loro riproduzione.

ANCORA FIRME DIGITALI E CERTIFICATI: VERIFICA ON-LINE E OFF-LINE

Supponiamo che due utenti, siano essi A e B, non si conoscano. L'utente A richiede alla certification authority un certificato fornendogli i propri dati e la propria chiave pubblica. Per poter ricevere il certificato dovrà rispondere ad un challenge proposto dalla CA in modo da dimostrare di saper utilizzare la propria chiave. L'utente B farà altrettanto.

Una volta ottenuti i certificati i due utenti non avranno più necessità di interagire con la certification authority, ma avranno solamente bisogno di conoscere la chiave pubblica della CA.

Questo uso dei certificati è detto di tipo offline poiché gli utenti non hanno bisogno di costanti interazioni con la terza parte fidata nel momento in cui desiderano scambiarsi messaggi tra loro.

Si parla invece di verifica online quando gli utenti contattano la certification authority ad ogni scambio di messaggi.

OFFLINE: è preferibile nel caso di una CA che gestisce un elevato numero di utenti, poiché i canali di comunicazione vengono stabiliti direttamente dagli utenti. La CA non deve quindi essere costantemente operativa, e non necessita di elevate risorse computazionali o di ampiezza di banda.

ONLINE: ogni qualvolta due utenti desiderino stabilire un canale di comunicazione devono richiedere la mediazione della CA. Ne risulta ovvio che la CA deve essere costantemente online ad avere risorse sufficienti a soddisfare le richieste di tutti gli utenti che gestisce.

71 / 86

cert(A) cert(B)

AKpubA

BKpubB

C.A.


I certificati hanno un periodo di validità. Occorre quindi compiere valutazioni sulla lunghezza del periodo di validità da impostare.

Se applichiamo un periodo troppo breve l'utente sarà costretto a farsi autenticare troppo frequentemente con conseguenti perdite di tempo e costi ingenti da sostenere.

Se applichiamo invece un periodo di validità troppo lungo le informazioni certificate potrebbero perdere di validità nel tempo: ad esempio la chiave pubblica potrebbe cambiare, l'utente potrebbe trasferirsi e cambiare quindi il suo indirizzo o cambiare professione....

Per questa ragione è stato introdotto un meccanismo di revoca dei certificati. Quando un utente richiede la revoca del proprio certificato, la CA genera un certificato di revoca che comunica a chi lo riceve che quello precedente è da considerarsi non più valido

Vediamo un esempio:

- A aveva inviato a B il suo cert(A)- A cambia professione, chiede quindi la revoca del (cert(A)) e la invia a B- B elimina il vecchio cert(A)- A invia a B il nuovo cert(A)

Il problema nasce però dal fatto che se l'utente A non inviasse la revoca all'utente B quest'ultimo resterebbe convinto della validità del certificato precedente.

Vediamo un altro scenario in cui D rappresenta un attaccante:

- D si impossessa di cert(A) e di kpriv(A)- A se ne accorge e chiede la revoca del certificato- D può comunque continuare ad usare il vecchio certificato revocato di A e comunicare con altri utenti spacciandosi per A. Se questi verificano i certificati in modalità offline e non hanno ricevuto la revoca da parte di A, saranno convinti di parlare con A. Se gli utenti invece verificano i certificati in modalità online riescono a scoprire l'nganno.

Qual'è dunque l'utilità dei sistemi di verifica offline? Sostanzialmente questa modalità viene utilizzata quando si hanno numerose conversazioni nelle quali è poco importante garantire l'identità certa. In questi casi tuttavia potrei utilizzare meccanismi più semplici.

Le certification authority quindi forniscono normalmente due tipi di servizio:- verifica offline: gratuito o a bassissimo costo- verifica online: a pagamento. L'uso tipico è legato a transazioni di tipo economico.

72 / 86


MARCHE TEMPORALI E VALIDITÀ NEL TEMPO DELLA FIRMA DIGITALE

Come abbiamo visto, i certificati sono caratterizzati da una proprio periodo di validità. Sorge quindi il problema di stabilire a livello legale quando un certificato scada e se i documenti di cui si sta verificando l'autenticità siano stati firmati in un periodo lecito.

Se penso di dover utilizzare un documento firmato anche dopo la scadenza del certificato devo avere a disposizione un meccanismo che mi consenta di verificare che tale documento è stato scritto e firmato in un periodo valido.

Le garanzie legali sonochiaramente valide solo nel periodocompreso nell'intervallo Delta(T)

Come posso sapere se il documento è stato firmato all'istante a, b o dopo la scadenza?

Occorre quindi associare al documento una data di creazione, ma questa non può essere apposta dal suo creatore, ma deve essere apposta da una terza parte fidata.

Per ottenere ciò devo far firmare il documento anche dalla CA, la quale oltre alla sua firma apporrà un timestamp che rappresenta la data di creazione.

La verifica del timestamp dovrà necessariamente essere effettuata in modalità online.

73 / 86

Delta(T)

acreazione revoca

scadenzab


LEZIONE 20INTRUSION DETECTION

HOST INTRUSION DETECTION E NETWORK INTRUSION DETECTION

Il principale difetto dell'analisi dei log consiste nel fatto che essa avviene nel momento in cui l'attacco è stato subito, quindi si tratta di un'analisi post-incidente. I log inoltre sono un riassunto poco particolareggiato: se viene scritto un file da 200Kb su disco, mediante l'analisi dei log potrò capire solamente che è stato creato un file e che la dimensione del file è pari a 200Kb, tuttavia non avrei alcuna informazione sul contenuto.

Un IDS invece permette analisi preventive e maggiormente accurate, tuttavia genera sia falsi positivi, sia falsi negativi. La presenza di falsi positivi implica la necessità dell'intervento umano, poiché non è possibile discernere in maniera automatica tra falso e reale. La presenza di falsi negativi comporta invece la perdita di conoscenza di attacchi avvenuti.

Distinguiamo tra HIDS ovvero host intrusion detection system e NIDS ovvero network intrusion detection system.

Uno strumento che può essere usato come NIDS è ad esempio ntop che permette di verificare le percentuali di traffico per protocollo, la creazione di macro aggregati, ...

Se ad esempio verificassimo che:- PC1 occupa: 1% di banda- PC1 occupa: 4% di banda- PC1 occupa: 95% di banda

potremmo facilmente dedurre che c'è qualche problema sul terzo pc

74 / 86


ESEMPI DI DUMP TRAFFICO INTERNET E ANALISI DI TRAFFICO NORMALE

Utilizzando ad esempio tcpdump osserviamo il seguente traffico di rete:

client.38060 > server.telnet S 3890.3890(0) DFserver.telnet > client.38060 S 2230.2230(0) ACK 3891client.38060 > server.telnet S ...................... ACK 2231

In realtà vengono utilizzati degli ISN (internet serial number) relativi per rendere il traffico più facilmente leggibile e comprensibile.

client.38060 > server.telnet P 1.28(27) ACK 1 DFserver.telnet > client.38060 ACK 9

P indica il flag PUSH che dice al destinatario di non aspettare il riempimento del buffer, ma di inviare direttamente sul canale.

Quello che abbiamo visto è un esempio di dump di traffico normale che potremmo avere in una qualunque rete.

Ipotizziamo invece di individuare il seguente traffico sulla nostra rete:

client.39904 > server.telnet F 14:14(0) ACK 186server.telnet > client.39904 ACK 15 DFserver.telnet > client.39904 F 186.186(0) ACK 15client.39904 > server.telnet ACK 187 DF

Questo è un tipico esempio di chiusura gracefull di una connessione. In pratica si tratta di una chiusura gradevole, educata in cui è prevista una fase di commiato.

Oltre a questo metodo di chiusura, il protocollo prevede un metodo di chiusura istantanea che tronca la connessione in maniera netta, senza alcun saluto.Supponiamo che il client voglia chiudere la connessione con il server:

client.39904 > server.telnet R 28:28(0) ACK 1 DF

Quest'ultimo metodo è valido e previsto dal protocollo ed è utilizzato spesso dai NIDS per chiudere una connessione quando mi accorgo che è in corso un tentativo di attacco (tramite l'analisi delle signature della parte ascii di un pacchetto).

75 / 86

source destination syn isn byteDon't

fragment


Supponiamo un attacco IDA. Un attacco IDA è una tecnica che sfrutta una vulnerabilità di alcune versioni di IIS per causare un buffer overflow. Viene perpetuato tramite una richiesta http del tipo:

get ida.html?0.............. numero particolare lunghissimo

Una volta identificato l'attacco potrei fare un RST (reset) della connessione.In pratica un modo di agire può essere:

● lascio passare la get e la inoltro al server

● il server gestisce la richiesta e risponde al firewall

● il firewall non inoltra la risposta bensì invia un reset

Così facendo ho potuto loggare sul firewall il tentativo di intrusione che altrimenti non avrei potuto registrare se avessi provveduto immediatamente al blocco della richiesta.

DIFFERENZE TRA ANOMALY E MISUSE DETECTION

Sono entrambe tecniche di identificazione degli errori, ma che si distinguono molto per il loro modo di procedere.

La misuse detection è una tecnica basata sulconfronto per pattern matching tra la signature della parte ascii di un pacchetto e un database di attacchi conosciuti e di vulnerabilità di sistema note per identificare possibili intrusioni.

L'anomaly detection è un'analisi euristica basata sul confronto tra comportamento normale e comportamento attuale. Occorre quindi stabilire, secondo i criteri che si ritengono più appropriati, uno stato della rete che consideriamo normale e confrontare continuamente questo con lo stato attuale. Qualora i due stati differissero notevolmente si avrebbe un'anomalia

PORT SCANNING (FIN SCAN, HALF CONNECT SCAN, ACK SCAN)

Supponiamo di individuare sulla nostra rete il seguente traffico:

ack.com:23 > 150.145.10.11:23 ACK 2322ack.com:23 > 150.145.10.17:23 ACK 2322ack.com:23 > 150.145.10.40:23 ACK 2322

Notiamo che si tratta di connessioni provenienti da uno stesso host verso diversi host, ma sempre sulla stessa porta. La porta sorgente inoltre non è una porta effimera (tipicamente utilizzata dai client), inoltre l'ACK è sempre uguale. Indubbiamente un traffico di questo tipo non è piacevole...

76 / 86


Questo è un tipico esempio di ACK scan: una modalità di port scanning utilizzata durante la fase di intelligence gathering (raccolta di informazioni sulla rete della vittima prima di un attacco).

Se il pacchetto arriva a destinazione (nel nostro esempio il server) questi risponderà con un RST sia se la porta è aperta, sia se la porta è chiusa. Se invece il pacchetto non giunge a destinazione il mittente potrebbe notare uno tra questi due comportamenti:

● non torna indietro alcuna risposta

● torna indietro un ICMP: host unreachable

Nel caso in cui la rete obbiettivo fosse protetta da un firewall che blocca i ping provenienti dall'esterno, l'attaccante potrebbe scoprire quali macchine sono accese

Nel caso in cui invece il ping fosse abilitato e le macchine interne rispondessero, ma il mittente attaccante non ricevesse alcuna risposta egli potrebbe desumere che la rete è protetta da un firewall/IDS e capire una regola.

Supponiamo invece di individuare sulla nostra rete il seguente traffico:

stealthycom:50141 > victim.org:5 F 0:0(0)stealthycom:50141 > victim.org:23 F 0:0(0)stealthycom:50141 > victim.org:140 F 0:0(0)stealthycom:50141 > victim.org:143 F 0:0(0)

Notiamo che si tratta di connessioni provenienti da uno stesso host. L'internet sequence number inoltre è 0 (e questo non è normale nemmeno per un singolo pacchetto, figuriamoci per quattro consecutivi).

Si tratta di un tentativo di FIN scan.

Se la porta della macchina di destinazione è chiusa ritorna un RST, mentre se la porta è aperta non ritorna nulla.

Questa è una tecnica di scanning con capacità di firewall bypassing ed evasion. Non solo infatti questo tipo di scan oltrepassa il firewall, ma non ne permette nemmeno il logging.

Tuttavia le macchine windows quando ricevono un FIN “fuori luogo” ritornano sempre un RST, quindi mediante questo genere di scan posso eseguire anche un rudimentale controllo di tipo OS FINGERPRINTING ed individuare macchine windows.

77 / 86


THREE-WAY HANDSHAKE

Uno dei primi scan eseguiti è stato il CONNECT scan. Questa tecnica instaurava molteplici connessioni sulle varie porte concludendo il ThreeWay Handshake. Tuttavia aveva il difetto che le connessioni andate a buon fine vengono loggate.

Un'evoluzione fu dunque quella dell'HALF-CONNECT scan o SYN scan. Questa tecnica si basa sulla stessa tecnica del FIN scan, ma utilizza ovviamente un SYN. Una macchina che riceve uno scan di questo tipo risponde con un ACK se la porta contattata appartiene ad un server, altrimenti restituisce un RST. Inoltre poiché non conclude la connessione non può essere loggato.

OS FINGERPRINTING

Il protocollo TCP ha una sua implementazione modello, tuttavia ogni vendor lo implementa con alcune varianti.

Per determinare il sistema operativo della macchina che vogliamo analizzare dobbiamo analizzare le risposte che ci provengono da essa a pacchetti forgiati appositamente.

0 0 URG ACK PSH RST SYN FIN

Ad esempio possiamo provare ad inviare pacchetti costruiti con varie combinazioni dei primi due flag TCP e vedere come il sistema risponde. Ogni SO risponde in maniera differente. Un altro modo è quello di agire sulle TCP option.

Sostanzialmente quindi questa tecnica si basa sul principio di Stimolo-Risposta

78 / 86


LEZIONE 21STEGANOGRAFIA E WATERMARKING

IDEA GENERALE DI STEGANOGRAFIA: CONTENITORE E CONTENUTO; RIDONDANZA

Si tratta di una tecnica diversa dalla crittografia: mentre la crittografia si occupa di rendere incomprensibile il messaggio, la steganografia ha l'obiettivo di nascondere il messaggio stesso.

Storicamente si sono utilizzati supporti difficilmente individuabili per dimensione (ad esempio i microfilm)

Ma in rete? Non potendo nascondere i bit, dobbiamo dissimularli. Il messaggio viene nascosto dentro un altro messaggio, diverso e privo di ogni correlazione con il documento che vogliamo nascondere.

CONTENITORI TESTUALI

Come possiamo realizzare una tecnica simile? Occorre giocare sulla ridondanza dei documenti in cui vogliamo nascondere le informazioni.

Il contenitore deve essere caratterizzato da elevati livelli di ridondanza (poter essere scritto in più modi diversi). A quel punto posso crearlo in modo tale da codificarne all'interno il contenuto.

Requisiti per la steganografia:

1. contenitore ridondante

2. contenuto piccolo (rispetto al contenitore)

Il contenuto viene reso invisibile fra i molto bit inutili del contenitore (ad es. in un frame di un video, in un testo scritto).

E' addirittura possibile individuare un messaggio già presente in un contenitore molto grande senza modificarlo (es: identificare singole lettere all'interno di un testo molto lungo).

79 / 86


Un testo, nella pratica, permette di inserire contenuti troppo piccoli: occorrerebbero testi molto lunghi. E' meglio quindi usare CONTENUTI MULTIMEDIALI.

CONTENITORI AUDIO (TECNICA DEL BIT MENO SIGNIFICATIVO)

Un file audio è realizzato come una serie di campionamenti di un onda: diversi numeri corrispondenti al valore del segnale in un dato istante.

Sostituire l'ultimo bit di ognuno di questi valori comporta un minimo errore di campionamento, totalmente impercettibile; in generale è di per sé casuale per via del rumore di fondo.

Posso codificare in questo modo una messaggio descritto dal bit meno significativo di ogni campionamento.

CONTENITORI IMMAGINI (PIXMAP E FORMATI COMPRESSI)

Un immagine BMP è in pratica una matrice che contiene in ogni cella in tre valori RGB (8 + 8 + 8 bit = 24 bit).

Preso ad esempio un pixel giallo (255, 255, 0), se lo cambio con (254, 254, 1) la differenza è pressochè impercettibile. Anche questo è sfruttabile per codificare messaggi.

I formati compressi come JPEG e GIF non sono adatti a questo tipo di steganografia: sono formati creati proprio per ridurre la ridondanza, quindi un cambiamento di questo tipo si nota!

LE STRUTTURE DATI NON CANONICHE COME CONTENITORE

Esempio: lista non ordinata (di norma l'ordine è rilevante nelle liste)

Se uso una lista per rappresentare l'insieme {2,3,5}

2 -> 3 -> 5 è equivalente a 2 -> 5 -> 3

Posso quindi fornire un significato alla ridondanza ed assegnare un senso alle varie permutazioni.

Ad esempio il formato JPEG usa solo 2 bit invece di 24 per identificare il colore di un pixel nella matrice dell'immagine. Questi 2 bit fanno riferimento a una tabella che contiene un elenco dei colori, ad es:

0 | 255,0,0 1 | 255,255,0 2 | 0,0,255

In questo caso nella tabella il valore 1 identificherà il colore giallo.

80 / 86


L'ordine dei colori in questa tabella è ARBITRARIO, è una struttura dati non canonica. Posso utilizzarla come detto prima.

Altro modo di nascondere cose sul disco:

sfruttare le tecniche di GARBAGE COLLECTION

Una cosa cancellata ma ancora presente sul disco è un OTTIMO contenitore: non rappresentando alcuna informazione, la sua ridondanza è INFINITA.

CENNI ALLE DIFFERENZE TRA STEGANOGRAFIA E WATERMARKING

E' una tecnica stenografica particolare per "marcare", in forma nascosta, il contenitore. Viene usato per proteggere copyright. Nella pratica allega un contenuto stenografico, che per sua natura è IMPOSSIBILE da cancellare per l'utente senza distruggere il contenitore.

81 / 86


LEZIONE 22ATTACCHI IN RETE

IP FRAGMENTATION ALLO SCOPO DI EFFETTUARE FIREWALL BYPASSING

MAN-IN-THE-MIDDLE

ATTACCO DI MITNICK (IP SPOOFING ALLA CIECA)

ARP CACHE POISONING

82 / 86


LEZIONE 23SNIFFING

Il destinatario di un pacchetto che viaggia su rete locale è individuato in base alla corrispondenza tra il destination Mac contenuto nel pacchetto e quello dell'interfaccia di rete del destinatario.

Un pc “educato” passa al kernel, per la fase di decapsulazione, solo i pacchetti inviati in unicast e diretti a sé o quelli inviati in broadcast.

Un indirizzo Mac, come sappiamo, è costituito da 6 byte dei quali i primi tre identificano il vendor (il produttore dell'interfaccia di rete) mentre gli ultimi tre rappresentano univocamente l'interfaccia (teoricamente a livello globale, in realtà è però possibile che esistano due o più schede al mondo con lo stesso Mac).Un pacchetto inviato in broadcast avrà come MacAddress: ff:ff:ff:ff:ff:ff

Un pc “spione” invece intercetta tutti i pacchetti che passano sul canale.

NIC IN MODALITÀ PROMISCUA

Per poter forzare l'interfaccia di rete a catturare anche i pacchetti non ad essa destinati occorre attivare il flag di promiscuous mode. Questa operazione può essere svolta in maniera semplice e rapida tramite ifconfig. Non solo: alcuni tool di sniffing, come wireshark, attivano automaticamente la scheda in modalità promisqua.

Al fine di tutelare la sicurezza delle comunicazioni, si pone quindi il problema di individuare un pc che sta svolgendo un'operazione di sniffing

83 / 86


SNIFFING DETECTION SU HOST

Avendo accesso fisico alla macchina sospetta possiamo seguire diverse strade:

● usare ifconfig per verificare se sulla NIC è attivo il flag di modalità promisqua.Tuttavia potrebbe non essere visibile se il binario di ifconfig è stato alterato (ad esempio grazie all'uso di un rootkit)

● utilizzare tool come primiscuous check

● utilizzare tripwire o altro integrity checker per verificare se ifconfig è stato alterato (presuppone di poter fare un confronto con una signature di ifconfig calcolata quando il sistema non era certamente stato alterato)

● eseguire in modalità live (con bootstrap da cd) una distribuzione Linux di tipo forense come FCCU o Helix

SNIFFING DETECTION VIA RETE

A livello di rete invece, identificare un pc che sta sniffando è un'operazione più complessa poiché non abbiamo la possibilità di accedere fisicamente al pc incriminato ed in una rete ampia potrebbe anche non essere immediato individuare un sospetto.

RISPOSTA A STIMOLI

Il concetto da applicare in questi casi (come in molti altri ambiti della sicurezza) è quello di causalità: fornendo uno stimolo ad una macchina specifica o in broadcast provochiamo una risposta da parte del colpevole.

Per fare questo dobbiamo inviare in rete pacchetti appositamente forgiati per individuare il colpevole. Abbiamo detto che un pc che sta sniffando intercetta anche i pacchetti che non sono destinati ad esso, quindi li decapsulerà e li analizzerà. Sapendo questo possiamo ingannare il sistema e ricevere una risposta.

Un esempio: forgiamo un ICMP echo request (ping) con le seguenti caratteristiche:

SourceMac: quello della mia macchinaDestinationMac: quello di una macchina sicuramente innocenteSourceIP: quello della mia macchinaDestinationIP: quello della macchina sospetta (o di broadcast)

84 / 86


Il pacchetto verrà ricevuto sia dalla macchina innocente che dal colpevole. Entrambe le macchine effettueranno la decapsulazione, ma il vero destinatario si accorgerà che il pacchetto non era destinato a lui e non eseguirà alcuna azione. Il colpevole invece troverà sé stesso come destinatario e risponderà alla richiesta di ping.

Per individuare alcune macchine windows invece si può utilizzare come DestinationMac FF:00:00:00:00:00

Questi sono controlli fatti dal tool antisniff. Altri modi di agire potrebbero essere: usare un ACK scan forgiato o nepad

TEST DI LATENZA AL VARIARE DEL TRAFFICO DI RETE

Un'altra strategia è invece quella di analizzare le prestazioni della scheda di rete del sospetto attraverso quello che viene definito test di latenza.

L'idea è quella di valutare quali sono le prestazioni attuali della scheda del sospetto (una misura plausibile potrebbe essere il tempo di risposta al ping) in modo da capire qual'è il suo valore normale. Successivamente inondiamo la rete di pacchetti ad es. un milione in un secondo. Infine testiamo nuovamente i tempi di risposta della vittima. Se questi saranno notevolmente superiori o addirittura egli non risponderà sapremo che quella macchina stava sniffando. Questo perché abbiamo inviato una mole enorme di pacchetti ad host diversi da lui, ma questi li ha intercettati tutti sovraccaricando la propria interfaccia.

DNS QUERY (REVERSE LOOKUP)

Ci aspettiamo inoltre che una macchina che sta sniffando esegua numerose query ai DNS per capire con chi stanno comunicando i vari host della rete. Possiamo quindi analizzare statisticamente le query ai DNS per individuare una macchina che ne esegue oltre un livello normale. Alternativamente o parallelamente possiamo inviare pacchetti forgiati con indirizzi IP falsi e vedere quale macchina cerca di risolvere un IP non valido

85 / 86


ANTI-ANTI SNIFFING

Ovviamente un attaccante non è stupido e quindi adotterà tecniche per evitare di essere individuato.

Sniffing di host mirati:Anziché catturare la totalità del traffico di rete ci si può limitare a catturare le comunicazioni da e verso un numero limitato di macchine. Grazie ad un comportamento di questo tipo è possibile eludere controlli basati sui tempi di risposta poiché difficilmente verrà intasata l'interfaccia.

Sniffing a soglie:Un'altra soluzione è quella di catturare pacchetti fino a che le risorse della macchina che sta sniffando non superano un determinato limite. (sogliature su traffico, cpu, ram...)

Analisi offline dei file:Se non vengono eseguite query DNS immediate è possibile eludere i controlli basati sull'analisi delle interrogazioni ai DNS.

ETHERNET BUS, HUB E SWITCH: SNIFFING SU SWITCH

In reti a BUS tutti i pacchetti passano indistintamente. Essere collegati al BUS in un qualunque punto permette quindi di intercettare l'intero traffico.

Le reti a stella che utilizzano un HUB sono del tutto simili a quelle a BUS, questo perché un HUB non è altro che un ripetitore elettrico che propaga su tutte le porte i segnali che riceve.

In reti a stella che utilizzano uno SWITCH invece l'intercettazione è più complicata poiché uno switch non è un puro e semplice ripetitore, bensì instaura canali di comunicazioni diretti tra le porte coinvolte. In questo caso uno sniffer dovrebbe adottare tecniche più complesse come avvelenare la cache dello switch in modo che questi esegua un mirror delle comunicazioni anche sulla porta ad esso associata oppure realizzare un vero e proprio attacco di tipo MIM (man in the middle) con ARP cache poisoning

86 / 86

INDICE GENERALE - matteotirelli.com · matteo tirelli appunti del corso di sicurezza 2007/2008...

Documents

Transcript of INDICE GENERALE - matteotirelli.com · matteo tirelli appunti del corso di sicurezza 2007/2008...