Si se trata de escribir una cadena alfanumérica y hacer que la misma se divida en bloques separados de letras o números, entonces en ese caso escribí un código simple que hace eso, el tema es que justo me dieron ganas de no hacer nada XD y lo dejé funcionando pero sin terminar ya que no llegué a implementar memoria dinámica para que quede terminado.
En lugar de eso existe un array de cadenas de un máximo aceptable de 20 cadenas, pero para ver como se hace te va a servir.
Tu código dijiste que estaba mal por eso te muestro este otro código.

Como te dije, está sin terminar pero por eso mismo si te interesa lo podés terminar, implementando memoria dinámica para el array de cadenas que vas a usar para guardar todos los bloques.

#include<stdlib.h>
#include<stdio.h>
#include<string.h>
//http://www.cplusplus.com/reference/cstdlib/realloc/
 
 
int main(){
 
 
	char cadena[512];
	//char** array_de_cadenas_r = 0;
	//char** array_de_cadenas = (char**)malloc(sizeof(char)*1);
	//array_de_cadenas[0] = (char*)malloc(sizeof(char)*128);
 
	char array_de_cadenas[20][128] = {{0}};
 
	printf("ingrese la cadena..\n");
	scanf("%s", cadena);
 
	int modo=0;
	int pos=-1;
	int let;
	int num;
	int i=0;
	int j;
	while(cadena[i]){
 
		if(pos == 20) break;
 
		if(cadena[i] >= 'a' && cadena[i]<='z'){
			let++;
			num=0;
		}
		else if(cadena[i] >= 'A' && cadena[i]<='Z'){
			let++;
			num=0;
		}
		else if(cadena[i] >= '0' && cadena[i]<='9'){
			num++;
			let=0;
		}
		else
		{
			let=0;
			num=0;
		}
 
		if((modo==1&&let)||(modo==2&&num));
		else
		{
			pos++;
			j=0;
 
			//int a=0;
			//char backup[512];
			//strcpy(backup, array_de_cadenas[a]);
			//array_de_cadenas_r = (char**)realloc(array_de_cadenas, sizeof(char)*(pos+1));
			//array_de_cadenas[pos] = (char*)malloc(sizeof(char)*128);
		}
 
 
		if(let){
 
			array_de_cadenas[pos][j] = cadena[i];
			j++;
			modo=1;
		}
		else if(num){
 
			array_de_cadenas[pos][j] = cadena[i];
			j++;
			modo=2;
		}
		else
		{
			modo=0;
		}
 
		i++;
	}
 
	for(int b=0; b<pos+1; b++){
	      printf(array_de_cadenas[b]);
	      putchar('\n');
	}
 
	//for(int c=0; c<pos; c++) free(array_de_cadenas[c]);
	//free(array_de_cadenas);
 
	system("pause");
	return 0;
}
 

ya directamente nos tiran el problema sin saludar ni despedirse  

con un malware podés hacer una "threat" XD,
usá la API de Windows ok, o fijate alguna librería para manejar el uso de hilos (THREADS)..

lo primero que se requiere es que si podés usar las etiquetas de código, y las de c++ preferentemente:


Es para mejor lectura del texto, después me vi obligado a mirar algo sobre win8 porque no lo tengo XD
http://www.softwareok.com/?seite=faq-Windows-8&faq=3
http://conocimientoadictivo.blogspot.com/2012/10/informacion-tecnica-windows-8.html

Pero como dijiste, tu código parece no salirse de lo standard , podés decirnos algunos datos más sobre el compilador, las opciones de compilación o las opciones del proyecto en general, si tu sistema es x32 o x64, etc
Más información así la gente se anima a responderte, y lo de las etiquetas.
hasta luego

si son detalles importantes, mirá este es otro 'aprouch' XD
http://foro.elhacker.net/programacion_cc/dll_wrapper_1_creando_nuestra_psapidll_sin_def-t386998.0.html

El tema de const char* a char* o vice versa, es un tema de 'casting', se soluciona haciendo casting y listo, puesto que 'const' es tan sólo una protección del compilador a nivel código, para el programador, para que se remarquen que ciertas "cosas" son constantes. Y Siendo así, deberías o bien respetar esto o bien saber muy bien por qué habrías de cambiarlo..

