Temas

Hola buenas tardes recien encontre en mi biblioteca el libro de "Lenguaje ensablador para computadoras basadas en Intel Quinta Edicion de KIP R. Irvine" ni me acordaba que lo tenia y bueno quiero empezar a programar en este lenguaje alguna sugerencia para un nuevo???

Que ensamblador me recomiendan Radasm o de plano me bajo el Microsoft Macro Assembler 8.0 (MASM) ??? 

Alguien me puede decir la diferencia entre MASM y MASM32???

Gracias todos los comentarios son bienvenidos saludos

[MOD: Imágenes adaptadas a lo permitido.]

Hola amigos viendo los diferentes tutoriales sobre el PE Header el de Ferchu y el de The Swash   me surgio un problema al mover el Bound Import del Tutorial The Swash de la parte "practica #2:"  con un archivo en visual basic que en si es un msgbox nada mas
cito

¿Hay solución?
Si, te cuento que hay 2 una menos ortodoxa que la otra pero ambas funcionan. Una preservadora y otra no presevadora.

   Primera solución: Yoda(creador de LordPE) alguna vez mencionó que se puede establecer el RVA del directorio BOUND_IMPORT_DIRECTORY a 00 porque este era poco importante. Mi amigo karmany opinó al respecto y estoy de acuerdo con él, este directorio tiene como utilidad optimizar entonces me parece que importa. El ejecutable no deja de funcionar pero no preserva el estado original del ejecutable.
   Segunda solución: Personalmente me parece la mejor y consiste en mover de sitio el BOUND_IMPORT_DIRECTORY. Si sabemos que está justo despues de la última sección, tranquilamente lo desplazamos 0x28 bytes y así tenemos espacio para una función. Posteriormente se actualiza el RVA en el Directorio de datos y lo habríamos solucionado.

Metodo 1 poner en 0     RVA: 0x000,Size: 0x00 correcto hasta aqui

EL PROBLEMA ( seguro es algo bien sencillo lo que me falla )

Cuando muevo 0x28 bytes para mover ahi osea quedaria 0x228 + 0x28 =0x250 vamos al HEX editor PASOS QUE ESTOY SIGUIENDO EN LAS IMAGENES
PASO 1
Compio los bytes de la bound Import despues me voy 0x28 bytes despues


PASO 2
y ahi pego los datos posteriomente con el LORD PE cambio el RVA:0x250 pero




Pero me rompe el archivo ahora si tecleo a mano los datos de la Bound Import me jala no me rompe el archivo  alguien sabe si estoy haciendo algo mal en el HEX porque cuando pego veo que me hace mas chico el ARCHIVO de 1 a 4 bytes maximo por los offsets que me muestra al final ya lo pongo en la imagen alguien sabe que podria estar haciendo mal ???
Antes me posiciono al ultimo y me dice que es el offset 4000 despues de pegar los Bytes me dice 3FFB



Ya Logre mover la Bound Import  pero tecleando todos los datos  a mano en este archivo son 20 pero supongo si quiero modear algo mas grande van a ser mas por eso quiero saber como copiarlos y pegarlos desde el editor HEX



Gracias y Saludos!!!

MOD: Imágenes adaptadas a lo permitido.

Hola Miren tengo este problema paso la direccion del arreglo d eestructuras para q leea el primer elemento que es codigo(variable de tipo string) pero se va directamente a leer el nombre y no me deja ingresar el codigo  aqui el code q para mi esta bien y es problema del getline podrian echarme una mano ??

#include<iostream>
#include<string.h>

using namespace std;

struct pro{
       string codigo;
       string nombre;
       string descripcion;
       string laboratorio;
       double precio;
       double iva;
       int existencia;
       };

void leer(struct pro *apt)
{
  double IVA = 0.16;
  double total;
      cout<<"Teclea el Codigo "<<endl;
    getline (cin,apt->codigo);/////NO PASA POR AQUI POR LO VISTO
    cout<<"Nombre "<<endl;// PASA DIRECTAMENTE A INGRESAR EL NOMBRE Y EL CODIGO SE LO PASA POR LO HUEV..S
    getline (cin,apt->nombre);
    cout<<"Descripcion: "<<endl;
    getline (cin,apt->descripcion);
    cout<<"Laboratorio: "<<endl;
    getline(cin,apt->laboratorio);
    cout<<"Precio: "<<endl;
    cin>>apt->precio;
    total=(apt->precio*IVA);
    apt->iva=total;
    cout<<"Cuantos ay en existencia"<<endl;
    cin>>apt->existencia;

}


