PROGETTO E REALIZZAZIONE DI UNO STRUMENTO PER L'ACQUISIZIONE E TRASMISSIONE DI DOCUMENTI WEB

1. UNIVERSITA’ DEGLI STUDI DI TRIESTE
______________________
FACOLTA’ DI INGEGNERIA
Corso di Laurea in Ingegneria Informatica
TESI DI LAUREA
in
PROGRAMMAZIONE WEB
PROGETTO E REALIZZAZIONE DI UNO
STRUMENTO PER L'ACQUISIZIONE E
TRASMISSIONE DI DOCUMENTI WEB
Laureando: Relatore:
Gabriele Formisano Prof. Ing. Eric Medvet
_________
Anno Accademico 2011/2012
1

2. INDICE
Introduzione………………………………3
1Motivazioni…………………………….4
2Progettazione…………………………8
3Realizzazione……………………………11
4Server e Test…………………………….22
Appendice
Bibliografia
2

3. Introduzione
Negli ultimi anni il web è entrato sempre più nelle nostre
vite, ormai gran parte dell’informazione e dei servizi
consumati dalle persone passa attraverso esso, infatti il
web ogni giorno si arricchisce con nuove tecnologie che lo
migliorano sia nell’inte rfaccia visiva e nell’usabilità
sia introducendo nuove funzionalità sempre più complesse. Al
contempo però l’utilizzo del web può mettere in “pericolo”
sia l’utente che visualizza i contenuti e utilizza i
servizi, sia gli amministratori che gestiscono i si ti web
dove questi risiedono. Infatti sono frequenti attacchi da
parte di entità esterne che mirino a distorcere le
informazioni, attraverso modifiche illecite, contenute nei
siti web che all’acquisizione di dati personali, anche
sensibili, come password p er conti correnti e carte di
credito, agli inconsapevoli utenti.
L’obiettivo di questa tesi è l’implementazione di un
software che possa aiutare al rilevamento di questi ed altri
tipi di attacchi, aiutando al contempo sia l’utente che
l’amministratore del sito web a salvaguardare la propria
sicurezza on -line, infatti si tratterà della progettazione e
della realizzazione di uno strumento per l'acquisizione e la
trasmissione di documenti web e di come questo possa essere
utilizzato nel campo della sicurezza s ul web.
Nella prima parte si andranno ad esporre le motivazioni che
hanno spinto alla realizzazione di questo strumento, la
tematica del capitolo riguarderà la descrizione di alcuni
tipi di attacco che un sito web può subire e le contromisure
che si posson o adottare.
L'argomento della seconda parte riguarderà l a fase di
progettazione, verranno presentate le caratteristiche che lo
strumento dovrà avere e quale tipologia di dati dovrà
generare.
La terza parte sarà dedicata alla fase di realizzazione
dello strumento, per cui verranno descritte le scelte che si
sono fatte durante la fase di sviluppo, le tecnologie
utilizzate ed analizzati gli algoritmi e i protocolli di
comunicazione usati.
3

4. Nella quarta parte verranno descritti i test effettuati e i
risultati ottenuti.
1. Motivazioni
Lo strumento che si vorrà realizzare si andrà ad inserire in
un progetto sullo studio di rilevazioni di attacchi
informatici a siti web dal “Machine Learning Lab” del
dipartimento DIA dell’Università di Trieste. In questo
capitolo andremmo a descrivere alcune delle tipologie di
attacco che un sito web può subire e per alcune di queste
descrivere quali siano le possibili contromisure. Ora
andremmo ad esporre e comprendere le motivazioni che hanno
spinto allo sviluppo dello strumento.
Queste motivazioni possono essere divise in due gruppi:
1. Ricerca: sono attacchi poco conosciuti, tendenzialmente
sono innocui all’utente, ma sono molto difficili da
rilevare da parte di un amministratore di un sitoe
posso portare a risultati imprevisti. Si tenterà di
esporre una metodologia per contrastarli. Sono il
principale motivo che hanno spinto alla creazione del
suddetto studio.
2. Pratica:sono attacchi comuni e si conosco già sia gli
effetti che alcune tipologie di contromisure, in quest o
caso si andrà a descrivere quale possa essere
l’utilizzo dello strumento in questi determinati casi.
1.1. Motivazioni di Ricerca
1.1.1. Searchredirection
Un attacco di SearchRedirection avviene quando un utente
proveniente da una pagina dei risultati di un motore di
ricerca viene reindirizzato ad un sito web scelto
dall'attaccante. Il server web compromesso identifica
automaticamente queste richieste in base al Referrer
4

5. dell'header HTT P, che assume valori speciali quando la
pagina precedente visitata è una pagina dei risultati di un
motore di ricerca. In caso contrario, il server web
restituisce il contenuto originale. L'attacco
SearchRedirection può essere difficilmente rilevato
dall'amministratore del sito, che di solito lo visita senza
provenire da una pagina dei risultati di un motore di
ricerca.
1.1.2. Search spam
Un attacco Search Spam consiste invece nell'aggiunta di
contenuto illegittimo ad un sito web esistente. L'aggiunta
può essere costituita da una porzione di pagina o da una
pagina intera che di solito contiene uno o più link ad un
altro sito web scelto dall'attaccante. Questo attacco mira
deliberatamente a manipolare i risultati dei motori di
ricerca, dal momento che gli a lgoritmi di ranking, come ad
esempio PageRank, dipendono anche dal numero e dalla
rilevanza di link in entrata.
Attacchi di questo tipo in siti web di interesse pubblico
potrebbe essere molto pericolosi. In primo luogo, essi sono
difficili da individuare, perché gli amministratori del sito
non saranno mai in grado rilevare alcuna anomalia nel
contenuto servito. Seconda e più importante, gli utenti
visualizzeranno il contenuto di un sito attendibile senza
sospetti, nemmeno l'utilizzo di protocolli crittog rafici,
come HTTPS sarebbe di aiuto agli utenti, perché il
TransportLayer Security autentica il server del sito nel suo
complesso. Infatti, questi attacchi possono potenzialmente
creare uno scenario molto strano.
Come si diceva in precedenza queste due tipologie di attacco
hanno portato alla creazione di uno studio precedentemente
citato; quello che si pensa è che, analizzando il codice
delle pagine web, in particolare la struttura del D OM Tree,
si possano rilevarli e contrastarli evitando così spiacevol i
inconvenienti per l’utente.
5