Hola, como había estado comentado algunas cosas acerca de reemplazar DLLs existentes con versiones propias,
http://foro.elhacker.net/programacion_cc/dll_wrapper_1_creando_nuestra_psapidll_con_def-t386996.0.html

justo me había acordado de una 'wrapper' muy famosa en el ambiente del hacking de juegos.
Es del 2002 de un programador llamado Crusader, y durante un tiempo esto había servido para utilizar wallhacks en el Counter-Strike, aunque se debería poder usarse en otros juegos basados en Opengl32.

este es el link del proyecto
http://www.mediafire.com/?zad5ce1gd8lr8k2

Lo que hice fue agregar algunas líneas para remover el cielo y para un wallhack. La DLL de reemplazo (wrapper) se debe poner en la carpeta del juego (ver imagen 1).

Esto es detectado por los sistemas antitrampas, validan los archivos y las rutas. Pero puede servir a alguien para practicar con Opengl32.
Con los hacks se aprende XD

NIVEL: Beginner
Test: WinXP SP3 32BITS

Tomando en cuenta el tutorial anterior acerca del creamiento de una versión propia de una DLL conocida,
http://foro.elhacker.net/programacion_cc/dll_wrapper_1_creando_nuestra_psapidll_con_def-t386996.0.html

Algo que se denominaba ‘wrapper’, en este caso vamos a hacer lo mismo pero sin la necesidad de usar un archivo .DEF para los símbolos exportados.
El tema es que para hacer la exportación de símbolos en este caso sin usar .DEF tenemos que utilizar en nuestras funciones de reemplazo, el nombre completo y correcto de las funciones originales.
 
Primero vayamos a las opciones del proyecto, y veamos que la opción de la convención de llamada  esté en __cdecl, porque si bien sabíamos que PSAPI usaba __stdcall, pero lo que vamos a hacer en esta ocasión es especificarlo explícitamente en el código, para cada función.
Por defecto siempre esta opción se encuentra en __cdecl, en otras palabras lo que quiero decir es que lo dejen así..



Empecemos diciendo en lo que es similar al anterior método, por ejemplo los prototipos de las funciones. Veamos una definición de tipo para la función EnumProcesses en main.cpp
 

typedef BOOL (WINAPI* EnumProcesses_t)(DWORD*,DWORD,DWORD*);

Una declaración de puntero a función

BOOL (WINAPI* pEnumProcesses)(DWORD*,DWORD,DWORD*);

Veamos como se expecifica explícitamente la convención de llamada __stdcall (WINAPI).
La definición de nuestra función de reemplazo, que como habíamos visto antes, retorna el puntero a función original. En este caso a la EnumProcesses original en la DLL original que renombramos PSAPI2.DLL

BOOL WINAPI newEnumProcesses(DWORD* pProcessIds, DWORD cb, DWORD* pBytesReturned)
{
      return pEnumProcesses(pProcessIds, cb, pBytesReturned);
}

El tema es que como no estamos usando un .DEF tenemos que especificar en el código, qué funciones son las que van a ser exportadas. Esto se hace con __declspec (dllexport)
 
Veamos una macro que al mismo tiempo también especifica que se trata de un estilo de función de C con lo cual evitamos el planchado de nombres en los símbolos exportados.

#define DLLEXPORTING extern "C" __declspec (dllexport)

 Más información acerca de esto:
 http://msdn.microsoft.com/es-es/library/a90k134d(v=vs.80).aspx
http://msdn.microsoft.com/en-us/library/a90k134d(v=vs.80).aspx
http://msdn.microsoft.com/es-AR/library/0603949d(v=vs.80).aspx
http://msdn.microsoft.com/en-us/library/aa278942(v=vs.60).aspx

En el compilador vamos a dejar que la convención de llamada por defecto sea __cdecl, y vamos a valernos de especificar __stdcall en los prototipos o definiciones de tipos y en los punteros a función, como ya vimos.
En el anterior tutorial, teníamos 2 instancias de funciones de reemplazo para cada función que íbamos a exportar. Y vimos que la segunda instancia no era necesaria antes, pero ahora si lo va a ser.
 
