nerthase 2.0 » Tutto il resto

Hacking: SQLInjection con SqlMap

nerthase — Tue, 30 Mar 2010 21:19:44 +0000

Molte volte ci addentriamo nel mondo del Web, nella creazione di un proprio spazio personale che piano piano si evolve, ma non sempre adottiamo le giuste precauzioni ed i giusti accorgimenti per quanto riguarda la sicurezza. In questi casi, ci viene in aiuto sqlmap, un ottimo tool per l’analisi delle vulnerabilità presenti in molte applicazioni web che fanno uso di database SQL.

Introduzione a SQLmap

SQLmap è in grado di automatizzare il processo di analisi di vulnerabilità o exploit ai quali sono soggetti tantissimi server web. SQLmap è scritto in Python, il che lo rende indipendente dal sistema operativo utilizzato. Per funzionare, richiede solo in interprete Python in versione maggiore o uguale alla 2.5. Ho già introdotto in precedenti articoli (Hacking: SQL Injection, Difesa contro l’SQL Injection) il concetto di SQLInjection, tutti i pericoli che ne derivano e come difendersi progettando bene la propria applicazione web; ora vediamo come SQLmap riesce nell’analisi di SQLInjection in modo automatico e preciso. SQLmap implementa tre tecniche per l’analisi di vulnerabilità per l’SQL Injection:

Inferential blind SQL injection, also known as boolean based blind SQL injection: sqlmap appends to the affected parameter in the HTTP request, a syntatically valid SQL statement string containing a SELECT sub-statement, or any other SQL statement whose the user want to retrieve the output. For each HTTP response, by making a comparison based upon HTML page content hashes, or string matches, with the original request, the tool determines the output value of the statement character by character. The bisection algorithm implemented in sqlmap to perform this technique is able to fetch each output character with at maximum seven HTTP requests. This is sqlmap default SQL injection technique.
UNION query (inband) SQL injection, also known as full UNION query SQL injection: sqlmap appends to the affected parameter in the HTTP request, a syntatically valid SQL statement string starting with a UNION ALL SELECT. This techique is useful if the web application page passes the output of the SELECT statement to a for cycle, or similar, so that each line of the query output is printed on the page content. sqlmap is also able to exploit partial (single entry) UNION query SQL injection vulnerabilities which occur when the output of the statement is not cycled in a for construct whereas only the first entry output is displayed. This technique is much faster if the target url is affected by because in a single HTTP response it returns the whole query output or a entry per each response within the page content. This SQL injection technique is an alternative to the first one.
Batched (stacked) queries support, also known as multiple statements support: sqlmap tests if the web application supports stacked queries then, in case it does support, it appends to the affected parameter in the HTTP request, a semi-colon (;) followed by the SQL statement to be executed. This technique is useful to run SQL statements other than SELECT like, for instance, data definition or data manipulation statements possibly leading to file system read and write access and operating system command execution depending on the underlying back-end database management system and the session user privileges.

Uso di SQLmap

SQLmap è un tool molto potente quanto sofisticato. Il suo uso non è molto semplice ed immediato, ma vediamo di imparare ad usarlo con una guida passo passo. Ricordo che è possibile trovare un manuale molto completo sul sito ufficiale del progetto. Un primo sguardo all’uso del programma, può essere ottenuto con il comando python sqlmap.py -h da digitare nel proprio Terminale in Mac OS X o in una qualsiasi console di comando di un sistema operativo Linux o Windows. Questo comando restituisce una lista molto completa e dettagliata di tutti le opzioni di uso del programma.

Un’opzione molto valida è quella di ottenere un output del programma, analizzando i vari livelli di output. I livelli di verbosity (opzione -v) disponibili sono:

python sqlmap.py -u "http://172.16.213.131/sqlmap/mysql/get_int.php?id=1" -v 1

python sqlmap.py -u "http://172.16.213.131/sqlmap/mysql/get_int.php?id=1" -v 2

python sqlmap.py -u "http://172.16.213.131/sqlmap/mysql/get_int.php?id=1" -v 3

python sqlmap.py -u "http://172.16.213.131/sqlmap/mysql/get_int.php?id=1" -v 4

python sqlmap.py -u "http://172.16.213.131/sqlmap/mysql/get_int.php?id=1" -v 5

L’opzione -u specificata nel comando precedente è obbligatoria e serve per specificare l’indirizzo da analizzare. Alternativamente, può essere usata l’opzione –url.

python sqlmap.py --url "http://172.16.213.131/sqlmap/mysql/get_int.php?id=1"

Un’altra modalità di analisi, che non includa direttamente l’indirizzo web del sito da analizzare, è quella di specificare un file contenente una richiesta HTTP valida, che quindi SQLmap effettuerà analizzando i risultati (opzione -r). In questo caso, deve esistere un file contenente la richiesta HTTP in questo modo:

POST /sqlmap/mysql/post_int.php

HTTP/1.1 Host: 172.16.213.131

User-Agent: Mozilla/4.0

id=1

e quindi l’applicazione SQLmap dovrà essere eseguita nel modo seguente:

python sqlmap.py -r request.txt

Una funzionalità ancora più interessante, consiste nell’analizzare un intero sito web, alla ricerca di tutte le possibili vulnerabilità. Questa feature è possibile grazie all’appoggio di Google, che è in grado di restituire risultati relativi ad un singolo dominio specificando ulteriori opzioni (opzione -g del programma SQLmap). Il comando diventa quindi:

python sqlmap.py -g "site:yourdomain.com ext:php" -v 1

In questo caso SQLmap analizzerà i primi 100 risultati di Google relativi al dominio specificato, alla ricerca di risultati che contengano al loro interno richieste GET, in modo da poter verificare la presenza di possibili vulnerabilità.

SQLmap non è in grado di analizzare solo applicazioni web che fanno uso di richieste GET, ma anche quei servizi che per maggiore protezione, fanno uso di richieste POST. In questo caso entrano in gioco le opzioni –method e –data di SQLmap:

python sqlmap.py -u "http://test-site.it/test-page.php" --method POST --data "id=1"

Queste sono solo alcune situazioni di utilizzo di SQLmap, è possibile trovarne altre sul manuale ufficiale presente sul sito web del programma. Di seguito uno dei video ufficiali per l’uso del programma disponibili anch’essi sul sito web del programma:

Buddy System con MallocLab

nerthase — Sat, 27 Mar 2010 21:15:46 +0000

Dopo avervi parlato dei vari progetti che ho svolto recentemente in Università, voglio condividere con voi anche un progetto molto interessante che ho realizzato 2 anni fa. Si tratta di un allocatore di memoria, quindi di un argomento abbastanza di basso livello, non facilmente comprensibile ai più novizi. Questo progetto mi è stato assegnato durante il corso di Ingegneria degli Algoritmi dal mio caro prof. Camil Demetrescu, indubbiamente uno dei migliori professori che abbia mai incontrato.

Descrizione

Lo scopo del progetto è quello di realizzare un allocatore di memoria (usando il linguaggio C) e paragonarne l’efficienza con l’allocatore di memoria predefinito di sistema (la classica malloc in C). Per eseguire questi test ho usato un framework chiamato MallocLab che prende in input l’allocatore di memoria da me realizzato, esegue alcuni test su sequenze reali di malloc, free e realloc e assegna un punteggio all’allocatore, in base al suo comportamento rispetto all’allocatore di memoria di sistema.

Di seguito sono disponibili per il download il package di MallocLab ed un suo esempio di uso:

Dopo questa breve introduzione agli strumenti necessari per la comprensione di questo progetto, passo a parlarvi della mia soluzione. Come evidente nel titolo, la mia soluzione per l’allocatore di memoria è basata sulla tecnica del Buddy System.

Il Buddy System o buddy memory allocation è una tecnica di allocazione dinamica della memoria che divide la memoria in partizioni per soddisfare una richiesta di memoria nel miglior modo possibile. Questo sistema suddivide ricorsivamente la memoria in due metà finché il blocco ottenuto è grande appena a sufficienza per l’uso, cioè quando un’ulteriore divisione lo renderebbe più piccolo della dimensione richiesta.

Da questa definizione (tratta da Wikipedia) potete immaginare che il Buddy System lavori come un albero binario. Questo è evidente per quanto riguarda chiamate alla funzione malloc, mentre è meno intuitivo quando si libera una porzione di memoria con la funzione free. In questo caso, il blocco viene liberato, e se possibile, viene riunito con il blocco fratello (per questo è necessario immaginare che il Buddy System lavori come un grande albero binario).

Soluzione adottata

Di seguito un segmento della relazione del progetto, per capire meglio la tecnica utilizzata:

Soluzione adottata

Il progetto è stato sviluppato usando la tecnica del Buddy System Binario come strategia di allocazione di memoria.

Categorie e dimensioni dei blocchi

Nel Buddy System Binario adottato si hanno le stesse proprietà descritte nelle specifiche, in particolare, le categorie di blocchi, e quindi la dimensione dei blocchi utilizzati, è 2k con k = 6, 7, …, 24, (ovvero dimensioni che vanno da 64 Bytes, a 16 Mega Bytes).

Il limite inferiore di 64B è stato fissato perché sperimentalmente è stato trovato che non venivano effettuate eccessive richieste di blocchi di dimensione inferiore ai 64B.

Il limite superiore di 16MB è stato dettato dal driver, in quanto impone un limite di 20MB alla dimensione dell’heap, e quindi era inutile considerare blocchi di dimensione superiore ai 16 MB (ovvero 32MB, 64MB, …).

Per tenere traccia delle 19 categorie, viene mantenuto in memoria un array con indici da 0 a 18, e nella cella di posizione i dell’array, viene mantenuta una lista collegata dei blocchi liberi appartenenti a quella categoria.

Operazione di fusione di blocchi compagni

Nella soluzione adottata, inoltre, la fusione di blocchi compagni non viene effettuata appena possibile, ma viene effettuata ogni 1500 chiamate alla funzione mm_free; in particolare vengono esaminati tutti i blocchi liberi presenti in memoria, e si verifica se è possibile fonderli con i rispettivi compagni. In questo modo il costo medio della funzione mm_free diminuisce, in quanto solo una chiamata ogni 1500 provoca rallentamento dovuto alla fusione dei blocchi.

Informazioni di controllo

Il modo in cui vengono gestite le informazioni di controllo, differiscono leggermente a seconda dello stato del blocco:

Sia per i blocchi liberi che per i blocchi allocati, vengono mantenute informazioni necessarie per identificare il tipo e lo stato del blocco:

la categoria a cui il blocco appartiene, e quindi indirettamente la dimensione del blocco;
un valore che indica se il blocco è attualmente in uso o è libero.

Per i blocchi liberi oltre alle informazioni usate per i blocchi allocati (necessarie per identificare il tipo e lo stato del blocco), vengono mantenute delle informazioni per gestire le liste collegate dei blocchi liberi:

un valore che indica se il blocco ha un successore nella lista dei blocchi liberi della stessa categoria;
l’indirizzo del successore. Queste informazioni vengono mantenute secondo il seguente schema:
Le informazioni in rosso sono considerate per i soli blocchi liberi, in particolare, nei blocchi in uso, i 4 Byte riservati all’indirizzo del blocco successore nella lista collegata, diventano parte del Payload del blocco.

Vantaggi:

semplicità di implementazione, per quanto riguarda i controlli da effettuare;
allineamento agli 8 Byte implicito, in quanto una volta allineato il primo blocco, tutti gli altri risulteranno allineati perché tutti di dimensione multipla di 8 Byte;
velocità di esecuzione, dovuta soprattutto ai punti precedenti;
occupazione minima delle informazioni di controllo, che praticamente sono contenute in un solo Byte.