6. 1.2. Motivazioni Pratiche
1.2.1. Web Defacement
Il "Web Defacement" è il processo di introduzione di
modifiche non autorizzate ad un sito web, è una forma molto
comune di attacco.
Il Web è diventato una componente essenziale della nostra
società. Un gran numero di organizzazioni di tutto il mondo
si affidano al Web per le loro operazioni quotidiane, in
tutto o solo in parte. Oggi, la fiducia in un'organizzazione
dipende fortemente dalla qualità della sua presenza nel Web,
che deve trasmettere un senso di fiducia e affidabilità ai
suoi utenti nel tempo. Ogni attacco che corrompe il
contenuto di un sito Web può quindi causare gravi danni per
l'organizzazione, così come per i suoi utenti o clienti.
Nella maggior parte dei siti web manca un sistema di una
sorveglianza sistematico dell'integrità e la rilevazione di
Web Defacement è spesso basate su controlli occasionali da
parte degli amministratori o il feedback da parte degli
utenti. Infatti, un recente studio su più di 60.000 siti
compromessi si è scoperto che il 40% dei defacement è durato
per più di un settimana e che il tempo di reazione non
diminuisce in modo significativo per i siti ospitati da
parte degli Internet Provider né tenendo conto
dell'importanza dei siti quantificata con il loro PageRank.
6

7. Esistono delle tecniche per la rilevazione automatica di
“Web Defacement” che sono destinati ad essere gestiti
dall'organizzazione che ospita il sito web da monitorare,
infatti queste tecnologie richiedono l'i nstallazione di
apparecchi dedicati all'interno dell'organizzazione.
Essenzialmente, tutte tali tecnologie si basano sul
confronto tra la risorsa Web e una copia incorrotta
conservata in un luogo sicuro.
Ogni volta che la risorsa Web viene modificata, la copia di
fiducia viene aggiornata e verrà utilizzata nel caso in cui
ci sia il sospetto che la pagina on line possa aver subito
delle modifiche non autorizzate, in questo modo si potrà
verificare se effettivamente è avvenuta una contraffazione.
1.2.2. Phishing
Un altro campo di utilizzo di questo strumento è nella
rilevazione di Phishing. Il Phishing è una forma di frode
online che mira a rubare le informazioni sensibili ad un
utente, quali password di servizi o numeri di carte di
credito. La vittima è indotta a fornire queste informazioni
ad una pagina web che viene realizzata dall'attaccante in
modo che imiti una pagina legittima. Recenti statistiche
circa il numero crescente di attacchi phishing suggeriscono
che questo problema di sicurezza necessita ancora di
attenzioni significative. Una soluzione a questo problema
sta, quando un utente inserisce le la coppia username e
password, nel confronto della pagina con cui sta interagendo
e la pagina legittima, se queste due sono troppo simili
probabilmente saremo di fronte ad un caso di phishing, per
cui sarà necessario avvisare l'utente del pericolo.
Anche in questi due casi lo strumento che si vorrà
realizzare è utile nel contrastare queste tipologie
d’attacco, esso è in grado si ottenere “copia” della
7

8. pagina acquisita per cui nel primo caso la si potrà
utilizzare come copia di fiduciamentre nel secondo la si
potrà confrontare con la pagina originale e avvisare
l’utente del pericolo di phishing.
2. Progettazione
Quello che si vorrà realizzare in questa tesi è uno
strumento che sia in grado di acquisire e trasmettere
documenti web, o più comunemente chiamate pagine internet,
esso dovrà essere in grado di funzionare autonomamente e di
lavorare in modo sistematico e automatico. Uno strumento del
genere non esiste in commercio per cui lo si dovrà creare ex
novo, in quanto l’unico modo con cui si potrebbero
ottenere gli stessi risultati sarebbe quello di farlo
manualmente, ma questo richiederebbe un inutile spreco di
tempo e risorse.
Questo strumento dovrà inoltre comunicare con una
applicazione remota, che gli invierà il lavoro da eseguire,
cioè una lista di documenti web da analizzare, esso
successivamente dovrà rispondere con i dati ottenuti dalla
relativa elaborazione.
8

9. Si è pensato, per questi motivi, di creare una architettura
di tipo client-server, dove lo strumento si comporterà come
un server, cioè riceverà i comandi da un client, eseguirà il
lavoro e restituirà i risultati; in realtà come vedremo più
avanti il comportamento sarà leggermente diverso a causa di
alcuni limiti delle tecnologie utilizzate.
Lo strumento, come detto, avrà principalmente due funzioni:
 Acquisizione: generazione a partire dal documento web di
due file:
 un file di tipo testuale contenente la struttura del
DOM tree, cioè la rappresentazione ad oggetti del
documento
 un file immagine con la rappresentazione grafica del
documento web, detta anche “screenshot”.
 Trasmissione: i file generati dovranno essere t rasmessi
ad una applicazione remota
2.1. Che cos’è il DOM e la sua importanza
Il DOM (Document Object Model) è un interfaccia per la
programmazione di applicazioni (API), cioè un insieme di
funzioni metodi e proprietà che i programmi posso
richiamare al fine di delegare il lavoro al sistema
sottostante, specifica per rappresentare e interagire
oggetti contenuti nei documenti web: HTML o XML. É
indipendente dal linguaggio e cross -platform, è stato
definito dal W3C anche se poi i costruttori di browser ne
hanno variato e creato versioni di proprietarie.
Con il Document Object Model, i programmatori p ossono creare
documenti, navigare la loro struttura e aggiungere,
modificare o eliminare elementi e contenuti. Tutto ciò che
si trova in un documento HTML o XML è possibile accederci,
9

10. modificarlo, cancellarlo o aggiungerlo utilizzando il
Document Object Model.
Inoltre esso definisce un modello di come gli oggetti
interagiscono tra di loro, cioè le relazioni gerarchiche e
di parentela, infatti esso è usato come struttura intermedia
tra una pagina web (HTML o XML) e la visualizzazione finale
creata dai moderni web browser. Infatti un browser prima di
visualizzare la pagina web crea a partire dal file HTML o
XML una struttura ad oggetti dei vari elementi, che verranno
poi rappresentati, questa è salvata in memoria e ci si potrà
accedere attraverso i metodi d efiniti nel DOM o con il
JavaScript, modificandone il contenuto in tempo reale.
Esempio:
<TABLE>
<TBODY>
<TR>
<TD>Shady Grove</TD>
<TD>Aeolian</TD>
</TR>
<TR>
<TD>Over the River,
Charlie</TD>
<TD>Dorian</TD>
</TR>
</TBODY>
</TABLE>
La pagina è costituita da nodi, in sostanza ogni cosa
presente nella pagina, ogni tag (come<table>), ogni testo
(come " ShadyGrove ") è un nodo. I nodi (come ad es.<a>)
possono avere attributi (come href="...") e proprietà.
Inoltre un nodo (come<body> ) può contenere altri nodi, in
questo caso si parla di«elemento» della pagina.
Lo strumento descritto in questa tesi dovrà ricavare la
struttura gerarchica del DOM e per ogni Nodo definire i
propri figli e i seguenti attributi:
● tipo di elemento (html, bod y,p, div, ecc...)
● posizione nella finestra del browser definite dalle
coordinate x, y
● dimensione del box altezza e larghezza in pixel
10

