// Titolo: Stack in azione v0.2
// Autore: Saio
// Data: Marzo 2005

////////////
// PAG.02 //
////////////


-----------------------------
INDICE PAG.01 PAG.02 PAG.03 PAG.04
-----------------------------

///////MODIFICA DEL RET/////////

// Vediamo come cambiare l'indirizzo di ritorno di RET.
// Normalmente finita la chiamata di function in RET
// c'e' l'indirizzo che ci manda all'istruzione x=1, per cui in uscita
// avro' 1. Visto che ora sappiamo come ragiona lo stack (da pag.01),
// si puo' cambiare l'indirizzo al suo interno per saltare in una posizione
// da noi voluta, ad esempio quella subito precedente a printf("\n%d\n\n",x)
// in modo da saltare x=1 ed avere in uscita x=0.

------------------inizio example3.c (I)--------------------
void function(int a, int b, int c) {
char buffer1[5];
int *k;

k=buffer1+0;
*k=*k+0;
}

void main(){
int x;

x=0;
function (1,2,3);
x=1;
printf("\n%d\n\n",x);
}
-------------fine example3.c (I)------------------

//lanciamo il programma e verifichiamolo
[root@localhost phrack-49]# ./example3
1
[root@localhost phrack-49]#
// Conoscendo la posizione di buffer e' facile risalire alla posizione
// di RET che sara' situato a buffer+28, per cui k=buffer+28.
// Per sapere pero' che indirizzo immettervi dentro dobbiamo debuggare

[root@localhost phrack-49]# gcc -static example3.c -o example3
[root@localhost phrack-49]# gdb example3
(gdb) disassemble main
Dump of assembler code for function main:
0x8048200 <main>: push %ebp
0x8048201 <main+1>: mov %esp,%ebp
0x8048203 <main+3>: sub $0x8,%esp
0x8048206 <main+6>: movl $0x0,0xfffffffc(%ebp)
0x804820d <main+13>: sub $0x4,%esp
0x8048210 <main+16>: push $0x3
0x8048212 <main+18>: push $0x2
0x8048214 <main+20>: push $0x1
0x8048216 <main+22>: call 0x80481e0 <function>
0x804821b <main+27>: add $0x10,%esp
0x804821e <main+30>: movl $0x1,0xfffffffc(%ebp)
0x8048225 <main+37>: sub $0x8,%esp <----- indirizzo
0x8048228 <main+40>: pushl 0xfffffffc(%ebp)
0x804822b <main+43>: push $0x8092168
0x8048230 <main+48>: call 0x80486f0 <printf>
0x8048235 <main+53>: add $0x10,%esp
0x8048238 <main+56>: mov %ebp,%esp
0x804823a <main+58>: pop %ebp
0x804823b <main+59>: ret
0x804823c <main+60>: lea 0x0(%esi,1),%esi
End of assembler dump.
 
(gdb) disassemble function
Dump of assembler code for function function:
0x80481e0 <function>: push %ebp
0x80481e1 <function+1>: mov %esp,%ebp
0x80481e3 <function+3>: sub $0x28,%esp
0x80481e6 <function+6>: lea 0xffffffe8(%ebp),%eax
0x80481e9 <function+9>: mov %eax,0xffffffe4(%ebp)
0x80481ec <function+12>: mov 0xffffffe4(%ebp),%edx
0x80481ef <function+15>: mov 0xffffffe4(%ebp),%eax
0x80481f2 <function+18>: mov (%eax),%eax
0x80481f4 <function+20>: mov %eax,(%edx)
0x80481f6 <function+22>: mov %ebp,%esp
0x80481f8 <function+24>: pop %ebp
0x80481f9 <function+25>: ret
0x80481fa <function+26>: lea 0x0(%esi),%esi
End of assembler dump.
(gdb)q

// L'indirizzo che ci permette di saltare x=1 e' ' 0x8048225 ',
// per cui pongo *k=0x8048225 e quando la function dovra'
// tornare al main, nel leggere RET trovera' tale indirizzo
// da noi immesso. Riscriviamo il programma:


//////////// questo e' il programma che da 0 /////////////

-------------------inizio example3.c (II)-----------------------
void function(int a, int b, int c) {
char buffer1[5];
int *k;
k=buffer1+28;
*k=0x8048225;
}

void main(){
int x;

x=0;
function (1,2,3);
x=1;
printf("\n%d\n\n",x);
}
-------------------fine example3.c (II)-----------------------

// lanciamo il programma e verifichiamolo
[root@localhost phrack-49]# ./example3
0
[root@localhost phrack-49]#

///////////////////////// Note aggiuntive ///////////////////////

// Introduciamo buffer2[10] al programma e analizziamo lo stack
void function(int a, int b, int c) {
char buffer1[5];
char buffer2[10];
int *k;

k=buffer1+28;
*k=0x8048225;
}

void main(){
int x;

x=0;
function (1,2,3);
x=1;
printf("\n%d\n\n",x);
}


// Come mostrato in fig.02 Possiamo ottenere lo stesso risultato partendo
// Dal buffer2 e incrementando di 44 sullo stack per raggiungere il RET
// In questo caso il seguente programma dara' sempre 0 come uscita
void function(int a, int b, int c) {
char buffer1[5];
char buffer2[10];
int *k;

k=buffer2+44;
*k=0x8048225;
}

void main(){
int x;

x=0;
function (1,2,3);
x=1;
printf("\n%d\n\n",x);
}

// Potete trovare i miei dati di partenza per intero qui,



----------------------
INDICE PAG.01 PAG.02 PAG.03 PAG.04
----------------------