Svantaggi:

si hanno solamente 19 categorie, e l’intervallo tra una categoria e quella successiva non è minimale;
la memoria non utilizzata, ma allocata, in un blocco è al più pari alla metà della dimensione del blocco, in quanto per una richiesta di 2k + 1 Bytes, viene allocato un blocco di dimensione 2k+1 Bytes.

Implementazione in C

Di seguito il codice C del mio allocatore di memoria:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368

#include "mm.h"
#include "memlib.h"

team_t team = {
/* Team name */
"N Team",
/* First member's full name */
"nerthase",
/* First member's email address */
"webmaster@nerthase.com",
/* Second member's full name (leave blank if none) */
"",
/* Second member's email address (leave blank if none) */
""
};

typedef unsigned int u_int;

#define STRUCT_ELEM 19
#define STRUCT_ELEM_SIZE 4
#define STRUCT_SIZE ( STRUCT_ELEM * STRUCT_ELEM_SIZE )
#define HEADER_SIZE 1

#define PACK(index, state) ( ((index) | ((state) << 7)) & 0x9F ) //vedi righe seguenti per la struttura
#define SET_HEADER(addr, byte) { *(addr) = (byte); } //inserisce nel byte all'indirizzo addr, il byte byte
#define SET_NEXT(addr, next) { if ((next) != 0) { *(addr) = ((*(addr)) | 0x40); *((u_int *) ((addr) + HEADER_SIZE)) = (next); } else { *(addr) = ((*(addr)) & 0xBF); } } //imposta il next nel blocco di indirizzo addr

#define INDEX(header) ( (*((char *) (header))) & 0x1F ) //l'indice della categoria è nei 5 bit meno significativi del primo byte del blocco
#define STATUS(header) ( ((*((char *) (header))) & 0x80) >> 7 ) //lo stato è nel bit più significativo del primo byte del blocco
#define HAS_NEXT(header) ( ((*((char *) (header))) & 0x40) >> 6 ) //il bit che mi indica se un blocco ha un next, è il secondo bit del primo byte
#define NEXT(header) ( (HAS_NEXT((header))) ? ((char *) (*((u_int *) ((header) + HEADER_SIZE)))) : 0) //il next è nei byte 2-5 del blocco

//arg è la dimensione del blocco, res sarà l'indice dei blocchi più piccoli che possono contenere quella dimensione
#define SIZE2INDEX(res, size) { size_t _tmp = 32; for (res = 6 ; res < STRUCT_ELEM + 6 ; ++res) { _tmp = _tmp * 2; if (_tmp >= (size)) break; } res = res - 6; }

//esp è l'indice nella struttura, res sarà la dimensione dei blocchi a indice esp
#define INDEX2SIZE(res, index) { int _esp; int _i = (index) + 6; res = 32; for (_esp = 6 ; _esp <= _i ; ++_esp) { res = res * 2; } }

//calcola l'indirizzo di struct[i]
#define STRUCT(i) ( (heap_addr) + 4*(i) )

//inserisce un blocco nella struttura (in testa alla lista)
#define ADD_BLOCK(addr) { int _i = INDEX(addr); SET_NEXT((addr), (*((u_int *) (STRUCT(_i))))); *((u_int *) STRUCT(_i)) = ((u_int) (addr)); }

//rimuove il primo blocco di indice i, cancella l'header, e "ritorna" l'indirizzo del blocco appena eliminato
#define REMOVE_FIRST_BLOCK(b_addr, index) { b_addr = ((char *) (*((u_int *) STRUCT(index)))); *((u_int *) STRUCT(index)) = ((u_int) NEXT(b_addr)); SET_HEADER(b_addr, PACK(0, 0)); }

int c;
char *heap_addr;
size_t heap_size; //taglia dell'heap effettivo, quindi senza la struttura

char *get_buddy (char *addr)
{
size_t size;
u_int offset, min, max;
char *buddy;
INDEX2SIZE(size, INDEX(addr));

min = ((u_int) heap_addr) + STRUCT_SIZE;
max = ((u_int) heap_addr) + STRUCT_SIZE + heap_size;
offset = ((u_int) addr) - min;

if ( (offset % (size * 2)) == 0 )
{
buddy = addr + size;
}
else
{
buddy = addr - size;
}

//verifico se il buddy è nell'heap
if ( (u_int) buddy < min || (u_int) buddy >= max) return 0;

if ( INDEX(addr) != INDEX(buddy) ) return 0;
if ( STATUS(buddy) != 0) return 0;

return buddy;
}

void remove_block (char *addr)
{
int index = INDEX(addr);
char *p, *next;

p = (char *) (*((u_int *) STRUCT(index)));

if ( p == addr )
{
REMOVE_FIRST_BLOCK(p, index);
return;
}

//scandisco la lista fino a che non mi posiziono su blocco prima di quello da rimuovere
next = NEXT(p);
while (next != addr)
{
p = next;
next = NEXT(p);
}

//rimuovo il blocco
SET_NEXT(p, (u_int) NEXT(addr));
//elimino le informazioni dal blocco
SET_HEADER(addr, PACK(0, 0));
}

int coalesce (char *addr)
{
char *buddy, *new_addr;
int index = INDEX(addr) + 1;
if (index == 1) return 0;

//trovo il buddy
buddy = get_buddy(addr);
if (buddy == 0) return 0;

//stabilisco come sono ordinati
new_addr = (buddy > addr) ? addr : buddy;

//li rimuovo
remove_block(buddy);
remove_block(addr);

//inserisco il blocco di dimensione doppia
SET_HEADER(new_addr, PACK(index, 0));
ADD_BLOCK(new_addr);

return 1;
}