Veamos exports.cpp
Esta es la segunda instancia, debe ser del tipo __cdecl para ser compatible con la directiva extern “C”, y al mismo tiempo debe ser el símbolo marcado para ser exportado, eso se hace con __declspec (dllexport) como dijimos antes. Y por último, el nombre de esta función debe ser exactamente igual al de la original.

DLLEXPORTING BOOL EnumProcesses(DWORD* pProcessIds, DWORD cb, DWORD* pBytesReturned)
{
       //return newEnumProcesses(pProcessIds, cb, pBytesReturned);
}

Por eso si la convención de llamada por defecto es __cdecl entonces esta función tendría esa convención.
Por eso dije antes que la dejen como estaba a la opción esa. De otra forma debería especificar __cdecl
explícitamente en la definición de la función.
 
En teoría debería deberíamos usar el puntero a la función original a modo de una llamada a función por puntero (ya sea como return+puntero o sólo el puntero si se trata de una función de tipo void).
 
Es en este punto donde necesitamos ver este tutorial anterior en el cual se comentaba un caso en el cual el compilador genera código de stack frame dentro de la función lo cual altera la pila y el registro EBP.
Link:
http://foro.elhacker.net/programacion_cc/gltest1_problema_con_la_convencion_de_llamada-t384879.0.html
 
Esta situación no es diferente a la del enlace anterior, por lo que la solución es la misma; nuestra función de reemplazo de tipo __cdecl va a tener que restaurar el registro EBP antes de saltar a la función original.
Vamos a utilizar la instrucción JMP para ir a la original y no la instrucción CALL (aunque vimos que se puede).
 

DLLEXPORTING BOOL EnumProcesses(DWORD* pProcessIds, DWORD cb, DWORD* pBytesReturned)
{
             int a = 85;
             a = 85 - 85 + 85;
             // usa ebp
             // agrega edi al stack
             // add esp, 0x14
 
             __asm mov eax,[esp+0x10]
             __asm mov EnumProcesses_ebp_save,eax
             __asm mov ebp,EnumProcesses_ebp_save
             __asm add esp,0x14//debe borrar hasta ebp, no más que eso (no el retaddress ni los argumentos)
             __asm jmp newEnumProcesses
             //return newEnumProcesses(pProcessIds, cb, pBytesReturned);
}

El fix con ensamblador en línea (inline ASM), guarda el registro EBP y lo restaura antes de saltar a la función original, también se deja la pila equilibrada con ADD ESP, X
Tanto la ubicación del EBP original en la pila como la cantidad de espacios que se deben reducir para equilibrar la misma, se deben obtener de un desensamblador por ejemplo. Sino, pueden utilizar un depurador como el OllyDBG.
 
Veamos igualmente una imagen de como resulta el código de ensamblador:




Como ustedes pueden ver se genera al final este código:
Lo cual es una correcta liberación de pila, pero el problema es que este código no se genera sino usamos el fix.

Como ya dije, es la misma situación que la del tutorial de convención de llamada para un caso con Opengl32.
 
El resultado es una DLL wrapper de PSAPI.DLL que no requiere .DEF para realizar las exportaciones.
Psapi.lib tampoco es requerida, recordemos que hacemos un enlazamiento dinámico con la DLL PSAPI.DLL original (que renombramos a PSAPI2.DLL).

Y los nombres de los EXPORTS no resultan cambiados.



Funciona.



Proyecto VC++6:
http://www.mediafire.com/?8su3luoh0r72ypf

Saludos

NIVEL: Beginner
Test: WinXP SP3
 
Este tutorial te va a enseñar como crear algo conocido como ‘Wrapper’ de una DLL, cuya traducción es ‘envoltura’ pero se conoce con el término del inglés directamente. Las wrappers son versiones propias de DLL’s conocidas. En este caso vamos a hacer un wrapper de una DLL muy conocida llamada PSAPI.DLL.
Si no la conocen investíguenla XD, pero se trata de una DLL bastante común encontrarla cargada en muchos procesos.
La técnica de construir wrappers tiene al menos 2 objetivos:
1: Hooking. ya que nuestra propia versión de la DLL va a contener nuestras propias versiones de las funciones originales, y al mismo
Tiempo necesitamos llamar a las originales dentro de las nuestras.
El tema es que podemos ejecutar nuestro código antes de que se ejecute el código original.
2: Cargar una DLL. Lo que estamos haciendo al crear nuestra propia versión de una DLL conocida es hacer que al programa víctima se le cargue nuestra DLL en lugar de la original. Esta carga no la hace el programa víctima sino el sistema operativo. El SO detecta nuestra DLL en la misma ubicación que el archivo ejecutable del programa y la carga automáticamente, ya que existe una dependencia real con la DLL.
 