11. ● contenuto (content) :
● testo visibile per i box normali (
ricorsivamente, il testo dei figli)
● codice per gli script
● coppie <nome, valore> per gli attributi
definiti esplicitamente (href, src,id,class..)
● timestap: orario della creazione del file testo
Il file di testo risultante sarà in formato JSON e prendendo
le esempio precedente risulterà: (2 riche sul json e
esempio)
Si è scelto di estrarre il DOM invece di analizzare
direttamente il codice HTML o XML principalmente perché la
struttura della pagina è influenzata, non solo dal codice ma
anche da altri file , in particolare citiamo CSS (Cascading
Style Sheets ), fogli di sti le la cui funzione è quella di
formattare il contenuto, e JavaScript (linguaggio di
scripting impiegato nel il web) utilizzato per interagire e
modificare sia il contenuto e che la grafica delle pagina
web, in questo modo avremo la possibilità di avere
l’effettiva struttura della pagina.
3. Realizzazione
Lo strumento che si vorrà realizzare dovrà, come già detto,
estrarre delle informazioni e interagire con i documenti
web, quindi c’è la necessità di interpretarne il codice e
per fare questo ci si è appoggiati ad un software di uso
comune utilizzato a questo scopo: il web browser. I web
browser sono gli unici programmi in commercio che hanno come
funzione principale quella di scaricare un documento web da
11

12. un server remoto interpretarne il codice e d i crearne una
rappresentazione visiva, cioè ciò che ci viene mostrato ogni
volta che ci colleghiamo ad un sito internet con un
browser.La rappresentazione che questo programma effettua
del documento, come sappiamo, è condizionata non solo dal
codice con cui è scritto, HTML/XML , ma anche come abbiamo
citato nel capitolo precedente dai file CSS e JavaScript.
Per questi motivi lo strumento si baserà su una web browser,
la scelta è ricaduta su Google Chrome, grazie al quale è
possibile creare delle estensione per aggiungere nuove
funzionalità al browser. Infatti quello che andremo
effettivamente a sviluppare sarà proprio un estensione per
Google Chrome.
In questo capitolo andremo ad analizzare gli algoritmi che
sono alla base dell’acquisizione della pagina we b e
successivamente quelli relativi alla trasmissione dei dati.
3.1. Extensions
Le estensioni sono piccoli programmi software che possono
modificare e migliorare la funzionalità del browser Chrome.
Si scrivono utilizzando tecnologie web come HTML, JavaScript
e CSS. È inoltre possibile utilizzare il sistema di
estensione per costruire pacchetti applicativi, una sorta di
app scaricabile ed installabile dal web.
Ogni estensione deve avere i seguenti file:
Un file manifest
Uno o più file HTML (a meno che l'estensione sia un
tema)
Uno o più file JavaScript (opzionali)
Qualsiasi altro tipo di file, ad esempio file di
immagine, CSS...
Questi file devono essere contenuti in una singola cartella.
3.1.1. Manifest
Il file manifest, chiamato manifest.json, fornisce
informazioni circa l'estensione, ad esempio il nome
dell'estensione, i file contenuti, quali azioni può compiere
sul browser, ecc...
12

13. Di seguito è mostrato un esempio di manifest:
{
"name": "My Extension",
"version": "2.1",
"description": "Gets information from Google.",
"icons": { "128": "icon_128.png" },
"background": {
"scripts": ["bg.js"]
},
"permissions": ["http://*.google.com/",
"https://*.google.com/"],
"browser_action": {
"default_title": "",
"default_icon": "icon_19.png",
"default_popup": "popup.html"
}
}
3.1.2. Background Page
Molte estensioni hanno una Background Page, una pagina
invisibile che contiene la logica principale
dell'estensione. Le Background Page sono particolarmente
utili se si voglia eseguire un script per un lungo periodo
di tempo, infatti esse partono all’apert ura del browser e
durano per tutto il tempo necessario al processo eseguito o
finché il browser stesso non sarà chiuso. Le Background Page
sono sempre attive per cui, se ce ne sono molte installate,
le prestazioni di Chrome possono diminuire.
3.1.3. Content Scripts
Se un'estensione deve interagire con le pagine web che
l'utente carica allora l'estensione deve utilizzare un
Content Script. I Content Script sono file JavaScript che
vengono eseguiti all’interno delle pagine web. Grazie allo
standard Document Obje ct Model (DOM), possono leggere i
dettagli delle pagine web visitate dal browser e apportarne
modifiche.
3.2. Descrizione dei file:
13

14. L’estensione, creata per il progetto, è formata dai i
seguenti file, il codice lo si potrà analizzare
nell’appendice:
 background page:
 background.html: pagina principale contiene il canvas
 Content Script:
 main.js: contiene la logica principaledell’intero
programma,
 domgenerator: estrae il DOM dalla pagina visitata,
 pageinfo: ricava le dimensioni della pagina,
 Jquery:libreria Jquery,
 Jszip: libreria javascript per creare file zip
14

15. 3.3. Descrizione degli algoritmi
3.3.1. Acquisizione
3.3.1.1. Algoritmo principale
L’algoritmo principale dell’estensione si trova nel file
main.js, esso viene invocato dal file background.html, dove
risiedono i link ai JavaScript e l’elemento canvas. Quando
si avvia il browser, l’estensione si si attiva
automaticamente per prima cosa essa contatterà
l’applicazione esterna per controllare se è pronta
all’invio del lavoro , se lo è, risponderà con una lista di
pagine web, che verranno inserite in una coda e per ognuna
di queste verranno eseguiti i seguenti passi:
1. apertura della pagina web su un nuovo tab del browser,
2. se necessario, verrà estratto il DOM (vedere paragrafo
x.y)
3. se necessario, verrà ricavato lo screenshot (vedere
paragrafo x.y)
4. verrà generato un file “zip” in cui verranno inseriti
i dati precedentemente ottenuti
5. invio del file zip
6. conferma dell’arrivo del file a destinazione,
inserimento di eventuale altre pagine nella coda,
7. chiusura del tab,
8. se la coda non è vuota, ritornare al punto 1.
15