void split (int i) //Splitta il primo blocco di indice i nella struttura
{
char *b_addr;
char *addr1, *addr2;
size_t size;
INDEX2SIZE(size, i - 1);

//rimuovo il blocco dalla struttura
REMOVE_FIRST_BLOCK(b_addr, i);

//splitto il blocco
addr1 = b_addr;
addr2 = b_addr + size;

//preparo i due nuovi blocchi e li inserisco nella struttura
SET_HEADER(addr1, PACK(i - 1, 0));
ADD_BLOCK(addr1);

SET_HEADER(addr2, PACK(i - 1, 0));
ADD_BLOCK(addr2);
}

void expand_heap ()
{
int index;
char *new;
size_t max;
INDEX2SIZE(max, 18);

if (heap_size < max)
{
new = (char *) mem_sbrk(heap_size);
//inserisco il nuovo blocco nella struttura
SIZE2INDEX(index, heap_size);
SET_HEADER(new, PACK(index, 0));
ADD_BLOCK(new);
heap_size = heap_size * 2;
}
else //vuol dire che l'heap è arrivato a 16M, quindi posso permettermi solo altri 4M (quasi :D)
{
size_t size;
INDEX2SIZE(size, 11); //alloco blocchi di dimensione fissa 128k (11)
new = (char *) mem_sbrk(size);
SIZE2INDEX(index, size);
SET_HEADER(new, PACK(index, 0));
ADD_BLOCK(new);
if(coalesce(new));
heap_size = heap_size + size;
}
}

int find_block (size_t size) //trova un blocco libero che può contenere size byte e ne restituisce l'indice, altrimenti -1
{
int i, index;
size_t b_size;
SIZE2INDEX(index, size); //ottengo l'indice del blocco più piccolo che può contenere size byte

search:
//trovo il primo blocco disponibile
for (i = index ; i < STRUCT_ELEM ; ++i)
{
INDEX2SIZE(b_size, i); //ottengo la taglia dei blocchi di indice i
if (b_size > heap_size) //se sono di taglia maggiore della dimensione dell'heap, devo sicuramente espandere
{
expand_heap();
if ((i = i - 2) == index - 2) i = index - 1; //riaggiusto gli indici in modo da riconsiderare il blocco appena creato
}
else
{
if ( *(STRUCT(i)) == 0); //se non ci sono blocchi nella struttura di dimensione adeguata, continuo a cercare oltre
else
{
break;
}
}
}
if (i == STRUCT_ELEM) //return -1;
{
expand_heap();
goto search;
}

//splitto il blocco fino ad arrivare ad uno di dimensione b_size
for ( ; i > index ; --i) split(i);

return index;
}

int mm_init(void)
{
int i;
u_int *p;

//allineo l'heap a 8 byte (in realtà allineo la parte del blocco che restituisco nella malloc)
for (i = 1 ; i <= 8 ; ++i)
{
u_int tmp = (u_int) mem_sbrk(1); //alloco un byte per volta
if (((tmp + STRUCT_SIZE) % 8) == 6) break;
//quando il byte allocato ha come resto 6, significa che il prossimo blocco allocato sarà allineato a 7 byte
//ma l'indirizzo che restituisco nella malloc, sarà allocato quindi a 8 byte come richiesto
}

INDEX2SIZE(heap_size, 6);
heap_addr = (char *) mem_sbrk(STRUCT_SIZE + heap_size);

for (i = 0 ; i < STRUCT_ELEM ; ++i)
{
//scrivo 0 in tutte le celle della struttura (4 byte)
*((u_int *) STRUCT(i)) = 0;
}

SIZE2INDEX(i, heap_size); //trovo l'indice del blocco di dimensione heap_size
p = (u_int *) STRUCT(i); //ottengo l'indirizzo all'interno della struttura dei blocchi di quella dimensione

*p = (u_int) (heap_addr + STRUCT_SIZE); //inserisco il primo blocco allocato, quello di dimensione heap_size
SET_HEADER((char *) *p, PACK(i, 0)); //imposto adeguatamente l'header del blocco

return 0;
}

void *mm_malloc(size_t size)
{
char *block;
int index;

index = find_block(HEADER_SIZE + size);
if (index == -1) return NULL;

REMOVE_FIRST_BLOCK(block, index);
SET_HEADER(block, PACK(index, 1));

return block + 1;
}

void mm_free(void *ptr)
{
char *b_addr = ((char *) ptr) - 1;
int index = INDEX(b_addr);

SET_HEADER(b_addr, PACK(index, 0));
ADD_BLOCK(b_addr);

if ((++c % 1500) == 0)
{
int i;
char *addr = 0;

for (i = 0 ; i < STRUCT_ELEM ; ++i)
{
addr = (char *) (*((u_int *) STRUCT(i)));

while (1)
{
char *tmp = addr;
if (addr == 0) break;
addr = NEXT(addr);
coalesce(tmp);
}
}
}
}

void split_2 (char *block) // Splitta un blocco che non è nella struttura
// In particolare lascia la prima metà di blocco invariata
// e la seconda la azzera e la inserisce nella struttura
{
char *addr1, *addr2;
size_t size;
int i = INDEX(block);
INDEX2SIZE(size, i - 1);

//splitto il blocco
addr1 = block;
addr2 = block + size;

// Il primo blocco cambia solo di dimensione
SET_HEADER(addr1, PACK(i - 1, 1));

// Il secondo invece viene anche inserito nella struttura
SET_HEADER(addr2, PACK(i - 1, 0));
ADD_BLOCK(addr2);
}

