Mensajes

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

hola

una pregunta

he visto que despues de encontrar kernel32 buscan las funciones

por ejemplo

Código (asm) [Seleccionar] Expandir

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

Código (asm) [Seleccionar] Expandir

mov eax, [eax+08h]


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

Código (asm) [Seleccionar] Expandir

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

Código (asm) [Seleccionar] Expandir

                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

Código (asm) [Seleccionar] Expandir

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

Código (asm) [Seleccionar] Expandir

mov edi, [ebp + 0x08]

lo cual me parecio que debia ser

Código (asm) [Seleccionar] Expandir

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

Código (asm) [Seleccionar] Expandir

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

Código (asm) [Seleccionar] Expandir

                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

;------------------------------------
       ;          +-----------------------+
       ; 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

Hola tengo unas dudas sobre PEB

bueno, ya entendi como se encuentra PEB gracias al blog de Nox donde te explica sobre eso

estuve haciendo pruebas para verificar si lo que hacia estaba bien, perdon por poner una mezcla de ASM y C pero no encontre otra manera de verificar que realmente la comparacion de PE fuera exacto

Código (c) [Seleccionar] Expandir

#include <windows.h>
#include <stdio.h>

int main()
{

__asm{

xor eax, eax
mov eax, fs:[0x30]
mov eax, [eax+0x0C]
mov eax, [eax+0x1C]
mov eax, [eax]
mov eax, [eax+0x08]
mov ebx, eax
add ebx, [eax + 0x3C]
cmp ebx, 'PE'
je bien


}
bien:
MessageBox(0, "bien hecho", "mensaje", 0 );
getchar();

}

ahora, lo que sabia es que despues de esto tenia que llegar a IMAGE DATA DIRECTORY, donde se encuentra RVA o VirtualAddress

aqui no se dos cosas, cual es el tamaño de IMAGE_OPTIONAL_HEADER?

acaso son 0x78?

entonces seria 0x76 y 0x78 empieza IMAGE_DATA_DIRECTORY?

y lo que tendria que seguir en el codigo para llegar a EAT seria?

mov ebx, [ebx + 0x78]

y bueno, de aqui que mas tendria que hacer para encontrar por ejemplo, LoadLibraryA y Getprocaddress?

e visto que buscan direccion de nombres [0x20] y numero de nombres [0x18] e incluso veo que se saltan eso y van directo a [0x24] que seria numero de funciones

me gustaria hacer un ejercicio para mostrar un MessageBox cargando user32.dll con LoadLibrary y mostrando MessageBoxA con GetprocAddress y ponerle algun mensaje, todo usando PEB

espero me puedan ayudar

P.D. Nox, me podrias decir que compilador usaste para compilar el ejemplo de tu blog, porfavor?

salu2

a que bien, gracias por las respuestas

y gracias Nox, por el link... se ve interesante tu blog

salu2 

necesitas saber como abrir el archivo, busca informacion sobre

FILE *fp fopen()

hola

estoy tratando de programar una aplicacion para descargar archivos, del codigo que les pondre, el segundo for( ; ; ), se detiene y no termina de descargar los datos y los archivos quedan incompletos, que podria suceder?, lo estoy haciendo en linux

Código (c) [Seleccionar] Expandir

if(argc > 2){

char *hst, *file, *dire;
char datos[512];
char buffer[1024];
hst = argv[1];
file = argv[2];
dire = argv[3];

int sock;
int i = 0;
int bytes = 0;
int dbytes;

memset(buffer, 0, 1024);

struct sockaddr_in cox;
struct hostent *ht;

sprintf(datos, "GET %s HTTP/1.1\nHost: %s\nUser-Agent: Mozilla/4.0\n\n", file, hst);

sock = socket(AF_INET, SOCK_STREAM, 0);

ht = gethostbyname(hst);

cox.sin_family = AF_INET;
cox.sin_port = htons(80);
cox.sin_addr = *((struct in_addr*)ht->h_addr);
memset(&cox.sin_zero, 0, 8);

connect(sock, (struct sockaddr*)&cox, sizeof(struct sockaddr));

FILE *fp = fopen(dire, "wb");

send(sock, datos, strlen(datos), 0);

for(;;){

recv(sock, buffer + i, 1, 0);
i++;
if(strncmp(buffer+i-4, "\r\n\r\n", 4) == 0){
break;
}
}
for(;;){

memset(buffer,0,1024);
bytes = recv(sock, buffer, 1024, 0);
dbytes += bytes;
printf("%d KB\n", dbytes/1024);
fwrite(buffer, sizeof(char), bytes ,fp);
if(bytes <= 0){
break;
}
}
printf("Bytes: %d\n", dbytes);
fclose(fp);
close(sock);
}
}


