Mensajes

mi versión simplificada 

Código (c) [Seleccionar] Expandir

#include <windows.h>
#include <stdio.h>

char *getpass(char *pass,unsigned int length){
  DWORD num,modo,i=0;
  HANDLE input=GetStdHandle(STD_INPUT_HANDLE);
  HANDLE output=GetStdHandle(STD_OUTPUT_HANDLE);
  GetConsoleMode(input,&modo);
  SetConsoleMode(input,modo&~(ENABLE_ECHO_INPUT|ENABLE_LINE_INPUT));
  do{
    ReadConsole(input,&pass[i],1,&num,NULL);
    if(pass[i++]=='\r')break;
    WriteConsole(output,"*",1,&num,NULL);
  }while(i<length);
  pass[i]=0;
  WriteConsole(output,"\n",1,&num,NULL);
  SetConsoleMode(input,modo);
  return pass;
}

int main(void){
  char pass[32]={0};
  printf("ingrese clave: ");
  getpass(pass,sizeof(pass));
  puts(pass);
  return 0;
}

S2

el problema se da a la hora de resumir el hilo para continuar la ejecucion, por lo que sospecho que hay algun fallo cuando el exe2 se copia en la memoria del exe1, pero no se a ciencia cierta cual podria ser el fallo, pues cuando intento ejecutar, por ej, el bloc de notas en la calculadora lo hace sin problemas, el fallo lo da cuando intento con otra app.

para "ese código" tenes que asegurarte que ambos ejecutables tengan la misma imagebase, dado que el código no comprueba la imagebase del ejecutable original, en caso de no ser iguales tendrías que asegurarte que el segundo ejecutable tenga el directorio reloc's y realizar el relocado manual... acá tenes un ejemplo de como hacerlo:

Código (cpp) [Seleccionar] Expandir

#include <windows.h>
#include <stdio.h>

typedef ULONG (WINAPI *tNtUnmapViewOfSection)(HANDLE ProcessHandle, PVOID BaseAddress);
typedef ULONG (WINAPI *tNtQueryInformationProcess)(HANDLE ProcessHandle,DWORD ProcessInformationClass,
PVOID ProcessInformation,ULONG ProcessInformationLength,PULONG ReturnLength);

typedef struct{
   PIMAGE_DOS_HEADER dos_header;
   PIMAGE_NT_HEADERS nt_headers;
   PIMAGE_SECTION_HEADER section_header;
   LPBYTE file_data;
}NEW_PROCESS_INFO, *PNEW_PROCESS_INFO;

typedef struct _PEB {
  BYTE   Reserved1[2];
  BYTE   BeingDebugged;
  BYTE   Reserved2[1];
  PVOID  Reserved3[1];
  PVOID  ImageBaseAddress;
  PVOID  Ldr;
  PVOID  ProcessParameters;
  BYTE   Reserved4[104];
  PVOID  Reserved5[52];
  PVOID  PostProcessInitRoutine;
  BYTE   Reserved6[128];
  PVOID  Reserved7[1];
  ULONG  SessionId;
} PEB, *PPEB;

typedef struct _PROCESS_BASIC_INFORMATION {
  PVOID Reserved1;
  PPEB PebBaseAddress;
  PVOID Reserved2[2];
  ULONG_PTR UniqueProcessId;
  PVOID Reserved3;
} PROCESS_BASIC_INFORMATION;