void *mm_realloc(void *ptr, size_t new_size)
{
char *old = ((char *) ptr) - 1;
char *new;
size_t old_size, const_old_size;
int i;
int old_index = INDEX(old);

//ottengo la taglia del blocco vecchio
INDEX2SIZE(old_size, old_index);
const_old_size = old_size;

if (new_size < old_size && new_size > (old_size / 2)) return old + 1;

if (new_size < old_size) //sono sicuro che è anche minore della metà
{
int new_index;
SIZE2INDEX(new_index, new_size); //è sicuramente minore di old_index

for (i = old_index ; i > new_index ; --i) split_2(old);

return old + 1;
}

while (new_size >= old_size) // vedo se posso fare il coalesce con il blocco alla sua destra
{
char *buddy = get_buddy(old);
if ((u_int) buddy == 0 || (u_int) buddy < (u_int) old) goto nuovo;
else //posso unire i 2 blocchi
{
remove_block(buddy);

old_size = old_size * 2;
old_index = old_index + 1;

SET_HEADER(old, PACK(old_index, 1));
}
}

// se arrivo qui, significa che facendo il coalesce progressivo di blocchi vicini, sono arrivato ad un blocco della taglia desiderata :D
return old + 1;

nuovo: // non posso fare altro che allocare un nuovo blocco e copiare il contenuto
new = mm_malloc(new_size);

for (i = 0 ; i < const_old_size ; ++i)
{
*(new + i) = *(old + 1 + i);
}

mm_free(ptr);
return new;
}

Lo sviluppo di questo progetto mi ha richiesto molto tempo e fatiche, ma devo dire che ne è valsa indubbiamente la pena, in quanto ho scoperto che il C è un linguaggio dalle potenzialità infinite. Concludendo, vi metto a disposizione per il download, il mio allocatore e la relazione (molto semplice) che ho scritto per presentare il progetto:

Se avete dubbi o domande su tecniche utilizzate, non fatevi alcun problema a chiedere.

Creare RSS per tutti i siti

nerthase — Tue, 16 Mar 2010 21:24:26 +0000

Spesso mi capita di dover seguire siti web di alcuni miei professori, che non hanno a disposizione i feed RSS. Fino ad oggi usavo alcuni siti web che promettono di controllare gli aggiornamenti della pagina al posto tuo, e di notificarti le novità. Questi siti però non hanno una vita lunga, anzi, spesso funzionano per poco tempo, fino a quando hanno un numero limitato di utenti. Oggi invece ho scoperto Feedity.

Feedity è un servizio web che crea i feed RSS anche per i siti che non li mettono a disposizione. Questa funzionalità è molto utile, in quanto ognuno di noi può creare un feed RSS per un sito di interesse, e soprattutto possono essere effettuate molte personalizzazione.

La cosa più interessante di questo servizio, è la creazione di un canale di feed personale, per ogni sito che si desidera monitorare. Sarà quindi possibile seguire i propri feed (creati tramite Feedity) con il lettore di RSS che si preferisce. Unica nota dolente, è che l’account gratuito notifica un massimo di 10 aggiornamenti per pagina, non immediatamente, ma ogni 5 ore.

Il funzionamento del sito è talmente semplice ed intuitivo che non necessita di alcuna spiegazione. Potete valutare voi di persona, ed in caso di problemi, cercheremo di trovare una soluzione.

L’ADSL in alcune parti non arriverà mai…

nerthase — Sat, 06 Mar 2010 18:56:50 +0000

La telecom ha pubblicato di recente una pagina Web dove poter consultare gli elenchi aggiornati delle zone coperte da ADSL. Questo progetto portato avanti da Telecom da diverso tempo, si chiama Anti Digital Divide.

A vederlo così, sembra tutto rose e fiori per gli sfortunati come me ancora non raggiunti da ADSL. Invece, molti dei comuni del Lazio che sono in lista (parlo per la mia provincia), hanno la copertura ADSL già da diversi anni, e soprattutto, una copertura che è stata fornita al di fuori del progetto Anti Digital Divide. Forse hanno pubblicato questo piccolo elenco per accendere le speranze degli “scoperti”, o per far credere che stanno lavorando per noi.

Con pochissima fiducia, ho consultato l’elenco della mia regione, ed ho visto che il mio comune, ancora non è in lista. Con ancor meno fiducia, ho fatto la verifica di copertura mediante l’apposito servizio, e mi ha dato lo stesso risultato.

In attesa di una svolta, visto che anche il WiMax sembra non arrivare mai, continuo a dare i miei 12 euro mensili a Telecom per una 56k più che insoddisfacente.

PhotoShop bloccato in “Reading Preferences”

nerthase — Sat, 27 Feb 2010 21:58:58 +0000

Le mie disavventure con la suite di programmi Adobe non avranno mai fine. Dopo l’errore 150:30 ed i problemi di licenza in DreamWeaver, oggi aprendo PhotoShop CS4, il programma rimane bloccato e non si avvia. PhotoShop rimane bloccato durante l’avvio, e lo Splash Screen iniziale è fermo durante il passo “Reading Preferences“.

Non resta che forzare l’uscita del programma. Questo errore è causato da un errore nella lettura delle preferenze e impostazioni di PhotoShop. La soluzione a questo problema è un po’ drastica, in quanto comporta l’eliminazione delle preferenze di PhotoShop.

Per risolvere questo problema dobbiamo individuare sulla tastiera i tasti CMD, ALT e SHIFT (per Windows premere i tasti CTRL, ALT e SHIFT) e tenerli premuti durante il prossimo avvio di PhotoShop. Vi verrà chiesto se volete veramente cancellare le impostazioni. Rispondete SI ed avrete il vostro PhotoShop nuovamente funzionante.

Io personalmente non ho impostazioni di fondamentale importanza in PhotoShop, ma se qualcuno di voi lo usa quotidianamente per lavoro, potrebbe trovare questa soluzione improponibile. Se conoscete una soluzione meno drastica, vi prego di comunicarmela.

Grazie

jDownloader: RapidShare e MegaUpload senza limiti

nerthase — Sat, 27 Feb 2010 21:14:08 +0000

jDownloader è un utilissimo programma open source scritto completamente in Java, e quindi compatibile con tutti i sistemi operativi che lo supportano. Il suo scopo è quello di scaricare file da siti come RapidShare e MegaUpload, ma anche tanti altri come loro. jDownloader si occuperà di attendere la disponibilità del download al posto nostro, ed effettuerà anche il bypass dei codici CAPTCHA spesso utilizzati da siti del genere.