todavia le faltan cosas, pero ahorita lo hice para que descargue de esta manera

./downfiles www.oocities.org /dreamlfpg315/dll/ensamblador.txt ensamblador.txt

pues tengo varios link sobre PEB, por ejemplo

http://el-blog-de-thor.blogspot.mx/2011/05/obtener-la-direccion-base-de.html

asi que si logro entender lo mejor posible como funciona, solo que me esfuerzo para entender ASM, y eso hace que me confunda rapido

y formato PE si estudie, por ejemplo

http://foro.elhacker.net/analisis_y_diseno_de_malware/taller_en_construccionsecciones_en_archivos_pe-t362515.0.html

http://foro.elhacker.net/analisis_y_diseno_de_malware/que_es_un_runpe-t340360.0.html

y libros si tengo, creanme que los sigo estudiando el lenguaje, tambien tengo varios link donde estuve googlendo para encontrar cosas como "movzx", "lodsb", etc...

y bueno, sigo haciendo ejercicios para acostumbrarme, y durante muchos años me acostumbre al codigo de alto nivel, y el cambio a lenguaje de bajo nivel, pues me confunden varias cosas

bueno, espero no una gran explicacion a todo, pero lo que puedan ayudarme seria muy bueno

salu2

jeje gracias a los 2 por responderme

mmm creo ahora entender porque cuando quise hacer un shell me funcionaron de las dos formas

Código (asm) [Seleccionar] Expandir

[BITS 32]

call start

start:

mov eax, cd
push eax
mov eax, 76B4E5FDh
call eax
mov eax, 76B1214Fh
call eax

cd:
db 'cmd.exe', 0


Código (asm) [Seleccionar] Expandir

[BITS 32]

call start

start:

lea eax, [cd]
push eax
mov eax, 76B4E5FDh
call eax
mov eax, 76B1214Fh
call eax

cd:
db 'cmd.exe', 0


y pues nop, el vino no me llego, solo era para los que viven en España, asi que le deje la desicion a dimitrix sobre si se lo quedaba el o se lo daba al segundo lugar, no se que habra hecho, ya no pregunte, pero bueno

gracias

salu2

hola

Me podrian ayudar a entender esto

Código (asm) [Seleccionar] Expandir

api_call:
  pushad     ;registros a pila
  mov ebp, esp
  xor edx, edx
  mov edx, [fs:edx+48] ;puntero a PEB
  mov edx, [edx+12]    ;puntero a LDR
  mov edx, [edx+20]    ;puntero al primer modulo de la lista de InMemoryOrder


next_mod:
  mov esi, [edx+40]    ;puntero al nombre de los modulos
  movzx ecx, word [edx+38] ;logitud a verficar
  xor edi, edi



Esta parte no la entiendo... se movera a esi edx+40, supuestamente es el puntero a los modulos pero donde encuentro informacion sobre el porque edx+40 apunta a los nombres

movzx tengo entendido que es para mover a un destino rellenando con ceros, pero porque un word [edx+38]?

Código (asm) [Seleccionar] Expandir

loop_modname:
  xor eax, eax
  lodsb
  cmp al, 'a'        ;el nombre del modulo esta en minuscula
  jl not_lowercase   ;lo pasamos
  sub al, 0x20       ;a mayuscula   

not_lowercase:
  ror edi, 13        ;rotamos hacia la derecha
  add edi, eax       ;el valor del hash
  loop loop_modname  ;hasta ecx=0

