Hace unos cuantos años, yo utilizaba una librería con DevCPP llamada Winbgim que si no me equivoco es como una "portación" de esa librería graphics para MinGW... Es más usando un poco de google recién encontré un video de como configurar el codeblocks para usarla, capaz que tal vez te sirva


B#

Te estás haciendo un lío con los punteros de estructuras xD

Primero fijate las definiciones tuyas:

conjuntoEnteros *conjuntoA[]
conjuntoEnteros conjuntoA[]);

En la primera estás haciendo como un "doble puntero" y en la segunda creo que está bien pero yo al menos lo definiría en todas las funciones así:

Ejemplo:

short int Pertenece(int x, conjuntoEnteros *conjuntoA);

Después tama no está definido porque lo estás usando como si fuera una variable ya definida en una operación de comparación mayor que(conjuntoA>tama=tam;)... para acceder a un dato de un puntero a una estructura sería así:

conjuntoA->tama=tam;

Solo lo podés usar con punto (conjuntoA.tama=tam;)si solo si la estructura no la envías como puntero, osea como si la tuvieses de variable global/local, pero en tu caso creo que estás o en realidad querías enviarla como puntero en cada parametro de tus funciones.

EDIT: Si podés usá la etiqueta GeSHi cuando escribás un mensaje en el foro porque el código escrito así nomás queda horrible a la vista


B#

Bueno ahí estuve averiguando un poco y tenés razón, también estuve buscando y encontré algo que te pueda servir, que según ví me pareció muy completo:

http://askubuntu.com/questions/221835/installing-ubuntu-on-a-pre-installed-windows-8-64-bit-system-uefi-supported

Sinó la alternativa (que creo que te resultará más facil supongo ) copiar todos los datos importantes que tengas en windows 8 y sacarlo, instalar windows 7 y finalmente hacer como hice yó...


B#

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#