16. 3.3.1.2. Estrazione del DOM:
per estrarre il DOM si esegue sulla pagina caricata lo
script contente nel file domgenerator.js, questo ricava
ricorsivamente ogni nodo dell’albero, i relativi fi gli e
gli attributi associati.
1. Ottenere la radice del documento
2. ricavare gli elementi:
o tipo di elemento (html, body,p, div, ecc...)
o posizione nella finestra del browser definite dalle
coordinate x, y
o dimensione del box altezza e larghezza in pixel
o contenuto (content) :
o testo visibile per i box normali ( ricorsivamente, il
testo dei figli)
o codice per gli script
o coppie <nome, valore> per gli attributi definiti
esplicitamente (href, src,id,class..)
o timestap: orario della creazione del file testo
3. ottenere tutti i figli
4. per ogni figlio ripetere dal punto 2 fino al
completamento dell’intero albero.
3.3.1.3. Creazione dell’Immagine
L’immagine della pagina web è ottenuta utilizzando il
metodo chrome.tabs.captureVisibleTab() fornito dal browser
Google Chrome, però questo permette di ottenere l’immagine
della sola parte visibile del tab attivo nella finestra del
browser, in un formato d i stringa codificata. Quindi se
vogliamo ottenere la pagina web in tutta la sua interezza,
altezza e larghezza, dovremo usare questo metodo per
ottenere le varie parti della pagina e successivamente
16

17. unirle insieme. Esistono delle funzioni JavaScript per po ter
posizione la finestra del browser in un altro punto del la
pagina , per cui interando questa funzioni saremo in grado
di coprire l’intera pagina, mentre per unire le varie
immagini in una unica si sono usate delle proprietà
dell’elemento Canvas . L’elemento Canvas è stato introdotto
con la nuova versione dell’HTML, cioè HTML5, questo
permette la manipolazione delle immagini. Infatti esso ha un
metodo che consente di posizionare al suo interno
un’immagine utilizzando il metodo drawImage(image, dx, dy) ,
dove “image” è l’immagine da inserire, “dx” la
coordinata x dell’elemento canvaspartendo da sinistra e
“dy” quella y partendo dall’alto. Per cui creando un
elemento canvas con le stesse dimensioni della pagina ed
inserendo di volta in volta la parte di questa ottenuta con
il metodo chrome.tabs.captureVisibleTab(), si ha possibilità
di creare l’immagine intera della pagina.
Infine per estrarre l’immagine dall’elemento canvas si
utilizza il metodo toDataURL() metodo ha due argomenti: il
tipo di MIME per i dati immagine di ritorno (PNG, JPEG), e
il livello di qualità dell'immagine entro il range da "0.0"
a "1.0"
Per cui l'algoritmo per la creazione dello screenshot della
pagine web è descrivibile mediante alcuni passaggi:
1. ottenere le dimensione della pagine e della finestra
2. creazione di un elemento canvas delle stesse dimensione
della pagina da acquisire
3. spostare la finestra del browser all'inizio della
pagina (cordinata 0,0),
4. utilizzando la funziona data da Chrome,
chrome.tabs.captureVisibleTab, ottenere la parte
visualizzata,
5. inserire la parte visualizzata, all'interno del canvas,
6. timeout di un secondo,
7. spostare la finestra del browser in un altro punto,
corrispondente all'altezza o larghezza della stessa
finestra
8. se la pagine non è finita, ripetere dal punto 4,
17

18. 9. quando tutti i pezzi della pagina sono stati inseriti
nel canvas, ottenere l'immagine complessiva invando la
funzione "ctx.canvas.toDataURL("image/png",1.0)"
Pseudo-codice:
Canvascanvas; //elemento canvas
IntwidthPage; // larghezza della pagina in pixel
IntheightPage; // altezza della pagina in pixel
IntwidthWin; // larghezza della finestra in pixel
IntheightWin; // altezza della finestra in pixel
IntwidthPX = 0; // larghezza della pagina in pixel
“fotografata”
IntheightPX = 0; // altezza della pagina in pixel
“fotografata”
while (widthPX<= widthPX&&heightPX<= heightPage ){
movePage(widthPX,heightPX);
screeshot();
putShotintoCanvas()
widthPX += widthWin; ;
heightPX += heightWin;
}
String dataImg = CanvasToImage();
18

19. 3.3.2. Trasmissione
Lo strumento, come detto nel capitolo precedente, dovrà
colloquiare con un applicativo esterno, ad esempio con un
client che invii il lavoro da eseguire per cui l’estensione
si dovrebbe comportare come un server, mettersi in ascolto
su una porta ed aspetta re la connessione di un client.
Purtroppo questo non si può realizzare utilizzando alcun
metodo fornitoci dalle estensioni di Google Chrome e
nemmeno utilizzando gli script di Javascript. Quello che
faremo sarà leggermente diverso ma in sostanza non cambi erà
di molto le cose in quanto l’applicativo esterno comunque
invierà il lavoro da svolgere e l’estensione restituirà i
dati elaborati.
La differenza sarà che l’estensione si comporterà
inizialmente come un client che aprirà la connessione con
l’applicativo e chiederà il lavoro da svolgere per cui esso
sarà a tutti gli effetti un server e infatti verrà
sviluppato con tecnologia opportuna, come andremo a vedere
in seguito sarà utilizzato il linguaggio PHP.
19

20. Di seguito verranno descritte le varie fasi dell a
comunicazione ed il formatto dei messaggi.
3.3.2.1 Protocollo di Comunicazione
Messaggi
Il protocollo di comunicazione tra l'estensione e il server
è relativamente semplice:
Analizziamo innanzitutto come sono strutturati i messaggi,
ne esistono di 2 tipi, uno per la richiesta e una per la
risposta.
Il messaggio di richiesta, cioè quello inviato
dall'estensione al server è formato da 3 campi, che sono
inseriti nell'header del messaggio HTTP, nel campo Form
Data:
● "msg": di tipo stringa, che identifica un par ticolare
comando:
● "ready": pronto a iniziare,
● "done": elaborazione effettuata,
● "error": c'è stato un errore,
● "id": di tipo intero, identifica l'ID del sito
elaborato, opzionale, si usa nei casi in cui
l'elaborazione o è andata a buon fine o c'è stato un
errore, non si usa con il comando "ready" con cui si
avvia la comunicazione. (opzionale)
● "data": rappresenta i dati dell'elaborazione, è una
stringa codificata in Base64, il server ne dovrà
effettuare la decodifica. Eventualmente può essere
usata nel caso di errore per identificare il tipo di
errore. (opzionale)
Il messaggio di risposta è invece quello inviato dal server
all'estensione in risposta al messaggio di richiesta, è
codificato in formato JSON e contiene 2 campi:
"msg" : di tipo stringa, che identifica una particolare
risposta:
 "ok", si è ricevuto il comando e gli eventuali dati,
20

21.  "no", non si ha alcun lavoro da svolgere, (non
serve)
 "end", si ha concluso con il lavoro,