BOOL get_replacement_info(const char* full_file_path, PNEW_PROCESS_INFO new_process_info){
  DWORD bytes_read;
  HANDLE hFile=CreateFileA(full_file_path,GENERIC_READ,FILE_SHARE_READ,NULL,
    OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
  if(hFile==INVALID_HANDLE_VALUE)
  return FALSE;
  DWORD file_size=GetFileSize(hFile,NULL);
  new_process_info->file_data=(LPBYTE)malloc(file_size*sizeof(LPBYTE));
  if(ReadFile(hFile,new_process_info->file_data,file_size,&bytes_read,0)){
    new_process_info->dos_header = (PIMAGE_DOS_HEADER)(&new_process_info->file_data[0]);
    new_process_info->nt_headers = (PIMAGE_NT_HEADERS)(&new_process_info->file_data[new_process_info->dos_header->e_lfanew]);
    return TRUE;
  }
  free(new_process_info->file_data);
  CloseHandle(hFile);
  return FALSE;
}

BOOL RunPE(LPSTR file, LPSTR host){
  NEW_PROCESS_INFO new_process_info;
  HMODULE hNtdll=GetModuleHandleA("ntdll.dll");
  tNtUnmapViewOfSection NtUnmapViewOfSection=(tNtUnmapViewOfSection)
  (GetProcAddress(hNtdll,"NtUnmapViewOfSection"));
  tNtQueryInformationProcess NtQueryInformationProcess=(tNtQueryInformationProcess)
  (GetProcAddress(hNtdll,"NtQueryInformationProcess"));
  if(!NtUnmapViewOfSection||!NtQueryInformationProcess)
    return FALSE;
  if(get_replacement_info(file,&new_process_info)){
    PROCESS_INFORMATION process_info;STARTUPINFOA startup_info;
    RtlZeroMemory(&startup_info,sizeof(STARTUPINFOA));
    if(CreateProcessA(NULL,host,NULL,NULL,FALSE,CREATE_SUSPENDED,NULL,NULL,&startup_info,&process_info)){
      //Get client base address
      PEB Peb;PROCESS_BASIC_INFORMATION pbi;/*ProcessBasicInformation*/
      NtQueryInformationProcess(process_info.hProcess,0,&pbi,sizeof(pbi),NULL);
      ReadProcessMemory(process_info.hProcess,(LPCVOID)pbi.PebBaseAddress,&Peb,sizeof(Peb),NULL);
      //Reloc new process
      if(new_process_info.nt_headers->OptionalHeader.ImageBase!=(DWORD)Peb.ImageBaseAddress){
        DWORD Delta=((DWORD)Peb.ImageBaseAddress-new_process_info.nt_headers->OptionalHeader.ImageBase);
        if(new_process_info.nt_headers->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress){
          PIMAGE_BASE_RELOCATION pIBR=NULL;
          DWORD pRVAIBR=(DWORD)new_process_info.nt_headers->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress;
          for(int i=0;i<new_process_info.nt_headers->FileHeader.NumberOfSections;i++){
            PIMAGE_SECTION_HEADER pimage_section_header=(PIMAGE_SECTION_HEADER)(
              (LPBYTE)&new_process_info.nt_headers->OptionalHeader+new_process_info.nt_headers->FileHeader.SizeOfOptionalHeader+
              (i*sizeof(IMAGE_SECTION_HEADER))
            );
            if((pRVAIBR>=pimage_section_header->VirtualAddress)&&(pRVAIBR<=(pimage_section_header->VirtualAddress+pimage_section_header->SizeOfRawData))){
              PIMAGE_SECTION_HEADER section=(PIMAGE_SECTION_HEADER)pimage_section_header;
              pIBR=(PIMAGE_BASE_RELOCATION)(pRVAIBR+section->PointerToRawData-section->VirtualAddress+new_process_info.file_data);
              break;
            }
          }
          PBYTE dest=NULL;
          for(;pIBR->VirtualAddress>0;){
            DWORD pRVAIBR=(DWORD)pIBR->VirtualAddress;
            for(int i=0;i<new_process_info.nt_headers->FileHeader.NumberOfSections;i++){
              PIMAGE_SECTION_HEADER pimage_section_header=(PIMAGE_SECTION_HEADER)(
                (LPBYTE)&new_process_info.nt_headers->OptionalHeader+new_process_info.nt_headers->FileHeader.SizeOfOptionalHeader+
                (i*sizeof(IMAGE_SECTION_HEADER))
              );
              if((pRVAIBR>=pimage_section_header->VirtualAddress)&&(pRVAIBR<=(pimage_section_header->VirtualAddress+pimage_section_header->SizeOfRawData))){
                PIMAGE_SECTION_HEADER section=(PIMAGE_SECTION_HEADER)pimage_section_header;
                dest=(PBYTE)(pRVAIBR+section->PointerToRawData-section->VirtualAddress+new_process_info.file_data);
                break;
              }
            }
            if(dest){
              PWORD relInfo=(PWORD)((PBYTE)pIBR+IMAGE_SIZEOF_BASE_RELOCATION);
              for(DWORD i=0;i<((pIBR->SizeOfBlock-IMAGE_SIZEOF_BASE_RELOCATION)/2);i++,relInfo++){
                if((*relInfo>>12)==IMAGE_REL_BASED_HIGHLOW){
                  PDWORD pAddress=(LPDWORD)(dest+(*relInfo&0xfff));
                  *pAddress+=Delta;
                }
              }
            }
            pIBR=(PIMAGE_BASE_RELOCATION)(((DWORD)pIBR)+pIBR->SizeOfBlock);
          }
        }else{
          puts("no reloc table");
          TerminateProcess(process_info.hProcess,0);
          return FALSE;
        }
        new_process_info.nt_headers->OptionalHeader.ImageBase=(DWORD)Peb.ImageBaseAddress;
      }
      //Remove target memory code
      NtUnmapViewOfSection(process_info.hProcess,(PVOID)new_process_info.nt_headers->OptionalHeader.ImageBase);
      //Allocate memory in target process starting at replacements image base
      VirtualAllocEx(process_info.hProcess,(PVOID)new_process_info.nt_headers->OptionalHeader.ImageBase,
        new_process_info.nt_headers->OptionalHeader.SizeOfImage,MEM_COMMIT|MEM_RESERVE,PAGE_EXECUTE_READWRITE);
      //Copy in PE header of replacement process
      WriteProcessMemory(process_info.hProcess,(PVOID)new_process_info.nt_headers->OptionalHeader.ImageBase,
        &new_process_info.file_data[0],new_process_info.nt_headers->OptionalHeader.SizeOfHeaders,NULL);
      //Write in all sections of the replacement process
      for(int i=0;i<new_process_info.nt_headers->FileHeader.NumberOfSections;i++){
        //Get offset of section
        int section_offset=new_process_info.dos_header->e_lfanew+sizeof(IMAGE_NT_HEADERS)+(sizeof(IMAGE_SECTION_HEADER)*i);
        new_process_info.section_header=(PIMAGE_SECTION_HEADER)(&new_process_info.file_data[section_offset]);
        //Write in section
        WriteProcessMemory(process_info.hProcess,(LPVOID)((DWORD_PTR)new_process_info.nt_headers->OptionalHeader.ImageBase+
          new_process_info.section_header->VirtualAddress),&new_process_info.file_data[new_process_info.section_header->PointerToRawData],
          new_process_info.section_header->SizeOfRawData,NULL);
      }
      //Get CONTEXT of main thread of suspended process, fix up EAX to point to new entry point
      CONTEXT thread_context;
      thread_context.ContextFlags=CONTEXT_FULL;
      GetThreadContext(process_info.hThread,&thread_context);
      thread_context.Eax=new_process_info.nt_headers->OptionalHeader.ImageBase+new_process_info.nt_headers->OptionalHeader.AddressOfEntryPoint;
      SetThreadContext(process_info.hThread,&thread_context);
      //Resume the main thread, now holding the replacement processes code
      ResumeThread(process_info.hThread);
      free(new_process_info.file_data);
      return TRUE;
    }else
      puts("createprocess fail!");
  }else
    puts("get_replacement_info fail!");
  return FALSE;
}

int main(void){
  RunPE("C:\\WINDOWS\\explorer.exe","C:\\CodeBlocks\\Examples\\MyApp.exe");
  system("pause");
  return 0;
}

S2

Luego de inicializarlo con strcpy, voy agregando cadenas con strcat, pero al ser la variable cad de 10 elementos, ¿no deberia haber un error?

te lo explico brevemente, cuando haces uso de malloc/new con valores pequeños la memoria reservada está en el heap (un espacio ya reservado para ser usado de esta forma), por lo que es posible que puedas desbordar el buffer hasta cierto límite (mientras lo que sobreescribas no afecte directamente a otro proceso/función, ya que si lo haces terminará provocando un error [los cuales son los más complicados de encontrar]), tb tienes que tener en cuenta que los tamaños son "redondeados" a tamaños prácticos para el CPU (en el caso del heap son alineados a sizeof(*void) [cuyo tamaño es distinto si es 32 o 64 bits] si mal no recuerdo) y en caso de espacios grandes de memoria a una página (512 bytes aprox), entonces si reservas 10 bytes, el redondeo será de 12 [en 32 bits] (3*sizeof(*void)=3*4=12)

S2

de nadas  , aunque me parece raro... yo pude compilarlo sin parchear nada (debe ser distinta la versión de la librería que tenemos  )

S2

no, lo que debe detectar es cuando el CE intenta tener acceso a la memoria del juego (lo más probable es una protección por driver: ntprotectvirtualmemory, ntreadvirtualmemory), puedes probar lo siguiente: utiliza algún programa como process hacker o el process explorer para suspender el proceso del juego, luego trata de descargar el driver mediante el RU y recién ahí intenta usar el CE (puedes probar tb sin descargar el driver).

S2

si te tira ese error es porque están mal los nombres de los archivos (el que dice dll es el estático y el otro el dinámico), probá renombrando los archivos o bajándolos de nuevo... luego para compilar estáticamente tuve que agregar esto:

En el código:

Código (c) [Seleccionar] Expandir

#define CURL_STATICLIB
#include <curl/curl.h>

En el linker (dependencias de curl):

curl
idn
rtmp
ssh2
ssl
crypto
wldap32
gdi32
wsock32
z
winmm

S2

En el caso de dos de las que mencionas ("zlib" y "libcurl") en mi caso en la carpeta libs de mi compilador tengo:

libcurl.a -> 483kb
libcurldll.a -> 103kb
libz.a -> 92kb
libzdll.a-> 39kb

Donde por el nombre te darás cuenta que una es para linkeo estático y la otra es para linkeo dinámico (si, ambos se hacen a través de un archivo ".a"), lo que puede estar pasando es que no tengas la versión estática de la librería o la tengas con otro nombre, si no la tienes debes ir a la página del creador de la librería y descargarla desde ahí.

Lo mismo se aplica para cualquier librería.

S2

Themida no tiene protección contra inyección, dicha protección debe estar dentro del código del anticheat (si tiene un driver suelen hookear ntcreatesection o ntcreatethread para detectar inyecciones), fuera de eso, que te detecte el CE puede ser por varios motivos (detectar el driver del CE [si está corriendo] o detección del proceso del CE), podrías (si es que se puede, dado que nunca usé el CE) desactivar el driver y ver si te lo sigue detectando, si no es así, prueba cambiar el nombre del ejecutable, si cambiando el nombre lo sigue detectando puede ser por el nombre de la ventana... etc... de todas formas, para ver el código del programa puedes utilizar algún antirootkit como el Rootkit Unhooker o alguno parecido para dumpear el proceso (con eso ya puedes ver parte del código [que no esté virtualizado]), si está virtualizado hasta hoy no hay ningún método 100% funcional para desvirtualizar así que esa parte no podrás verla... je

S2

[EDIT:]

En realidad es sin el asterisco (*)...

Código (cpp) [Seleccionar] Expandir


int punt::a = NULL;


Ahí asignas que el puntero es NULL osea que no apunta a nada, en tu caso estabas asignando que el valor de la dirección donde apunta es NULL.

antes de tratar "enseñar" a los demás deberías leer un poco  

Hola , al intentar solucionar un problema de un puntero que uso con muchos objetos, lo puse estatico pero el compilador no me deja siquiera definirlo .

Sera que el operador static no puede ser aplicado a un puntero ?¿

EDIT: Me autorespondo . Ya encontré como solucionarlo , era algo muy simple....

si tenia un miembro estatico como puntero ej

Código (cpp) [Seleccionar] Expandir

class punt
 {
     public:
         static int *a;
 };

// la forma de definirlo era asi
int *punt::a = NULL;

// Y no
int punt::*a;  // Como estaba intentando  :¬¬

La sintaxis de los miembros estáticos es: "<type> <class_name>::<static_variable>;" o "<type> <class_name>::<static_variable> = <value>;" si quieres darle un valor inicial, por lo tanto en tu caso quedaría:

Código (cpp) [Seleccionar] Expandir

int* punt::a;

o

Código (cpp) [Seleccionar] Expandir

int* punt::a=NULL;

S2

EDIT: con respecto al acceso, sigue las mismas reglas que los miembros no estáticos (solo para miembros, no para métodos estáticos)

no es necesario inyectar ni nada por el estilo, simplemente tienes que encontrar la dirección de la comparación y "nopearla"  o modificarla como te sea conveniente mediante writeprocessmemory...

S2

PD: la inyección de código se utiliza más cuando se quieren agregar comportamientos más que modificarlos.