Test Foro de elhacker.net SMF 2.1

hola

una pregunta

he visto que despues de encontrar kernel32 buscan las funciones

por ejemplo

push offset kernelbase ; direccion de kernel32.dll
   push offset nLoadLibrary ; cadena de texto con: LoadLibraryA
   push 0Dh ; longitud de LoadLibraryA + 1
   call busca_libreria ; buscamos LoadLibraryA dentro de kernel32.dll


mov eax, fs:[30h] ; puntero al PEB
   mov eax, [eax+0ch] ; puntero a la estructura de datos
   mov esi, [eax+1ch] ; extrae la primera entrada
   lodsd ; avanza a la siguiente
   mov eax, [eax+08h] ; obtiene la direccion base y la guarda en eax
   ret


; ***************************************************************************
; Buscamos la direccion de una funcion dada la direccion base de una libreria
; ***************************************************************************
busca_funcion:
   mov eax, [esp+8] ; funcion apunta al nombre de la funcion (ej: LoadLibraryA)
   mov funcion, eax
   mov eax, [esp+12] ; base apunta a la base de la libreria (ej: kernel32.dll)
   mov eax, [eax]
   mov base, eax



Tengo una duda sobre las funciones

al inicio de busca_funcion... hay mov eax, [esp+8]

yo al principio creia o talvez no lo entiendo bien, que esp+8 era donde se habia guardado MZ

mov eax, [eax+08h]


entonces quise hacer algo como esto para ir guardando en la pila los datos

mov    eax, [fs:0x30]   
mov    eax, [eax + 0x0C]   
mov    eax, [eax + 0x1C]   
mov    eax, [eax]     
mov    eax, [eax + 0x08] 

push ebp
mov ebp, esp
sub esp, 12
mov edi, [ebp + 0x08]
mov edx, edi
add edx, [edi + 0x3C]
mov [ebp - 0x0C], edx

al compilarlo no tuve problemas pero al ejecutarlo salia un error y se cerraba la aplicacion, pero...bueno, como uso windows 7 hay otra forma de encontrar kernel

                xor eax, eax
mov eax, [fs:0x30]
mov eax, [eax+0x0C]
mov eax, [eax+0x0C]
mov eax, [eax]
mov eax, [eax]
mov eax, [eax+0x18]

Entonces quise hacer algo como esto

xor eax, eax
mov eax, [fs:0x30]
mov eax, [eax+0x0C]
mov eax, [eax+0x0C]
mov eax, [eax]
mov eax, [eax]
mov eax, [eax+0x18]

push ebp
        mov ebp, esp
sub esp, 12

mov edi, [ebp + 0x08]

mov edx, edi
add edx, [edi + 0x3C]
mov [ebp - 0x0C], edx


y tampoco tuve problemas y el error no me parecio, pero si se dan cuenta de algo, puse


mov edi, [ebp + 0x08]

lo cual me parecio que debia ser

mov edi, [ebp + 0x18]

al compilarlo tampoco hubo algun problema, pero al investigar mas me encontre con otro ejemplo, donde hace lo mismo que el primer ejemplo

LoadK32Function:
       mov    eax, [fs:0x30]   ; address of PEB
       mov    eax, [eax + 0x0C]   ; PEB->Ldr
       mov    eax, [eax + 0x1C]    ; Ldr->InMemoryOrderModuleList (first element is ntdll.dll)
       mov    eax, [eax]      ; InMemoryOrderModuleList->Flink (second element is kernel32.dll)
       mov    eax, [eax + 0x08]   ; DllBase

push    ebp
mov    ebp, esp
sub   esp, 12      ; make room for 3 DWORDS
mov    edi, [ebp + 0x08]    ; edi = DosHeader
cmp word [edi], 'MZ'
mov    edx, edi
add    edx, [edi + 0x3C] 
cmp word [edx], 'PE'
jne    LoadK32Function_fail
mov   [ebp - 0x0C], edx

_WinMain@16:

       push    LoadLibraryName
       push    dword [Kernel32Addr]
       call    LoadK32Function

Y aqui ya estoy confundido, que hace realmente ebp+0x08? porque al segundo ejemplo que puse de WinMain, si cambio de igual forma como encontrar kernel en sistemas windows 7, sigue funcionando ebp+0x08 pero si lo cambio a 0x18 ya no funciona

                xor eax, eax
mov eax, [fs:0x30]
mov eax, [eax+0x0C]
mov eax, [eax+0x0C]
mov eax, [eax]
mov eax, [eax]
mov eax, [eax+0x18]

push    ebp
mov    ebp, esp
sub   esp, 12      ; make room for 3 DWORDS
mov    edi, [ebp + 0x18]    ; edi = DosHeader
cmp word [edi], 'MZ'
mov    edx, edi
add    edx, [edi + 0x3C] 
cmp word [edx], 'PE'
jne    LoadK32Function_fail
mov   [ebp - 0x0C], edx   

Esta es una explicacion que dieron pero no entiendo porque comenzar con 0x08

Citar;------------------------------------
       ;          +-----------------------+
       ; ebp-0x0C | PE Header             |
       ;          +-----------------------+
       ; ebp-0x08 | Export table addr     |
       ;          +-----------------------+
       ; ebp-0x04 | AddressOfNames        |
       ;          +-----------------------+
       ; .....
       ;          +-----------------------+
       ; ebp+0x08 | kernel32 base address |
       ;          +-----------------------+
       ; ebp+0x0C | function name         |
       ;          +-----------------------+
       ;------------------------------------

espero me puedan ayudar con esta duda, porque me gustaria saber porque ebp tendria que comenzar con 0x08, porque no se si tambien podria haber comenzado con 0x04 y "function name" comenzar con 0x08 y si es "MZ" porque no comienza con 0x18, al principio tambien crei que era porque MZ era un DWORD pero es WORD, pero ahora no tengo idea sobre ebp, espero me puedan explicar

