• Humilde Visor de claves de el msn 0.1v by YST  
        Descripción: Programa que te muestra todas las claves y cuentas guardadas en el Msn Live.
                         
  
  
• Humilde Visor de claves de el Firefox 0.1v by YST
        Descripción: Programa que te muestra las claves guardadas en el Firefox 3
     
     
  
• CrearImport
        Descripción: Programa que crea un import parecido a el "kernel32.inc" que trae el Fasm por defecto , con todas las funciones de la libreria indicada.
     
     
  
• PE visor by YST
        Descripción: Pequeño visor del formato PE de cualquier archivo que contenga este formato.
     
     
  
  Codigos generales.
   
     
  
• ChangeEntryPoint
        Descripción: Cambia el EntryPoint de un archivo con formato PE.
     
     
  
• GetAddressFunction
        Descripción: Función que simula la función GetProcAddress de la kernel32.dll
   
     
  
• Split
        Descripción: Codigo que parte una cadena por medio de un separador.
   
     
  
• Zerar
        Descripción: Función que llena de tantos 0 como le indiques una posición.
     
     
  
• cInstr
        Descripción: Función que te dice si una cadena se encuentra dentro de otra y de encontrarsre devuelve la posicion donde se    encuentra y en caso contrari devuelve 0
     
     
  
• StrReverse
        Descripción: Función pone una cadena al revez (ej: "Hola" te la dejaria en "aloH" )
     
     
  
• EncriptacionChangeCase
        Descripción: Función que remplaza todas las mayusculas por minuscula y viceversa
     
     
  
• EncriptacionXOR
        Descripción: Función que cifra mediante un XOR
     
     
  
• Encriptacion YST
        Descripción: Función que cifra mediante un algoritmo propio
     
     
  
• Infección USB
        Descripción: Función que infecta unidades extraibles
     
     
  
• DetectaExtención
        Descripción: Función que devuelve la extención de un archivo.
     
     
  
• cRtlMoveMemory
        Descripción: Función que simula la función RtlMoveMemory de kernel32.dll .
     
     
  
• EOFExtraDataExtract
        Descripción: Función que devuelve donde se encuentra el fin del archivo mediante el formato PE .
   
     
  
• antiemulator
        Descripción: Función que detecta la emulación de algunos antivirus .
   
     
  
• CapetaVaciaOUnidad
        Descripción: Función que dice si una ruta no contiene archivos .
   
     
  
• ASCIITOUNICODE
        Descripción: Función que pasa una cadena ascii a unicode .
   
     
  
• ConcatenarUnicode
        Descripción: Función que concatena 2 cadenas en unicode .
   
     
  
• LenUnicode
        Descripción: Función que mide una cadena en unicode.
   
     
  
• StringToHex
  Descripción: Función que pasa una cadena ASCII a Hexadecimal.
   
     
  
• HexToString
  Descripción: Función que pasa una cadena Hexadecimal a una cadena ASCII.
   
     
  
• SHA1Hash
  Descripción: Saca el hash sha1 de un dato
   
     
  
• Propagación por emule
  Descripción: Codigo que se propaga por el sistema p2p emule.
   
     
  
• Propagación por Omemo
  Descripción: Codigo que se propaga por el sistema p2p Omemo.
   
     
  
• Propagación por Ares
  Descripción: Codigo que se propaga por el sistema p2p ares.
   
     
  
• fRight
  Descripción: Funcion que iguala a la función Right de Visual basic 6.
   
     
  
• RC4
  Descripción:Codigo que cifra usando el algoritmo RC4.
   
     
  
• Rot39
  Descripción:Codigo que cifra usando el algoritmo ROT39.
   
   
  
• Ejecución de comandos con pipes
  Descripción:Codigo que muestra los valores devueltos por un ping 127.0.0.1 .
   
   
  
• IsVirtualPCPresent
  Descripción:Detecta si estamos siendo ejecutados en una maquina virtual .
     
   
  
• Llamar funciones de librerias como lo hace el Visual basic 6
  Descripción: Ejemplo de como llama las api's el visual basic 6 , codigo original por karcrack traducido por mi .

proc ASCIITOUNICODE,Cadena,Buffer
push ecx ebx
mov  eax,[Cadena]
mov ebx,[Buffer]
dec eax
sub ebx,2
.bucle:
inc eax
cmp byte[eax],0
je .salir
add ebx,2
mov cl,byte[eax]
mov byte[ebx],cl
mov byte[ebx+1],0
jmp .bucle
.salir:
pop ebx ecx
ret
endp

include 'win32ax.inc'
.code
start:
stdcall cInstr,"98y4ct2y3Hola83925832c","Hola"
.if eax = FALSE
invoke MessageBox,0,"No esta.",0,0
.else
invoke MessageBox,0,eax,0,0
.endif
invoke ExitProcess,0
;////////////////////////////////////////////////////////////////////////////////////////////////////
;//Descripción: Funcion que ve si la segunda cadena se encuentra dentro de la primera             //
;//c1 = Cadena                                                                                   //
;//c2 = Cadena que se buscara en c1                                                             //
;// Retorna:                                                                                   //
;// Si no se encuentra o hay error retorna FALSE , en el caso de que se encuentre devuelve eax//
;// apuntandoa la posicion de c1 donde se encontro c2                                        //
;// by YST                                                                                  //
;////////////////////////////////////////////////////////////////////////////////////////////
proc cInstr,c1,c2
push edi esi ebx ecx  edx
stdcall Len,[c2]
mov edi,eax
stdcall Len,[c1]
mov esi,eax
cmp edi,esi
jg .Falso
mov edx,[c1]
mov ebx,[c2]
dec edx
inc esi
.bucle:
dec esi
inc edx
mov cl,byte[edx+edi]
mov byte[edx+edi],0
stdcall comparar,edx,[c2]
mov byte[edx+edi],cl
.if eax = 0
mov eax,edx
jmp .salir
.endif
cmp esi,0
jne .bucle
.Falso:
mov eax,FALSE
.salir:
pop edx ecx ebx 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
.end start

antiemulator:
push ebx ecx
invoke GetTickCount
mov ebx,eax
mov eax,2
mov ecx,250
mul ecx
invoke SleepEx,eax,FALSE ; 250 * 2= 500 ( para confundir un poco el antivirus )
invoke GetTickCount
sub eax,ebx
cmp eax,500
jl .si
mov eax,FALSE
pop ecx ebx
ret
.si:
pop ecx ebx
mov eax,TRUE
ret

include 'win32ax.inc'
.data
buffer rb 100
.code
start:
stdcall StrReverse,kk,buffer
invoke MessageBox,0,buffer,kk,0
leave
ret
kk: db  "Estoy cifrado",0
proc StrReverse,cCadena,cBuffer
push ebx esi edi eax ecx
mov ebx, [cCadena]
mov esi,[cBuffer]
stdcall Len,ebx
mov ecx,eax
mov al,byte[ebx]
dec ecx
mov edi,0
.bucle:
mov ah,byte[ebx+ecx]
mov byte[esi+edi],ah
inc edi
dec ecx
jecxz .salir
jmp .bucle
.salir:
mov byte[esi+edi],al
mov byte[esi+edi+1],0
pop ecx eax edi esi ebx
ret
endp
proc Len , SRC
push ecx edi
mov ecx,-1
mov edi,[SRC]
mov al,0
repnz scasb
mov eax,ecx
not eax
dec eax
pop edi ecx
ret
endp
.end start

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     
 

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

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