En cuanto a seguridad, es una técnica no efectiva para crear un hack para un programa que tenga seguridad. Sería muy fácil validar los archivos en disco que se cargan al proceso (con MD5 por ejemplo), o validar las rutas, etc etc
Mientras no sea para nada de hacking, tiene cierto atractivo esta idea XD.
 
Acerca de como se crea algo así.. Bueno lo primero es conocer la DLL original que queremos reemplazar, es decir todas sus funciones o al menos las que el proceso víctima utilice (dependencias).

Esto significa que debemos conocer los prototipos de estas funciones, incluyendo su convención de llamada y demás.
Teniendo eso en primer lugar, vamos a considerar que también necesitamos usar la DLL original porque dependemos de las funciones originales. Esto se resuelve cambiándole el nombre a la DLL original. En el caso de PSAPI.DLL lo podemos cambiar a PSAPI2.DLL.
Luego vamos a necesitar cargar la DLL original renombrada y hacer un enlazamiento dinámico con ella,  y conseguir las direcciones originales de las funciones que necesitamos. Obviamente esto lo hacemos con LoadLibrary + GetProcAddress.
Luego en nuestra propia DLL ponemos las funciones de reemplazo respetando los prototipos y le ponemos las direcciones de retorno a las originales que importamos dinámicamente con GetProcAddress.
Utilizamos obviamente punteros a función para los retornos en las funciones de reemplazo (hooks).

La convención de llamada usada en PSAPI.DLL para las funciones es __stdcall, por eso podemos hacer que todas las funciones en nuestro proyecto sean por defecto __stdcall para no tener que especificarlo explícitamente en cada una.


Veamos a PSAPI.DLL


Veamos sus exportaciones.


Vamos a concentrarnos en una de sus funciones sólamente, por ejemplo EnumProcesses
 

Necesitamos un prototipo de función, definamos un tipo de dato correspondiente a esta función.

typedef BOOL (* EnumProcesses_t)(DWORD*,DWORD,DWORD*);

Creamos un puntero a función que va a servir de retorno a la original dentro de la función de reemplazo.

BOOL (* pEnumProcesses)(DWORD*,DWORD,DWORD*);

Creamos la función de reemplazo (vemos que retorna con el puntero a la original)

BOOL  newEnumProcesses(DWORD* pProcessIds, DWORD cb, DWORD* pBytesReturned)
{
     return pEnumProcesses(pProcessIds, cb, pBytesReturned);
}

Ahora creamos otra instancia más (no realmente necesaria en este caso), esta función va a ser la que se exporte para que pueda ser usada por el programa víctima.

BOOL  _EnumProcesses(DWORD* pProcessIds, DWORD cb, DWORD* pBytesReturned)
{
     return newEnumProcesses(pProcessIds, cb, pBytesReturned);
}

Y básicamente hacer lo mismo con las demás funciones XD.
Para compilar este proyecto se requiere del archivo psapi.h que contiene los tipos de datos usados en las funciones de reemplazo. No se requiere psapi.lib que es una librería de enlazamiento estático.
 
Vamos a necesitar un archivo .DEF que debe ser incluído en el proyecto.
Hay unas reglas para usar el .DEF y estas son:
1: se debe empezar poniendo LIBRARY y seguido el nombre de la DLL.
2: se debe poner EXPORTS
3: se deben poner uno por uno, los nombres que deseamos para cada símbolo, seguido de cada
Nombre debe ir el signo ‘=’ y el nombre real del símbolo, el cual obtenemos del desensamblado.
4: seguido a lo anterior se deja un espacio y se coloca un ‘arroba' y el número de índice de exportación.
 
