Pancia Asia-Pelusi Sara-La pittura romana - Copia (1).pptx
Rilevazione di defacement invisibili su siti Web: Tecniche per la raccolta di informazioni
1. CORSO DI LAUREA TRIENNALE IN
INGEGNERIA DELL'INFORMAZIONE
Rilevazione di defacement invisibili su siti Web:
Tecniche per la raccolta di informazioni
LAUREANDO RELATORE
Stefano Scoppa Chiar.mo Prof. Alberto Bartoli
Università degli Studi di Trieste
1
4. Indice
Capitolo 1: Introduzione.......................................................................................................................5
Defacement invisibili su siti Web: breve panoramica......................................................................5
Metodi di attacco.............................................................................................................................6
Profilo della Tesi..............................................................................................................................6
Obiettivo della Tesi..........................................................................................................................6
Motivazioni......................................................................................................................................6
Capitolo 2: Definizione roadmap.........................................................................................................7
Delineamento della struttura del progetto per l'analisi delle informazioni......................................7
Delineamento degli strumenti necessari .........................................................................................7
Delineamento dei programmi necessari...........................................................................................7
Delineamento di una Base di Dati necessaria..................................................................................8
Scelta della tipologia di siti Web da prendere come riferimento.....................................................8
Raccolta di URLs dei siti scelti come riferimento...........................................................................8
Raccolta di informazioni dei siti scelti come riferimento................................................................9
struttura della Base di Dati.............................................................................................................10
LinkExtractor.................................................................................................................................25
JlinkExtractor.................................................................................................................................25
JfileOrganizer.................................................................................................................................27
JurlSaver........................................................................................................................................29
Downloader....................................................................................................................................30
DownloaderLauncher.....................................................................................................................30
Operazioni del programma DownloaderLauncher....................................................................30
Downloader....................................................................................................................................31
Operazioni del programma Downloader...................................................................................31
Capitolo 3: Conclusioni......................................................................................................................33
Appendice...........................................................................................................................................34
esempio di codice di DownloaderLauncher..............................................................................34
esempio di codice di Downloader.............................................................................................35
4
5. Capitolo 1: Introduzione
Il web defacement è la modifica non autorizzata di come visivamente appare un sito web.
Tale azione è ormai un elemento ricorrente in Internet, così come il phishing, gli worm, gli
attacchi di tipo denial of service e altri fenomeni analoghi. Le motivazioni che spingono un
attaccante ad agire in questo modo sono molteplici, incluse la dimostrazione di abilità, le
ragioni ideologiche, la truffa ed il ricatto con implicazioni prevalentemente di danno
economico. La gravità di questo problema è ormai diventata incontrovertibile, come
dimostrato da numerosi dati di fatto. Attacchi di questo genere sono ormai effettuati in
maniera automatizzata ed in larga scala, in modo analogo a quanto avviene con la
propagazione dei virus e degli worm.
Defacement invisibili su siti Web: breve panoramica
Un attaccante in grado di modificare a proprio piacimento l'aspetto di una pagina web può
effettuare modifiche che non influenzano l'aspetto visivo della pagina stessa, risultando
non percettibili all'occhio umano, ma che interessano il contenuto informativo trasmesso
tra le macchine in gioco. Questo tipo di defacement, chiamato invisible defacement, è
estremamente diffuso e molto pericoloso. Tipicamente il contenuto dei siti web è descritto
in HTML, le azioni invece sono spesso scritte in semplici linguaggi di scripting, JavaScript
ad esempio; all'interno di queste porzioni di codice un attaccante può definire o modificare
a piacimento una o più azioni. Uno scenario possibile vede l'attaccante implementare su
un sito web legittimo del codice maligno, ogni visitatore del sito risulta, senza che se ne
renda conto, una potenziale vittima. La gravità di questo problema viene segnalata anche
dalla Sophos Labs in un recente Security Threat Report del Gennaio 2009:
1. la tecnica degli “invisible defacement” dei siti web è ormai diventata lo strumento
principale per la diffusione di virus e malware, più della e-mail
2. Sophos rileva una nuova pagina web con questa caratteristiche ogni 4.5 secondi
con 20.000 casi al giorno di nuovi codici sospetti
3. nel 2008 è stata rilevata una diffusione più che tripla rispetto a quella rilevata nel
2007
4. più del 85% di queste pagine è associata a siti web “legittimi”, quali ad esempio
ambasciate di paesi europei o quotidiani di rilevanza nazionale
si rileva inoltre che nel 2008 i principali siti web diffusori di malware sono locati negli Stati
Uniti, in Cina e in Russia con percentuali rispettivamente del 37%, 27.7% e 9.1%; questa
analisi confrontata con dati dell'anno precedente sposta la maggiore responsabilità della
diffusione di malware dalla Cina agli Stati Uniti. Il passaggio di testimone si intuisce anche
dall'uso sempre maggiore di parole inglesi all'interno del malware a scapito di parole
cinesi.
5
6. Metodi di attacco
Le metodologie di attacco molto numerose; il sito The Web Hacking Incidents Database da
anni raccoglie in una Base di Dati le segnalazioni di avvenuti attacchi e alcune delle
metodologie da loro classificate sono: Administration Error, Brute Force, Buffer Overflow,
Content Spoofing, Credential/Session Prediction, Cross Site Scripting (XSS), Denial of
Service, Failure to Restrict URL Access, Insufficient Anti-automation, Known Vulnerability,
LDAP Injection, Misconfiguration, Redirection, Session Hijacking, SQL Injection, SSI
Injection, Weak Password Recovery Validation, XPath Injection. Una delle tecniche più
usate è la SQL Injection, spesso implementata in strumenti per il defacement automatico;
questi programmi sono in grado di localizzare ed attaccare simultaneamente centinaia di
siti web, sono configurabili nel tipo di defacement da effettuare e spesso fanno uso di
proxy HTTP per rendere più difficile l'individuazione dell'origine dell'attacco.
Profilo della Tesi
La parte rimanente di questa tesi è organizzata come segue: il Capitolo 2 presenta un
possibile modus operandi per la raccolta automatica di informazioni; si parte da una analisi
di progetto, di strumenti e di programmi necessari per arrivare alla raccolta ed al
salvataggio delle informazioni. Il Capitolo 3 presenta le conclusioni a cui questa tesi vuole
arrivare. Il Capitolo 4 propone una possibile integrazione in rilevatori automatici di
defacciamenti che ancora non trattano il defacciamento invisibile.
Obiettivo della Tesi
Si descrive un possibile modus operandi per la raccolta automatica e sistematica via
Internet di informazioni che possono aiutare a studiare il problema del defacciamento
invisibile. In base alle premesse descritte nell'introduzione si focalizza l'attenzione su siti
web appartenenti alla famiglia delle Banche Online ed Istituti di Credito localizzati negli
Stati Uniti. La raccolta di dati deve comprendere tutto il contenuto di una pagina web di
riferimento più tutto il contenuto di tutti i riferimenti presenti nella pagina di partenza, se nel
riferimento è presente un nuovo riferimento si ripete l'operazione; si delinea così una
struttura ad albero con un livello di profondità definibile da utente. Una successiva
comparazione tra stessi contenuti informativi raccolti in tempi diversi potrebbe portare in
risalto delle modifiche, da stabilirne successivamente la natura.
Motivazioni
Il problema dell'invisible defacement necessita di una soluzione sistematica e su larga
scala; recenti ed autorevoli studi dedicati al web defacement dimostrano l'efficacia di tale
approccio e la carenza di sistemi automatici di monitoraggio e rilevazione remota di
defacciamenti invisibili hanno portato all'ideazione di questa tesi.
6
7. Capitolo 2: Definizione roadmap
In questo capitolo vengono elencati e discussi i passi fondamentali affrontati per il corretto
svolgimento dell'analisi delle informazioni
Delineamento della struttura del progetto per l'analisi delle informazioni
Il progetto deve comprendere:
un insieme di URLs da monitorare
un programma che esegua periodicamente delle connessioni a tutti gli URLs da monitorare e
che scarichi tutto il contenuto delle pagine HTML a cui si è connesso
una Base di Dati atta al salvataggio degli URLs da monitorare e di tutte le informazioni
scaricate
Delineamento degli strumenti necessari
Gli strumenti utilizzati sono:
motori di ricerca Yahoo! Directory, Google Directory, Credit Union DataBase
NetBeans IDE 6.1 su Java Platform 1.5 con librerie TopLink Essentials, HTML Parser 2,
MySQL JDBC Driver, JUnit 4.1
MySQL Administrator 5 & MySQL Query Browser
Delineamento dei programmi necessari
I programmi necessari per la realizzazione del progetto sono:
un programma che estragga una lista di URLs interessanti da una pagina HTML
e che li salvi in una apposita tabella della Base di Dati.
il programma in questione lo chiameremo LinkExtractor
un programma che esegua periodicamente delle connessioni a tutti gli URLs
precedentemente scaricati, che scarichi tutto il contenuto delle pagine HTML a cui si è
connesso e che salvi tutte le informazioni in una apposita tabella della Base di Dati.
il programma in questione lo chiameremo Downloader
7
8. Delineamento di una Base di Dati necessaria
Le tabelle necessarie per il salvataggio dei dati sono:
una tabella per il salvataggio degli URLs da monitorare scaricati da LinkExtractor.
la tabella in questione la chiameremo resources
una tabella per il salvataggio dei dati scaricati da Downloader.
la tabella in questione la chiameremo snapshots
Scelta della tipologia di siti Web da prendere come riferimento
E' stato stabilito che i siti Web da prendere come riferimento fossero unicamente appartenenti alla
famiglia delle Banche Online e Istituti di Credito
Raccolta di URLs dei siti scelti come riferimento
Partendo da una ricerca con il motore Google Directory, ad esempio, è possibile trovare elenchi di
URLs interessanti per il progetto
il numero di URLs ritenuto adeguato per il progetto è stato stimato attorno alle 500 unità,
di conseguenza si è pensato di sviluppare un programma che in automatico riesca ad estrarre
e a salvare URLs interessanti presenti in pagine HTML come quella di sopra
8
9. Raccolta di informazioni dei siti scelti come riferimento
Il programma principale del progetto, il Downloader, è strutturato in modo da poter
scaricare tutto il contenuto della pagina verso cui si effettua la connessione
estrarre tutte le parti di codice JavaScript contenuto all'interno della pagina stessa
estrarre tutte le parti di codice JavaScript riferito all'interno della pagina stessa
estrarre tutti gli URLs riferiti all'interno della pagina e verso questi effettuare una nuova
connessione
essere ricorsivo con un livello di ricorsione definibile dall'utente
essere multithreading e schedulabile
9
10. struttura della Base di Dati
Struttura dello Schema per la Base di Dati necessaria:
lo Schema in questione, chiamato “stedrake”, consta di un set di tabelle così definite:
users
elenca i vari utenti che accedono allo Schema; ogni utente registrato può usare le tabelle per
diversi studi
sites
elenca le varie tipologie di siti Web da monitorare, ad esempio informazione, finanza, salute,
società etc
resources
elenca i siti Web da monitorare, raggruppati o meno per categorie
snapshots
elenca gli Snapshots acquisiti dai siti Web
sensoroutcomes
elenca i risultati delle elaborazioni sugli Snapshots
di seguito viene riportato in dettaglio la struttura di ogni tabella.
10
11. Tabella users
le utenze dello Schema vengon identificate dalla Primary Key “id”, altri campi identificano
la email, il nome e il cognome dell'utente
elenco delle chiavi:
Primary Key “id” è un tipo BigInt, Java lo interpreterà come tipo Long, non può essere null
ed è autoincrementale
elenco dei campi:
“email” è l'indirizzo email dell'utente, è un tipo VarChar, Java lo interpreterà come tipo
String, non può essere null
“password” è la password dell'utente per accedere allo Schema, è un tipo VarChar, Java lo
interpreterà come tipo String, non può essere null
“name” è il nome dell'utente per accedere allo Schema, è un tipo VarChar, Java lo
interpreterà come tipo String, non può essere null
“lastName” è il cognome dell'utente, è un tipo VarChar, Java lo interpreterà come tipo
String, non può essere null
11
12. Tabella sites
le tipologie dei siti Web vengon identificate dalla Primary Key “id”,
altri campi identificano il nome della tipologia, una data di riferimento, un intervallo temporale per
il monitoraggio e a quale utenza questa categoria è riferita; questo ultimo campo è Foreign Key
verso la tabella users
elenco delle chiavi:
Primary Key “id” è un tipo BigInt, Java lo interpreterà come tipo Long, non può essere null
ed è autoincrementale
Foreign Key “userId” punta alla Primary Key “id” della tabella users, è un tipo BigInt, Java
lo interpreterà come tipo Users, non può essere null perchè deve esistere una dipendenza
Users => Sites di tipo uno a molti
elenco dei campi:
“name” è il nome delle tipologie di siti Web, è un tipo VarChar, Java lo interpreterà come
tipo String, non può essere null
“monitoringReferenceTime” è la data di riferimento, è un tipo DateTime, Java lo
interpreterà come tipo Date, non può essere null
“monitoringInterval” è l'intervallo di tempo tra un monitoraggio ed un altro, è un tipo
Integer, Java lo interpreterà come tipo int, non può essere null
12
13. Tabella resources
i siti Web vengon identificati dalla Primary Key “id”,
altri campi identificano il nome del sito Web, l'URL e a quale tipologia di siti Web questo sito è
riferito; questo ultimo campo è Foreign Key verso la tabella sites
elenco delle chiavi:
Primary Key “id” è un tipo BigInt, Java lo interpreterà come tipo Long, non può essere null
ed è autoincrementale
Foreign Key “siteId” punta alla Primary Key “id” della tabella sites, è un tipo BigInt, Java lo
interpreterà come tipo Sites, non può essere null perchè deve esistere una dipendenza Sites
=> Resources di tipo uno a molti
elenco dei campi:
“name” è il nome della pagina HTML delimitato dal tag TITLE, è un tipo VarChar, Java lo
interpreterà come tipo String, può essere null
“url” è l'URL della pagina HTML, è un tipo VarChar, Java lo interpreterà come tipo String,
non può essere null
13
14. Tabella sensoroutcomes
i risultati di una elaborazione vengon identificati dalla Primary Key “id”,
altri campi identificano la data dell'avvenuta computazione, quanto tempo è servito, quale Classe ha
prodotto l'elaborazione e che versione, il risultato ottenuto e da quale Snapshot è stato elaborato il
risultato; questo ultimo campo è Foreign Key verso la tabella snapshots
elenco delle chiavi:
Primary Key “id” è un tipo BigInt, Java lo interpreterà come tipo Long, non può essere null
ed è autoincrementale
Foreign Key “snapshotId” punta alla Primary Key “id” della tabella snapshots, è un tipo
BigInt, Java lo interpreterà come tipo Snapshots, non può essere null perchè deve esistere
una dipendenza Snapshots => Sensoroutcomes di tipo uno a molti
elenco dei campi:
“computationDate” è la data della computazione, è un tipo DateTime, Java lo interpreterà
come tipo Date, non può essere null
“computationTime” indica il tempo di computazione, è un tipo BigInt, Java lo interpreterà
come tipo Long, non può essere null
“authorClassName” è il nome della Classe che ha prodotto l'elaborazione, è un tipo VarChar,
Java lo interpreterà come tipo String, può essere null
14
15. “authorSerialVersionUID” è la versione della Classe che ha prodotto l'elaborazione, è un
tipo BigInt, Java lo interpreterà come tipo Long, non può essere null
“outcome” è il prodotto dell'elaborazione, è un tipo MediumBlog, Java lo interpreterà come
tipo byte[], non può essere null
15
16. Tabella snapshots
in questa tabella vengono salvati più elementi, ognuno di questi elementi è uno Snapshot:
l'intera pagina HTML verso la quale viene effettuata la connessione, tale elemento è
identificato dal tipo “html”
ogni singolo blocco di codice JavaScript presente all'interno della pagina HTML
precedentemente scaricata, tale elemento è identificato dal tipo “embeddedJS”
ogni singolo blocco di codice JavaScript riferito all'interno della pagina HTML
precedentemente scaricata e non presente all'interno di essa, tale elemento è identificato dal
tipo “referencedJS”
ogni singolo elemento Frame presente all'interno della HTML precedentemente scaricata,
tale elemento è identificato dal tipo “frame”
gli snapshots vengono identificati dalla Primary Key “id”,
altri campi identificano la data di scaricamento dell'oggetto e quanto tempo è stato impiegato, il tipo
dell'oggetto, il tipo di codifica ad esso applicata, l'oggetto scaricato, l'indirizzo IP da cui è stato
scaricato e l'URL, la versione del programma Downloader che ha eseguito lo scaricamento, la
Risorsa di riferimento, lo Snapshot, se presente, che ha portato alla elaborazione di ogni singolo
Snapshot; questi ultimi 2 campi sono Foreign Key verso la tabella resources e verso la tabella
snapshots
16
17. elenco delle chiavi:
Primary Key “id” è un tipo BigInt, Java lo interpreterà come tipo Long, non può essere null
ed è autoincrementale
Foreign Key “resourceId” punta alla Primary Key “id” della tabella resources, è un tipo
BigInt, Java lo interpreterà come tipo Resources, non può essere null perchè deve esistere
una dipendenza Resources => Snapshots di tipo uno a molti
Foreign Key “parentSnapshotId” punta alla Primary Key “id” della tabella snapshots, è un
tipo BigInt, Java lo interpreterà come tipo Snapshots, può essere null perchè può non
esistere una dipendenza Snapshots => Snapshots di tipo uno a molti.
Un valore assegnato indica che lo snapshot in questione è stato creato dipendentemente da
uno snapshot avente come “id” proprio il valore assegnato; viene così descritta una
dipendenza padre-figlio tra uno e più snapshot.
Un valore non assegnato indica che lo snapshot in questione non è stato creato
dipendentemente da un altro snapshot; esso non ha padre.
elenco dei campi:
“downloadDate” è la data di scaricamento, è un tipo DateTime, Java lo interpreterà come
tipo Date, non può essere null
“downloadTime” indica il tempo di scaricamento, è un tipo BigInt, Java lo interpreterà come
tipo Long, non può essere null
“contentType” è il tipo di oggetto scaricato (html, javascript embedded o referenced, frame),
è un tipo VarChar, Java lo interpreterà come tipo String, non può essere null
“contentEncoding” se presente indica la codifica di carattere per pagine XHTML, è un tipo
VarChar, Java lo interpreterà come tipo String, non può essere null
“content” è l'oggetto scaricato, è un tipo MediumBlog, Java lo interpreterà come tipo byte[],
non può essere null
“ipAddress” è l'indirizzo IP dell'oggetto scaricato, è un tipo VarChar, Java lo interpreterà
come tipo String, non può essere null
“url” è l'URL dell'oggetto scaricato, è un tipo VarChar, Java lo interpreterà come tipo String,
non può essere null
“downloaderVersion” è la versione del programma Downloader che ha eseguito lo
scaricamento, è un tipo Integer, Java lo interpreterà come tipo int, non può essere null
di seguito viene riportato il diagramma Entità – Relazioni.
17
18. diagramma Entità - Relazioni
Legenda:
P = Primary Key
F = Foreign Key
A = Autoincremental
N = Not Null
di seguito vengono riportate le EntityClass riferite alle tabelle necessarie allo sviluppo del progetto.
18
19. Class Users
@Entity
@Table(name = quot;usersquot;)
public class Users implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@Column(name = quot;idquot;, nullable = false)
private Long id;
@Column(name = quot;emailquot;, nullable = false)
private String email;
@Column(name = quot;passwordquot;, nullable = false)
private String password;
@Column(name = quot;namequot;, nullable = false)
private String name;
@Column(name = quot;lastNamequot;, nullable = false)
private String lastName;
@OneToMany(cascade = CascadeType.ALL, mappedBy = quot;userIdquot;)
private Set<Sites> setSites;
public Users() {
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public Set<Sites> getSitesCollection() {
return setSites;
}
public void setSitesCollection(Set<Sites> setSites) {
this.setSites = setSites;
}
}
19
20. Class Sites
@Entity
@Table(name = quot;sitesquot;)
public class Sites implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@Column(name = quot;idquot;, nullable = false)
private Long id;
@Column(name = quot;namequot;, nullable = false)
private String name;
@Column(name = quot;monitoringReferenceTimequot;, nullable = false)
@Temporal(TemporalType.TIMESTAMP)
private Date monitoringReferenceTime;
@Column(name = quot;monitoringIntervalquot;, nullable = false)
private int monitoringInterval;
@JoinColumn(name = quot;userIdquot;, referencedColumnName = quot;idquot;)
@ManyToOne
private Users userId;
@OneToMany(cascade = CascadeType.ALL, mappedBy = quot;siteIdquot;)
private Set<Resources> setResources;
public Sites() {
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Date getMonitoringReferenceTime() {
return monitoringReferenceTime;
}
public void setMonitoringReferenceTime(Date monitoringReferenceTime) {
this.monitoringReferenceTime = monitoringReferenceTime;
}
public int getMonitoringInterval() {
return monitoringInterval;
}
public void setMonitoringInterval(int monitoringInterval) {
this.monitoringInterval = monitoringInterval;
}
public Users getUserId() {
return userId;
}
public void setUserId(Users userId) {
this.userId = userId;
}
public Set<Resources> getResourcesCollection() {
return setResources;
}
public void setResourcesCollection(Set<Resources> setResources) {
this.setResources = setResources;
}
}
20
21. Class Resources
@Entity
@Table(name = quot;resourcesquot;)
public class Resources implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@Column(name = quot;idquot;, nullable = false)
private Long id;
@Column(name = quot;namequot;)
private String name;
@Column(name = quot;urlquot;, nullable = false)
private String url;
@JoinColumn(name = quot;siteIdquot;, referencedColumnName = quot;idquot;)
@ManyToOne
private Sites siteId;
@OneToMany(cascade = CascadeType.ALL, mappedBy = quot;resourceIdquot;)
private Set<Snapshots> setSnapshots;
public Resources() {
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public Sites getSiteId() {
return siteId;
}
public void setSiteId(Sites siteId) {
this.siteId = siteId;
}
public Set<Snapshots> getSnapshotsCollection() {
return setSnapshots;
}
public void setSnapshotsCollection(Set<Snapshots> setSnapshots) {
this.setSnapshots = setSnapshots;
}
}
21
22. Class Snapshots
@Entity
@Table(name = quot;snapshotsquot;)
public class Snapshots implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@Column(name = quot;idquot;, nullable = false)
private Long id;
@Column(name = quot;downloadDatequot;, nullable = false)
@Temporal(TemporalType.TIMESTAMP)
private Date downloadDate;
@Column(name = quot;downloadTimequot;, nullable = false)
private long downloadTime;
@Column(name = quot;contentTypequot;, nullable = false)
private String contentType;
@Column(name = quot;contentEncodingquot;, nullable = false)
private String contentEncoding;
@Lob
@Column(name = quot;contentquot;, nullable = false)
private byte[] content;
@Column(name = quot;ipAddressquot;, nullable = false)
private String ipAddress;
@Column(name = quot;urlquot;, nullable = false)
private String url;
@JoinColumn(name = quot;resourceIdquot;, referencedColumnName = quot;idquot;)
@ManyToOne
private Resources resourceId;
@OneToMany(mappedBy = quot;parentSnapshotIdquot;)
private Set<Snapshots> setSnapshots;
@JoinColumn(name = quot;parentSnapshotIdquot;, referencedColumnName = quot;idquot;)
@ManyToOne
private Snapshots parentSnapshotId;
@Column(name = quot;downloaderVersionquot;, nullable = false)
private Integer downloaderVersion;
public Snapshots() {
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Date getDownloadDate() {
return downloadDate;
}
public void setDownloadDate(Date downloadDate) {
this.downloadDate = downloadDate;
}
public long getDownloadTime() {
return downloadTime;
}
public void setDownloadTime(long downloadTime) {
this.downloadTime = downloadTime;
}
public String getContentType() {
return contentType;
}
public void setContentType(String contentType) {
this.contentType = contentType;
}
22
23. public String getContentEncoding() {
return contentEncoding;
}
public void setContentEncoding(String contentEncoding) {
this.contentEncoding = contentEncoding;
}
public byte[] getContent() {
return content;
}
public void setContent(byte[] content) {
this.content = content;
}
public String getIpAddress() {
return ipAddress;
}
public void setIpAddress(String ipAddress) {
this.ipAddress = ipAddress;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public Resources getResourceId() {
return resourceId;
}
public void setResourceId(Resources resourceId)
{
this.resourceId = resourceId;
}
public Set<Snapshots> getSnapshotsCollection() {
return setSnapshots;
}
public void setSnapshotsCollection(Set<Snapshots> setSnapshots) {
this.setSnapshots = setSnapshots;
}
public Snapshots getParentSnapshotId() {
return parentSnapshotId;
}
public void setParentSnapshotId(Snapshots parentSnapshotId) {
this.parentSnapshotId = parentSnapshotId;
}
public void setDownloaderVersion(Integer downloaderVersion)
{
this.downloaderVersion = downloaderVersion;
}//setDownloaderVersion
public Integer getDownloaderVersion()
{
return downloaderVersion;
}//getDownloaderVersion
}
23
24. Class Sensoroucomes
@Entity
@Table(name = quot;sensoroutcomesquot;)
public class Sensoroutcomes implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@Column(name = quot;idquot;, nullable = false)
private Long id;
@Column(name = quot;computationDatequot;, nullable = false)
@Temporal(TemporalType.TIMESTAMP)
private Date computationDate;
@Column(name = quot;computationTimequot;, nullable = false)
private long computationTime;
@Column(name = quot;authorClassNamequot;, nullable = false)
private String authorClassName;
@Column(name = quot;authorSerialVersionUIDquot;, nullable = false)
private long authorSerialVersionUID;
@Lob
@Column(name = quot;outcomequot;)
private byte[] outcome;
public Sensoroutcomes() {
}
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Date getComputationDate() {
return computationDate;
}
public void setComputationDate(Date computationDate) {
this.computationDate = computationDate;
}
public long getComputationTime() {
return computationTime;
}
public void setComputationTime(long computationTime) {
this.computationTime = computationTime;
}
public String getAuthorClassName() {
return authorClassName;
}
public void setAuthorClassName(String authorClassName) {
this.authorClassName = authorClassName;
}
public long getAuthorSerialVersionUID() {
return authorSerialVersionUID;
}
public void setAuthorSerialVersionUID(long authorSerialVersionUID) {
this.authorSerialVersionUID = authorSerialVersionUID;
}
public byte[] getOutcome() {
return outcome;
}
public void setOutcome(byte[] outcome) {
this.outcome = outcome;
}
}
24
25. LinkExtractor
Il programma LinkExtractor è stato suddiviso per semplicità di progettazione in 3 parti ognuna delle
quali esegue specificatamente un compito; le 3 parti in questione sono:
JLinkExtractor
JFileOrganizer
JurlSaver
JlinkExtractor
Programma scritto per estrarre in maniera semiautomatica da una pagina HTML i riferimenti a
HomePages di Istituti di Credito e Banche Online ritenuti interessanti per lo studio.
Il programma in esecuzione si presenta così:
in alto a destra è possibile inserire un URL dal quale estrarre altri URL alla pressione del bottone
“extract”.
Il risultato dell'estrazione viene presentato nella lista in alto a sinistra; da tale lista è possibile
eliminare elementi che hanno al loro interno stringhe uguali a quelle digitate all'interno del campo
“remove links that match”.
E' possibile selezionare uno o più elementi presenti nella lista e visualizzarli all'interno di un web
browser cliccando il bottone “browse selection”.
25
26. La versione attuale del programma JLinkExtractor permette di salvare la lista ottenuta su un file,
questo perchè in seguito verranno eseguite altre operazioni di filtraggio, ma se la lista ottenuta è la
lista definitiva si può modificare il JLinkExtractor in modo che possa salvare le informazioni
direttamente nella Base di Dati.
In basso a sinistra è presente un campo di testo per eventuali messaggi di errore in fase di lettura e
in fase di scrittura.
esempio di utilizzo del programma:
inserimento di un URL di riferimento e pressione del bottone “extract”
filtraggio degli elementi presenti nella lista, ad esempio rimozione di tutti gli indirizzi che
contengono la stringa “google”
salvataggio della lista ottenuta su un file, ad esempio “US Federal Reserve.txt”
26
27. JfileOrganizer
Il programma legge ogni singola riga presente in uno o più files e rimuove i duplicati, il risultato
viene salvato su un nuovo file;
è stato scritto perchè è stato riscontrato che uno stesso URL può essere elencato più volte in
differenti pagine Web.
Il programma in esecuzione si presenta così:
In alto a sinistra è possibile caricare uno o più files alla pressione del bottone “load file”,
al momento della lettura vengono eliminate tutte le righe duplicate.
In alto a destra è possibile salvare la nuova lista di URL senza duplicati su un nuovo file.
In basso a sinistra e a destra sono presenti due campi di testo per eventuali messaggi di errore in
fase di lettura e in fase di scrittura.
27
28. esempio di utilizzo del programma:
caricamento di uno o più files alla pressione del bottone “load file”
assegnazione del nome e salvataggio di tutta la lista senza duplicati su un unico file alla
pressione del bottone “save file”
28
29. JurlSaver
Il programma legge ogni singola riga presente in un file, esegue una connessione allo Schema
“stedrake” della Base di Dati e crea un nuovo record per ogni riga.
Il programma in esecuzione si presenta così:
esempio di utilizzo del programma:
caricamento di un file alla pressione del bottone “load file”
salvataggio di ogni riga presente sul file nella Base di Dati, per la precisione i dati vengono
salvati nella tabella resources alla pressione del bottone “save on db”
29
30. Downloader
Il programma Downloader è stato suddiviso per semplicità di progettazione in 2 parti ognuna delle
quali esegue specificatamente un compito; le 2 parti in questione sono:
DownloaderLauncher
Downloader
DownloaderLauncher
Programma scritto per allocare, schedulare e lanciare varie istanze del programma Downloader .
Durante l'esecuzione si connette alla Base di Dati, legge dalla tabella resources tutti i record
presenti, per ogni record estrae l'URL salvato e per ogni URL lancia una istanza del Downloader
con parametro l'URL attuale.
Operazioni del programma DownloaderLauncher
public void run() {
//inizializza un oggetto EntityManager
initEntityManager();
//stabilita la connessione con la Base di Dati chiede una lista di oggetti di tipo Resources
query = entityManager.createQuery(quot;SELECT r FROM Resources rquot;);
List<Resources> resultListResources = query.getResultList();
//termina un oggetto EntityManager
closeEntityManager();
//creazione di un oggetto ScheduledThreadPoolExecutor con una dimensione iniziale
ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(32);
//per ogni oggetto di tipo Resources crea una nuova istanza dell'oggetto Downloader con parametro il riferimento alla risorsa attuale
for(Resources resource : resultListResources) {
scheduledThreadPoolExecutor.scheduleAtFixedRate(new Downloader(resource), 0, TIME_INTERVAL, TimeUnit.SECONDS);
}//for
}//run
in appendice un esempio di codice di DownloaderLauncher
30
31. Downloader
Programma scritto per scaricare tutto il contenuto di una pagina HTML associata all'URL passato
dal DownloaderLauncher come parametro.
Lo scaricamento viene eseguito in diverse modalità in relazione al tipo di informazione che si
desidera analizzare; gli oggetti presi in considerazione sono del tipo
html
javascript
All'interno dell'oggetto HTML si cercano eventuali riferimenti ad altre pagine HTML delimitati da
etichette di tipo frame, per ogni riferimento trovato si esegue una nuova connessione verso il nuovo
URL reiterando la procedura di scaricamento; il livello di ricorsione permette di stabilire quanto
estesa deve essere la ricerca. Sempre all'interno dell'oggetto HTML si cercano oggetti di tipo
javascript, interamente contenuti o solo riferiti; se presenti, si esegue un salvataggio dei primi e uno
scaricamento dei secondi ed entrambi vengono annotati come componenti figli della pagina HTML
di partenza.
Operazioni del programma Downloader
public void run() {
Snapshots downloadedSnapshot = download(startingResource, 0, quot;htmlquot;);
}//run
Snapshot download(Resources resource, int recursionLevel, String type) {
//se il livello di ricorsione è stato raggiunto esce
if (recursionLevel > MAX_RECURSION_LEVEL) return null;
//scarica il contenuto richiesto
byte[] content = directDownload(resource);
//se è un oggetto di tipo javascript referenziato
if(type.equals(REFERENCEDJS_CONTENT)) {
return new Snapshot(content);
}//if
//se è una pagina HTML
else if(type.equals(HTML_CONTENT)) {
//salva il contenuto intero della pagina
Snapshot pagina = new Snapshot(content);
//aggiunge gli snapshot inclusi
pagina.childrenSnapshots.put(EMBEDDEDJS_CONTENT, estraiEmbeddedJS(content));
//estrae gli snapshot referenziati
pagina.childrenSnapshots.put(REFERENCEDJS_CONTENT, downloadReferencedJS(content, recursionLevel));
//aggiunge le pagine html figlie (Frame)
pagina.childrenSnapshots.put(HTML_CONTENT, downloadFrames(content, recursionLevel));
return pagina;
}// else if
}//download
31
32. //torna una lista di oggetti di tipo javascript contenuti all'interno della pagina HTML
List<Snapshot> estraiEmbeddedJS(byte[] content) {
return listSnapshotsEmbeddedJS;
}//estraiEmbeddedJS
//torna una lista di riferimenti contenuti all'interno di etichette di tipo frame
List<Snapshot> downloadFrames(byte[] content, int recursionLevel) {
List<Snapshot> htmls = new ArrayList<Snapshot>();
List<String> htmlUrls = estraiFrames(content);
for(Iterator<String> it = htmlUrls.iterator(); it.hasNext();) {
String url = it.next();
//chiamata ricorsiva al downloader
htmls.add(download(url, recursionLevel+1, HTML_CONTENT));
}//for
return htmls;
}//downloadFrames
//torna una lista di oggetti di tipo javascript riferiti all'interno della pagina HTML
List<Snapshot> downloadReferencedJS(byte[] content, int recursionLevel) {
List<Snapshot> referencedJS = new ArrayList<Snapshot>();
List<String> referencedUrls = estraiReferencedJS(content);
for(Iterator<String> it = referencedUrls.iterator(); it.hasNext();) {
String url = it.next();
//chiamata ricorsiva al downloader
referencedJS.add(download(url, recursionLevel+1, REFERENCEDJS_CONTENT));
}//for
return referencedJS;
}// downloadReferencedJS
//torna una lista di riferimenti a oggetti di tipo javascript
List<String> estraiReferencedJS(byte[] content) {
return listSnapshotsReferencedJS;
}//estraiReferencedJS
in appendice un esempio di codice di Downloader
32
33. Capitolo 3: Conclusioni
La descrizione di una procedura per la raccolta di informazioni utili per la rilevazione di
defacement invisibili su siti web è stata eseguita con successo e le specifiche descritte
negli obiettivi della tesi sono state rispettate. Lo studio è stato effettuato prevalentemente
presso il Laboratorio Programmazione Reti di Calcolatori con la visione e l'aiuto
fondamentale del Professor Alberto Bartoli e dei Dottori Giorgio Davanzo e Eric Medvet.
33
34. Appendice
esempio di codice di DownloaderLauncher
public class DownloaderLauncher {
private EntityManagerFactory entityManagerFactory;
private EntityManager entityManager;
private String PERSISTENCE_UNIT_NAME = quot;SteDrakePUquot;;
private EntityTransaction transaction;
private Query query;
public static int TIME_INTERVAL = 60;
public static void main(String[] args) {
DownloaderLauncher downloaderLauncher = new DownloaderLauncher();
downloaderLauncher.run();
}//main
public void run() {
List<Resources> resultListResources = null;
entityManager = initEntityManager();
transaction = entityManager.getTransaction();
try {
transaction.begin();
query = entityManager.createQuery(quot;SELECT r FROM Resources rquot;);
resultListResources = query.getResultList();
}//try
finally {
if(transaction.isActive()) {
transaction.rollback();
}//if
closeEntityManager();
}//finally
ScheduledThreadPoolExecutor scheduledThreadPoolExecutor = new ScheduledThreadPoolExecutor(32);
for(Resources resource : resultListResources) {
scheduledThreadPoolExecutor.scheduleAtFixedRate(new Downloader(resource), 0, TIME_INTERVAL, TimeUnit.SECONDS);
}//for
}//run
public EntityManager initEntityManager() {
entityManagerFactory = Persistence.createEntityManagerFactory(PERSISTENCE_UNIT_NAME);
return entityManagerFactory.createEntityManager();
}//initEntityManager
public void closeEntityManager() {
entityManager.close();
entityManagerFactory.close();
}//closeEntityManager
}//DownloaderLauncher
34
35. esempio di codice di Downloader
public class Downloader implements Runnable {
private final static int DOWNLOADER_VERSION = 4;
private final static int MAX_RECURSION_LEVEL = 10;
private static String HTML_CONTENT = quot;htmlquot;;
private static String EMBEDDEDJS_CONTENT = quot;embeddedJSquot;;
private static String REFERENCEDJS_CONTENT = quot;referencedJSquot;;
private static String FRAME_CONTENT = quot;framequot;;
private Resources startingResource;
private final static int MAX_CONTENT_SIZE = 512000;
private final static int BUFFER_STEP_SIZE = 512;
private final static int MAX_ATTEMPTS = 3;
private final static long RETRY_INTERVAL_SECS = 10;
private EntityManagerFactory entityManagerFactory;
private EntityManager entityManager;
private String PERSISTENCE_UNIT_NAME = quot;SteDrakePUquot;;
private EntityTransaction transaction;
private Query query;
private long parentSnapshotID = 0;
private Snapshots parentSnapshot;
private Resources resourceReferencedJS;
private Resources parentResourceForFrame;
public Downloader(Resources startingResource) {
this.startingResource = startingResource;
entityManagerFactory = Persistence.createEntityManagerFactory(PERSISTENCE_UNIT_NAME);
}//Downloader
public void run() {
download(startingResource, 0, quot;htmlquot;);
entityManagerFactory.close();
}//run
public EntityManager initEntityManager() {
return entityManager = entityManagerFactory.createEntityManager();
}//initEntityManager
public void closeEntityManager() {
entityManager.close();
}//closeEntityManager
Snapshots download(Resources resource, int recursionLevel, String type) {
Snapshots snapshot = new Snapshots();
if(recursionLevel > MAX_RECURSION_LEVEL) {
return null;
}//if
Date globalDate = Calendar.getInstance().getTime();
long globalDownloadMillis = Calendar.getInstance().getTime().getTime();
byte[] content = directDownload(resource.getUrl());
globalDownloadMillis = Calendar.getInstance().getTime().getTime() - globalDownloadMillis;
if(type.equals(REFERENCEDJS_CONTENT)) {
Resources actualResource = resourceReferencedJS;
byte[] contentReferencedJS = null;
Date date = Calendar.getInstance().getTime();
long downloadMillis = Calendar.getInstance().getTime().getTime();
contentReferencedJS = directDownload(resource.getUrl());
downloadMillis = Calendar.getInstance().getTime().getTime() - downloadMillis;
snapshot.setDownloadDate(date);
snapshot.setDownloadTime(downloadMillis);
snapshot.setUrl(resource.getUrl());
snapshot.setIpAddress(getIPAddress(resource.getUrl(), type));
snapshot.setContentType(type);
snapshot.setResourceId(actualResource);
snapshot.setDownloaderVersion(DOWNLOADER_VERSION);
snapshot.setContentEncoding(getContentEncoding(resource.getUrl()));
snapshot.setParentSnapshotId(parentSnapshot);
35