void imprimir(struct pro *ap)
{
cout<<" CODIGO:      "<<ap->codigo<<endl;
cout<<" NOMBRE:      "<<ap->nombre<<endl;
cout<<" DESCRIPCION: "<<ap->descripcion<<endl;
cout<<" LABORATORIO: "<<ap->laboratorio<<endl;
cout<<" PRECIO:      "<<ap->precio<<endl;
cout<<" IVA:         "<<ap->iva<<endl;
cout<<" EXISTENCIA:  "<<ap->existencia<<endl;
}
int main ()
{
     int n=0;
     pro * apt=0;

cout<<"Numero de elementos"<<endl;
cin>>n;
apt= new pro[n];
for(int i=0;i<n;i++)
{
leer(&apt);
}
for(int j=0;j<n;j++)
{
imprimir(&apt[j]);
}

     delete [] apt ;
    return 0;
}

Saludos Gracias

Hace mucho tiempo que ya no estoy programando a si que les dejo un codigo que lo diseñe pensando en saltarme que sea tan facil debuggearte con el olly y otras cosas =D Vale decir que se puede convertir en un loader para exes entre otras cosas pero necesitas arreglar un poco el cargador del IAT =/

Código (ASM) [Seleccionar] Expandir



;This code work with the relocation table  :P
         Path fix "C:\windows\system32\ntdll.dll"

include "win32ax.inc"
struct UNICODE_STRING
       Len dw ?
       MaxLen dw ?
       Buffer dd ?
ends
.data
kernel32 du "kernel32.dll",0
US UNICODE_STRING
nt dd ?
.code
start:


stdcall ReadFILE,Path

stdcall Loader,eax

mov [nt],ecx
stdcall GetAddressFunction,ecx,"RtlInitUnicodeString"

stdcall eax,US,kernel32




invoke MessageBoxW,0,[US.Buffer],0,0








invoke ExitProcess,0


proc GetAddressFunction,pMZ,pApi

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   ;esi * 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 ;lstrcmp
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

SizeOfImage       equ 0x50
pe                equ 0x3c
NumberOfSections  equ 0x6
VirtualAddr       equ 0xc
proc Loader uses edx edi esi ebx,MZ
       local PE          dd ?
       local ExeBuffer   dd ?

       local Delta       dd ?
       local IBR         dd ?
       local NumberBlocks dd ?
       local I               dd ?
       local IBR2 dd ?
       local Type            dd ?
       local IAT             dd ?
       local offset          dd ?

 mov eax,[MZ]
 add eax,dword[eax+pe]
 mov [PE],eax

mov eax,[PE]
cmp dword[eax+0x80],0
je _EXIT

mov eax,[MZ]
mov eax,dword[eax+0x3c]
add eax, [MZ]
xchg eax,[PE]
mov eax,[PE]
mov eax,dword[eax+0x80]
add eax,[MZ]
mov [IAT],eax

_LOADERIAT:


mov eax,[IAT]
mov eax,dword[eax+12]
add eax,[MZ]



invoke LoadLibrary,eax
mov ebx,eax

mov eax,[IAT]

mov eax,dword[eax+16]
add eax,[MZ]

mov edi,eax
_APIs:

mov eax,edi
mov ecx,[MZ]
add dword[eax],     ecx

mov eax,dword[eax]
add eax,2

invoke GetProcAddress,ebx,eax
mov dword[edi],eax

add edi,4
cmp dword[edi],0
jne _APIs

add [IAT],20
mov eax,[IAT]

cmp dword[eax+12],0
jne _LOADERIAT



_EXIT:
invoke GlobalAlloc,GPTR,dword[eax+SizeOfImage]
     mov [ExeBuffer],eax

mov eax,[PE]

movzx edi,word[eax+NumberOfSections]

_Secciones:
dec edi

mov eax,28h
mul edi
add eax,0xf8
add eax,[PE]

mov ecx,[ExeBuffer]
add ecx,dword[eax+VirtualAddr]



mov edx,dword[eax+0x14];PointerRawData
add edx,[MZ]

invoke RtlMoveMemory,ecx, edx,dword[eax+10h]

cmp edi,0
jne _Secciones


mov eax,[PE]
invoke RtlMoveMemory,[ExeBuffer]   , [MZ]   ,dword[eax+0x54]

mov edi,[PE]
mov edi,dword[edi+0x34]

mov ecx,[ExeBuffer]

sub ecx,edi
mov [Delta],ecx

mov esi,[PE]

mov eax,[esi+0xA0]
add eax,[ExeBuffer]

 mov [IBR],eax

_EX:

mov eax,[IBR]
add eax,8
mov eax,dword[eax]
and eax,0xff

mov ecx,[IBR]
mov ecx,dword[ecx+4]
sub cl,8
mov eax,2
xchg eax,ecx
div ecx
mov [NumberBlocks],eax
inc [NumberBlocks]

_Ini:
push [IBR]
pop [IBR2]

add [IBR2],6; IBR - WORD
_BLOCKS:
dec [NumberBlocks]

add [IBR2],2

