Programmazione inversa Parte II

[Thejuster]

La scorsa volta, Abbiamo appreso qualche argomento basilare riguardante il linguaggio Assembly.

 

Ripeto però, che per poter moddare programmi o giochi, c'è bisogno di una conoscenza elevata di diversi linguaggi.
In questa lezione, iniziamo a fare sul serio :)

 

Apprenderemo come eseguire una mod / Patch di un programma.

 

Realizzeremo un Patch in C#.

Essi, proprio in C#.

Per un solo motivo, Per farvi capire che il C# non scherza nemmeno lui :P

 

Ho già preparato l'occorrente per questa lezione, e scritto 2 programmini ad hoc.

 

 

 

Cosa ci occore?

 

1) Strumento di Debugger
Abbiamo bisogno di Ollydbg o IDA., Consiglio Ollydbg per i newbie.

Io uso ADA per risalire anche ai vari namling delle librerie.

 

Download Ollydgb

 

http://www.ollydbg.de/download.htm

 

 

2) Strumento di editor Esadecimale

 

Come secondo tool, ci serve un buon editor esadecimale. ( HEX Editor )

vi consiglio

 

 

http://www.hhdsoftware.com/Downloads/free-hex-editor

 

 

3) Visual C#

 

Scaricabile dal sito di microsoft

 

 

 

4) Materiale per questa lezione

 

http://www.mediafire.com/download/aodd32vm24wrxe2/Lezione_2.rar

 

 

 

Cosa contiene il rar?

 

Contiene un programmino che ho scritto apposta in C++.

Il programmino simula lo status di un gioco. All'avvio è impostato su Schermata del titolo.

poi effettuando delle scelte, possiamo spostarci tipo in battaglia, shop, gioco, ecc. ecc.

 

Il nostro scopo è quello di modificare il programma, facendogli fare ciò che diciamo noi e non quello per la quale

è stato programmato.

 

Cosa dobbiamo fare?

Il programma contiene un modulo segreto. che ci mostrerà un messaggio nel caso riusciamo a chiamare quel metodo.

Invece, normalmente, non è stato programmato per eseguire quel metodo. Noi invece dobbiamo trovare il modo

di fargli attivare quel metodo nascosto.

 

 

All'interno trovate 3 file exe.

 

Hidden Quest (Moddato).exe

Questo è l'exe moddato. Sarà il risultato finale se riusciamo nell'impresa.

 

Hidden Quest.exe

E' l'exe originale senza mod

 

 

Hidden Quest Patcher.exe

E' il mio programma per patchare Hidden Quest.

Una volta che ho scoperto come attivare il modulo segreto, ho ricavato gli indirizzi ed i relativi Offset.

Successivamente, ho modificato il DUMP di memoria del file e gli ho detto di fare questo invece di quello.

 

C'è la possibilità sia di Patchare l'exe che riportarlo allo stato originale :)

 

 

E poi c'è la cartella sorgenti.

Dove c'è anche la mia soluzione.

 

Ma vi consiglio di non vedere la soluzione. Dobbiamo arrivarci noi.
Se invece non ci riuscite, potete guardare io come ho fatto.

 

 

 

LIVELLO PER PROGRAMMATORE ESPERTO: FACILE

LIVELLO PER NEWBIE : MEDIO / FACILE

 

Tempo impiegato per la soluzione: 10 minuti

Tempo totale (modifiche e creazione patcher) : 20 minuti

 

 

 

-----------------------------------------------------------------------------

 

Sorgente del programma principale

#include <iostream>
#include <conio.h>

using namespace std;

int avvio = 1;


void Funzione1()
{

    cout << "-------------------------------------" << endl;
    cout << "Questo e' il metodo pubblico, normalmente chiamato dall'applicazione" << endl;
    cout << "Prova a scroprire il metodo segreto..." << endl;
    cout << "Su avanti, invece di far apparire questo testo cerca di far apparire il testo contenuto nel metodo segreto" << endl;

    getch();

}