Pero veamos una imagen para entender como se hace:
 

Veamos el código de la DLL:

En main.cpp se encuentran los prototipos de las funciones y los punteros a funciones. Para no poner todo veamos sólo el caso de EnumProcesses

typedef BOOL (* EnumProcesses_t)(DWORD*,DWORD,DWORD*);
 

BOOL (* pEnumProcesses)(DWORD*,DWORD,DWORD*);
 

Luego tenemos las funciones de reemplazo. Estas retornan un puntero a función.

BOOL  newEnumProcesses(DWORD* pProcessIds, DWORD cb, DWORD* pBytesReturned)
{
     return pEnumProcesses(pProcessIds, cb, pBytesReturned);
}

Luego se muestra un código que se trata de una clase y la creación de un objeto de tipo de la clase, esto busca que se inicializen los punteros a función cuando el programa es ejecutado, ya que cuando se crea el objeto se ejecuta la rutina que inicializa los punteros a función.

/*
class Inicializar
{
public:
    Inicializar()
    {
        pEnumProcesses = 0;
        pEnumProcessModules = 0;
        pGetModuleBaseNameA = 0;
        pGetModuleBaseNameW = 0;
        pGetModuleFileNameExA = 0;
        pGetModuleFileNameExW = 0;
        pGetModuleInformation = 0;
        pEmptyWorkingSet = 0;
        pQueryWorkingSet = 0;
        pInitializeProcessForWsWatch = 0;    
        pGetWsChanges = 0;
        pGetMappedFileNameW = 0;
        pGetMappedFileNameA = 0;
        pEnumDeviceDrivers = 0;
        pGetDeviceDriverBaseNameA = 0;
        pGetDeviceDriverBaseNameW = 0;
        pGetDeviceDriverFileNameA = 0;
        pGetDeviceDriverFileNameW = 0;
        pGetProcessMemoryInfo = 0;
        pEnumPageFilesA =0;
        pEnumPageFilesW =0;
        pGetPerformanceInfo =0;
        pGetProcessImageFileNameA =0;
        pGetProcessImageFileNameW=0;
 
        HINSTANCE myDLL;
        myDLL = LoadLibrary("psapi2.dll");
 
        if(myDLL != NULL)
        {
           pEnumProcesses = (EnumProcesses_t)GetProcAddress(myDLL, "EnumProcesses");
           pEnumProcessModules = (EnumProcessModules_t)GetProcAddress(myDLL, "EnumProcessModules");
           pGetModuleBaseNameA = (GetModuleBaseNameA_t)GetProcAddress(myDLL, "GetModuleBaseNameA");
           pGetModuleBaseNameW = (GetModuleBaseNameW_t)GetProcAddress(myDLL, "GetModuleBaseNameW");
           pGetModuleFileNameExA = (GetModuleFileNameExA_t)GetProcAddress(myDLL, "GetModuleFileNameExA");
           pGetModuleFileNameExW = (GetModuleFileNameExW_t)GetProcAddress(myDLL, "GetModuleFileNameExW");
           pGetModuleInformation = (GetModuleInformation_t)GetProcAddress(myDLL, "GetModuleInformation");
           pEmptyWorkingSet = (EmptyWorkingSet_t)GetProcAddress(myDLL, "EmptyWorkingSet");
           pQueryWorkingSet = (QueryWorkingSet_t)GetProcAddress(myDLL, "QueryWorkingSet");
           pInitializeProcessForWsWatch = (InitializeProcessForWsWatch_t)GetProcAddress(myDLL, "InitializeProcessForWsWatch");        
           pGetWsChanges = (GetWsChanges_t)GetProcAddress(myDLL, "GetWsChanges");
           pGetMappedFileNameW = (GetMappedFileNameW_t)GetProcAddress(myDLL, "GetMappedFileNameW");
           pGetMappedFileNameA = (GetMappedFileNameA_t)GetProcAddress(myDLL, "GetMappedFileNameA");
           pEnumDeviceDrivers = (EnumDeviceDrivers_t)GetProcAddress(myDLL, "EnumDeviceDrivers");
           pGetDeviceDriverBaseNameA = (GetDeviceDriverBaseNameA_t)GetProcAddress(myDLL, "GetDeviceDriverBaseNameA");
           pGetDeviceDriverBaseNameW = (GetDeviceDriverBaseNameW_t)GetProcAddress(myDLL, "GetDeviceDriverBaseNameW");
           pGetDeviceDriverFileNameA = (GetDeviceDriverFileNameA_t)GetProcAddress(myDLL, "GetDeviceDriverFileNameA");
           pGetDeviceDriverFileNameW = (GetDeviceDriverFileNameW_t)GetProcAddress(myDLL, "GetDeviceDriverFileNameW");
           pGetProcessMemoryInfo = (GetProcessMemoryInfo_t)GetProcAddress(myDLL, "GetProcessMemoryInfo");
           pEnumPageFilesA =(EnumPageFilesA_t)GetProcAddress(myDLL, "EnumPageFilesA");
           pEnumPageFilesW =(EnumPageFilesW_t)GetProcAddress(myDLL, "EnumPageFilesW");
           pGetPerformanceInfo =(GetPerformanceInfo_t)GetProcAddress(myDLL, "GetPerformanceInfo");
           pGetProcessImageFileNameA =(GetProcessImageFileNameA_t)GetProcAddress(myDLL, "GetProcessImageFileNameA");
           pGetProcessImageFileNameW =(GetProcessImageFileNameW_t)GetProcAddress(myDLL, "GetProcessImageFileNameW");
        }
    }
};
 
 
//
Inicializar Init;
*/
 
 