salu2

http://win32assembly.online.fr/pe-tut7.html

Leete el formato PE si no vas andar y andar preguntando hasta que se cansen de darte explicaciones y empiezen los insultos.

Por cierto EBP es el registro que apunta a la base de la pila , pero generalmente dentro de las llamadas "funciones" se guarda esp en ebp y se usa para acceder a los datos que se ingresaron en la pila ..

Espero ser de ayuda

Salu2

hola

es que y entendi PE, por eso no pido que me expliquen sobre eso, lo que quiero saber es porque ebp + 0x08 tiene a "MZ" si supuestamente deberia ser 0x18, o acaso 0x08 no tiene nada que ver con lo que se guarda en eax?

porque como lo menciono, tengo la idea que eax tiene "MZ", y al abrir la funcion con push ebp crei que para acceder a MZ otra vez tenia que ser 0x18 pero me aparece un error, y si le pongo 0x08 la aplicacion se executa bien

y al revisar otros ejemplos, veo que usan 0x08, pero porque?, de donde sale o porque se accede a ese hexadecimal?

porque bueno, ya entendi el formto PE, como llegar a EAT y que tengo que hacer una comparacion de de las funciones y al encontrarlas se guardan y luego se reutilizan y asi ya no se importa nada

porfavor, no pido explicacion de PE, solo de porque [ebp + 0x08] o [esp + 8]

se que

push ebp
mov ebp, esp
sub esp, 12

es para reservar espacio, algo de esto lo lei del manual de rodojos sobre exploits

espero me puedan ayudar, pero repito no es explicacion sobre formato PE ni como llegar a tal direccion ni nada de eso

salu2 y gracias

Porque no vas depurando y comparando estructuras?, como te dice YZT tienes que leerte el formato PE, de acuerdo a la base que tengas en el formato PE, y la documentación que tengas sobre las estructuras más que manejas (como el peb), no sería dificultad programar algo así.

Si lees el tute de zeropad que te puse en el anterior link, ahí está todo explicadito...

Saludos,
Nox.

ya entendi el formato PE dice...
para saber cual es el problema de tu codigo, depura el codigo, sino os basta el depurador del compilador que usas pues hay
muchos otros

ok gracias, voy a seguir buscando

Nox, del link intente descargar el mas reciente archivo pero el doc me parece como dañado solo puedo ver el codigo y el doc creo del 2008 no se si solo esta por partes

bueno, voy a seguir intentando, lo frustante no es que no sepa como, porque de tanto que busque y lei, ya logre entender que debo hacer, los pasos son casi sencillos, buscar kernel32, buscar EAT y RVA, hacer comparacion de las funciones que necesito,   guardarlas y luego usarlas, bueno otra opcion es hacer comparaciones solo con el hash de las funciones, pero es frustante que pequeñas cosas como ebp+0x08 no lo entiendas y te tengas que detener

lo maximo que puedo imaginar es que cuando meto en la pila la funcion que necesito "db 'GetProcAddress'" son 4 bytes "0x04" y cuando meto la base de kernel32 como DWORD son 4 bytes "0x08" entonces seria

0x04 -->funcion
0x08 -->kernel32

push ebp
mov ebp, esp
/////////

y al meter esp en ebp

0x08 --> kernel32
0x0C --> funcion

mov edi, [ebp + 0x08] --> kernel32 --> "MZ"

bueno, tratare de seguirle por mi parte para no comenzar con problemas como menciono YZT, por lo menos el como hacerlo y que tengo que hacer, podria decir que ya tengo la idea, solo me hace falta practicar mas con ASM y ver el porque de varias cosas

gracias, salu2  ;-)

hola Belial aqui puedes descargar los 14 capitulos de la programacion de virus en asm de la web de ricardo:

http://ricardonarvaja.info/WEB/OTROS/PROGRAMACION%20DE%20VIRUS/

espero que tesirba yo lla enpese a leerlos pero me atore en un capitulo y decidi bajarme los capitulos de programacion de masm y radasm que son 7 creo y boy en el 4
saludos flamer


push ebp
mov ebp, esp
;sub esp,x ; opt

;EBP = Valor anterior de EBP
;EBP+4 = Dirección de retorno
;EBP+8 = 1er parámetro
;EBP+C = 2do parámetro
;...etc

mov esp, ebp
pop ebp
retn cArgs*4


Cuando vemos algo así, es porque estamos frente a una función de alto nivel o "stack frame". Un stack frame permite manejar parámetros y/o variables locales (espacio reservado en la stack restando una cantidad determinada al registro Extended Stack Pointer o "ESP").

También existen los opcodes "ENTER" y "LEAVE" que se encargan de crear y liberar el stack frame.

Funcionamiento de un stack frame :


push 0
push 1234
call fnExample
ret

fnExample:
push ebp
mov ebp, esp

mov eax, dword ptr[ebp+0x08] ; eax = 1234
mov eax, dword ptr[ebp+0x0C] ; eax = 0

leave
retn 2*4


PD: Ahora que puedo darme el gusto de leer completamente el hilo, sería recomendable que en vez de usar funciones que encuentres por Internet, aprendas a programar correctamente en ASM ya que tus dudas son muy básicas, y el código del ejemplo que has facilitado está terriblemente desorganizado. Además que no es nada complicado recorrer el Export Directory, comparar, y encontrar la función que se requiera.

hola

Flamer

gracias por el link

zu-zu

lo siento,  :rolleyes:, llevo 2 meses usando ASM y todavia hay muchas cosas muy basicas que no entiendo, espero con mas practica pueda entender mas cosas

gracias, salu2