void Funzione2()
{
    cout << "-------------------------------------" << endl;
    cout << "Complimenti! hai moddato correttamente il programma" << endl;
    cout << "Questo e' il metodo segreto, il cui si attiva solo patchando il programma" << endl;
    cout << "Congratulazioni :)" << endl;

    getch();


}



int main()
{
    cout << "+----------------------------------" << endl;
    cout << "| Lezione di livello semplicissimo " << endl;
    cout << "+----------------------------------" << endl;
    cout << "\n\n" << endl;

    cout << "Questo programma ha 2 funzioni, una pubblica ed una nascosta." << endl;
    cout << "Normalmente e' stato programmato per avviare la funzione pubblica." << endl;
    cout << "Riesci a moddare questa applicazione e facendo avviare il metodo nascosto invece del pubblico?" << endl;

    cout << "\n\nPremi INVIO per avviare" << endl;

    getch();

    if(avvio == 1)
    {
        Funzione1();
    }

    if(avvio == 2)
    {
        Funzione2();
    }

    return 0;
}

Ricordate gli insegnamenti della prima lezione,

Usate la vostra fantasia, spremete il cervello e cercate di riuscire a moddare questo programma.

 

Il consiglio che vi dò, e di ricordavi dei termini e descrizioni della prima lezione.

Sopratutto, come chiamare i metodi e funzioni in assembly.

 

Se non ci riuscite entro questa sera,

La soluzione e spiegazione dettagliata ve la mando questa sera con calma :)

 

Se invece ci riuscite,

Spiegate come avete fatto passo passo.

 

 

Buona Fortuna.

Edited May 19, 2016 by Thejuster

[Thejuster]

nemmeno un commento?

 

o nessuno ha provato ad aprire Hidden Quest.exe con Ollydbg?

 

:)

[Makeratore]

@Thejuster, è contro il regolamento fare doppi-post (puoi farlo solo dopo 24 ore dall'ultimo post).

 

Se non c'è nessun commento, è dovuto sicuramente al fatto che hai aperto da pochissimo questo topic. ;)

[Guardian of Irael]

Difatti un solo giorno per provare potrebbe esser poco, io fino ad ora non ho avuto tempo >

[Thejuster]

Ed ecco qui ci siamo.

 

Dunque dovete sapere che lo scopo di questa lezione non era affatto casuale,

Sapevo benissimo che nessuno ci sarebbe riuscito dato del scarse conoscenze.

Lo davo già per scontato :)

 

L'obiettivo principale della lezione era quello di farvi aprire un exe con Ollydbg ed iniziare a spulciare il suo interno.

Per capire almeno come muovervi.

 

Le mie lezioni sono piccole, veloci ma molto complete.

Ed ho un metodo molto ottimale per insegnare le cose, nessuna guida è scritta a casaccio.

 

Nella prima lezione ho spiegato alcuni termini dell'assembly che vi ripeto qui

 

 

Queste sono delle istruzioni più comunemente usate in Assembly.

ADD Addizione
SUB Sottrazione
TEST Confronto logico
CMP Confronto tra due valore tipo if (aaa == bbb) { ok; }
NOP Nessuna Operazione
RET Return
JMP Salto Incondizionato

Se apriamo Hidden Quest.exe con Ollydbg trascinandolo nel programma cosa succede?

 

 

La riga evidenziata di nero, ci indica che quello è il punto di partenza del programma.

 

Scorrendo più in basso notiamo altre chiamate.

 

Proprio quello che Hidden Quest.exe ci dice quando lo apriamo

 

 

Come vedete, Abbiamo scovato all'interno dell'exe i due metodi.

Quello segreto e quello pubblico.

 

Ogni funzione, metodo o procedura e racchiusa tra quelle linee doppie nere.

Che ci indica dove inizia una procedura e dove finisce.

Quindi possiamo farci già un idea di come analizzare il codice.

 

Come detto nella prima lezione,

