Mensajes

Hay varias formas de ocultar un proceso o al menos el objetivo es, hacer funcionar tu programa correctamente sin que
sea visto por algún vizor de procesos. Lo mejor es cargar un driver con técnicas de rootkit para ocultar el proceso
el problema es, en versión de Windows de 64-bits esta el patchGuard pero también es posible saltarlo ( 2012 ). y cargar tu driver
de 64-bits.
El otro es hookear la API encargada de obtener la información del vizor de procesos, el problema es, si hookeas la API NtQuerySysteminformation de taskmgr el proceso se podra mirar con alguna otra herramienta de vizor, a menos que establescas un hook en la API encargada de todo visualizador de procesos, esto no funcionara con un visualizador de procesos que carguen un driver para obtener esa información porque la informacion que queremos obtener no pasara por tu hook, lo que tendrás que hacer es, analizar la aplicación que quieres saltarte, saber como funciona, y hookear las APIs que usa para esa información, si carga un driver, la aplicación siempre copia el buffer desde modo nucleo a modo usuario ( dependiendo del metodo que utiliza ), y al final siempre usa funciones de USER32.dll, KERNEL32.dll, para mostrarla
en los controles. eso sin tomar en cuenta si tiene protección.
Las otras maneras son, inyectar tu proceso en un otro proceso y de esa manera podrás hacer trabajar tu programa sin que se muestre en ningun visualizador, el problema es, en Windows x64, algunos metodos comunes de inyeccion no funcionan debido a que en entorno de emulacíon incluyendo algunas transiciones de APIs solo funcionan con procesos de 32-bits. pero se puede buscar alternativas de inyeccion o hacks.
De qué método les gustaría hablar?   

Muchas gracias. Con lo que me has dicho ya me he aclarado algo.

Y entonces deduzco que en un sistema x64 como Windows 7 x64, sólo se pueden cargar drivers de 64 bits ¿no?

Sí, al menos de forma normal.

A diferencia de aplicaciones en ring3 que en ese mismo sistema Windows 7 x64 pueden ser de 32 o de 64 bits y ambas se ejecutan bien. ¿Es eso?

Es que no tengo claras las cosas.

En una version de 64-bit de Windows, una aplicación es emulada y no cargada nativamente, hay unas DLLs que se encargan de emular el entorno y trasladar versiones de llamadas desde 32-bit a 64-bits y podría funcionar correctamente
dependiendo de lo que haga tu programa, solo por si alguna vez tu programa no funcionara en una version de 64-bits, existe la posibilidad de que no funcione correctamente o tendrías que modificar para que soporte versiones de 64-bit.

Seguro, tu lo dijiste:

Se me olvidaba:

Lo estoy intentando cargar en WINDOWS 7 x64.

Compilarlo para 64-bits y conseguir tu propia firma digital o desactivar el PatchGuard.

El ensamblador no es portable, en proyectos grandes de miles de paginas de codigos ( más si es escrito en ASM ) es mucho
más dificil de mantener ordenado, modificar/mejorar partes, arreglar errores incluso si el programador lo tien ordenado.
C/C++ creo que es el lenguaje perfecto, estándar, portable, eficiente todo esto más la optimizacion que ofrece el compilador.
Compañias dudo que escriban sus programas en ASM por los motivos que mencione, no es nada bueno para ellos.
Aparte que C/C++ puede hacer el 90-92% de las cosas que ASM puede hacer. pero a la vez es tan bueno saber programar en ASM.

[Fire_Hugo12]

Sin ánimos de ofender amigo, considero que lo más correcto es que el código que coloques para este tipo de casos sea código estándar, ya que no sabemos que compilador está utilizando Fire_Hugo12. Por las dudas tenemos que PCHAR es equivalente a un apuntador a caracter (char *) y ULONG es equivalente a un entero largo sin signo (unsigned long int). Con respecto al problema puedes utilizar una lista enlazada e ir insertando de manera ordenada en tu caso de mayor a menor. Para eliminar la más baja o las más bajas vas recorriendo palabra a palabra y comprobando si no es la más baja la concatenas en otra nueva cadena y reduces el contador de dicha palabra, esto lo haces hasta que dicho contador llegue a cero.

Claro todo el mundo sabe eso, ni siquiera tengo la idea de porque lo mencionas. respecto al tema se tendría que mirar tu código
y de que forma lo implementas para saber si es tan veloz y eficiente.

Tu podrías estar buscando esto:

Ordenamiento burbuja en C++

ordena una lista de enteros podrias hacer un array con las veces que se repiten las palabras, o mejor aún hacer una estructura de este tipo:

typedef struct WordInfo
{
   PCHAR   lpWord;
   ULONG   nRep;
}

lpWord, puntero a la palabra.
nRep, las veces que se repite la palabra.

de esta forma lo tienes mejor ordenado.

Deberías publicar que tipo de programa o/y añadir más detalles, así los usuarios podrán saber de ante mano un poco y
si son capaces de programarlo o no.

Escribe la linea en donde el compilador se queja, y detalles que el compilador muestra sobre el error 

Hay algunos diferencias en los códigos, el ejemplo de naderST la memoria asignada es de uno solo espacio de memoria, y es semi-dinamica, la columna es constante, no puede cambiar de longitud. Además no es posible liberar memoria de un index del array determinado, debido a que si se libera un puntero del array que en realidad es un puntero al mismo bloque de memoria asignada más un offset y luego al intentar el puntero principal generar una exception. 

Tu código es incorrecto, estas asignando un nuevo array de X cantidad y almacenas el puntero a tal memoria
en la mismo espacio de memoria, lo que buscas es esto:

Código (c) [Seleccionar] Expandir

PULONG*   CustAllocate(  PULONG*   lppMain,
                        ULONG     x,
                        ULONG     y)
{
   
    lppMain = (PULONG*)malloc(x * sizeof(PULONG));
    for(int z = 0;z < x; z++)
         lppMain[z] = malloc(y * sizeof(PULONG));
   
    return lppMain;
}


PULONG*   CustFree( PULONG*   lppMain,
                   ULONG     x)
{
    for(int z = 0; z < x; z++)
         free(lppMain[z]);
   
    free((PULONG)lppMain);
    return lppMain;
}

Y si piensas trabajar en Windows, entonces es mejor usar la W32 que la libreria(s) de VC.