"jobs": è un array che contiene i dati relativi ai siti da
elaborare, può essere usato insieme al messaggio "ok", è
composto a sua volta da un oggeto con 2 attributi:
 "id", di tipo intero , identificatore del sito,
 "url", di tipo stringa, rappresenta l'url del sito.
 "type", tipo di lavoro da eseguire, dm solo dom,
dsdom e immagine im, solo immagine
3.3.3 Comunicazione
Quando l'estensione si avvia, cioè viene lanciato il
browser, viene inviato un messaggio che avvisa il server che
il programma è pronto a ricevere comandi ed ad iniziare
l'elaborazione, questo messaggio ha il campo "msg", settato
21

22. con "ready" gli altri camp i possono essere non settati, in
risposta a questo messaggio il server può: se non ha lavoro
rispondere "ok" ma su il campo works è nullo o vuoto
l'estensione si mette in attesa per un determinato periodo
di tempo e successivamente reinvia il medesimo com ando,
altrimenti il server invia il comando "ok" con una array di
uno o più siti da elaborare.
estensione server
msg: “READY”
msg:”OK”
works:[
id:0 work:”www..sito1.it”;
Id:1 work:”www.sito2.it”;
…]
Quando l'estensione ha finito di analizzare un sito invierà
un messaggio con il campo "msg" settato con " done" e
verranno inoltre inviati l'id del sito, settando il relativo
campo e i dati inseriti nel campo "data", in risposta a
questo messaggio si avrà:
1. ok, si sono ricevuto tutti i dati senza errori, il
server può o inviare ancora altri dati da elaborare,
oppure no, lasciando il campo works a NULL, in questo
caso il server saprà che ci saranno comunque altri
dati in arrivo...
22

23. 2. end, non si ha più lavoro da eseguire, si può
chiudere il programma,
estensione server
msg:”done”
id: 0
data:” dkijfedjrfe....”
msg: “ok”
Infine l'estensione può inviare al server un messaggio di
errore, cioè si è riscontrato un errore durat e
l'elaborazione, ad esempio il sito non esiste o non si è in
grado di raggiungere la risorsa, le risposte sono identiche
al quelle del caso positivo , cioè avvisare di aver finito
il lavoro ("end"), oppure si può continuare con le altre
elaborazioni in coda ("ok") , eventualmente si può provare a
riinviare il sito e fare un altro tentativo.
4. Server e Test finali
23

24. L’ultima operazione da svolgere è quella di testare lo
strumento e di calcolarne l e prestazioni, per questi motivi
è stato realizzato un semplice applicativo server con cui
far interagire lo strumento.
Questo applicativo server è stato realizzato con il
linguaggio lato server PHP, la scelta è ricaduta su questo
linguaggio principalmente per la sua semplicità d’uso e p er
la facilità di impostare l’ambiente di sviluppo, in quanto
in rete si trovano molti programmi di tipo web server che si
appoggiano sulla piattaforma Apache http server, in
particolare è stato usato XAMPP, software open source adatto
allo scopo.
Le funzioni principali dell’ applicativo server saranno:
ricevere i comandi dallo strumento/estensione
generare ed inviare il lavoro da eseguire per lo
strumento
ricevere e salvare i dati in memoria
calcolare le prestazioni dello strumento
Andremo ora ad analizzare queste fasi:
Ricevere i comandi dallo strumento/estensione
Come abbiamo visto nel paragrafo Trasmissione del capitolo
precedente il server dovrà mettersi in ascolto, ricevere ed
interpretare i comandi che arrivano dallo strumento e
rispondere nel modo corretto secondo il protocollo
descritto.
Generare ed inviare il lavoro da eseguire per lo strumento
Il server ha disposizione delle liste di documenti web che
dovrà inviare allo strumento utilizzando la struttura del
messaggio corretta descritta nel paragrafo Trasmissione del
capitolo precedente, inoltre dovrà essere in grado di
generare dei carichi di lavoro differenti in base ad alcuni
parametri che si vorranno testare: documenti analizzati per
unità di tempo.
Ricevere e salvare i dati in memo ria
Ricevere i dati inviati dallo strumento, cioè essere in
grado di estrarre i dati dall’header http, generare il file
zip con la codifica corretta e salvarla nella memoria del
server.
24

25. Calcolare Le prestazioni dello strumento
Per prima cosa bisogna definire quali test si vogliono far
eseguire allo strumento, principalmente saranno del tipo:
documenti analizzati per unità di tempo.
Fase di Test
Il Test effettuato sullo strumento è stato quello della
misurazione del carico, cioè quante pagine riusciva ad
evadere nell’arco di tempo di un minuto .
Ogni volta che arriva una richiesta il server invia una
numero di pagine in modo che la coda che lo strumento
dispone sia sempre lunga uguale nell’arco di un determinato
periodo di tempo.
Esempio: Si vuole vedere se lo strumento riesce ad evadere
10 pagine al minuto.
Il server invia 10 pagine e fa partire il timer di un
minuto, ogni volta che arriva una pa cchetto aumenta il
contatore di uno e vede se il minuto è passato, se è passato
invia una lista di pagine in modo che lo strumento ne abbia
sempre 10 a disposizione , cioè il numero stesso di risultati
ricevuti. Se invece lo strumento riesce a restituire tu tti e
10 l’elaborazione delle pagine , si mette in attesa e
aspetta lo scadere del minuto e alla richiesta successiva
invierà una nuova lista di 10 siti.
Durante l’esecuzione di alcuni test preliminari si è notato
come la pagine web avessero differenti te mpi nella loro
elaborazione, cioè alcune pagine venivano evase in tempi
rapidi, circa 10 secondi altre via via sempre più lentamente
raggiungendo anche il minuto. Il tempo di elaborazione di
una pagina si è scoperto dipendeva principalmente da due
fattori:
la dimensione della pagina espressa in pixel , infatti
per ottenere lo screenshot della stessa bisogna
scorrerla sia in altezza che in larghezza, e questo
comporta un notevole dispendio di tempo a causa della
natura stessa dell’algoritm o per la creazione
dell’immagine .
La dimensione del pacchetto da inviare, infatti a fine
elaborazione viene creato un file “.zip” che verrà
inviato in rete, il tempo per l’invio del pacchetto e
25