Nel campo [ 1 ]

Abbiamo gli indirizzi, sono quelli che ci dobbiamo ricordare.

 

Se premiamo F2 mettiamo un segnalino o Breackpoint per non dimenticarci dove sta.

Anche perché come notate, un semplicissimo programma in assembly è molto lungo.

 

 

Quindi analizziamo bene la prima parte del codice.

 

Notiamo che ci sono diversi CALL.

come spiegato precedentemente, il CALL chiama una procedura o funzione.

Quindi possiamo analizzare che dopo un tot di righe l'assembly ci chiama una procedura.

Ma fino a li va tutto bene, scendiamo più giu e vediamo cos'altro troviamo.

 

 

 

Oh, ed eccoci qui.

Abbiamo trovato il punto esatto di quando noi premiamo Enter.

Prima di premerlo ci dice: Premi INVIO per continuare.

E lo troviamo scritto proprio lì.

 

sotto, proprio come nel sorgente originale c'è la chiamata

getch();


return 0;


}

Ora qui, dobbiamo analizzare bene il codice Assembly e capire cosa fà.

CMP EAX,1
JNZ SHORT Hidden_Q.004015D4
CALL Hidden_Q.00401340

Ragioniamo.

 

CMP EAX,1 ( Se il valore nel registro AX è uguale a 1 )

JNZ SHORT Hidden_Q.004015D4 ( Ma se è minore di zero va a questa procedura che potrebbe essere NULL o dare un eccezione )

 

Altrimenti

 

 

CALL Hidden_Q.00401340 ( SE AX è uguale a 1, Chiama l'istruzione all'indirizzo 00401340 )

 

 

Quindi?

 

Noi, sappiamo che il programma è settato fisso su 1 ricordate?

 

int valore = 1;

 

quindi ci chiamerà sempre quell'indirizzo 00401340

 

Ma un momento, ritorniamo sopra e cerchiamo questo indirizzo vediamo dove si trova.

 

 

 

 

 

 

Eccolo lì beccato.

00401340   |     %55 PUSH  EBP

Sotto notiamo un'altra istruzione, che sarebbe il metodo nascosto!

004013E1 |   %55 PUSH EBP

Perfetto direi, li abbiamo beccati entrambi! :D

 

Ora non ci resta che modificare, e dirgli che invece di chiamare quell'indirizzo ovvero 00401340 Che è il metodo pubblico,

ci deve chiamare 004013E1 che sarebbe il metodo nascosto.

 

Ma come?

 

Scendiamo di nuovo giù alla funzione CALL sotto al CMP EAX,1 dove eravamo prima.

 

Proprio li.

 

 

 

 

Clicchiamo con il tasto destro su quella chiamata che ci porta al metodo pubblico ( 00401340 )

e seguiamo dove ci porta nel DUMP di memoria.

 

 

 

Notiamo che ci seleziona degli offset.

A noi serviranno proprio quelli!

 

Quindi segniamoceli da qualche parte, tipo sul blocco notes.

 

E8 6C FD FF FF

 

 

Ora sempre tenendo selezionato la righa, premiamo spazio, ed incolliamo l'indirizzo del metodo nascosto che sarebbe 004013E1

Se non lo ricordate dove lo abbiamo visto guardate 2 screen sopra a questa.

 

Quindi cosa succede ora.

 

 

 

Modificando il CALL e premendo invio, notiamo che gli offset nel DUMP di memoria sono cambiati!

 

quindi questo nuovo set di indirizzi, saranno la patch al nostro programma

 

quindi copiamoci anche questi e gli commentiamo scrivendo.

 

Patch: E8 0D FE FF FF

 

 

Ora abbiamo gli offset sia originali che Patchati.

 

 

Originali: E8 6C FD FF FF

Patchati: E8 0D FE FF FF

 

 

 

Già ora, abbiamo correttamente patchato il nostro programma.

Ci basterebbe salvarlo e puff, abbiamo patchato il programma.

 