Ma le novità e le potenzialità di jDownloader non sono finite qui. Esso infatti è in grado di effettuare il download di filmati di YouTube, MegaVideo e quanto altro possiate immaginare. Inoltre ha anche l’opzione per effettuare i download usufruendo di un account premium in vostro possesso. E se invece non possedete un account premium, jDownloader si occuperà di effettuare un cambio di IP per il vostro computer, in modo da evitare controlli e barriere applicati da alcuni siti di File Sharing.

Dopo questa breve panoramica per questo meraviglioso software, veniamo ad una breve guida di configurazione ed utilizzo:

Dopo l’installazione, è necessario settare alcune impostazioni iniziali per l’utilizzo del software,

Impostiamo il percorso per i nostri download ed il comportamento che jDownloader dovrà adottare per i file scaricati. Queste semplici impostazioni sono già sufficienti per iniziare ad effettuare il download dei nostri file.

Come vi dicevo prima, jDownload è in grado di cambiare l’IP del nostro computer mediante una riconnessione del router. Questa impostazione è molto utile nel caso di siti di File Sharing che effettuano controlli su IP. Basterà individuare il modello del nostro router, selezionare “Ottieni IP router” ed infine “Crea script di riconnessione“. Automaticamente jDownloader creerà uno script ad hoc per il nostro router in grado di effettuare una riconnessione, e quindi il cambio di IP.

Per chi di noi possiede un account premium, può usarlo tramite jDownloader per scaricare al massimo della velocità con il massimo della comodità. Sono supportati più di 100 servizi di Hosting.

jDownloader ha la possibilità di intercettare il contenuto degli appunti di sistema. In pratica ci basterà individuare su internet l’elenco dei link del file che vogliamo scaricare, copiarli e spostarci su jDownloader. Il programma avrà già intercettato i nostri appunti, e sarà in corso l’analisi dei link. Se al termine dell’analisi i file che si desidera scaricare sono tutti online, basterà premere il tasto “Continua” per iniziare il download.

jDownloader è in grado di estrarre i file una volta scaricati, anche se protetti da password, e di unirli in un unico file, come da origine. Voi non dovrete fare assolutamente nulla.

. . .

jDownloader è un software molto completo e funzionale. Lo sviluppatore rilascia continui aggiornamenti, che ne garantiscono il funzionamento continuo. Adesso vi lascio alcuni link per il download del programma e delle dipendenze necessarie:

Generatore di Password

nerthase — Sat, 27 Feb 2010 00:09:13 +0000

Dopo aver visto come creare una password sicura, e come evitare di farsi rubare la propria password, non poteva mancare un programma per la generazione di password robuste, ma allo stesso tempo facili da ricordare.

Il programma da me realizzato, si chiama Mnemonic Password Generator, e ha lo scopo di generare una password diversa per ogni servizio che voi utilizzate. Questa password inoltre, sarà basata su vostri dati personali, e quindi facile da ricordare. Ad esempio, basterà dire al programma che io mi chiamo Mario, nato a Settembre, e che voglio una password per Twitter, ed una possibile password che il programma mi proporrà, potrebbe essere mario09twitter. Come potete vedere questa password è molto facile da ricordare, ma ha tutti gli elementi necessari per durare a lungo contro attacchi di hacker, cracker e malintenzionati.

Mnemonic Password Generator è stato realizzato in Java ed offre tutte i controlli necessari a personalizzare la propria password preferendo facilità o sicurezza. Il programma non fa alcun uso delle password generate e/o dei dati inseriti. Questi ultimi sono richiesti al solo scopo di generare una password che sia adatta a voi, e quindi facile da ricordare. MPG (sigla del programma) memorizza i dati da voi inseriti (ma non la password) in un file temporaneo sul vostro computer. L’unico scopo di questo salvataggio, è di evitarvi di riempire tutti i campi ogni volta. Potete, comunque, in qualunque momento eliminare il file contenente questi dati.

Il programma Mnemonic Password Generator è disponibile per il download per diverse piattaforme:

Mnemonic Password Generator compatibile con Windows XP / Vista / Seven

Non necessita di installazione. Applicazione portabile.

Mnemonic Password Generator compatibile con Mac OS X v10.5 e successive

Versione sviluppata su piattaforma Mac OS X 10.6 e quindi pienamente compatibile.

Mnemonic Password Generator compatibile con Linux ed altre piattaforme

Versione Universal Binary dell’applicazione. Funziona su qualsiasi sistema.

Per malfunzionamenti o problemi di vario genere, sono a vostra completa disposizione.

Password: come evitare il Crack

nerthase — Fri, 26 Feb 2010 00:33:46 +0000

Dopo avervi parlato del Brute Force, delle sue applicazioni e avervi rilasciato un esempio di codice Java che lo implementa, vi voglio parlare delle PASSWORD, della loro importanza, e soprattutto dell’attenzione che bisogna avere al momento di sceglierne una.

Analizziamo prima alcuni dati fondamentali:

Con un semplice programma Java, un tentativo di login presso un sito richiede meno di un secondo;
La lunghezza media delle password più usate è di 6 caratteri (il minimo che forum come phpBB permettono);
Se nella password di 6 caratteri sono usati solo numeri (data di nascita) i casi possibili sono 10⁶ = 1000000;
Se nella password di 6 caratteri sono usate solo lettere, i casi possibili sono 21⁶= 85766121;
Se la password è una parola italiana di senso compiuto, abbiamo questi valori relativi alla lunghezza:
- Parole italiane di 6 caratteri: 13545
- Parole italiane di 7 caratteri: 25802
- Parole italiane di 8 caratteri: 35409
- Parole italiane di 9 caratteri: 46069
- Parole italiane di 10 caratteri: 47932

