Recopilación de mis codigos.

[YST]

Programas

• 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 .

[YST]

Código (asm) [Seleccionar] Expandir


;Función que cifra con un xor 10 cada byte de una cadena
; 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 EncriptacionXOR,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]
inc ebx
dec eax
.bucle:
dec ebx
cmp ebx,0
jbe .salir
inc eax
xor byte[eax],10
jmp .bucle
.salir:
pop ebx
ret
endp

[YST]

Código (ASM) [Seleccionar] Expandir


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

[YST]

Código (asm) [Seleccionar] Expandir


macro  MacroYSTEncript Posicion,Tamaño{
local ..Caracter,..numero
..numero  = Tamaño
repeat Tamaño
..numero  = ..numero - 1
load ..Caracter from  Posicion+%-1
..Caracter = byte ..Caracter + 3
..Caracter = byte not ..Caracter
..Caracter = byte ..Caracter xor 45
..Caracter = byte ..Caracter xor ..numero
store  ..Caracter at  Posicion+%-1
end repeat
}     


Código (ASM) [Seleccionar] Expandir


proc YSTEncript,cCadena,cBuffer,cTamaño
push eax ebx ecx  edx esi
mov ebx,[cBuffer]
mov esi,[cCadena]
dec esi
dec ebx
.Eb:
dec [cTamaño]
inc esi
inc ebx
mov cl,byte[esi]
add cl,3
mov byte[ebx],cl
not byte[ebx]
xor byte[ebx],45
mov edx,[cTamaño]
xor byte[ebx],dl
cmp [cTamaño],0
jne .Eb
pop  esi edx ecx ebx eax
ret
endp

proc YSTDesencript,cCadena,cBuffer,cTamaño
push  eax ebx ecx  edx esi
mov ebx,[cBuffer]
mov esi,[cCadena]
dec esi
dec ebx
.Eb:
dec [cTamaño]
inc esi
inc ebx
mov cl,byte[esi]
mov byte[ebx],cl
mov edx,[cTamaño]
xor byte[ebx],dl
not byte[ebx]
xor byte[ebx],45
sub byte[ebx],3
cmp [cTamaño],0
jne .Eb
pop  esi edx ecx ebx eax
ret
endp

[YST]

Código (ASM) [Seleccionar] Expandir


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

[YST]

Código (ASM) [Seleccionar] Expandir


include 'win32ax.inc'
.code
start:
invoke LoadLibrary,"user32.dll"
stdcall  GetAddressFunction,eax,"MessageBoxA"
stdcall eax,0,0,0,0
invoke ExitProcess,0
proc GetAddressFunction,pMZ,pApi
;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
cmp esi,0
je .error
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:
ret
.error:
xor eax,eax
jmp .salir
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
.end start

[YST]

Código (ASM) [Seleccionar] Expandir


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

[YST]

Código (ASM) [Seleccionar] Expandir


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'
.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

[YST]

Código (ASM) [Seleccionar] Expandir


include 'win32ax.inc'

.code
start:

stdcall CapetaVaciaOUnidad,"F:"

.if eax = TRUE
invoke MessageBox,0,"La carpeta esta vacia",0,0
.else
invoke MessageBox,0,"La carpeta no esta vacia",0,0
.endif

invoke ExitProcess,0

proc CapetaVaciaOUnidad,ruta
locals
Find  WIN32_FIND_DATA    ?
HandleBusqueda dd ?
Ruta dd ?
endl

push ebx

invoke GlobalAlloc,GPTR,MAX_PATH+1
mov [Ruta],eax
stdcall Concat,[ruta],"\*", [Ruta]
invoke FindFirstFile,[Ruta] , addr Find
mov [HandleBusqueda],eax
invoke FindNextFile ,eax, addr Find
invoke lstrcpy,[Ruta],addr Find.cFileName
mov ebx,[Ruta]

.if word[ebx] = ".."
invoke FindNextFile, [HandleBusqueda], addr Find
.endif
invoke lstrcpy,[Ruta],addr Find.cFileName
mov ebx,[Ruta]
.if word[ebx] = ".."

invoke GlobalFree,[Ruta]
mov eax,TRUE
.else
.if dword[ebx] = "RECY"
.if dword[ebx+4] = "CLER"
invoke GlobalFree,[Ruta]
mov eax,TRUE
.endif
.else
invoke GlobalFree,[Ruta]
mov eax,FALSE
.endif
.endif
.endif
pop ebx

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
.end start