26. della relativa risposta del server dipendono dalla
dimensione dello stesso, più grande è il file da
inviare e più tempo ci si impiega a trasmetterlo. La
dimensione del pacche tto dipende principalmente dalle
dimensione dei file che contiene, il primo il file
quello testuale, che contiene l’albero DOM, non
determinava grosse variazioni da pagina a pagina,
infatti si aggira attorno 1MB, mentre file immagine,
varia anche esso in base alla dimensione della pagina,
infatti si sono riscontrate immagini da meno di un MB
fino a quelle da oltre 10MB.
A causa di queste differenze nei tempi si è deciso di
raggruppare le pagine, che hanno comuni caratteristiche , in
gruppi distinti in modo da avere test omogenei.
Sono stati creati tre gruppi, in cui si distinguevano pagine
“piccole”, “medie”, “grandi” i parametri per la
decisione se una pagina facesse parte di un gruppo invece
che di un altro sono quelli appena descritti, dimensione in
pixel della pagina e dimensione del pacc hetto in MB, in
questo modo si sonopotuti fare dei test simili in cui i
tempi di elaborazio ne erano simili e si discostavano di poco
all’interno del gruppo.
Nella seguente tabella si possono vedere i gruppi e i
criteri con cui si sono definiti:
TIPO Dimensione PX Dimensione MB Tempo Medio Tempo Medio
(altezza) Secondi ( D O M ) secondi ( D O M +
screenshot)
Piccoli <2000 <3,5 4,7 12
Medio 2000-5000 3,5-5 6,6 23,2
Grande >5000 >5 8,4 57
Si sono effettuati due tipi di test sulla misura del c arico:
solo DOM; infatti in alcuni casi c’è la necessità di
estrarre solo quello senza l’immagine, riducendo
notevolmente il tempo di elaborazione.
DOM e immagine.
26

27. I test sono stati eseguiti sul pc del tesista un notebook
con le seguenti caratteristiche:
◦ processore Intel Core 2 Duo P8400 a 2.20GHz
◦ 4 Gb di ram
Mentre si è utilizzata una connessione ad internet ADSL 7
Mbps.
Sono stati selezionati 80 siti internet (vedere Appendice),
per ogni gruppo si sono svolti 10 ripetizioni e ricavate
delle medie pesate dei tempi, in modo da avere delle stime
il più
preciso possibile. In questo mo do sono stati realizzati i
seguenti grafici.
I seguenti grafici rapp resentano il primo il caso in cui
viene richiesto solo il DOM e il secondo quello in cui
vengono richiesti il DOM e lo screenshot, non si è eseguito
il caso solo screenshot perché i ris ultati ottenuti non si
discostavano di molto dal secondo caso citato, in quanto la
creazione e la trasmissione del DOM non aumentadi molto la
dimensione totale del pacchetto rispetto al caso in cui
veniva creato sia il DOM che lo screensho t.
Grafico 1:
27

28. Misura del Carico (solo dom)
14
12
10
8 piccoli
Inviati al minuto
medi
grandi
6
4
2
0
2 4 6 8 10 12 14 16
Lunghezza coda in ogni minuto
Grafico 2:
Misura del Carico (dom + screenshot)
6
5
4
Inviati al minuto
piccoli
3 medi
grandi
2
1
0
0 2 4 6 8 10 12 14
Lunghezza coda in ogni minuto
28

29. Conclusioni
Lo strumento, come denotano i grafici, non è molto efficiente in
quanto non riesce ad elaborare molte pagine al minuto, infatti nel
caso peggiore, quelle “grandi, riesce ad arrivare ad un massimo di
due, questo è dovuto principalmente ai limiti delle tecnologie
utilizzate, in quanto non è possibile nè parallelizzare nè creare più
thread che possano elaborare più pagine contemporaneamente, il fatto
che è il linguaggio JavaScript, per quanto possa essere indispensabile
nel campo della manipolazione della struttura DOM e nella
programmazione web, ha dei limiti in altri tipi di elaborazioni.
Comunque l’obiettivo finale della tesi è stato raggiunto: acquisire
ed trasmettere documenti web, in modo automatico e sistematico.
Un ultima cosa va detta, in questo contesto non si è detto nulla se
effettivamente lo strumento abbia una utilità nella rilevazione degli
attacchi web, ma questo esula dagli argomenti dell’elaborato e ci
saranno altre sedi in cui si potrà dimostrate questa sua
caratteristica.
Appendice
Tabella risultati
Latabella seguente mostra alcuni risultati dei test effettuati con lo
strumento: tempi per eseguire l’elaborazione e dimensioni della
pagina nel caso DOM+Screenshot
Pagina Web Secondi Secondi Byte Pixel Tipo
(DOM+ (solo DOM)
screenshot)
http://www.nyu.edu/ 5 9 792423 1008 p
http://en.wikipedia.org/wiki/Astronomer 5 11 1178746 1715 p
http://www.unicef.it/default.aspx.htm?ph=1 5 13 2125943 1818 p
http://www.amazon.com/ 7 15 2055855 3384 p
http://www.mappets.it/ 3 19 1374302 3600 p
http://it.wikipedia.org/wiki/Pagina_principale 2 13 1117647 2691 p
http://lists.w3.org/Archives/Public/w3c-wai-ua/1999JanMar/0195.html 5 7 332884 2367 p
http://www.ebay.it/ 3 11 1246874 1875 p
http://www.units.it/ 7 7 765534 722 p
http://www.stereomood.com/ 5 13 1691593 1432 p
29

