Some days ago after many more days of research and reversing I managed to solve a crackme that a friend of mine (CT) passed to me. This crackme was supposed to be used in a security conference held in Spain called
NoConName and was conceived to be presented as the II level of a crackme contest.
Where to find the crackme?
During the days I was trying to solve the crackme I found a really interesting web portal devoted to crackers (in the good/bad sense
) that is basically a repository of crackmes, solutions, forums ... everything I would ask for a place like this to be.
Some tips
- If you are a beginner as I was/am in the reversing field your best friends for this crackme can be:
- But I heard that some people haven't even needed to disassemble, in this post I cover a reversing view of solving the crackme.
- I have worked quite a lot with the output taken from Objdump, but then I saw It would be easier to use the GDB output (set logging file FILE) because of the relative memory addresses that it uses (main+243) that match more precisely with the output you get when debugging with GDB.
- Use breakpoints to see how the program executes
- Use watchpoints to check the values that the variables hold over the time
- As for every crack there is something that allows you to find the solution and this is ranked as an easy crack
- Maybe in certain moments you don't know that the code does but you can anticipate the ranges in the result you will get
My dirty solution
If you are really really fed up and want to see my solution (haven't uploaded to crackmes.de yet as I want people to be interested in solving it as, well) here you have my friend! Sorry that it's an [javascript:void(0);/*1247300948733*/ spanglish] code
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define MAX_STR 1000
//many variables, some of them are written in spanish
int len,newpos,salto,i,j,increase=5,ciphered_index,seed_value,procesed=0;
//cifred = encrypted ;) it will hold the ciphered string
int cifred[MAX_STR];
//reversed= decyphered string
char reversed[MAX_STR], str[MAX_STR];
//array taken from original crackme executable that is used to do the translations between numbers and letters
char alphabet[]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
//function reversed/regenerated from crackme binary that is used to tell which position of the array we are decrypting.
//i think CT (the author) just used it so that ncn binary encrypted strings in a non sequential way
int vacia(int len,int pivote){
//printf("(%d,%d)",len,pivote);
if(len >= pivote){
if( cifred[pivote] == 0 ){
newpos=pivote;
}
else{
newpos=vacia(len, pivote+1);
}
}
else{
pivote = pivote - len;
pivote = pivote - 1;
if (cifred[pivote]==0){
newpos=pivote;
}
else{
newpos=vacia(len, pivote+1);
}
}
return newpos;
}
//a study of the binary will reveal that the "encrypting engine" puts the seed used in the second position of the ciphered array
//this is cifred[1], thus this function gets that char placed in that position and returns its seed value translated using the
//alphabet array
int get_seed(char single_char){
int result=61;
for(i=0;i<62;i++){
if(single_char==alphabet[i]){
result=i;
}
}
return result;
}
//main funcion of the ncn decrypter
int main(int argc,char *argv[]) {
if (argc != 2){
printf("Error, provide ciphered text as the unique argument\n");
exit(1);
}
len = strlen(argv[1]);
if ( len > MAX_STR) {
printf("Error, ciphered text too long, it must be < %d \n",MAX_STR);
exit(1);
}
//trying avoiding buffer overflows
strncpy(str,argv[1],len);
//this variable holds always the same value
salto = 3;
//newpos is the position of the array we are working on, it will be changed according to "vacia" function output
newpos = 1;
//we get the original seed used from the encrypted text passed
seed_value = get_seed(str[1]);
//oops debug code, you can remove when compiling
printf("seed=%d",seed_value);
//cifred array is just an array to simulate the original ncn code, it holds which positions of the encrypted text
//have been processed, cifred[i]=0 means not processed, cifred[i]=1 means processed
for(i=0;i<len;i++) {
cifred[i]=0;
}
//as I mentioned position 1 of the encrypted text always holds the seed so we marked it as already processed
cifred[1]=1;
//the main processing loop
for(i=0;i<len-1;i++){
//check which position of the encrypted string we are processing
newpos = vacia(len-1,salto+newpos);
//update that possition as processed
cifred[newpos]=1;
//the greatest nonsense I managed to achieve (at least it worked and can be useful for other similar situations):
//when I was analyzing assembly code I could not find what the heck where some really weird instructions at the beginning
//and at the end of the code, what did a do? take them as a black box and pass this code the possible used and
//then match the ouput with the encrypted position we are dealing with each time
for (j=0;j<62;j++){
//yeah its inline assembler, very useful though, %N, where n is a number is the Nth variable you have passed (seed_value in this case)
asm ( "mov %3,%%eax;"
"add %1,%%eax;"
"mov %%eax,%%ecx;"
"add %2,%%ecx;"
"mov $0x84210843,%%eax;"
"imul %%ecx;"
"lea (%%edx,%%ecx,1),%%eax;"
"mov %%eax,%%edx;"
"sar $0x5,%%edx;"
"mov %%ecx,%%eax;"
"sar $0x1f,%%eax;"
"sub %%eax,%%edx;"
"mov %%edx,%%eax;"
"shl $0x5,%%eax;"
"sub %%edx,%%eax;"
"add %%eax,%%eax;"
"sub %%eax,%%ecx;"
"mov %%ecx,%0;"
: "=m" (ciphered_index)
: "m" (j), "m" (increase), "m" (seed_value)
);
//you might be wondering what this "blackbox" of code does?? ok don't laugh, it generates the integer remainder of a division!!
//and it's damn clear that somewhere the binary needed this instruction as the seed taken from "rand" function is too long
//and the seed must be a number between 0 and 61! therefore in c code all this lines in assembly mean "seed=rand()%62"
if ( alphabet[ciphered_index] == str[newpos] ){
reversed[procesed]=alphabet[j];
}
//fprintf("j=%d,crypt=%d,newpos=%c,str[newpos]=%calphabet=\n",j,ciphered_index,newpos,(char *) str[newpos],(char *)alphabet[ciphered_index]);
}
// some computations to mimic the reversed binary behaviour
increase=increase+5;
procesed++;
}
reversed[procesed]=0;
//here it is!
printf("String reversed is %s\n",reversed);
return 0;
}
Solution code attachment:un_ncner.c
My even more dirty debugging files
ncn: file format elf32-i386
Disassembly of section .init:
08048320 <_init>:
8048320: 55 push %ebp
8048321: 89 e5 mov %esp,%ebp
8048323: 83 ec 08 sub $0x8,%esp
8048326: e8 b9 00 00 00 call 80483e4 <call_gmon_start>
804832b: e8 20 01 00 00 call 8048450 <frame_dummy>
8048330: e8 eb 04 00 00 call 8048820 <__do_global_ctors_aux>
8048335: c9 leave
8048336: c3 ret
Disassembly of section .plt:
08048338 <time@plt-0x10>:
8048338: ff 35 f4 99 04 08 pushl 0x80499f4
804833e: ff 25 f8 99 04 08 jmp *0x80499f8
8048344: 00 00 add %al,(%eax)
...
08048348 <time@plt>:
8048348: ff 25 fc 99 04 08 jmp *0x80499fc
804834e: 68 00 00 00 00 push $0x0
8048353: e9 e0 ff ff ff jmp 8048338 <_init+0x18>
08048358 <strlen@plt>:
8048358: ff 25 00 9a 04 08 jmp *0x8049a00
804835e: 68 08 00 00 00 push $0x8
8048363: e9 d0 ff ff ff jmp 8048338 <_init+0x18>
08048368 <__libc_start_main@plt>:
8048368: ff 25 04 9a 04 08 jmp *0x8049a04
804836e: 68 10 00 00 00 push $0x10
8048373: e9 c0 ff ff ff jmp 8048338 <_init+0x18>
08048378 <printf@plt>:
8048378: ff 25 08 9a 04 08 jmp *0x8049a08
804837e: 68 18 00 00 00 push $0x18
8048383: e9 b0 ff ff ff jmp 8048338 <_init+0x18>
08048388 <srand@plt>:
8048388: ff 25 0c 9a 04 08 jmp *0x8049a0c
804838e: 68 20 00 00 00 push $0x20
8048393: e9 a0 ff ff ff jmp 8048338 <_init+0x18>
08048398 <strncpy@plt>:
8048398: ff 25 10 9a 04 08 jmp *0x8049a10
804839e: 68 28 00 00 00 push $0x28
80483a3: e9 90 ff ff ff jmp 8048338 <_init+0x18>
080483a8 <rand@plt>:
80483a8: ff 25 14 9a 04 08 jmp *0x8049a14
80483ae: 68 30 00 00 00 push $0x30
80483b3: e9 80 ff ff ff jmp 8048338 <_init+0x18>
Disassembly of section .text:
080483c0 <_start>:
80483c0: 31 ed xor %ebp,%ebp
80483c2: 5e pop %esi
80483c3: 89 e1 mov %esp,%ecx
80483c5: 83 e4 f0 and $0xfffffff0,%esp
80483c8: 50 push %eax
80483c9: 54 push %esp
80483ca: 52 push %edx
80483cb: 68 15 88 04 08 push $0x8048815
80483d0: 68 b0 87 04 08 push $0x80487b0
80483d5: 51 push %ecx
80483d6: 56 push %esi
80483d7: 68 d4 84 04 08 push $0x80484d4
80483dc: e8 87 ff ff ff call 8048368 <__libc_start_main@plt>
80483e1: f4 hlt
80483e2: 90 nop
08048484 <vacia>:
8048484: 55 push %ebp
8048485: 89 e5 mov %esp,%ebp
8048487: 83 ec 0c sub $0xc,%esp; subimos el esp 11 bytes
804848a: 8b 45 08 mov 0x8(%ebp),%eax;metemos salto+newpos en eax
804848d: 3b 45 0c cmp 0xc(%ebp),%eax; comparamos longitud con salto+newpos
8048490: 7e 0c jle 804849e <vacia+0x1a>;si longitud<salto+newpos vamos a salto1
8048492: 8b 55 0c mov 0xc(%ebp),%edx;mettemos longitud en edx
8048495: 8b 45 08 mov 0x8(%ebp),%eax; metemos salto+newpos en eax
8048498: 29 d0 sub %edx,%eax; restamos ambos registros
804849a: 48 dec %eax ; decrementamos en 1
804849b: 89 45 08 mov %eax,0x8(%ebp);guardamos el resultado como posible valor de retorno
salto1
804849e: 8b 45 08 mov 0x8(%ebp),%eax;
80484a1: 05 20 9b 04 08 add $0x8049b20,%eax;indice cifred(eax)
80484a6: 80 38 30 cmpb $0x30,(%eax); cifred(eax) ==48
80484a9: 75 08 jne 80484b3 <vacia+0x2f>; llamamos recursivamente a vacia
80484ab: 8b 45 08 mov 0x8(%ebp),%eax; hacemos los preparativos para salir de la funcion
80484ae: 89 45 fc mov %eax,-0x4(%ebp)
80484b1: eb 1c jmp 80484cf <vacia+0x4b>; salimos de la funcion
80484b3: 8b 45 0c mov 0xc(%ebp),%eax;preparacion para llamaa recursiva
de vacia(param1,param2)
80484b6: 89 44 24 04 mov %eax,0x4(%esp)
80484ba: 8b 45 08 mov 0x8(%ebp),%eax
80484bd: 40 inc %eax
80484be: 89 04 24 mov %eax,(%esp)
80484c1: e8 be ff ff ff call 8048484 <vacia>
80484c6: 89 45 08 mov %eax,0x8(%ebp); gilipolleces? antes de salir de la funcion
80484c9: 8b 45 08 mov 0x8(%ebp),%eax
80484cc: 89 45 fc mov %eax,-0x4(%ebp)
80484cf: 8b 45 fc mov -0x4(%ebp),%eax
80484d2: c9 leave
80484d3: c3 ret
080484d4 <main>:
80484d4: 55 push %ebp
80484d5: 89 e5 mov %esp,%ebp
80484d7: 53 push %ebx
80484d8: 83 ec 14 sub $0x14,%esp
80484db: 83 e4 f0 and $0xfffffff0,%esp;alineamiento del esp???
80484de: b8 00 00 00 00 mov $0x0,%eax;movemos 0 a eax
80484e3: 29 c4 sub %eax,%esp; restamos 0 a esp??
80484e5: c7 45 f8 40 9a 04 08 movl $0x8049a40,-0x8(%ebp);en la posición -8 en relacion al ebp ubicamos un alfabeto alfanumerico (array min(90))
80484ec: c7 05 a8 9a 04 08 02 movl $0x2,0x8049aa8; simbolo semilla
80484f3: 00 00 00
80484f6: c7 05 b4 9a 04 08 03 movl $0x3,0x8049ab4; simbolo salto no varia en tol programa
80484fd: 00 00 00
8048500: c7 05 a0 9a 04 08 01 movl $0x1,0x8049aa0; simbolo newpos
8048507: 00 00 00
804850a: c7 05 74 9b 04 08 00 movl $0x0,0x8049b74; simbolo procesadas
8048511: 00 00 00
8048514: c7 04 24 00 00 00 00 movl $0x0,(%esp)
804851b: e8 28 fe ff ff call 8048348 <time@plt> ; time devuelve los ticks del programa=1242518429, los 6 ultimos digitos varian
8048520: 89 04 24 mov %eax,(%esp);movemos el resultado a la pila
8048523: e8 60 fe ff ff call 8048388 <srand@plt>; con lo que tenemos en la pila llamamos a generar semilla
8048528: c7 05 70 9b 04 08 05 movl $0x5,0x8049b70; variable increase=5
804852f: 00 00 00
8048532: e8 71 fe ff ff call 80483a8 <rand@plt>
8048537: 89 c1 mov %eax,%ecx ; pasamos el resutlado de rand al registro ecx el número es totalmente aleatorio
8048539: b8 43 08 21 84 mov $0x84210843,%eax; movemos este valor fijo a eax
804853e: f7 e9 imul %ecx; multiplicamos la salida de rand por el valor fijo y guardamos el resultado en eax
8048540: 8d 04 0a lea (%edx,%ecx,1),%eax; movemos edx+ecx->eax
8048543: 89 c2 mov %eax,%edx;
8048545: c1 fa 05 sar $0x5,%edx;dividimos edx=eax por 32 y lo guardamos en edx
8048548: 89 c8 mov %ecx,%eax; lo dejamos en eax
804854a: c1 f8 1f sar $0x1f,%eax;multiplicamos eax por 2^31
804854d: 29 c2 sub %eax,%edx;edx=edx-eax
804854f: 89 d0 mov %edx,%eax
8048551: a3 a8 9a 04 08 mov %eax,0x8049aa8; movemos el eax en el simbolo semilla
8048556: 8b 15 a8 9a 04 08 mov 0x8049aa8,%edx;sacamos el simbolo semilla al edx
804855c: 89 d0 mov %edx,%eax
804855e: c1 e0 05 shl $0x5,%eax
8048561: 29 d0 sub %edx,%eax
8048563: 01 c0 add %eax,%eax
8048565: 29 c1 sub %eax,%ecx
8048567: 89 c8 mov %ecx,%eax
8048569: a3 a8 9a 04 08 mov %eax,0x8049aa8; volvemos a mover eax a la variable semilla suele ser un valor entre 0-60??
804856e: 83 7d 08 02 cmpl $0x2,0x8(%ebp); como podemos comprobar esto solo se trata de la tipica comprobacion de if $#=2 then ok else wrong parameters
8048572: 74 1a je 804858e <main+0xba>; si es igual vamos a salto858e
8048574: 8b 45 0c mov 0xc(%ebp),%eax
8048577: 8b 00 mov (%eax),%eax
8048579: 89 44 24 04 mov %eax,0x4(%esp)
804857d: c7 04 24 a0 88 04 08 movl $0x80488a0,(%esp) ; sintaxis incorrecta
8048584: e8 ef fd ff ff call 8048378 <printf@plt>
8048589: e9 18 02 00 00 jmp 80487a6 <main+0x2d2>; sale del programa
salto858e:
804858e: c7 04 24 c9 88 04 08 movl $0x80488c9,(%esp)
8048595: e8 de fd ff ff call 8048378 <printf@plt>; sintaxis OK
804859a: 8b 45 0c mov 0xc(%ebp),%eax; metemos la direccion de la cadena pasada ...posteriormente le sumamos 4?? no seria mejor lea 0xc+4(%ebp),eax
804859d: 83 c0 04 add $0x4,%eax
80485a0: 8b 00 mov (%eax),%eax
80485a2: 89 04 24 mov %eax,(%esp);lo dejamos en esp
80485a5: e8 ae fd ff ff call 8048358 <strlen@plt>
80485aa: 83 f8 03 cmp $0x3,%eax; si la longitud es mayor que 3 saltamos
80485ad: 77 19 ja 80485c8 <main+0xf4>
80485af: c7 44 24 04 04 00 00 movl $0x4,0x4(%esp); mostramos que la longitud debe ser mayuor que 3 y salimos
80485b6: 00
80485b7: c7 04 24 d6 88 04 08 movl $0x80488d6,(%esp)
80485be: e8 b5 fd ff ff call 8048378 <printf@plt>
80485c3: e9 d5 01 00 00 jmp 804879d <main+0x2c9>
80485c8: 8b 45 0c mov 0xc(%ebp),%eax; metemos en esp la direccion de la cadena a cifrar para comprobar su longitud
80485cb: 83 c0 04 add $0x4,%eax
80485ce: 8b 00 mov (%eax),%eax
80485d0: 89 04 24 mov %eax,(%esp)
80485d3: e8 80 fd ff ff call 8048358 <strlen@plt>
80485d8: 83 f8 4f cmp $0x4f,%eax
80485db: 76 2c jbe 8048609 <main+0x135>; si la cadena es menor que 0x4f=79 (quizas la longitud de los arrays para cifrado) saltamos a la tag linea 309 sino continuamos
80485dd: c7 05 ac 9a 04 08 50 movl $0x50,0x8049aac
80485e4: 00 00 00
80485e7: c7 44 24 08 50 00 00 movl $0x50,0x8(%esp)
80485ee: 00
80485ef: 8b 45 0c mov 0xc(%ebp),%eax
80485f2: 83 c0 04 add $0x4,%eax
80485f5: 8b 00 mov (%eax),%eax
80485f7: 89 44 24 04 mov %eax,0x4(%esp)
80485fb: c7 04 24 c0 9a 04 08 movl $0x8049ac0,(%esp)
8048602: e8 91 fd ff ff call 8048398 <strncpy@plt>
8048607: eb 35 jmp 804863e <main+0x16a>
linea 309:
8048609: 8b 45 0c mov 0xc(%ebp),%eax;sacamos la cadena introducida para pasarla a strlen
804860c: 83 c0 04 add $0x4,%eax
804860f: 8b 00 mov (%eax),%eax
8048611: 89 04 24 mov %eax,(%esp)
8048614: e8 3f fd ff ff call 8048358 <strlen@plt>
8048619: a3 ac 9a 04 08 mov %eax,0x8049aac; la longitud la guardamos en esta posición que concuerda con el simbolo length
804861e: c7 44 24 08 50 00 00 movl $0x50,0x8(%esp); metemos en la pila el numero 80...cifred?
8048625: 00
8048626: 8b 45 0c mov 0xc(%ebp),%eax
8048629: 83 c0 04 add $0x4,%eax
804862c: 8b 00 mov (%eax),%eax
804862e: 89 44 24 04 mov %eax,0x4(%esp)
8048632: c7 04 24 c0 9a 04 08 movl $0x8049ac0,(%esp)
8048639: e8 5a fd ff ff call 8048398 <strncpy@plt>; llamamos a strncpy para que copie 80 caracteres de la cadena pasada a clear
804863e: c7 05 10 9b 04 08 00 movl $0x0,0x8049b10; ponemos el contador "i" a 0
salto 3:
8048645: 00 00 00
8048648: a1 10 9b 04 08 mov 0x8049b10,%eax; eax="i"
804864d: 3b 05 ac 9a 04 08 cmp 0x8049aac,%eax; comparamos i con length
8048653: 7e 02 jle 8048657 <main+0x183>;si "i" < "length" saltamos detras del siguiente jmp
8048655: eb 15 jmp 804866c <main+0x198>;sino vamos a salto2
8048657: a1 10 9b 04 08 mov 0x8049b10,%eax; metemos en eax el contador "i"
804865c: 05 20 9b 04 08 add $0x8049b20,%eax; sumamos el valor de i con cifred[0]= esto es para indexar en el array cifred!!
8048661: c6 00 30 movb $0x30,(%eax); metemos 48d en esa posici0n
8048664: ff 05 10 9b 04 08 incl 0x8049b10; incrementamos i
804866a: eb dc jmp 8048648 <main+0x174>: tiramos patras a donde se pone "i" a 0 (salto3)
salto2:
804866c: a1 ac 9a 04 08 mov 0x8049aac,%eax; metemos la longitud en eax
8048671: 05 21 9b 04 08 add $0x8049b21,%eax ;preparamos el indice para apuntar a cifred+length+1
8048676: c6 00 00 movb $0x0,(%eax); ponemos a cifred[length+1] a 0
8048679: c7 05 10 9b 04 08 00 movl $0x0,0x8049b10; le asignamos a i el valor 0
8048680: 00 00 00
8048683: a1 a8 9a 04 08 mov 0x8049aa8,%eax; se guarda el valor semilla en eax
8048688: 05 40 9a 04 08 add $0x8049a40,%eax; se indexa min(semilla)
804868d: 0f b6 00 movzbl (%eax),%eax;guarda en eax el contenido de la posición de memoria min(semilla) y ademas como es un byte se rellena el destino con 0s a la izquierda
8048690: a2 21 9b 04 08 mov %al,0x8049b21; mueve un byte, supuestamente min(semilla)-> a cifred(1)
8048695: c7 05 10 9b 04 08 00 movl $0x0,0x8049b10; i=0;
804869c: 00 00 00
salto869f:
804869f: a1 10 9b 04 08 mov 0x8049b10,%eax; movemos i al eax
80486a4: 3b 05 ac 9a 04 08 cmp 0x8049aac,%eax; comparamos i con la longitud
80486aa: 7c 05 jl 80486b1 <main+0x1dd>; si es menor vamos a la linea de despues del jmp
80486ac: e9 cb 00 00 00 jmp 804877c <main+0x2a8>; si i>=length vamos al final para mostrar la cadena cifrada
80486b1: a1 ac 9a 04 08 mov 0x8049aac,%eax ; ponemos la longitud de la caden en eax
80486b6: 89 44 24 04 mov %eax,0x4(%esp); de eax la pasamos a la pila en esp+4
80486ba: a1 b4 9a 04 08 mov 0x8049ab4,%eax;movemos la variable salto que vale 3 al eax
80486bf: 03 05 a0 9a 04 08 add 0x8049aa0,%eax;sumamos salto+newpos donde newpos vale 1
80486c5: 89 04 24 mov %eax,(%esp); movemos salto+newpos a la pila
80486c8: e8 b7 fd ff ff call 8048484 <vacia>
80486cd: a3 a0 9a 04 08 mov %eax,0x8049aa0; vacia nos devuelvve una un nuevo newpos que guardamos en su posicion de mem asignada
80486d2: c7 05 a4 9a 04 08 00 movl $0x0,0x8049aa4; ponemos a la variable j
80486d9: 00 00 00
salto86dc:
80486dc: c7 04 24 40 9a 04 08 movl $0x8049a40,(%esp); se mete (min) en el la pila
80486e3: e8 70 fc ff ff call 8048358 <strlen@plt>; esto siempre deberia valer 90
80486e8: 39 05 a4 9a 04 08 cmp %eax,0x8049aa4; comparamos con j
80486ee: 72 02 jb 80486f2 <main+0x21e>; si j es mayor vamos a la posicion siguiente al jmp
80486f0: eb 27 jmp 8048719 <main+0x245>; sino vamos a salto 8719
80486f2: a1 a4 9a 04 08 mov 0x8049aa4,%eax; movemos j a eax
80486f7: 05 40 9a 04 08 add $0x8049a40,%eax; creamos el indice min(j)
80486fc: 8b 15 74 9b 04 08 mov 0x8049b74,%edx; metemos la variable procesadas en edx
8048702: 81 c2 c0 9a 04 08 add $0x8049ac0,%edx; creamos el indice clear(procesadas)
8048708: 0f b6 00 movzbl (%eax),%eax; metemos el byte min(j)->eax
804870b: 3a 02 cmp (%edx),%al; comparamos los bytes min(j),clear(procesadas)
804870d: 75 02 jne 8048711 <main+0x23d>;si no fuesen iguales saltamos despues de jmp siguiente
804870f: eb 08 jmp 8048719 <main+0x245>; saltamos al tag salto8719
8048711: ff 05 a4 9a 04 08 incl 0x8049aa4; incrementeamos "j"
8048717: eb c3 jmp 80486dc <main+0x208>; volvemos al tag donde se mete min en la pila para hacer un strlen
salto8719:
8048719: 8b 1d a0 9a 04 08 mov 0x8049aa0,%ebx; metemos newpos (deberia haberse actualizado tras vacia) en ebx
804871f: 81 c3 20 9b 04 08 add $0x8049b20,%ebx; indice cifred(newpos)
8048725: a1 a8 9a 04 08 mov 0x8049aa8,%eax; movemos la variable semilla en el eax
804872a: 03 05 a4 9a 04 08 add 0x8049aa4,%eax; sumamos semilla+j
8048730: 89 c1 mov %eax,%ecx; el resultado lo guardamos en ecx
8048732: 03 0d 70 9b 04 08 add 0x8049b70,%ecx;sumamos increase+semilla+j
8048738: b8 43 08 21 84 mov $0x84210843,%eax; movemos un valor hardcodeado en eax
804873d: f7 e9 imul %ecx; lo multiplicamos por la suma increase+j+semilla
804873f: 8d 04 0a lea (%edx,%ecx,1),%eax; metemos en eax la direccion generada de edx=clear(procesadas+ecx)
8048742: 89 c2 mov %eax,%edx; de ahi a edx pq eax sera sobre escrito por la siguiente instruccion??o no??
8048744: c1 fa 05 sar $0x5,%edx;dividimos por 32 pq es un shift right ademas de forma aritmetica para conservar el signo
8048747: 89 c8 mov %ecx,%eax; metemos en eax el vallor de la operacion imul con ecx anterior
8048749: c1 f8 1f sar $0x1f,%eax; dividimos por 2^31=2147483648
804874c: 29 c2 sub %eax,%edx; le restamos edx
804874e: 89 d0 mov %edx,%eax; el resultado va a eax
8048750: c1 e0 05 shl $0x5,%eax; ahora multiplicamos eax por 32
8048753: 29 d0 sub %edx,%eax; restamos eax
8048755: 01 c0 add %eax,%eax
8048757: 29 c1 sub %eax,%ecx
8048759: 89 c8 mov %ecx,%eax
804875b: 0f b6 80 40 9a 04 08 movzbl 0x8049a40(%eax),%eax
8048762: 88 03 mov %al,(%ebx); guardamos el resultado de al en cifred(newpos)
8048764: ff 05 74 9b 04 08 incl 0x8049b74; incrementamos procesadas
804876a: 83 05 70 9b 04 08 05 addl $0x5,0x8049b70; increase+5
8048771: ff 05 10 9b 04 08 incl 0x8049b10;incrementamos "i"
8048777: e9 23 ff ff ff jmp 804869f <main+0x1cb>; volvemos a salto869f
804877c: a1 ac 9a 04 08 mov 0x8049aac,%eax ; terminar la cadena en 0??
8048781: 05 21 9b 04 08 add $0x8049b21,%eax
8048786: c6 00 00 movb $0x0,(%eax)
8048789: c7 44 24 04 20 9b 04 movl $0x8049b20,0x4(%esp)
8048790: 08
8048791: c7 04 24 ee 88 04 08 movl $0x80488ee,(%esp)
8048798: e8 db fb ff ff call 8048378 <printf@plt>; se muestra la cdena encriptada es y el valor del array cifred
804879d: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp); se pone a cero una word de la pila
80487a4: eb 00 jmp 80487a6 <main+0x2d2>; se salta a la sigiuente linea?
80487a6: 8b 45 f4 mov -0xc(%ebp),%eax; se mueve a eax un valor, sugpongo que el codigo de salida del programa??
80487a9: 8b 5d fc mov -0x4(%ebp),%ebx
80487ac: c9 leave
80487ad: c3 ret
80487ae: 90 nop
80487af: 90 nop
Dump of assembler code for function main:
0x080484d4 <main+0>: push %ebp
0x080484d5 <main+1>: mov %esp,%ebp
0x080484d7 <main+3>: push %ebx
0x080484d8 <main+4>: sub $0x14,%esp
0x080484db <main+7>: and $0xfffffff0,%esp
0x080484de <main+10>: mov $0x0,%eax
0x080484e3 <main+15>: sub %eax,%esp
0x080484e5 <main+17>: movl $0x8049a40,0xfffffff8(%ebp)
0x080484ec <main+24>: movl $0x2,0x8049aa8
0x080484f6 <main+34>: movl $0x3,0x8049ab4
0x08048500 <main+44>: movl $0x1,0x8049aa0
0x0804850a <main+54>: movl $0x0,0x8049b74
0x08048514 <main+64>: movl $0x0,(%esp)
0x0804851b <main+71>: call 0x8048348 <time@plt>
0x08048520 <main+76>: mov %eax,(%esp)
0x08048523 <main+79>: call 0x8048388 <srand@plt>
0x08048528 <main+84>: movl $0x5,0x8049b70
0x08048532 <main+94>: call 0x80483a8 <rand@plt>
0x08048537 <main+99>: mov %eax,%ecx
0x08048539 <main+101>: mov $0x84210843,%eax
0x0804853e <main+106>: imul %ecx
0x08048540 <main+108>: lea (%edx,%ecx,1),%eax
0x08048543 <main+111>: mov %eax,%edx
0x08048545 <main+113>: sar $0x5,%edx
0x08048548 <main+116>: mov %ecx,%eax
0x0804854a <main+118>: sar $0x1f,%eax
0x0804854d <main+121>: sub %eax,%edx
0x0804854f <main+123>: mov %edx,%eax
0x08048551 <main+125>: mov %eax,0x8049aa8
0x08048556 <main+130>: mov 0x8049aa8,%edx
0x0804855c <main+136>: mov %edx,%eax
0x0804855e <main+138>: shl $0x5,%eax
0x08048561 <main+141>: sub %edx,%eax
0x08048563 <main+143>: add %eax,%eax
0x08048565 <main+145>: sub %eax,%ecx
0x08048567 <main+147>: mov %ecx,%eax
0x08048569 <main+149>: mov %eax,0x8049aa8
0x0804856e <main+154>: cmpl $0x2,0x8(%ebp)
0x08048572 <main+158>: je 0x804858e <main+186>
0x08048574 <main+160>: mov 0xc(%ebp),%eax
0x08048577 <main+163>: mov (%eax),%eax
0x08048579 <main+165>: mov %eax,0x4(%esp)
0x0804857d <main+169>: movl $0x80488a0,(%esp)
0x08048584 <main+176>: call 0x8048378 <printf@plt>
0x08048589 <main+181>: jmp 0x80487a6 <main+722>
0x0804858e <main+186>: movl $0x80488c9,(%esp)
0x08048595 <main+193>: call 0x8048378 <printf@plt>
0x0804859a <main+198>: mov 0xc(%ebp),%eax
0x0804859d <main+201>: add $0x4,%eax
0x080485a0 <main+204>: mov (%eax),%eax
0x080485a2 <main+206>: mov %eax,(%esp)
0x080485a5 <main+209>: call 0x8048358 <strlen@plt>
0x080485aa <main+214>: cmp $0x3,%eax
0x080485ad <main+217>: ja 0x80485c8 <main+244>
0x080485af <main+219>: movl $0x4,0x4(%esp)
0x080485b7 <main+227>: movl $0x80488d6,(%esp)
0x080485be <main+234>: call 0x8048378 <printf@plt>
0x080485c3 <main+239>: jmp 0x804879d <main+713>
0x080485c8 <main+244>: mov 0xc(%ebp),%eax
0x080485cb <main+247>: add $0x4,%eax
0x080485ce <main+250>: mov (%eax),%eax
0x080485d0 <main+252>: mov %eax,(%esp)
0x080485d3 <main+255>: call 0x8048358 <strlen@plt>
0x080485d8 <main+260>: cmp $0x4f,%eax
0x080485db <main+263>: jbe 0x8048609 <main+309>
0x080485dd <main+265>: movl $0x50,0x8049aac
0x080485e7 <main+275>: movl $0x50,0x8(%esp)
0x080485ef <main+283>: mov 0xc(%ebp),%eax
0x080485f2 <main+286>: add $0x4,%eax
0x080485f5 <main+289>: mov (%eax),%eax
0x080485f7 <main+291>: mov %eax,0x4(%esp)
0x080485fb <main+295>: movl $0x8049ac0,(%esp)
0x08048602 <main+302>: call 0x8048398 <strncpy@plt>
0x08048607 <main+307>: jmp 0x804863e <main+362>
0x08048609 <main+309>: mov 0xc(%ebp),%eax
0x0804860c <main+312>: add $0x4,%eax
0x0804860f <main+315>: mov (%eax),%eax
0x08048611 <main+317>: mov %eax,(%esp)
0x08048614 <main+320>: call 0x8048358 <strlen@plt>
0x08048619 <main+325>: mov %eax,0x8049aac
0x0804861e <main+330>: movl $0x50,0x8(%esp)
0x08048626 <main+338>: mov 0xc(%ebp),%eax
0x08048629 <main+341>: add $0x4,%eax
0x0804862c <main+344>: mov (%eax),%eax
0x0804862e <main+346>: mov %eax,0x4(%esp)
0x08048632 <main+350>: movl $0x8049ac0,(%esp)
0x08048639 <main+357>: call 0x8048398 <strncpy@plt>
0x0804863e <main+362>: movl $0x0,0x8049b10
0x08048648 <main+372>: mov 0x8049b10,%eax
0x0804864d <main+377>: cmp 0x8049aac,%eax
0x08048653 <main+383>: jle 0x8048657 <main+387>
0x08048655 <main+385>: jmp 0x804866c <main+408>
0x08048657 <main+387>: mov 0x8049b10,%eax
0x0804865c <main+392>: add $0x8049b20,%eax
0x08048661 <main+397>: movb $0x30,(%eax)
0x08048664 <main+400>: incl 0x8049b10
0x0804866a <main+406>: jmp 0x8048648 <main+372>
0x0804866c <main+408>: mov 0x8049aac,%eax
0x08048671 <main+413>: add $0x8049b21,%eax
0x08048676 <main+418>: movb $0x0,(%eax)
0x08048679 <main+421>: movl $0x0,0x8049b10
0x08048683 <main+431>: mov 0x8049aa8,%eax
0x08048688 <main+436>: add $0x8049a40,%eax
0x0804868d <main+441>: movzbl (%eax),%eax
0x08048690 <main+444>: mov %al,0x8049b21
0x08048695 <main+449>: movl $0x0,0x8049b10
0x0804869f <main+459>: mov 0x8049b10,%eax
0x080486a4 <main+464>: cmp 0x8049aac,%eax
0x080486aa <main+470>: jl 0x80486b1 <main+477>
0x080486ac <main+472>: jmp 0x804877c <main+680>
0x080486b1 <main+477>: mov 0x8049aac,%eax
0x080486b6 <main+482>: mov %eax,0x4(%esp)
0x080486ba <main+486>: mov 0x8049ab4,%eax
0x080486bf <main+491>: add 0x8049aa0,%eax
0x080486c5 <main+497>: mov %eax,(%esp)
0x080486c8 <main+500>: call 0x8048484 <vacia>
0x080486cd <main+505>: mov %eax,0x8049aa0
0x080486d2 <main+510>: movl $0x0,0x8049aa4
0x080486dc <main+520>: movl $0x8049a40,(%esp)
0x080486e3 <main+527>: call 0x8048358 <strlen@plt>
0x080486e8 <main+532>: cmp %eax,0x8049aa4
0x080486ee <main+538>: jb 0x80486f2 <main+542>
0x080486f0 <main+540>: jmp 0x8048719 <main+581>
0x080486f2 <main+542>: mov 0x8049aa4,%eax
0x080486f7 <main+547>: add $0x8049a40,%eax
0x080486fc <main+552>: mov 0x8049b74,%edx
0x08048702 <main+558>: add $0x8049ac0,%edx
0x08048708 <main+564>: movzbl (%eax),%eax
0x0804870b <main+567>: cmp (%edx),%al
0x0804870d <main+569>: jne 0x8048711 <main+573>
0x0804870f <main+571>: jmp 0x8048719 <main+581>
0x08048711 <main+573>: incl 0x8049aa4
0x08048717 <main+579>: jmp 0x80486dc <main+520>
0x08048719 <main+581>: mov 0x8049aa0,%ebx
0x0804871f <main+587>: add $0x8049b20,%ebx
0x08048725 <main+593>: mov 0x8049aa8,%eax
0x0804872a <main+598>: add 0x8049aa4,%eax
0x08048730 <main+604>: mov %eax,%ecx
0x08048732 <main+606>: add 0x8049b70,%ecx
0x08048738 <main+612>: mov $0x84210843,%eax
0x0804873d <main+617>: imul %ecx
0x0804873f <main+619>: lea (%edx,%ecx,1),%eax
0x08048742 <main+622>: mov %eax,%edx
0x08048744 <main+624>: sar $0x5,%edx
0x08048747 <main+627>: mov %ecx,%eax
0x08048749 <main+629>: sar $0x1f,%eax
0x0804874c <main+632>: sub %eax,%edx
0x0804874e <main+634>: mov %edx,%eax
0x08048750 <main+636>: shl $0x5,%eax
0x08048753 <main+639>: sub %edx,%eax
0x08048755 <main+641>: add %eax,%eax
0x08048757 <main+643>: sub %eax,%ecx
0x08048759 <main+645>: mov %ecx,%eax
0x0804875b <main+647>: movzbl 0x8049a40(%eax),%eax
0x08048762 <main+654>: mov %al,(%ebx)
0x08048764 <main+656>: incl 0x8049b74
0x0804876a <main+662>: addl $0x5,0x8049b70
0x08048771 <main+669>: incl 0x8049b10
0x08048777 <main+675>: jmp 0x804869f <main+459>
0x0804877c <main+680>: mov 0x8049aac,%eax
0x08048781 <main+685>: add $0x8049b21,%eax
0x08048786 <main+690>: movb $0x0,(%eax)
0x08048789 <main+693>: movl $0x8049b20,0x4(%esp)
0x08048791 <main+701>: movl $0x80488ee,(%esp)
0x08048798 <main+708>: call 0x8048378 <printf@plt>
0x0804879d <main+713>: movl $0x0,0xfffffff4(%ebp)
0x080487a4 <main+720>: jmp 0x80487a6 <main+722>
0x080487a6 <main+722>: mov 0xfffffff4(%ebp),%eax
0x080487a9 <main+725>: mov 0xfffffffc(%ebp),%ebx
0x080487ac <main+728>: leave
0x080487ad <main+729>: ret
End of assembler dump.
Dump of assembler code for function vacia:
0x08048484 <vacia+0>: push %ebp
0x08048485 <vacia+1>: mov %esp,%ebp
0x08048487 <vacia+3>: sub $0xc,%esp
0x0804848a <vacia+6>: mov 0x8(%ebp),%eax
0x0804848d <vacia+9>: cmp 0xc(%ebp),%eax
0x08048490 <vacia+12>: jle 0x804849e <vacia+26>
0x08048492 <vacia+14>: mov 0xc(%ebp),%edx
0x08048495 <vacia+17>: mov 0x8(%ebp),%eax
0x08048498 <vacia+20>: sub %edx,%eax
0x0804849a <vacia+22>: dec %eax
0x0804849b <vacia+23>: mov %eax,0x8(%ebp)
0x0804849e <vacia+26>: mov 0x8(%ebp),%eax
0x080484a1 <vacia+29>: add $0x8049b20,%eax
0x080484a6 <vacia+34>: cmpb $0x30,(%eax)
0x080484a9 <vacia+37>: jne 0x80484b3 <vacia+47>
0x080484ab <vacia+39>: mov 0x8(%ebp),%eax
0x080484ae <vacia+42>: mov %eax,0xfffffffc(%ebp)
0x080484b1 <vacia+45>: jmp 0x80484cf <vacia+75>
0x080484b3 <vacia+47>: mov 0xc(%ebp),%eax
0x080484b6 <vacia+50>: mov %eax,0x4(%esp)
0x080484ba <vacia+54>: mov 0x8(%ebp),%eax
0x080484bd <vacia+57>: inc %eax
0x080484be <vacia+58>: mov %eax,(%esp)
0x080484c1 <vacia+61>: call 0x8048484 <vacia>
0x080484c6 <vacia+66>: mov %eax,0x8(%ebp)
0x080484c9 <vacia+69>: mov 0x8(%ebp),%eax
0x080484cc <vacia+72>: mov %eax,0xfffffffc(%ebp)
0x080484cf <vacia+75>: mov 0xfffffffc(%ebp),%eax
0x080484d2 <vacia+78>: leave
0x080484d3 <vacia+79>: ret
End of assembler dump.
Interesting Links
