Hola, estoy intentando crackear un programa y necesito, por razones particulares, ver el valor de los registros CS, DS, y ES. He intentado buscarlos en el panel de registros, pero solo se ven los de proposito general y nada más (algunos otros como MMX tambien se ven) pero los que necesito no se encuentran listados.

Por favor si saben algun metodo u otro depurador que me ayude a visualizar el contenido de los registros CS, DS, y ES, estaría muy agradecido. Gracias de antemano por sus respuestas.

Hola, estoy desarrollando un malware en ensamblador. Ya ha fallado varias veces cuando intento hacer una operacion que usa los registros ESI y EDI. Lo he analizado y he descubierto que los registros DS y ES no apuntan a los datos embebidos dentro del mismo segmento de codigo.

Por eso necesito que me ayuden un poco explicandome como hacer que los registros DS (Data Segment) y ES apunten hacia CS (Code Segment). Será que pueden darme un breve ejemplo en codigo de como hacerlo?? Gracias de antemano por sus respuestas.

Hola, escribo este mensaje para preguntarles, ¿Como puedo eliminar un post que hice yo? Lo que ocurre es que mientras escribía un post, de casualidad se envio dos veces, y quisiera borrar el duplicado antes de que algun moderador piense que yo estoy haciendo spam.

No sé porque se envio doble, solo ocurrio. Si pudieran decirme como borrar el post, estaría muy agradecido. Gracias de antemano por sus respuestas.

[Disculpen, no sabía que mi post anterior había sido movido aquí, por favor, si pueden respondan a mi pregunta]

Hola, estoy desarrollando un virus sencillo en assembly. Es capaz de buscar archivos .exe en el directorio especificado, pero me falta una parte: ¿Que debo modificar en el PE Header de un exe para infectarlo con mi virus sencillo??? Es lo unico que me falta.

No piensen que estoy haciendo preguntas de lammers, ya que tengo conocimientos sobre algunas cosas sobre las cabeceras de los ejecutables de Windows, pero no sé que debiera modificar exactamente para que mi virus sea añadido al final del ejecutable y corra de primero.

Si pudieran darme una guia sobre que campos de los Headers del Exe debo modificar, estaría muy agradecido. Gracias por sus respuestas de antemano.

Hola, no sé si esto debería ir en este subforo, pero como vi que decía "Windows", me imagino que será cosas relacionadas a la programacion en Windows. Bueno, mi problema es este: Estoy desarrollando un virus simple. Ya mi virus es capaz de buscar archivos .exe, pero no sé como infectarlos, es decir, sobreescribir el PE header para poder añadir mi virus a él.

Eso es todo lo que me falta para terminar mi malware. Por favor, si pudieran darme una guía detallada sobre que hacer, que modificar y que añadirle al PE header para que mi virus se quede anexado al ejecutable sin dañarlo, estaría muy agradecido.

Gracias de antemano por sus respuestas

Hola, ¿Como están? Mi problema es el siguiente: Estoy desarrollando un virus en ASM y necesito llamar las APIs de Windows sin usar import tables en mi ejecutable, para mejorar la portabilidad del virus. Conseguí un código que busca la direccion del kernel32 y llama a unas APIs en esta pagina, pero no entiendo partes del codigo: http://www.rohitab.com/discuss/topic/38717-quick-tutorial-finding-kernel32-base-and-walking-its-export-table/

Me he encargado de comentar las lineas que entiendo en ingles, pero aún así hay partes que no comprendo. Si pudieran ayudarme indicandome que hacen las partes sin comentar estaría muy agradecido. Tengo algunos conocimientos sobre las estructuras internas de Windows, así que no piensen que estoy haciendo preguntas de novatos o fuera de lugar, espero no haberme equivocado en postear esta pregunta. Gracias por sus respuestas de antemano.

Aquí está el codigo fuente:

;This is a fragment of code that could be used to make malware that use API dynamicly without
;tells to the assembler which API we want to use. This is very useful to generate malware that
;no uses import table in the executable, provided a better way to perform actions without
;modify the host import table, like a virus, trojan. The original code was written by
;SIGSEV, but I added comments to the code to clarify its actions. I can't understand all, I need help
 
format pe console 4.0
 
pushad
call CodeStart
CodeStart:
	pop ebp
	sub ebp,CodeStart	; delta offset shit
 