30. http://www.amazon.com/ 3 14 2008729 3340 p
http://www.unipd.it/ 4 9 1022727 1549 p
http://www.unive.it/ 4 6 639713 826 p
http://www.asf.fr/control/index.aspx?alias=home 7 7 616149 712 p
http://weather.edition.cnn.com/weather/intl/forecast.jsp 3 15 1857725 2014 p
http://www.oracle.com/technetwork/java/index.html 3 8 485366 1488 p
http://www.abebooks.com/ 3 8 793490 1834 p
http://www.apple.com/itunes/ 5 10 1625484 2392 p
http://shop.nordstrom.com/ 5 9 726828 1159 p
http://www.talbots.com/online/home_page.jsp 5 8 990440 915 p
http://it.bluenile.co.uk/ 6 12 986044 1521 p
http://www.buildabear.com/ 7 12 1409930 1630 p
http://Ice.com 9 10 1085143 1255 p
http://www.provincia.belluno.it/nqcontent.cfm?a_id=1 3 15 1161853 1194 p
http://it.benetton.com/ 8 12 1861936 2276 p
http://www.dell.com/ 4 12 2877364 1288 p
http://www.turismoroma.it/ 9 11 1594078 2509 p
http://www.kotaku.com 3 18 2193808 2887 p
http://jkontherun.blogs.com 2 4 67892 699 p
http://www.regione.campania.it 6 10 699082 1387 p
http://www.regione.emilia-romagna.it 4 19 1253558 2405 p
http://www.regione.lazio.it 3 17 930493 1074 p
http://www.regione.liguria.it 6 19 1242347 1888 p
http://www.regione.marche.it 4 20 1159973 2059 p
http://www.regione.piemonte.it 3 15 646475 1207 p
http://www.regione.sardegna.it 2 10 447900 1276 p
http://www.regione.sicilia.it 3 6 344224 780 p
http://www.regione.vda.it 6 13 982427 1781 p
http://www.provincia.trento.it 6 18 852491 1050 p
http://www.androidiani.com/ 8 32 3692613 8235 m
http://money.cnn.com/ 9 16 1623122 4041 m
http://1-800-Flowers.com 3 22 3264986 3135 m
http://www.zappos.com/ 5 20 1842884 5605 m
http://en.wikipedia.org/wiki/Solar_wind 4 16 1732458 5088 m
http://en.wikipedia.org/wiki/Centaur_(minor_planet) 8 16 1849685 4793 m
http://www.sportmediaset.mediaset.it/calcio/ 9 24 4252894 3826 m
http://www.nytimes.com/ 6 19 2543887 4041 m
http://www.youtube.com/ 9 25 3962782 5282 m
http://ansa.it 6 23 3465434 4885 m
http://www.panorama.it/ 6 37 5547622 6356 m
http://espresso.repubblica.it/ 9 22 2610001 4433 m
http://www.ilsole24ore.com/ 6 29 4118805 7065 m
http://www.gazzettino.it/ 6 25 3741135 6206 m
http://ilpiccolo.gelocal.it/ 10 27 3893410 5631 m
http://www.sky.it/ 3 25 3463160 4418 m
http://www.comune.roma.it/wps/portal/pcr 8 14 1574200 3719 m
http://www.total-photoshop.com/ 8 26 3527405 3726 m
30

31. http://www.acmilan.com/it 6 19 2503179 2552 m
http://www.asroma.it/it/index.html 5 16 2540223 2329 m
http://www.zazzle.com/ 11 15 2283722 3070 m
http://it.eurosport.yahoo.com/ 3 21 3279406 4607 m
http://espresso.repubblica.it/ 6 21 2629271 4433 m
http://ansa.it 8 25 3507193 4918 m
http://www.lifehacker.com 9 27 2043120 3114 m
http://www.pcsintel.com 4 24 1734777 3968 m
http://www.regione.abruzzo.it 7 32 1083887 1779 m
http://www.nysun.com/ 5 34 1270552 2760 m
http://www.sky.it/ 8 41 6486780 4418 g
http://www.html5rocks.com/en/tutorials/internals/howbrowserswork/ 8 81 836292 36612 g
http://en.wikipedia.org/wiki/Peter_Heywood 9 52 3494273 8310 g
http://en.wikipedia.org/wiki/Astronomy 10 63 4114113 11142 g
http://www.rai.it/ 10 52 2711597 3086 g
http://www.nytimes.com/ 8 39 2471003 4021 g
http://www.pvrblog.com 10 56 2649788 6441 g
http://www.tvover.net 9 67 1581256 6471 g
http://www.lumberliquidators.com/ll/home 8 51 2455741 3200 g
http://www.tigerdirect.com/ 8 62 1906659 2766 g
http://Petco.com 6 48 1747840 2098 g
http://it.msn.com/ 8 36 1315259 2297 g
http://www.telefonino.net/ 8 92 1566551 2313 g
Codice Estensione
Background.html
<html>
<head>
<script src="jquery-1.7.1.min.js"></script>
<script src="main.js"></script>
<script src="pageinfo.js"></script>
<script src="jszip.js"></script>
<script src="domgenerator.js"></script>
</head>
<body>
<canvas id ="myCanvas"></canvas>
</body>
</html>
main.js
varsrvUrl = 'http://localhost/serverPHPTest2.php'; // Url del server (da modificare)
varRcommand ="ready"; // Comando "ready"
31