Detto questo, i conti sono presto fatti. Un possibile malintenzionato, sicuramente partirebbe a tentare le password che richiedono il minor numero di tentativi:

Attacco a dizionario

Questo tipo di attacco, è uno dei più semplici ma anche dei più riusciti. Se non vi sembra possibile, provate a ricordare, se avete mai pensato di inserire come password il nome di un vostro animale preferito, della vostra ragazza, della vostra auto preferita, e molto altro ancora… Tutte queste parole in genere sono presenti nel dizionario italiano, o in alcuni dizionari che Hacker o Cracker si costruiscono arricchendo il dizionario italiano, con parole aggiuntive, che potrebbero essere usate come password.

Facendo due rapidi calcoli, l’attaccante impiegherebbe:

Password di 6 caratteri: 13545 tentativi x 1 secondo = 13545 secondi = quasi 4 ore
Password di 7 caratteri: 25802 tentativi x 1 secondo = 25802 secondi = quasi 8 ore
. . .

Vediamo subito che in un giorno, la nostra password potrebbe essere facilmente violata. Per questo è sempre consigliabile adottare password che non sono presenti in un dizionario, o combinare due parole di senso compiuto, o alternare parole e numeri. In pratica allungare la password, e spaziare tra caratteri e numeri.

Attacco a Forza Bruta (Brute Force)

Questo tipo di attacco, sicuramente è conosciuto da tutti, se non altro per il mio precedente articolo. In questo caso l’attaccante proverà inizialmente password numeriche, perché come ben sapete, molti di noi ancora usano come password la propria data di nascita. Purtroppo proprio queste password, sono quelle che vengono violate più spesso, non da attaccanti esterni, ma da conoscenti che si divertono ad incasinare la vita altrui.

Comunque, un possibile attaccante questa volta impiegherebbe:

Password di 6 caratteri composta da soli numeri: 10⁶ tentativi x 1 secondo = più di 10 giorni
Password di 6 caratteri composta da sole lettere: 21⁶ tentativi x 1 secondo = più di 2 anni

Questi valori così elevati non devono affatto rassicurarvi, perché come vedremo più avanti, l’ipotesi di impiegare un secondo per tentare una password, è si realistica, ma molto obsoleta.

Phishing

Questo tipo di attacco, è uno dei più subdoli che possa esistere. Basato sull’Ingegneria Sociale, trae l’utente in inganno, in modo che sia egli stesso a fornire la password all’attaccante. Ormai si sentono notizie tutti i giorni su persone cadute in un attacco del genere. Il problema più grande, è generato dal fatto che questo attacco è semplicissimo da applicare, e che le persone non prestano mai attenzione quando forniscono i propri dati personali.

Il phishing in pratica consiste nel creare una falsa pagina di login (ad esempio una copia esatta della pagina di login del sito delle poste) e fornirla agli utenti in svariati modi (e-mail, forum, newsletter etc…). L’utente, ad esempio, riceve una e-mail in cui gli viene gentilmente chiesto di controllare periodicamente il suo conto Banco Posta presso il link fornito (che non punterà al sito delle Poste Italiane, ma bensì alla falsa pagina di login creata dall’attaccante). L’utente, riconoscendo visivamente la pagina di login, inserirà senza problemi i propri dati personali. Ed è qui, che ha perso tutto quello che possedeva.

Per evitare questo tipo di attaccho, basta prestare attenzione ai link che si visitano, e soprattutto all’URL della pagina nella quale forniamo i nostri dati. Verifichiamo che sia sempre la giusta pagina, e possibilmente, che usi il protocollo https.

Attacco distribuito

Questo non è un vero e proprio attacco, ma è un’evoluzione dei primi due attacchi che abbiamo visto. Infatti, per ridurre i tempi per portare a segno un attacco, non si usa un solo computer, ma se ne usano diversi, dividendosi i compiti. Se avete letto il mio recente articolo sul Puzzle Distribuito sapete di sicuro di cosa vi sto parlando.

In pratica, con un attacco a dizionario per parole di 6 lettere, usando un solo computer, venivano impiegate 4 ore. Se lo stesso attacco, fosse portato a compimento usando 4 computer, e dividendosi equamente le 13545 parole di 6 lettere, impiegherebbe solamente un’ora. Usando ancora più computer, questo attacco potrebbe impiegare pochi minuti. Un miglioramento di prestazioni elevato però, potrà essere quantificabile solo se il numero dei computer coinvolti è molto elevato. Pensate che un attacco a Forza Bruta usando caratteri e numeri potrebbe essere compiuto in meno di un giorno, invece dei 2 anni precedentemente calcolati.

Se vi state domandando come possano, eventuali Hacker o Cracker avere a disposizione una simile potenza di calcolo, vi dico un solo termine: Trojan. Sicuramente nella vostra vita, avete ricevuto almeno un allarme dall’antivirus, in cui vi veniva notificata la presenza di un Trojan all’interno del vostro computer. I Trojan non sono veri e propri virus che infettano e/o compromettono il vostro computer. Bensì sono dei cavalli di Troia che possono eseguire all’interno del vostro computer operazioni senza il vostro consenso. Spesso questi Trojan infettano milioni di computer restando apparentemente innocui per un lungo periodo di tempo. Infatti, è dopo aver infettato il giusto numero di macchine, che questi Trojan entrano in azioni, comandati da un Server centrale. Il Server comunicherà quindi ai Trojan il sito bersaglio, dividerà le possibili password tra i vari computer infettati, e l’attacco sarà compiuto in un batter d’occhio. Se ci pensate bene, è lo stesso sistema che ho usato io nella realizzazione del Puzzle Distribuito. Un semplice e banale sistema, che però può compromettere la sicurezza di intere strutture, in un tempo brevissimo.

