Mensajes

Y a mí me gustaría llegar a ser como tú.

Tener pocos posts...

Estar en un sitio "nuevo como éste"...

No saber por dónde tengo que ir (coincidirás conmigo en que no sabes en qué subforo meterte, yo tampoco, y estoy muy visto en los de Windows y Hardware, pasa de mí ahí dentro, es un consejo jejeje).

A modo personal comenta que PC tienes, es a modo personal 

Pues yo ya llevo una media de 150 post solo de dudas.. tambien dependera de tus ganas de aprender, leer, tiempo etc..

La unica manera es usando:
http://winapi.conclase.net/curso/index.php?cap=003#inicio

y hay que pasar los argumentos de consola a la aplicación windows

Estaba intentando convertir una consola a formulario. Para ello lo hice añadiendo una configuración equivocada ya que eso era para Qt.
La manera correcta de convertir una consola a un formulario y luego pasar los argumentos de linea de comandos a la aplicación es usando GetCommandLine

Como puedo mostrar que versión utilizo en un programa intente esto:

Código [Seleccionar] Expandir

#if_WIN64
isWow64=true;

#elif_WIN32
isWow64=false;

if(isWow64==true){
windows="Windows64bits";
}else{
windows="Windows32bits";
}
Sería correcto o debería hacer alguna otra cosa.

reverse engineering en accion 

Muchas gracias por tu respuesta me explique tan rapido que se me paso mencionar ese detalle se que kernel32 es para funciones de bajo nivel del sistema operativo pero mi pregunta es las aplicaciones que usa el usuario por ejemplo supongamos la calculadora si arranca con permisos de administrador o no el kernel32  influye en algo??????

Se que son  bibliotecas de enlace dinámico que implementa la biblioteca de windows pero mi pregunta es cuando uno esta usando la librería kernel32 o user32 cuando uno es administrador usa kernel32 o cuando uno usa user32 esta en modo usuario¿? Soy un total ingnorante al respecto por lo que cualquier explicacion me vendría bastante bien. Gracias.

Por lo menos podrías poner un titulo más descriptivo y una solución a tu problema.

Si tienes razón aparte que era el inyector que cuando no ponía la dll me mostraba el hola mundo por arte de magia.. por eso puse el código de ambos.

Y esto se puede deshacer o se va a quedar así para siempre?

Necesita funcionar como rootkit para que permanezca para siempre.. se puede ocultar el proceso, cambiar todos los procesos o hacerlos todos invisible tapar botones entre otras muchas cosas más..

Hace no mucho tiempo un compañero hizo un ejemplo en c# con las winapi y funcionaba como rootkit pero claro hay que implementarlo

Hola en este tutorial os enseñare a como poner tus procesos en PWNED con la siguiente apariencia:


El inyector:

Código [Seleccionar] Expandir

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <Tlhelp32.h>
#include <wchar.h>
#include <iostream>
using namespace std;

void error(char *err);

HANDLE myProc = NULL;

void error(char *err)
{
if (myProc != NULL) CloseHandle(myProc);
printf("%s", err);
exit(0);
}

HANDLE Startpausedprocess( char* cmd, PHANDLE ptr_thread ) // cleaned up a bit, but no RAII
{
    if( ptr_thread == nullptr ) return nullptr ;

    PROCESS_INFORMATION pi;
    STARTUPINFOA si {} ; // initialize with zeroes.
    si.cb = sizeof(STARTUPINFOA);

    if( !CreateProcessA( nullptr, cmd, nullptr, nullptr, false, CREATE_SUSPENDED,
                         nullptr, nullptr, std::addressof(si), std::addressof(pi) ) )
    {
        std::cerr << "CreateProcess failed, " << GetLastError() << '\n' ;
        *ptr_thread = nullptr ;
        return nullptr;
    }

    *ptr_thread = pi.hThread;
    return pi.hProcess;
}


int main(int argc, char *argv[])
{
char cmd[] = "taskmgr.exe" ; // note: non-const (writeable array)
    HANDLE thread = nullptr ;
    auto myProc=Startpausedprocess( cmd, std::addressof(thread) ) ;
if(myProc)
    {
        std::cout << "press enter to resume process... " && std::cin.get() ;
        ResumeThread(thread) ;

        //CloseHandle(thread) ;
        //CloseHandle(myProc) ;
    }

// Reservar memoria para el argumento (ruta de la DLL)
char thData[] = "dllmain.dll";
LPVOID dirToArg = VirtualAllocEx(myProc, NULL, strlen(thData), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
if (dirToArg == NULL)
error("[-] Error reservando memoria para argumento.\n");
else
printf("[+] Memoria reservada para argumento (%i bytes).\n", strlen(thData));


// Escribir la ruta de la DLL en la memoria reservada
SIZE_T written = 0;
if (WriteProcessMemory(myProc, dirToArg, (LPVOID)&thData, strlen(thData), &written) == 0)
error("[-] Error escribiendo memoria.\n");
else
printf("[+] Memoria escrita (arg %i bytes).\n", written);
//Lanzar un hilo con LoadLibrary
//Load the DLL
//Load the DLL
HANDLE rThread = CreateRemoteThread(myProc, NULL, NULL, (LPTHREAD_START_ROUTINE)GetProcAddress(LoadLibrary(L"Kernel32.dll"), "LoadLibraryA"), dirToArg, NULL, NULL);
if (rThread == NULL)
error("[-] Error creando el hilo.\n");
else
printf("[+] Hilo creado.\n");
CloseHandle(rThread);
}

El código, simplemente compilas en gcc y inyectais.

Código [Seleccionar] Expandir

#include "stdafx.h"
#include "cabecera minhook"//MHook header
#include <iostream>
#include <windows.h>
#include <Commctrl.h>
#include <conio.h>

using namespace std;

typedef void (*SENDMESSAGEW)();//Typedef for the hooked function
static SENDMESSAGEW Basewritefoobar;//Backup of the originak fonction

static wchar_t pwned[]=L"PWNED";

LRESULT WINAPI BSSSendMessageW(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
   if ( msg == LVM_INSERTITEMW || msg == LVM_SETITEMW)//Intercepts LVM_INSERTITEM and LVM_SETITEM messages
   {
       ((LVITEMW*)lparam)->pszText=pwned;//Replace the item text with our text.
   }
   return SendMessage(hwnd, msg, wparam, lparam);//Calls the real SendMessage function.
}

static bool Hook();

template <typename T>
inline MH_STATUS MH_CreateHookEx(void* target, void* const base, T** original)
{
   return MH_CreateHook(target, base, reinterpret_cast<void**>(original));
}


extern "C" __declspec (dllexport) void __cdecl SendWrite()
{

}

BOOL WINAPI DllMain(HINSTANCE hInst, ULONG ul_reason_for_call, LPVOID lpReserved)
{
//Different behaviors depending on the reason why DllMain is called
switch (ul_reason_for_call) {
case DLL_PROCESS_ATTACH:
if (!Hook())//Hook "Writefoobar"
{
cout << "Hook failed" << endl;
return 1;
}
break;
case DLL_PROCESS_DETACH:
break;
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
break;
}

return TRUE;
}

bool Hook()
{
   if (MH_Initialize() != MH_OK)
   {
       return false;
   }

   if (MH_CreateHookEx((void*)&SendMessageW, (void*)&BSSSendMessageW, &Basewritefoobar) != MH_OK)
   {
       return FALSE;
   }
   return MH_EnableHook((void*)&SendMessageW) == MH_OK;
}


Funcionara como filtro y cambiara la apariencia de vuestro administrador de tareas.