32. vardoneCmd ="done"; // Comando "done"
varerrorCmd ="error"; // Comando "error"
varwidthWin = 0 //larghezza finestra
varheightWin = 0 //alteza finestra
varwidthSite = 0 //larghezza sito
varheightSite = 0 //alteza sito
varws = 0; //larghezza fatta
varhs = 0; // altezza fatta
varmyCanvas; // canvas
varctx; // context del canvas
varworks = new Array(); // coda del lavoro
vardom; // domtree
varstrDataURI;
vartabid; // id tab
vartabopen = false;
varindexWork = -1;
send(srvUrl,Rcommand); // comando di inizio
function sleep(milliSeconds){
varstartTime = new Date().getTime(); // get the current time
while (new Date().getTime() <startTime + milliSeconds); // hog cpu
}
/** funzione invio dati (url del server, tipo di comando, id del work, dati) */
function send(destUrl, command, id, data) {
$.ajax({
url: destUrl,
type: "post",
data: { rqsmsg: command, id: id, data: data,
pixel:heightSite},
success: function(answer) {
varJSONobject = JSON.parse(answer);
if (JSONobject.msg == "ok") {
if (JSONobject.works != null) {
for (vari = 0; i<JSONobject.works.length; i++) {
works.push(JSONobject.works[i]);
}
}
if(tabopen){
tabopen = false;
chrome.tabs.remove(tabid);
}
32

33. openSite();
}
else if (JSONobject.msg == "end") {
id = id + 1;
sleep(200);
alert('FINITO!!!');
}
}
});
}
/** Funzione FOTO */
function photo() {
chrome.tabs.captureVisibleTab(null, { format: "png", quality: 10 },
function(dataUrl) {
varimg = new Image();
img.src = dataUrl;
img.onload = function() {
if (hs + heightWin<heightSite) {
if (ws + widthWin<widthSite) {
ctx.drawImage(img, ws, hs);
ws = ws + widthWin
scrollWinLeft(ws);
}
else {
ctx.drawImage(img, widthSite - widthWin, hs);
hs = hs + heightWin;
ws = 0;
scrollWinDown(hs);
scrollWinLeft(0);
}
}
else {
if (ws + widthWin<widthSite) {
ctx.drawImage(img, ws, heightSite - heightWin);
ws = ws + widthWin
scrollWinLeft(ws);
}
else { // se ha finito di scrollare tutta la pagina,
ottieni l'immagine dal canvas
ctx.drawImage(img, widthSite - widthWin, heightSite - heightWin);
33

34. hs = 0;
ws = 0;
strDataURI = ctx.canvas.toDataURL("image/png", 1.0).substring(22);
var zip = new JSZip();
if (works[indexWork].type == "ds") {
zip.add("dom" + works[indexWork].id + ".txt", JSON.stringify(dom));
}
zip.add("image" + works[indexWork].id + ".png", strDataURI, { base64:
true });
zipFile = zip.generate();
varzp = "data:application/zip;base64," + zipFile;
send(srvUrl, doneCmd, works[indexWork].id, zp);
}
}
}
});
}
/** funzione per abbassare la finestra del browser*/
function scrollWinDown(px) {
chrome.tabs.executeScript(tabid,
{ code: "document.body.scrollTop = '" + px + "'" });
sleep(600);
}
/** funzione per spostare a sinistra la finestra del browser */
function scrollWinLeft(px) {
chrome.tabs.executeScript(tabid,
{ code: "document.body.scrollLeft = '" + px + "'" });
sleep(600);
photo();
}
/** listerner, per comunicare col tab selezionato*/
chrome.extension.onConnect.addListener(function(port) {
port.onMessage.addListener(function(info) {
if (info.type == "dom") {
dom = info.dom;
if (works[indexWork].type == "dm") {
var zip = new JSZip();
34

35. zip.add("dom" + works[indexWork].id + ".txt", JSON.stringify(dom));
zipFile = zip.generate();
varzp = "data:application/zip;base64," + zipFile;
send(srvUrl, doneCmd, works[indexWork].id, zp);
}
else {
myCanvas = document.getElementById('myCanvas')
ctx = myCanvas.getContext("2d");
chrome.tabs.executeScript(tabid, { file: "pageinfo.js" });
}
}
else {
/** ottengo la dimensione della pagina e della finestra
del browser */
widthWin = info.widthWin;
heightWin = info.heightWin;
widthSite = info.widthSite;
heightSite = info.heightSite;
ctx.canvas.height = heightSite;
ctx.canvas.width = widthSite;
scrollWinDown(0);
scrollWinLeft(0);
}
});
});
/** funzione che apre il documentoweb successivo */
functionopenSite() {
indexWork = indexWork + 1;
// controllo se la coda è ancora piena
if (indexWork<works.length) {
/**controllo che il documento sia effettivamente on
line*/
$.ajax({
url: works[indexWork].url,
type: 'GET',
success: function(data) {
chrome.tabs.create({ url: works[indexWork].url },
function(tab) {
tabid = tab.id
tabopen =
true;
sleep(1000);
35

36. chrome.tabs.executeScript(tabid, { file: "domgenerator.js" })
});
},
error: function(data) {
send(srvUrl, errorCmd, works[indexWork].id);
}
});
}
/** se la coda è vuota, aspetto 10sec e poi invio comando
"Ready" */
else {
sleep(10000);
indexWork = indexWork - 1;
send(srvUrl, Rcommand);
}
}
pageinfo.js
/**ricavo la dimensione della pagina e quella della finestra */
document.documentElement.style.overflowX = 'hidden';
document.documentElement.style.overflowY = 'hidden';
vardimensioni = {
"type": "sito",
"widthWin": window.innerWidth,
"heightWin": window.innerHeight,
"widthSite": document.width,
"heightSite": document.height
};
chrome.extension.connect().postMessage(dimensioni);
domgenerator.js
/** script che estare il DOM Tree dalla pagina */
varmyObject = new JXONData(document);
var time = new Date().getTime();
varsCollectedTxt = ""
myObject.timestamp = time;
function contentValue(oXMLParent){
36

37. varoItChild;
if (oXMLParent.hasChildNodes()) {
for (varnChildId = 0; nChildId<oXMLParent.childNodes.length; nChildId++) {
oItChild = oXMLParent.childNodes[nChildId];
if ((oItChild.nodeType + 1 | 1) === 5) {
sCollectedTxt = sCollectedTxt + buildValue(oItChild.nodeValue);
}
else{
contentValue(oItChild)
}
}
}
return sCollectedTxt;
}
function buildValue(sValue) {
if (/^s*$/.test(sValue)) { return " "; }
if (/^(true|false)$/i.test(sValue)) { return sValue.toLowerCase() === "true"; }
if (isFinite(sValue)) { return parseFloat(sValue); }
return sValue;
}
function JXONData (oXMLParent) {
varnAttrLen = 0, nLength = 0;
if (oXMLParent.hasChildNodes()) {
for (varoItChild, sItKey, sItVal, nChildId = 0;
nChildId<oXMLParent.childNodes.length; nChildId++) {
oItChild = oXMLParent.childNodes.item(nChildId);
if ((oItChild.nodeType + 1 | 1) === 5) {
}
else if (oItChild.nodeType === 1 && !oItChild.prefix) { // nodeType is
"Element" (1)
sItKey = oItChild.nodeName.toLowerCase();
sItVal = new JXONData(oItChild);
if (this.hasOwnProperty(sItKey)) {
if (this[sItKey].constructor !== Array) { this[sItKey] = [this[sItKey]]; }
this[sItKey].push(sItVal);
} else { this[sItKey] = sItVal; nLength++; }
}
}
}
if (oXMLParent.nodeName.toLowerCase() != "#document")
{
this.content = contentValue(oXMLParent);
37

38. sCollectedTxt = "";
this.x = oXMLParent.offsetLeft;
this.y = oXMLParent.offsetTop;
this.w = oXMLParent.offsetWidth;
this.h = oXMLParent.offsetHeight
if (oXMLParent.hasAttributes()) {
varoItAttr;
this.keyAttributes = {};
for (nAttrLen; nAttrLen<oXMLParent.attributes.length; nAttrLen++) {
oItAttr = oXMLParent.attributes.item(nAttrLen);
this.keyAttributes[oItAttr.nodeName.toLowerCase()] = buildValue(oItAttr.nodeValue);
}
}
this.valueOf = function() { return this.keyValue; };
this.toString = function() { return String(this.keyValue); };
this.getItem = function(nItem) {
if (nLength === 0) { return null; }
variItem = 0;
for (varsKeyName in this) { if (iItem === nItem) { return this[sKeyName]; }
iItem++; }
return null;
};
this.getAttribute = function(nAttrib) {
if (nAttrLen === 0 || nAttrib + 1 >nAttrLen) { return null; }
varnItAttr = 0;
for (varsAttrName in this.keyAttributes) { if (nItAttr === nAttrib) { return
this.keyAttributes[sAttrName]; } nItAttr++; }
return null;
};
this.hasChildren = function() { return this.keyLength> 0; };
}
}
varadditionalInfo = {
"type":"dom",
"dom": myObject
};
chrome.extension.connect().postMessage(additionalInfo);
38

39. Bibliografia
Alberto Bartoli, Giorgio Davanzo, Eric Medvet
A Framework for Large-Scale Detectionof Web Site Defacements
Eric Medvet, EnginKirda, Christopher Kruegel,
(2008) Visual-Similarity-Based Phishing Detection
http://developer.chrome.com/extensions/
http://www.w3schools.com/
39