Dopo essermi tanto dilungato, concluderei semplicemente con il consigliarvi di utilizzare password abbastanza robuste, che non siano individuabili con un semplice attacco a dizionario o Brute Force usando solo lettere o numeri. Usate sempre lettere E numeri, e perché no, anche qualche carattere speciale. Tanto i tasti della tastiera li abbiamo pagati tutti, quindi perché non usare anche il simbolo § che altrimenti non sappiamo mai dove mettere?

Google, YouTube, Wikipedia insieme in People Finder

nerthase — Tue, 23 Feb 2010 16:11:24 +0000

Oggi voglio condividere con voi il progetto che ho realizzato con alcuni compagni di Università qualche tempo fa. People Finder, questo è il nome del progetto, nasce dall’esigenza di molti di avere a disposizioni informazioni di diverso genere a natura, tutto su un’unica pagina Web.

People Finder realizza proprio questo. People Finder permette di effettuare ricerche su personaggi famosi (ma potete spaziare su qualsiasi genere vogliate), e restituisce i risultati della ricerca, interrogando a sua volta Google Immagini, YouTube e Wikipedia. Come potete vedere dall’immagine seguente, tutte le informazioni vengono visualizzate in una singola pagina, e messe così a completa disposizione dell’utente finale. In particolare, in People Finder, potrete navigare tra le prima 16 immagini restituite da Google inerenti al personaggio desiderato, o tra 4 video dello stesso, ognuno avente un diverso criterio di valutazione, il tutto effettuando una sola ricerca, e su una sola pagina.

People Finder è stato realizzato in Java ed usa diverse librerie esterne per la gestione di Google, YouTube ed altro ancora. Per essere reso disponibile a tutti gli utenti, senza necessità di software di installazione, è stato sviluppato con tecnologia Web, e quindi il fulcro di People Finder è proprio la pagina JSP che si visualizza al momento della ricerca.

Come potete vedere nel video seguente, la navigazione tra le immagini ed i video è veramente immediata ed intuitiva. Inoltre viene messa in risalto la descrizione iniziale che Wikipedia offre del personaggio cercato. Nel resto della pagina, viene riportato il contenuto della pagina di Wikipedia, ovviamente ripulita e riorganizzata. People Finder è stato progettato e realizzato avendo cura di occupare il minor numero di risorse possibile, soprattutto per quanto riguarda la banda a disposizione.

Ma non è finita qui. People Finder può essere usato anche senza una connessione internet. Infatti è disponibile un piccolo applicativo da poter usare sul proprio computer, che permette di effettuare ricerche, di qualsiasi genere, e fornire i risultati interrogando la base documentale precostruita. Questa base documentale può essere completamente personalizzata, arricchita e adattata alle proprie esigenze. Quando si effettuano modifiche alla base documentale, c’è bisogno di ricostruirla per poter poi essere di nuovo utilizzata. Questo è l’unico momento in cui è necessaria una connessione internet.

I documenti all’interno della base documentale, vengono prelevati direttamente dal Web, utilizzando il portale di People Finder, ma questa volta limitandosi ai soli risultati di Wikipedia. Una volta collezionati questi documenti, vengono indicizzati esattamente nello stesso modo utilizzato da Google, ma con algoritmi diversi. Sarà quindi possibile effettuare ricerche libere, senza essere vincolati a ricercare esattamente il personaggio desiderato. L’utilizzo del software è mostrato nel seguente video.

People Finder è stato realizzato come progetto universitario, ma come potete vedere ha tutte le caratteristiche e potenzialità per essere usato e distribuito nel mondo reale. Avere una galleria di immagini, una galleria di video e la descrizione accurata e controllata di Wikipedia come risultato della ricerca, il tutto in una sola pagina, è per molti ancora un’utopia, che costringe ad effettuare più volte la stessa ricerca, per ottenere risultati di natura diversa, offerti da portali diversi.

Rubik’s 360

nerthase — Tue, 23 Feb 2010 13:24:03 +0000

Sono sempre stato un appassionato dei giochi d’ingegno e per i rompicapo in generale, e tra questi, non poteva di certo mancare il famosissimo Cubo di Rubik. Ma da un po’ di tempo, Rubik, ha tirato fuori il suo nuovo rompicapo, chiamato Rubik’s 360. A differenza dei precedenti, non si presenta come un cubo, ma come una sfera, da cui il nome “360″. Scopo di questo rompicapo non è dunque quello di allineare dei cubetti, ma di portare sei palline (i colori sono gli stessi delle facce dei cubi delle altre edizioni) nelle sezioni esterne della sfera.

Com’è fatto il Rubik’s 360:

Questo rompicapo è costituito da tre sfere concentriche:

la prima sfera presenta un foro e contiene, nella posizione iniziale, le sei palline. Queste possono passare attraverso il foro per raggiungere la seconda sfera
la seconda sfera possiede due fori, ciascuno dei quali permette alle palline di raggiungere le sezioni esterne di un emisfero della terza sfera
la terza sfera possiede sei sezioni esterne, abbinate dal colore alle palline, e due sezioni rotanti nere che permettono di intrappolare le palline che hanno raggiunto la loro destinazione.

Ciò che rende complicata la risoluzione del gioco è la presenza di alcuni contrappesi nelle prime due sfere che mantengono i fori al di sopra dell’asse di rotazione. È necessario capire in che modo essi agiscano per consentire alle palline di vincere la forza di gravità e proseguire verso le sezioni esterne. Per questo rompicapo, dunque, non esistono calcoli combinatori per studiare la disposizione delle palline.

Dopo questa breve spiegazione sulla struttura e sui segreti del Rubik’s 360, vi faccio vedere come si presenta una volta risolto. Risolvere questo rompicapo è molto più semplice che risolvere il Cubo di Rubik. Quando si ha in mano il Rubik’s 360, basterà ruotarlo con calma, e dopo alcuni tentativi, si capisce immediatamente il segreto per invertire la gravità all’interno della sfera. Infatti, tutto il segreto sta nel fare in modo che i buchi delle sfere interne vadano in basso, in modo da permettere alle palline di fuoriuscire.