pushad
mov eax,[IBR2]
movzx eax,word[eax]
mov ecx,eax
shr ecx,12
and eax,0xff
.if ecx = 3

;scfd
mov edx,[IBR]
mov edx,[edx]
add edx,eax
add edx,[ExeBuffer]



mov eax,dword[edx]
add eax,[Delta]



mov dword[edx],eax

.endif


popad


cmp [NumberBlocks],0
jne _BLOCKS

mov eax,[IBR]
mov eax,[eax+4]
add [IBR],eax
mov eax,[IBR]
cmp dword[eax],0
jne _EX



mov eax,[PE]
mov ecx,[ExeBuffer]


   ret
endp

proc ReadFILE, ruta
locals
   bUsados dd ?
   hFile   dd ?
   tamAr   dd ?
   hMap    dd ?
   IB      dd ?
endl

   invoke  CreateFile, [ruta], GENERIC_READ, FILE_SHARE_READ, 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;By Me


Si quieren sacarle algunas apis es cosa de cambiarlas por funciones =P

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

Hola,

leyendo mucho sobre este tema de quien fue primero la gallina o el huevo vi hasta informes que la gallina tenia que ser primero por una proteina, pues yo quiero plantear mi opinion en un medio publico y a ver si algun plantea sus teorias tambien

La respuesta es el huevo algunos se preguntaran quien puso el huevo pues un ante pasado de la gallina no una gallina como tal si no que una especie menos evolucionada y de dos padres de un ave anterior nace lo que conocemos hoy en dia como una gallina mediante un  huevo.

Alguien le falla el keylogger  del Poison ivy en win vista o win7 ?

Si es a si porfavor me pueden hacer una copia de su poison pero que conecte a localhost

PD: Es para el analisis depòr que falla ya que yo no logro que me falle y existen muchos que dicen que falla :S

[Parcheando el Alcohol 120% 2.0]

Parcheando el Alcohol 120% 2.0

• ¿Que se planea lograr con este parche?
  
  
  Lo que se planea es que nunca caduque el modo de prueba ( TRIAL ) .
  
  
  
• Tutorial
  
  
  Lo primero que haremos y que es bueno siempre hacerlo cuando se planee crackear algún programa es ver si esta enpaquetado con algún packer , para esto utilizaremos el peid(web) .
  
  
  
  
  
  Como vemos en el peid esta empaquetado con el UPX , existen varias opciones para desempaquetarlo yo usare el PE Explorer (web) con este p`rograma solo abrimos nuestro exe ( el alcohol ) y este se desempaqueta automaticamente y luego lo guardamos con el nombre Alchol_UNPACK.exe .
  
  
  Ejecutamos el alcohol  ( el empaquetado o el desempaquetado da igual) luego cambiamos la fecha de nuestro sistema y la adelantamos un año esto lo haremos para vencer el modo de prueba  , lo volvemos a ejecutar y nos saltara un mensaje como el siguiente
  
  
  
  
  Ya teniendo el exe desempaquetado lo abrimos con una muy buena modificación del olly dbg que es el Olly Shadow( DESCARGAR ) , para obtener donde dice el programa que estamos vencidos usaremos de guia el mensaje anterior por lo tanto pondremos un "BP MessageBoxW" en la barra de comandos y le damos a enter .
  
  
  Veremos que para cuando llama a MessageBoxW comprobamos que el mensaje sea el mismo que nos muestro si no es apretamos F9
  
  
  
  pero en el caso de ser vamos apretando F8 hasta que nos encontremos en el espacio de memoria del exe y no de la dll y llegaremos a un codigo como este
  
  
  
  analizamos un poco el codigo anterior al MessageBox hasta encontrarnos con unos saltos condicionales sospechosos , les pondremos un break point con F2 al test al,al y volveremos a lanzar el exe en este momento el exe parara en el BP y segurimos el anlaisis con F8 vemos que el JNZ luego del test al,al saltan al bloque cercano del codigo del MessageBox a si que cambiaremos la condición a JZ y le damos a F9 y EUREKA!!! nos muestra todo como si fuera dentro del plazo
  
  
  
  Saltos sospechosos:
  
  
  Código (asm) [Seleccionar] Expandir
  
/*43A181*/  TEST AL,AL
/*43A183*/  JNZ SHORT Alcohol_.0043A1A4
/*43A185*/  MOV ECX,DWORD PTR SS:[EBP-134]
/*43A18B*/  CMP ECX,0F
/*43A18E*/  JG SHORT Alcohol_.0043A1A4
/*43A190*/  FLD QWORD PTR SS:[EBP-13C]
/*43A196*/  CALL Alcohol_.0063D450
/*43A19B*/  CMP EAX,0F
/*43A19E*/  JLE Alcohol_.0043A434


  
  
  
  
  
  SE NECESSITA ELIMINAR LA CARPETA LENGS