finding_kernel32:
	mov ebx, [FS : 0x30]        ;FS:0x30 points to the address of Process Environment Block (PEB)
                                ;Now the Base Pointer (BX) points to the address of PEB in memory
 
	mov ebx, [ebx + 0x0C]       ;Now we move 0x0C (12 bytes) from the address of PEB
                                ;We get the value of ebx+0x0c, in other words, the address that has the PEB->Ldr pointer
 
                                ;Now we are in Ldr structure. We move the ebx pointer following the address in the
                                ;PEB->Ldr pointer.
 
	mov ebx, [ebx + 0x14]       ; get PEB->Ldr.InMemoryOrderModuleList.Flink (1st entry)
	mov ebx, [ebx]	            ;2nd Entry
	mov ebx, [ebx]	            ;3rd Entry
	mov ebx, [ebx + 0x10]   ; Get Kernel32 Base
	mov [ebp+dwKernelBase] , ebx
	add ebx, [ebx+0x3C]	; Start of PE header
	mov ebx, [ebx+0x78]	; RVA of export dir
	add ebx, [ebp+dwKernelBase]  ; VA of export dir
	mov [ebp+dwExportDirectory] , ebx
 
	lea edx,[ebp+api_GetProcAddress]    ;Load in ebp the address of the API function name.
	mov ecx,[ebp+len_GetProcAddress]    ;Load in ecx the size of the API function name
	call GetFunctionAddress             ;Call GetFunctionAddress
 
	mov [ebp+AGetProcAddressA] , eax    ;The API function address in memory was stored by the
                                        ;GetFunctionAddress function in eax, now we save the address
                                        ;of the GetProcAddress in a variable for later use.
 
	lea edx,[ebp+api_LoadLibrary]       ;Load in edx the API function name of LoadLibrary
	push edx                            ;Save edx in the stack
	push dword [ebp+dwKernelBase]
	call eax
	mov [ebp+ALoadLibraryA] , eax
	lea edx , [ebp+szUser32]
	push edx
	call eax
	lea edx , [ebp+api_MessageBoxA]
	push edx
	push eax
	mov ebx,[ebp+AGetProcAddressA]
	call ebx
	mov [ebp+AMessageBoxAA] , eax
 
	push 0
	lea edx,[ebp+szTitle]
	push edx
	lea edx,[ebp+szMsg]
	push edx
	push 0
	call eax
	popad
 
	push 0xBBBBBBBB   ;OEP
	retn
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;	  <<<<< GetFunctionAddress >>>>>>											;
;	 Extracts Function Address From Export Directory and returns it in eax   	;
;	 Parameters :  Function name in edx , Length in ecx						  ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
GetFunctionAddress:
	push ebx    ;Save status of registers before execute the subroutine
	push esi    ;to preserve its content. It could make some errors to the
	push edi    ;caller function if modify the values that are common of the whole
                ;program
 
	mov esi, [ebp+dwExportDirectory]
	mov esi, [esi+0x20]	;RVA of ENT
	add esi, [ebp+dwKernelBase]  ;VA of ENT
	xor ebx,ebx
	cld
 
	looper:
		  inc ebx
		  lodsd     ;Load a byte from the string pointed by SI into al register
		  add eax , [ebp+dwKernelBase]   ;eax now points to the string of a function
		  push esi		;preserve it for the outer loop
		  mov esi,eax
		  mov edi,edx
		  cld
		  push ecx
		  repe cmpsb
		  pop ecx
		  pop esi
		  jne looper
 
		  dec ebx
		  mov eax,[ebp+dwExportDirectory]
		  mov eax,[eax+0x24]	   ;RVA of EOT
		  add eax,[ebp+dwKernelBase]	 ;VA of EOT
		  movzx eax , word [ebx*2+eax]	;eax now holds the ordinal of our function
		  mov ebx,[ebp+dwExportDirectory]
		  mov ebx,[ebx+0x1C]	   ;RVA of EAT
		  add ebx,[ebp+dwKernelBase]	 ;VA of EAT
		  mov ebx,[eax*4+ebx]
		  add ebx,[ebp+dwKernelBase]
		  mov eax,ebx
 
		pop edi     ;Restore the registers to avoid generate a problem
		pop esi     ;in the caller function.
		pop ebx
		ret
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;	Data Shit				 	;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
szTitle:			  db	  "Yo !",0
szMsg:				db	"GreeTz From SIGSEGV",0
szUser32	 		db	  "User32.dll",0
AGetProcAddressA:   		dd	  0
api_GetProcAddress:   		db	  "GetProcAddress"
len_GetProcAddress:   		dd	  $-api_GetProcAddress
ALoadLibraryA:			dd	  0
api_LoadLibrary:   		db	  "LoadLibraryA",0
AMessageBoxAA:			dd	  0
api_MessageBoxA:   		db	  "MessageBoxA",0
dwKernelBase:			dd	  0
dwExportDirectory:   		dd	  0
 

Hola, tengo una duda: Me han dicho que Java y otros lenguajes son mas seguros que C/C++ disque por que no tienen punteros, y tambien dicen que son mas resistentes a fallos porque todo lo maneja la maquina virtual.

¿Es cierto eso? ¿Entonces C/C++ es inseguro? ¿Entonces si estoy creando un programa debería usar Java? Gracias de antemano.

Hola, ¿Como están? Tengo que hacer mi propio CGI hecho en C++ para recibir un archivo y subirlo al servidor. Ya tengo parte del código hecho y ya he investigado, pero resulta que al escribir lo que recibe por la entrada tambien se mezcla con algo que pareciera una cabecera HTTP. No se como recibir unicamente al archivo, sin cabeceras ni otras cosas. Gracias de antemano.

Ahora publicó parte de mi código que falla:

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <fstream>
 
using namespace std;
 
int main()
{
 
    ///Esto me funciona. Por lo menos puedo contar cuantos bytes mide el archivo aproximadamente.
    int content_length = atol(getenv("CONTENT_LENGTH"));
    char *content = new char[content_length];
 
    ///Abro un stream para escribir el archivo a subir.
    ofstream archivo;
    archivo.open("D:\\Archivos de Programa\\Apache Software Foundation\\Apache2.2\\uploads\\archivo_subido.txt");
 
    cout << "Content-type:text/html\r\n\r\n";
    cout << "<html><head><title>Page</title></head>";
    cout << "<body><h1>Content lenght: ";
    cout << content_length << "</h1>";
 
    ///He oido que los archivos enviados por HTML se recibe por la entrada estandar
    ///Asi que lo recibo lo copio a un buffer
    cin.read(content, content_length);
 
    cout << "<h1>Content</h1>";
    cout << "<b>" << content << "</b>";
 
    ///El contenido del archivo lo grabó en disco.
    archivo << content;
 
    /*cout << content;*/
 
    cout << "<br><br>" << content;
    cout << "</h1>";
    cout << "</body></html>";
 
    archivo.close();
 
    delete [] content;
 
    return 0;
}
 

¿Será que alguien sabe como puedo el archivo sin cabeceras HTTP, en binario puro y duro? Gracias de antemano.