Aqui quiero creer que lo que pasa es que lodsb leera byte por byte de mov esi, y lo metera en ax, se hara una comparacion con los ultimos 8 bits y si resulta a minuscula se hara mayuscula y saltara a not_lowercase

entiendo que ror es para voltear a la derecha, pero porque 13?, add hace una suma de edi + eax?, y como que el hash?, el que yo le pongo por ejemplo

push 0x876F8B31 ;hash para WinExec a pila

o cual hash?

y me imagino que el loop hace que repita ecx que se relizo en next_mod

Código (asm) [Seleccionar] Expandir

push edx           ;Posicion
  push edi           ;y hash del modulo actual a pila
  mov edx, [edx+16]  ;direccion base del modulo a edx
  mov eax, [edx+60]  ;cabecera PE a eax
  add eax, edx
  mov eax, [eax+120] ;EAT a eax
  test eax, eax      ;hay EAT?
  jz get_next_mod1   ;no, siguiente modulo
  add eax, edx
  push eax           ;EAT del modulo a pila
  mov ecx, [eax+24]  ;numero de funciones del modulo a ecx
  mov ebx, [eax+32]  ;RVA de las funciones a ebx
  add ebx, edx         

Código (asm) [Seleccionar] Expandir

push edx           ;Posicion
  push edi           ;y hash del modulo actual a pila

Esto creo que es edx del inicio, puntero del primer modulo, y el hash que se caba de encontrar, el cual todavia no entiendo cual

Código (asm) [Seleccionar] Expandir

mov edx, [edx+16]  ;direccion base del modulo a edx

este me imagino que es PVOID BaseAddress

Código (asm) [Seleccionar] Expandir

mov eax, [edx+60]  ;cabecera PE a eax
  add eax, edx
  mov eax, [eax+120] ;EAT a eax
  test eax, eax      ;hay EAT?
  jz get_next_mod1   ;no, siguiente modulo

creo que es el PE de kernel32.dll y la suma de eax y edx mas 120 me llevara a EAT, si no hay entonces llegare a get_next_mod1

Código (asm) [Seleccionar] Expandir

get_next_mod1:
  pop edi         ;hash del siguiente modulo a eax
  pop edx         ;posicion donde quedamos en la lista de modulos a edx
  mov edx, [edx]  ;puntero al siguiente modulo
  jmp short next_mod

me imagino que saco de la pila edi, edx y regresamos a la posicion de antes y se repite next_mod

Código (asm) [Seleccionar] Expandir

add eax, edx
  push eax           ;EAT del modulo a pila
  mov ecx, [eax+24]  ;numero de funciones del modulo a ecx
  mov ebx, [eax+32]  ;RVA de las funciones a ebx
  add ebx, edx     



posiblemente aqui se encuentra EAT me llevara a RVA donde estan las funciones del modulo

Código (asm) [Seleccionar] Expandir

get_next_func:
  jecxz get_next_mod ;si no quedan mas funciones, vamos con el siguiente modulo
  dec ecx            ;numero de la funcion - 1
  mov esi, [ebx+ecx*4]  ;RVA de la funcion a esi
  add esi, edx
  xor edi, edi

pero me imagino que pasa si se leen tods las funciones, aunque no entiendo como funcionaria

Código (asm) [Seleccionar] Expandir

loop_funcname:
  xor eax, eax
  lodsb           ;byte por byte del nombre de la funcion en ASCII
  ror edi, 13     ;buscamos
  add edi, eax    ;el caracter
  cmp al, ah      ;nulo que indica el final de la cadena
  jne loop_funcname ;hasta tener el hash completo de la funcion
  add edi, [ebp-8]  ;edi=hash del modulo+hash de la funcion
  cmp edi, [ebp+36] ;es la que buscamos?
  jnz get_next_func ;no, sigamos con la siguiente funcion   

  pop eax           ;EAT del modulo a eax
  mov ebx, [eax+36] ;conseguimos RVA
  add ebx, edx      ;le a?adimos la direccion base del modulo
  mov cx, [ebx+2*ecx]
  mov ebx, [eax+28]  ;RVA de la funciones a ebx
  add ebx, edx       ;le a?adimos la direccion base del modulo
  mov eax, [ebx+4*ecx] ;RVA de la funcion que queremos a eax
  add eax, edx       ;le a?adimos la direccion base del modulo y listo, en eax   

