Rilevazione di defacement invisibili su siti Web: Tecniche per la raccolta di informazioni

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 BartoliUniversità degli Studi di Trieste

1

2

Rilevazione di defacement invisibili su siti Web:

Tecniche per la raccolta di informazioni

3

IndiceCapitolo 1: Introduzione.......................................................................................................................5

Defacement invisibili su siti Web: breve panoramica......................................................................5Metodi di attacco.............................................................................................................................6Profilo della Tesi..............................................................................................................................6Obiettivo della Tesi..........................................................................................................................6Motivazioni......................................................................................................................................6

Capitolo 2: Definizione roadmap.........................................................................................................7Delineamento della struttura del progetto per l'analisi delle informazioni......................................7Delineamento degli strumenti necessari .........................................................................................7Delineamento dei programmi necessari...........................................................................................7Delineamento di una Base di Dati necessaria..................................................................................8Scelta della tipologia di siti Web da prendere come riferimento.....................................................8Raccolta di URLs dei siti scelti come riferimento...........................................................................8Raccolta di informazioni dei siti scelti come riferimento................................................................9struttura della Base di Dati.............................................................................................................10LinkExtractor.................................................................................................................................25JlinkExtractor.................................................................................................................................25JfileOrganizer.................................................................................................................................27JurlSaver........................................................................................................................................29Downloader....................................................................................................................................30DownloaderLauncher.....................................................................................................................30

Operazioni del programma DownloaderLauncher....................................................................30Downloader....................................................................................................................................31

Operazioni del programma Downloader...................................................................................31Capitolo 3: Conclusioni......................................................................................................................33Appendice...........................................................................................................................................34

esempio di codice di DownloaderLauncher..............................................................................34esempio di codice di Downloader.............................................................................................35

4

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

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

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

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

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

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

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

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



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

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



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

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



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

“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

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



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

diagramma Entità - Relazioni

Legenda:P = Primary KeyF = Foreign KeyA = AutoincrementalN = Not Null

di seguito vengono riportate le EntityClass riferite alle tabelle necessarie allo sviluppo del progetto.

18

Class Users