Ma noi dobbiamo creare un patcher giusto? non farlo manualmente dunque come si fà? come funziona?

 

 

Apriamo il nostro Editor Esadecimale ( HEX Editor )

 

 

Apriamo Sempre Hidden Quest.exe

 

 

Premiamo CTRL + F per iniziare una ricerca,

e cambiamo il metodo di ricerca.

Anzichè cercare una Stringa, cerchiamo gli offset esadecimali.

 

 

 

 

 

 

 

Scriviamo uno per uno gli offset originali! non quelli patchati perchè non esistono.

 

 

 

premendo su FIND ci cercherà esattamente dove è situato il SET di Offset che stiamo cercando.

Difatti, notate che ci ha selezionato e8 e a continuare ci sono gli altri.

 

e8 6c fd ff ff

 

Selezioniamoli.

 

 

 

 

Ora dobbiamo sapere precisamente a quale indirizzo del di memoria sono situati gli Offset

per poterli patchare.

 

 

 

 

 

Se ora premiamo sul primo offset, notiamo in basso l'indirizzo dell'offset

 

quindi ora sappiamo che:

 

 

All'indirizzo:

0x000009cf abbiamo e8

 

successivamente abbiamo

 

 

 

0x000009cf : 6c

 

e continuiamo a segnarceli sul blocco notes

 

fino ad avere un qualcosa del genere

0x000009cf : 0xe8
0x000009d0 : 0x6c
0x000009d1 : 0xfd
0x000009d2 : 0xff
0x000009d3 : 0xff

bene questi sono gli indirizzi relativi di offset.

 

quindi ora vi ricordate cosa dovevamo fare per patcharli?

 

cambiare gli offset.

 

 

Originali: E8 6C FD FF FF

Patchati: E8 0D FE FF FF

 

quindi in

 

0x000009d0 : 0x6c

 

sarà

 

0x000009d0 : 0x0D

 

 

e

 

0x000009d1 : 0xfd

 

sarà

 

0x000009d1 : 0xfe

 

 

.

 

questà ragazzi miei e la patch finale.

Ora siamo in grado di patchare il nostro programma.

 

 

Apriamo visual C#

 

creiamo un form

 

e un pulsante. per fare prima.

 

 

Con questo metodo, permettiamo di aprire un file exe e di passarlo successivamente allo stream

OpenFileDialog op = new OpenFileDialog();

            op.Filter = "File exe (*.exe)|*.exe";

            if (op.ShowDialog() == System.Windows.Forms.DialogResult.OK)
            {
                // Continua
            }

Ora Inizializziamo lo stream

OpenFileDialog op = new OpenFileDialog();

op.Filter = "File exe (*.exe)|*.exe";

if (op.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{


            FileStream fs = new FileStream(textBox1.Text, FileMode.Open, FileAccess.ReadWrite);

             //Ci posizioniamo agli indirizzo dell'offset
             //e scriviamo le modifiche :)

            fs.Position = 0x000009cf;
            fs.WriteByte(0xe8);
            fs.Position = 0x000009d0;
            fs.WriteByte(0x0d);
            fs.Position = 0x000009d1;
            fs.WriteByte(0xfe);
            fs.Position = 0x000009d2;
            fs.WriteByte(0xff);
            fs.Position = 0x000009d3;
            fs.WriteByte(0xff);
            fs.Close();

            MessageBox.Show("Programma Patchato :)");

}

Ecco fatto ragazzi.

 

Ora premendo sul pulsante, e scegliendo il file abbiamo patchato il programma.

Avviate e guardate :)

[Guardian of Irael]

 

Le mie lezioni sono piccole, veloci ma molto complete.

Io pure questa sera esco ed a parte aver finito di leggere da ieri notte a stamattina le soluzioni non ho avuto modo di applicarle e neanche di capire se erano così impossibili >

Comunque buona spiegazione anche condita di immagini passo passo! Il metodo mi piace, sì.

^ ^