finish:
  mov [esp+36], eax ;viene un popad asiq salvamos eax, escribiendolo sobre el valor

Y para finalizar

Me imagino que se hace exactamente lo mismo para buscar la funcion con loop

Código (asm) [Seleccionar] Expandir

loop_funcname:
  xor eax, eax
  lodsb           ;byte por byte del nombre de la funcion en ASCII
  ror edi, 13     ;buscamos
  add edi, eax    ;el caracter
  cmp al, ah      ;nulo que indica el final de la cadena
  jne loop_funcname ;hasta tener el hash completo de la funcion

esto no entiendo que hace, solo se que sirve para verfiricar que es la que buscamos, pero porque ebp-8 y ebp+36

Código (asm) [Seleccionar] Expandir

add edi, [ebp-8]  ;edi=hash del modulo+hash de la funcion
  cmp edi, [ebp+36] ;es la que buscamos?
  jnz get_next_func ;no, sigamos con la siguiente funcion   



Aqui y solo me imagino que es agregar a la pila todo los datos

Código (asm) [Seleccionar] Expandir

pop eax           ;EAT del modulo a eax
  mov ebx, [eax+36] ;conseguimos RVA
  add ebx, edx      ;le a?adimos la direccion base del modulo
  mov cx, [ebx+2*ecx]
  mov ebx, [eax+28]  ;RVA de la funciones a ebx
  add ebx, edx       ;le a?adimos la direccion base del modulo
  mov eax, [ebx+4*ecx] ;RVA de la funcion que queremos a eax
  add eax, edx       ;le a?adimos la direccion base del modulo y listo, en eax
 

y finalizamos

Código (asm) [Seleccionar] Expandir

finish:
  mov [esp+36], eax ;viene un popad asiq salvamos eax, escribiendolo sobre el valor

Perdon se que son muchas preguntas pero espero me puedan ayudar poco a poco, porque ya pase varios dias leyendo y googlendo sobre muchas cosas, afortundente el formato PE lo logre entender y bueno el manual que hay para formato PE sobre windows pues sigo leyendo

varias funciones que desconocia de ASM las sigo aprendiendo, ya logre hacer una shell con las direcciones de WinExec y ExitProcess, me costo un poco de trabajo porque no sabia como hacer un push a "db 'cmd.exe', 0'"... XD

y buscando me di cuenta que con esas mismas direcciones se puede ejecutar una shell con PEB, esto lo encontre del blog Harmony Security

Código (asm) [Seleccionar] Expandir

[BITS 32]
[ORG 0]

  cld                    // clear the direction flag
  call start             // call start, this pushes the address of 'api_call' onto the stack
delta:
  %include "./x86_api_call.asm"
start:
  pop ebp                // pop off the address of 'api_call' for calling later

  push byte +1           // push the command show parameter
  lea eax, [ebp+command-delta] // calculate an address to the command line
  push eax               // push the command line parameter
  push 0x876F8B31        // push the hash value for WinExec
  call ebp               // kernel32.dll!WinExec( &command, SW_NORMAL )

  push byte 0            // push the desired exit code parameter
  push 0x56A2B5F0        // push the hash value for ExitProcess
  call ebp               // call kernel32.dll!ExitProcess( 0 )

command:
  db "calc.exe", 0


y pues estoy interesado en aprender a hacer cosas como esas

bueno, espero me puedan ayudar

salu2

hola

me podrian explicar para que funciona LEA y cual es la diferencia entre LEA y MOV

es que googlendo encontre un poco pero no entendi bien, y pues algo que encontre tambien fue la diferencia de lea y mov pero me quisiera saber si alguien tiene una explicacion mas amplia porfavor

salu2