@Entity@Table(name = "users")public class Users implements Serializable { private static final long serialVersionUID = 1L; @Id @Column(name = "id", nullable = false) private Long id; @Column(name = "email", nullable = false) private String email; @Column(name = "password", nullable = false) private String password; @Column(name = "name", nullable = false) private String name; @Column(name = "lastName", nullable = false) private String lastName; @OneToMany(cascade = CascadeType.ALL, mappedBy = "userId") 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

Class Sites

@Entity@Table(name = "sites")public class Sites implements Serializable { private static final long serialVersionUID = 1L; @Id @Column(name = "id", nullable = false) private Long id; @Column(name = "name", nullable = false) private String name; @Column(name = "monitoringReferenceTime", nullable = false) @Temporal(TemporalType.TIMESTAMP) private Date monitoringReferenceTime; @Column(name = "monitoringInterval", nullable = false) private int monitoringInterval; @JoinColumn(name = "userId", referencedColumnName = "id") @ManyToOne private Users userId; @OneToMany(cascade = CascadeType.ALL, mappedBy = "siteId") private Set<Resources> setResources;

public Sites() { }





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

Class Resources

@Entity@Table(name = "resources")public class Resources implements Serializable { private static final long serialVersionUID = 1L; @Id @Column(name = "id", nullable = false) private Long id; @Column(name = "name") private String name; @Column(name = "url", nullable = false) private String url; @JoinColumn(name = "siteId", referencedColumnName = "id") @ManyToOne private Sites siteId; @OneToMany(cascade = CascadeType.ALL, mappedBy = "resourceId") private Set<Snapshots> setSnapshots;

public Resources() { }





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

Class Snapshots

@Entity@Table(name = "snapshots")public class Snapshots implements Serializable { private static final long serialVersionUID = 1L; @Id @Column(name = "id", nullable = false) private Long id; @Column(name = "downloadDate", nullable = false) @Temporal(TemporalType.TIMESTAMP) private Date downloadDate; @Column(name = "downloadTime", nullable = false) private long downloadTime; @Column(name = "contentType", nullable = false) private String contentType; @Column(name = "contentEncoding", nullable = false) private String contentEncoding; @Lob @Column(name = "content", nullable = false) private byte[] content; @Column(name = "ipAddress", nullable = false) private String ipAddress; @Column(name = "url", nullable = false) private String url; @JoinColumn(name = "resourceId", referencedColumnName = "id") @ManyToOne private Resources resourceId; @OneToMany(mappedBy = "parentSnapshotId") private Set<Snapshots> setSnapshots; @JoinColumn(name = "parentSnapshotId", referencedColumnName = "id") @ManyToOne private Snapshots parentSnapshotId; @Column(name = "downloaderVersion", nullable = false) private Integer downloaderVersion; public Snapshots() { }



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

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

Class Sensoroucomes

@Entity@Table(name = "sensoroutcomes")public class Sensoroutcomes implements Serializable { private static final long serialVersionUID = 1L; @Id @Column(name = "id", nullable = false) private Long id; @Column(name = "computationDate", nullable = false) @Temporal(TemporalType.TIMESTAMP) private Date computationDate; @Column(name = "computationTime", nullable = false) private long computationTime; @Column(name = "authorClassName", nullable = false) private String authorClassName; @Column(name = "authorSerialVersionUID", nullable = false) private long authorSerialVersionUID; @Lob @Column(name = "outcome") private byte[] outcome;

public Sensoroutcomes() { }



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

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

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

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.


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


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

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.



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

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("SELECT r FROM Resources r"); 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

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, "html");}//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

//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

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

Appendice

esempio di codice di DownloaderLauncher

public class DownloaderLauncher { private EntityManagerFactory entityManagerFactory; private EntityManager entityManager; private String PERSISTENCE_UNIT_NAME = "SteDrakePU"; 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("SELECT r FROM Resources r"); 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

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 = "html"; private static String EMBEDDEDJS_CONTENT = "embeddedJS"; private static String REFERENCEDJS_CONTENT = "referencedJS"; private static String FRAME_CONTENT = "frame"; 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 = "SteDrakePU"; 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, "html"); 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

entityManager = initEntityManager(); transaction = entityManager.getTransaction();

try { transaction.begin(); entityManager.persist(snapshot); transaction.commit(); }//try finally { if(transaction.isActive()) { transaction.rollback(); }//if

closeEntityManager(); }//finally }//if else if(type.equals(FRAME_CONTENT)) { byte[] contentFrame = null; Date date = Calendar.getInstance().getTime(); long downloadMillis = Calendar.getInstance().getTime().getTime(); contentFrame = directDownload(resource.getUrl()); if(contentFrame != null) { snapshot.setContent(contentFrame); }//if else { snapshot.setContent("Content Error".getBytes()); }//else 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(parentResourceForFrame); snapshot.setDownloaderVersion(DOWNLOADER_VERSION); snapshot.setContentEncoding(getContentEncoding(resource.getUrl())); snapshot.setParentSnapshotId(parentSnapshot); entityManager = initEntityManager(); transaction = entityManager.getTransaction();


closeEntityManager(); }//finally }//else if

36

else if(type.equals(HTML_CONTENT)) { String ipAddress = null; if(content != null) { snapshot.setContent(content); }//if else { snapshot.setContent("Content Error".getBytes()); }//else snapshot.setDownloadDate(globalDate); snapshot.setDownloadTime(globalDownloadMillis); snapshot.setUrl(resource.getUrl()); ipAddress = getIPAddress(resource.getUrl(), type); snapshot.setIpAddress(ipAddress); snapshot.setContentType(type); snapshot.setResourceId(resource); snapshot.setDownloaderVersion(DOWNLOADER_VERSION); snapshot.setContentEncoding(getContentEncoding(resource.getUrl())); entityManager = initEntityManager(); transaction = entityManager.getTransaction();


closeEntityManager(); }//finally entityManager = initEntityManager(); transaction = entityManager.getTransaction(); List resultList = null; try { transaction.begin(); query = entityManager.createQuery("SELECT s FROM Snapshots s"); resultList = query.getResultList(); }//try finally { if(transaction.isActive()) { transaction.rollback(); }//if

closeEntityManager(); }//finally ListIterator listIterator = resultList.listIterator(); while(listIterator.hasNext()) { Snapshots actualSnapshot = (Snapshots) listIterator.next(); if(snapshot.getContentType().equals(actualSnapshot.getContentType()) && snapshot.getIpAddress().equals(actualSnapshot.getIpAddress())) { parentSnapshotID = actualSnapshot.getId(); }//if }//while snapshot.setId(parentSnapshotID); parentSnapshot = snapshot; Parser parser = null; boolean successParser = false; String actualURL = null; actualURL = resource.getUrl();