Eso está comentado porque ya se hace en 'DllMain' directamente, junto con un LOG de información.

 
BOOL APIENTRY DllMain( HANDLE hModule, DWORD  ul_reason_for_call, LPVOID lpReserved )
{
    switch (ul_reason_for_call)
    {
        case DLL_PROCESS_ATTACH:
            {
                pEnumProcesses = 0;
                pEnumProcessModules = 0;
                pGetModuleBaseNameA = 0;
                pGetModuleBaseNameW = 0;
                pGetModuleFileNameExA = 0;
                pGetModuleFileNameExW = 0;
                pGetModuleInformation = 0;
                pEmptyWorkingSet = 0;
                pQueryWorkingSet = 0;
                pInitializeProcessForWsWatch = 0;    
                pGetWsChanges = 0;
                pGetMappedFileNameW = 0;
                pGetMappedFileNameA = 0;
                pEnumDeviceDrivers = 0;
                pGetDeviceDriverBaseNameA = 0;
                pGetDeviceDriverBaseNameW = 0;
                pGetDeviceDriverFileNameA = 0;
                pGetDeviceDriverFileNameW = 0;
                pGetProcessMemoryInfo = 0;
                pEnumPageFilesA =0;
                pEnumPageFilesW =0;
                pGetPerformanceInfo =0;
                pGetProcessImageFileNameA =0;
                pGetProcessImageFileNameW=0;
 
                HINSTANCE myDLL;
                myDLL = LoadLibrary("psapi2.dll");
 
                if(myDLL != NULL)
                {
                   pEnumProcesses = (EnumProcesses_t)GetProcAddress(myDLL, "EnumProcesses");
                   pEnumProcessModules = (EnumProcessModules_t)GetProcAddress(myDLL, "EnumProcessModules");
                   pGetModuleBaseNameA = (GetModuleBaseNameA_t)GetProcAddress(myDLL, "GetModuleBaseNameA");
                   pGetModuleBaseNameW = (GetModuleBaseNameW_t)GetProcAddress(myDLL, "GetModuleBaseNameW");
                   pGetModuleFileNameExA = (GetModuleFileNameExA_t)GetProcAddress(myDLL, "GetModuleFileNameExA");
                   pGetModuleFileNameExW = (GetModuleFileNameExW_t)GetProcAddress(myDLL, "GetModuleFileNameExW");
                   pGetModuleInformation = (GetModuleInformation_t)GetProcAddress(myDLL, "GetModuleInformation");
                   pEmptyWorkingSet = (EmptyWorkingSet_t)GetProcAddress(myDLL, "EmptyWorkingSet");
                   pQueryWorkingSet = (QueryWorkingSet_t)GetProcAddress(myDLL, "QueryWorkingSet");
                   pInitializeProcessForWsWatch = (InitializeProcessForWsWatch_t)GetProcAddress(myDLL, "InitializeProcessForWsWatch");        
                   pGetWsChanges = (GetWsChanges_t)GetProcAddress(myDLL, "GetWsChanges");
                   pGetMappedFileNameW = (GetMappedFileNameW_t)GetProcAddress(myDLL, "GetMappedFileNameW");
                   pGetMappedFileNameA = (GetMappedFileNameA_t)GetProcAddress(myDLL, "GetMappedFileNameA");
                   pEnumDeviceDrivers = (EnumDeviceDrivers_t)GetProcAddress(myDLL, "EnumDeviceDrivers");
                   pGetDeviceDriverBaseNameA = (GetDeviceDriverBaseNameA_t)GetProcAddress(myDLL, "GetDeviceDriverBaseNameA");
                   pGetDeviceDriverBaseNameW = (GetDeviceDriverBaseNameW_t)GetProcAddress(myDLL, "GetDeviceDriverBaseNameW");
                   pGetDeviceDriverFileNameA = (GetDeviceDriverFileNameA_t)GetProcAddress(myDLL, "GetDeviceDriverFileNameA");
                   pGetDeviceDriverFileNameW = (GetDeviceDriverFileNameW_t)GetProcAddress(myDLL, "GetDeviceDriverFileNameW");
                   pGetProcessMemoryInfo = (GetProcessMemoryInfo_t)GetProcAddress(myDLL, "GetProcessMemoryInfo");
                   pEnumPageFilesA =(EnumPageFilesA_t)GetProcAddress(myDLL, "EnumPageFilesA");
                   pEnumPageFilesW =(EnumPageFilesW_t)GetProcAddress(myDLL, "EnumPageFilesW");
                   pGetPerformanceInfo =(GetPerformanceInfo_t)GetProcAddress(myDLL, "GetPerformanceInfo");
                   pGetProcessImageFileNameA =(GetProcessImageFileNameA_t)GetProcAddress(myDLL, "GetProcessImageFileNameA");
                   pGetProcessImageFileNameW =(GetProcessImageFileNameW_t)GetProcAddress(myDLL, "GetProcessImageFileNameW");
 
                   DisableThreadLibraryCalls (myDLL);
                }
 
                if(!pEnumProcesses||!pEnumProcessModules ||!pGetModuleBaseNameA ||!pGetModuleBaseNameW
                    ||!pGetModuleFileNameExA ||!pGetModuleFileNameExW ||!pGetModuleInformation 
                    ||!pEmptyWorkingSet ||!pQueryWorkingSet
 
                    ||!pInitializeProcessForWsWatch ||!pGetWsChanges ||!pGetMappedFileNameW 
                    ||!pGetMappedFileNameA
                    ||!pEnumDeviceDrivers ||!pGetDeviceDriverBaseNameA ||!pGetDeviceDriverBaseNameW
                    ||!pGetDeviceDriverFileNameA ||!pGetDeviceDriverFileNameW ||!pGetProcessMemoryInfo
                    ||!pEnumPageFilesA ||!pEnumPageFilesW 
                    ||!pGetPerformanceInfo ||!pGetProcessImageFileNameA ||!pGetProcessImageFileNameW)
                {
                    printf("Wrapper not installed!\n");
                    system("pause");
                }
                else
                {
                    extern DWORD AddEnumProcesses;
                    printf("DLL\n");
                    printf("EnumProcesses 0x%x\n",AddEnumProcesses);
                    printf("newEnumProcesses 0x%x\n",newEnumProcesses);
                    printf("hModule 0x%x\n",hModule);
                    printf("PSAPI2.DLL 0x%x\n",GetModuleHandle("psapi2.dll"));
                    printf("pEnumProcesses 0x%x\n",pEnumProcesses);
                    system("pause");
                }
            }
            break;
 
        case DLL_THREAD_ATTACH:
        case DLL_THREAD_DETACH:
        case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}
 
///////////////////////////////
 

En exports.cpp sólamente tenemos las funciones de exportación, son las cuales son referenciadas en el archivo .DEF. Estas funciones retornan las funciones de reemplazo. Esto de tener 2 instancias no es necesario como ya se dijo, pero si lo es si se desea utilizar otro método que después voy a exponer.

BOOL  _EnumProcesses(DWORD* pProcessIds, DWORD cb, DWORD* pBytesReturned)
{
     return newEnumProcesses(pProcessIds, cb, pBytesReturned);
}
 

Veamos el código del programa ‘Dummy’ que actúa como el programa víctima:
 

//
// By 85
// elhacker.net
// etalking.com.ar
// david_bs@live.com
// 2013
//
 
#pragma comment(lib,"psapi.lib")
#include<windows.h>
#include<stdio.h>
 
//////////////////////
 
#define DLLIMPORTING extern "C" __declspec (dllimport)
DLLIMPORTING BOOL WINAPI EnumProcesses(DWORD *,DWORD,DWORD *);
DLLIMPORTING BOOL WINAPI EnumProcessModules(HANDLE,HMODULE *,DWORD,LPDWORD);
DLLIMPORTING DWORD WINAPI GetModuleFileNameExA(HANDLE,HMODULE,LPSTR,DWORD);
DLLIMPORTING DWORD WINAPI GetModuleFileNameExW(HANDLE,HMODULE,LPWSTR,DWORD);
 
DLLIMPORTING DWORD WINAPI GetModuleBaseNameA(HANDLE hProcess, HMODULE hModule, LPSTR lpBaseName, DWORD nSize);
DLLIMPORTING DWORD WINAPI GetModuleBaseNameW(HANDLE hProcess,HMODULE hModule,LPWSTR lpwBaseName,DWORD nSize);
 
#ifdef UNICODE
#define GetModuleFileNameEx GetModuleFileNameExW
#define GetModuleBaseName GetModuleBaseNameW
#else
#define GetModuleFileNameEx GetModuleFileNameExA
#define GetModuleBaseName GetModuleBaseNameA
#endif
 
//////////////////////
 
// To ensure correct resolution of symbols, add Psapi.lib to TARGETLIBS
// and compile with -DPSAPI_VERSION=1
void PrintProcessNameAndID( DWORD processID )
{
      TCHAR szProcessName[MAX_PATH] = TEXT("<unknown>");
 
      // Get a handle to the process.
      HANDLE hProcess = OpenProcess( PROCESS_QUERY_INFORMATION |
      PROCESS_VM_READ,
      FALSE, processID );
 
     // Get the process name.
     if (NULL != hProcess )
     {
         HMODULE hMod;
         DWORD cbNeeded;
 
         if ( EnumProcessModules( hProcess, &hMod, sizeof(hMod), &cbNeeded) )
         {
              GetModuleBaseName( hProcess, hMod, szProcessName, 
                                                sizeof(szProcessName)/sizeof(TCHAR) );
         }
     }
 
     // Print the process name and identifier.
     printf( TEXT("%s  (PID: %u)\n"), szProcessName, processID );
     // Release the handle to the process.
     CloseHandle( hProcess );
}
 
//////////////////////
 
int main(void)
{
      //////////////////////////
 
      // Get the list of process identifiers.
      DWORD aProcesses[1024], cbNeeded, cProcesses;
      unsigned int i;
 
      if ( !EnumProcesses( aProcesses, sizeof(aProcesses), &cbNeeded ) )
      {
            return 1;
      }
 
      // Calculate how many process identifiers were returned.
      cProcesses = cbNeeded / sizeof(DWORD);
 
      // Print the name and process identifier for each process.
      for ( i = 0; i < cProcesses; i++ )
      {
             if( aProcesses[i] != 0 )
             {
                  PrintProcessNameAndID( aProcesses[i] );
             }
      }
      system("pause");
      return 0;
}
 
//
 

El programa víctima si requiere que se referencie la librería estática psapi.lib
 
Los archivos:


El resultado



Proyecto VC++6:
http://www.mediafire.com/?q9ha83cs9oayhwm

Hasta luego

si capo, si el problema fuera ese fijate los typedef

y mirá esto de paso http://foro.elhacker.net/programacion_cc/gltest1_problema_con_la_convencion_de_llamada-t384879.0.html

Saludos