37

if(actualURL != null) { try { parser = new Parser(actualURL); successParser = true; }//try catch(ParserException ex) { ex.printStackTrace(); successParser = false; return null; }//catch }//if if(successParser) { ArrayList<Snapshots> arrayListSnapshotsEmbeddedJS = (ArrayList<Snapshots>) estraiEmbeddedJS(parser, snapshot); Iterator arrayListSnapshotsEmbeddedJSIterator = arrayListSnapshotsEmbeddedJS.iterator(); while(arrayListSnapshotsEmbeddedJSIterator.hasNext()) { Snapshots childSnapshot = (Snapshots) arrayListSnapshotsEmbeddedJSIterator.next(); Snapshots tempSnapshot = new Snapshots(); tempSnapshot.setDownloadDate(childSnapshot.getDownloadDate()); tempSnapshot.setDownloadTime(childSnapshot.getDownloadTime()); tempSnapshot.setContent(childSnapshot.getContent()); tempSnapshot.setUrl(childSnapshot.getUrl()); tempSnapshot.setIpAddress(childSnapshot.getIpAddress()); tempSnapshot.setContentType(childSnapshot.getContentType()); tempSnapshot.setResourceId(childSnapshot.getResourceId()); tempSnapshot.setDownloaderVersion(childSnapshot.getDownloaderVersion()); tempSnapshot.setContentEncoding(childSnapshot.getContentEncoding()); if(childSnapshot.getParentSnapshotId() != null) { tempSnapshot.setParentSnapshotId(childSnapshot.getParentSnapshotId()); }//if entityManager = initEntityManager(); transaction = entityManager.getTransaction();

try { transaction.begin(); entityManager.persist(tempSnapshot); transaction.commit(); }//try finally { if(transaction.isActive()) { transaction.rollback(); }//if

closeEntityManager(); }//finally }//while downloadReferencedJS(parser, recursionLevel, resource); downloadFrames(parser, recursionLevel, resource); }//if else { return null; }//else }//else if return snapshot; }//download List<String> downloadFrames(Parser parser, int recursionLevel, Resources resource) { parentResourceForFrame = null; List<String> listURL = new ArrayList<String>(); NodeList listFrame = null; boolean parserException = false;

38

if(parser != null) { try { listFrame = parser.parse(new HasAttributeFilter("FRAME")); }//try

catch(ParserException ex) { parserException = true; }//catch if(parserException) { listURL.clear(); }//if else { if(listFrame.size() > 0) { SimpleNodeIterator simpleNodeIteratorFrame = null; simpleNodeIteratorFrame = listFrame.elements();

while(simpleNodeIteratorFrame.hasMoreNodes()) { FrameTag frameTag = null; String frameName, frameLocation = null; frameTag = (FrameTag) simpleNodeIteratorFrame.nextNode(); frameName = frameTag.getFrameName(); frameLocation = frameTag.getFrameLocation(); if(frameLocation != null) { listURL.add(frameLocation); Resources resourceFromFrame = new Resources(); resourceFromFrame.setUrl(frameLocation); parentResourceForFrame = resource; download(resourceFromFrame, recursionLevel+1, FRAME_CONTENT); }//if }//while }//if }//else }//if return listURL; }//downloadFrames List<Snapshots> downloadReferencedJS(Parser parser, int recursionLevel, Resources resource) { List<Snapshots> referencedJS = new ArrayList<Snapshots>(); List<String> referencedUrls = estraiReferencedJS(parser, resource.getUrl()); resourceReferencedJS = resource; if(!referencedUrls.isEmpty()) { for(Iterator<String> it = referencedUrls.iterator(); it.hasNext();) { String url = null; url = it.next(); Resources fakeResource = null; fakeResource = new Resources(); fakeResource.setUrl(url); referencedJS.add(download(fakeResource, recursionLevel+1, REFERENCEDJS_CONTENT)); }//for }//if return referencedJS; }//downloadReferencedJS List<String> estraiReferencedJS(Parser parser, String url) { List<String> referencedUrls = new ArrayList<String>(); NodeList listScript = null; boolean parserException = false; if(parser != null) { try { listScript = parser.parse(new HasAttributeFilter("SCRIPT")); }//try

catch(ParserException ex) { Logger.getLogger(Downloader.class.getName()).log(Level.SEVERE, null, ex); parserException = true; }//catch

39

if(parserException) { referencedUrls.clear(); }//if else { parser.reset(); if(listScript.size() > 0) { SimpleNodeIterator simpleNodeIteratorScript = null; simpleNodeIteratorScript = listScript.elements();

while(simpleNodeIteratorScript.hasMoreNodes()) { ScriptTag scriptTag = null; String scriptTagGetAttributes = null; String type = null; String language = null; String urlSubString = null; scriptTag = (ScriptTag) simpleNodeIteratorScript.nextNode(); type = scriptTag.getType(); language = scriptTag.getLanguage(); scriptTagGetAttributes = scriptTag.getAttribute("src"); if(scriptTagGetAttributes != null) { if(url.endsWith("index.jsp")) { url.replace("index.jsp", ""); }//if

if(scriptTagGetAttributes.startsWith("http://") || scriptTagGetAttributes.startsWith("https://")) { referencedUrls.add(scriptTagGetAttributes); }//if

else { if(scriptTagGetAttributes.startsWith("../")) { int positionSlash = 0; scriptTagGetAttributes = scriptTagGetAttributes.substring(2); positionSlash = url.lastIndexOf("/"); urlSubString = url.substring(0, positionSlash); positionSlash = urlSubString.lastIndexOf("/"); urlSubString = urlSubString.substring(0, positionSlash);

if(!urlSubString.endsWith("/") && !scriptTagGetAttributes.startsWith("/")) { referencedUrls.add(urlSubString.concat("/").concat(scriptTagGetAttributes)); }//if

else { referencedUrls.add(urlSubString.concat(scriptTagGetAttributes)); }//else }//if

else { if(!url.endsWith("/") && !scriptTagGetAttributes.startsWith("/")) { referencedUrls.add(url.concat("/").concat(scriptTagGetAttributes)); }//if else { referencedUrls.add(url.concat(scriptTagGetAttributes)); }//else }//else }//else }//if }//while }//if }//else }//if return referencedUrls; }//estraiReferencedJS List<Snapshots> estraiEmbeddedJS(Parser parser, Snapshots parentSnapshot) { List<Snapshots> listSnapshot = new ArrayList<Snapshots>(); NodeList listScript = null; boolean successParser = false;

40

if(parser != null) { try { listScript = parser.parse(new HasAttributeFilter("SCRIPT")); successParser = true; }//try

catch(ParserException ex) { successParser = false; }//catch if(successParser) { parser.reset(); }//if }//if if(listScript != null) { if(listScript.size() > 0) { SimpleNodeIterator simpleNodeIteratorScript = null; simpleNodeIteratorScript = listScript.elements();

while(simpleNodeIteratorScript.hasMoreNodes()) { boolean realEmbeddedJS = true; ScriptTag scriptTag = null; String scriptCode = null; String scriptTagGetAttributes = null; scriptTag = (ScriptTag) simpleNodeIteratorScript.nextNode(); scriptCode = scriptTag.getScriptCode(); scriptTagGetAttributes = scriptTag.getAttribute("src"); if(scriptTagGetAttributes != null) { if(scriptCode.length() == 0 || scriptTagGetAttributes.startsWith("../") || scriptTagGetAttributes.startsWith("http://")|| scriptTagGetAttributes.startsWith("https://")) { realEmbeddedJS = false; }//if }//if if(realEmbeddedJS) { Snapshots snapshot = new Snapshots(); Date date = Calendar.getInstance().getTime(); long downloadMillis = Calendar.getInstance().getTime().getTime(); snapshot.setContent(new String(scriptCode).getBytes()); downloadMillis = 0;//Calendar.getInstance().getTime().getTime() - downloadMillis; snapshot.setDownloadDate(date); snapshot.setDownloadTime(downloadMillis); snapshot.setUrl(parentSnapshot.getUrl()); snapshot.setIpAddress(parentSnapshot.getIpAddress()); snapshot.setContentType(EMBEDDEDJS_CONTENT); snapshot.setResourceId(parentSnapshot.getResourceId()); snapshot.setDownloaderVersion(DOWNLOADER_VERSION); snapshot.setContentEncoding(getContentEncoding(parentSnapshot.getUrl())); snapshot.setParentSnapshotId(parentSnapshot); listSnapshot.add(snapshot); }//if }//while }//if }//if

return listSnapshot; }//estraiEmbeddedJS

public HttpURLConnection getConnection(String address) { HttpURLConnection.setFollowRedirects(true); HttpURLConnection conn = null;

URL urlSource = null;

41

try { urlSource = new URL(address); conn = (HttpURLConnection) urlSource.openConnection(); conn.setRequestProperty("User-Agent", "Mozilla/5.0 (Windows; U; Windows NT 6.0; it; rv:1.9.0.3) Gecko/2008092417 Firefox/3.0.3"); }//try

catch(Exception exception) { exception.printStackTrace();

}//catch

return conn; }//getConnection public String getContentEncoding(String stringURL) { String contentEncoding = "Unknown"; URL url = null; URLConnection uc = null; try { url = new URL(stringURL); }//try catch(MalformedURLException ex) { Logger.getLogger(Downloader.class.getName()).log(Level.SEVERE, null, ex); }//catch try { uc = url.openConnection(); }//try catch(IOException e) { System.err.println(e); }//catch contentEncoding = uc.getContentEncoding(); if(contentEncoding == null) { contentEncoding = "Unknown"; }//if return contentEncoding; }//getContentEncoding public String getIPAddress(String addressToCheck, String type) { boolean success = false; String ipAddress = ""; if(addressToCheck.startsWith("http://")) { addressToCheck = addressToCheck.substring(7); }//if

if(addressToCheck.startsWith("https://")) { addressToCheck = addressToCheck.substring(8); }//if

if(addressToCheck.endsWith("/")) { addressToCheck = (String) addressToCheck.subSequence(0, addressToCheck.length()-1); }//if if(type.equals(REFERENCEDJS_CONTENT)) { int firstSlash = addressToCheck.indexOf("/"); addressToCheck = addressToCheck.substring(0, firstSlash); }//if InetAddress inetAddress = null;

try { inetAddress = InetAddress.getByName(addressToCheck); success = true; }//try

42

catch(UnknownHostException ex) { success = false; }//catch

if(success) { byte[] ip = inetAddress.getAddress(); for(int index = 0; index < ip.length; index++) { if(index > 0) { ipAddress = ipAddress.concat("."); }//if

ipAddress = ipAddress.concat(String.valueOf(((int)ip[index])& 0xff)); }//for }//if else { ipAddress = "Unknown"; }//else return ipAddress; }//getIPAddress public byte[] directDownload(String url) { byte[] content = null; int attempts = MAX_ATTEMPTS; long downloadMillis = 0; while(attempts > 0) { try { URLConnection uc = (new URL(url)).openConnection(); uc.connect(); BufferedReader rb = new BufferedReader(new InputStreamReader(uc.getInputStream())); int offset = 0; int readBytes = 0; char[] charContent = new char[MAX_CONTENT_SIZE]; while((readBytes = rb.read(charContent, offset, BUFFER_STEP_SIZE)) != -1) { offset += readBytes; }//while content = new String(charContent).substring(0, offset).getBytes(); break; }//try catch(Throwable e) { attempts--; try { Thread.sleep(RETRY_INTERVAL_SECS * 1000); }//try catch(InterruptedException e2) { }//catch if(attempts == 0) { return null; }//if }//catch }//while if(content == null) { content = new String("content null").getBytes(); }//if return content; }//directDownload}//Downloader

43

Education

Rilevazione di defacement invisibili su siti Web: Tecniche per la raccolta di informazioni