class XX{
	public:
};
 
class XY{
	public:
};
 
typedef void (XX::*pfun)(void);
 
class X:public XX,XY{
	public:
		int ff(int a){
			return a;
		}
		static pfun f;
		static struct _t{
			pfun f;
		}t;
};
 
pfun X::f=pfun(&X::ff);//??????
struct X::_t X::t={pfun(&X::ff)};//??????

class X:public XX,XY

#define _WIN32_WINNT 0x0500
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
 
/*
REGISTERS
=========
0 eax
2 ebx
E ecx
4 edx
C ebp
6 esp
A edi
8 esi
 
OPCODES
=======
00 YYYYYYYY ->  jmp long
01 YYYY     ->  jmp short
02 YY       ->  jmp word
03 YYYY     ->  je  short
04 YY       ->  je  word
05 YYYY     ->  jne short
06 YY       ->  jne word
 
//MOV REG, 00000
14 YYYYYYYY ->  mov eax, long
15 YYYYYYYY ->  mov ecx, long
16 YYYYYYYY ->  mov edx, long
17 YYYYYYYY ->  mov ebx, long
18 YYYYYYYY ->  mov esp, long
19 YYYYYYYY ->  mov ebp, long
1A YYYYYYYY ->  mov esi, long
1B YYYYYYYY ->  mov edi, long
 
//MOV [REG-X], XXXXXXXX
1C XX YYYYYYYY ->  mov (R) , long ->  X reg X offset
 
//MOV REG, [REG-X]
1E XX  ->  mov eax, (R) ->  X reg X reg
1F XX  ->  mov ebx, (R)
20 XX  ->  mov ecx, (R)
21 XX  ->  mov edx, (R)
22 XX  ->  mov ebp, (R)
23 XX  ->  mov esp, (R)
24 XX  ->  mov edi, (R)
25 XX  ->  mov esi, (R)
 
//MOV REG, REG
26 XX  ->  mov R, R
 
//MOV [REG-X], REG
28 XX  ->  mov (R), eax ->  X reg X offset
29 XX  ->  mov (R), ebx
2A XX  ->  mov (R), ecx
2B XX  ->  mov (R), edx
2C XX  ->  mov (R), ebp
2D XX  ->  mov (R), esp
2E XX  ->  mov (R), edi
2F XX  ->  mov (R), esi
 
//SUB EDX, EAX
32 XX  ->  sub R, R   ->  X reg X reg
 
//LEA EAX, [EBP-8]
3C XX  ->  lea eax, (R) ->  X reg X reg
3D XX  ->  lea ebx, (R)
3E XX  ->  lea ecx, (R)
3F XX  ->  lea edx, (R)
40 XX  ->  lea ebp, (R)
41 XX  ->  lea esp, (R)
42 XX  ->  lea edi, (R)
43 XX  ->  lea esi, (R)
 
*/
 
typedef struct _REGISTERS{
  ULONG Edi;//00
  ULONG Esi;//04
  ULONG Ebp;//08
  ULONG Esp;//0C
  ULONG Ebx;//10
  ULONG Edx;//14
  ULONG Ecx;//18
  ULONG Eax;//1C
  ULONG Flg;//20
  ULONG Eip;//24
}REGISTERS, *PREGISTERS;
 
PULONG GetReg(PREGISTERS p,WORD reg){
  PULONG ret=NULL;
  switch(reg){
    case 0x0:// eax
      ret=&p->Eax;
    break;
    case 0x2:// ebx
      ret=&p->Ebx;
    break;
    case 0xE:// ecx
      ret=&p->Ecx;
    break;
    case 0x4:// edx
      ret=&p->Edx;
    break;
    case 0xC:// ebp
      ret=&p->Ebp;
    break;
    case 0x6:// esp
      ret=&p->Esp;
    break;
    case 0xA:// edi
      ret=&p->Edi;
    break;
    case 0x8:// esi
      ret=&p->Esi;
    break;
  }
  return ret;
}
 
void decrypt(REGISTERS p){
  PBYTE b=(PBYTE)p.Eip;
  BYTE Reg=0,RegEx=0;
  PULONG pReg=0,pRegEx=0;
  CHAR Offset=0;
 
  //FIX ME!
  b+=2;//lo ideal sería un long jmp, pero gcc no deja setearlo (o no se como)
 
  //Code Start!
  while(*b!=0xF0){
    switch(*b){
      case 0x1C://MOV [REG-X], XXXXXXXX
        Reg=*(++b);
        Offset=Reg&0xF;
        Reg>>=4;
        if(Reg&0x1)
          Offset=-Offset;
        Reg&=0xE;
        pReg=GetReg(&p,Reg);
        *((PDWORD)(*pReg+Offset))=*(DWORD*)(++b);
        b+=4;
      break;
      case 0x21://MOV EDX, [REG-X]
        Reg=*(++b);
        Offset=Reg&0xF;
        Reg>>=4;
        if(Reg&0x1)
          Offset=-Offset;
        Reg&=0xE;
        pReg=GetReg(&p,Reg);
        p.Edx=*((PDWORD)(*pReg+Offset));
        ++b;
      break;
      case 0x1E://MOV EAX, [REG-X]
        Reg=*(++b);
        Offset=Reg&0xF;
        Reg>>=4;
        if(Reg&0x1)
          Offset=-Offset;
        Reg&=0xE;
        pReg=GetReg(&p,Reg);
        p.Eax=*((PDWORD)(*pReg+Offset));
        ++b;
      break;
      case 0x32://SUB REG,REG
        Reg=*(++b);
        RegEx=Reg&0xF;
        Reg>>=4;
        pReg=GetReg(&p,Reg);
        pRegEx=GetReg(&p,RegEx);
        p.Eax=*pReg-*pRegEx;
        ++b;
      break;
      case 0x28://MOV [REG-X], EAX
        Reg=*(++b);
        Offset=Reg&0xF;
        Reg>>=4;
        if(Reg&0x1)
          Offset=-Offset;
        Reg&=0xE;
        pReg=GetReg(&p,Reg);
        *((PDWORD)(*pReg+Offset))=p.Eax;
        ++b;
      break;
      default:
        //FIX ME!
        b++;//Opcode no válido?
      break;
    }
  }
  p.Eip=(ULONG)++b;
}
 
void __stdcall vmachine(void);
asm(
  ".globl _vmachine\r\n"
  "_vmachine:\r\n"//function header...
  "  SUB     $0x24,%esp;\r\n"
  "  PUSH    %edi;\r\n"
  "  POP     (%esp);\r\n"
  "  PUSH    %esi;\r\n"
  "  POP     0x4(%esp);\r\n"
  "  PUSH    %ebp;\r\n"
  "  POP     0x8(%esp);\r\n"
  "  PUSH    %ebx;\r\n"
  "  POP     0x10(%esp);\r\n"
  "  PUSH    %edx;\r\n"
  "  POP     0x14(%esp);\r\n"
  "  PUSH    %ecx;\r\n"
  "  POP     0x18(%esp);\r\n"
  "  PUSH    %eax;\r\n"
  "  POP     0x1C(%esp);\r\n"
  "  PUSHF   ;\r\n"
  "  POP     0x20(%esp);\r\n"
  "  LEA     0x28(%esp),%eax;\r\n"
  "  MOV     %eax,0x0C(%esp);\r\n"
  "  CALL    _decrypt;\r\n"
  "  POPA    ;\r\n"
  "  POPF    ;\r\n"
  "  RET"
);
 
void cryptme(){
  int a,b,c;
  asm(
    " call jmp1;\n\t"
"jmp1:jmp _vmachine;\n\t"
  );
  /*a=15,b=8;c=a-b;*/
  asm(".byte\t\
    0x1C,0xD4,0x0F,0x00,0x00,0x00,\
    0x1C,0xD8,0x08,0x00,0x00,0x00,\
    0x21,0xD4,\
    0x1E,0xD8,\
    0x32,0x40,\
    0x28,0xDC,\
    0xF0\
  ");
  printf("%d %d %d\n",a,b,c);
  return;
}
 
int main(void){
  cryptme();
  system("pause");
  return 0;
}

  asm(
    " call jmp1;\n\t"
"jmp1:jmp _vmachine;\n\t"
  );

void cryptme(){
  int a,b,c;
  a=15,b=8;c=a-b;
  printf("%d %d %d\n",a,b,c);
  return;
}

004015F2  /$  55            PUSH    EBP
004015F3  |.  89E5          MOV     EBP, ESP
004015F5  |.  83EC 28       SUB     ESP, 28
004015F8  |.  C745 FC 0F000>MOV     DWORD PTR SS:[EBP-4], 0F         ; |
004015FF  |.  C745 F8 08000>MOV     DWORD PTR SS:[EBP-8], 8          ; |
00401606  |.  8B55 F8       MOV     EDX, DWORD PTR SS:[EBP-8]        ; |
00401609  |.  8B45 FC       MOV     EAX, DWORD PTR SS:[EBP-4]        ; |
0040160C  |.  29D0          SUB     EAX, EDX                         ; |
0040160E  |.  8945 F4       MOV     DWORD PTR SS:[EBP-C], EAX        ; |
00401611  |.  8B45 F4       MOV     EAX, DWORD PTR SS:[EBP-C]        ; |
00401614  |.  894424 0C     MOV     DWORD PTR SS:[ESP+C], EAX        ; |
00401618  |.  8B45 F8       MOV     EAX, DWORD PTR SS:[EBP-8]        ; |
0040161B  |.  894424 08     MOV     DWORD PTR SS:[ESP+8], EAX        ; |
0040161F  |.  8B45 FC       MOV     EAX, DWORD PTR SS:[EBP-4]        ; |
00401622  |.  894424 04     MOV     DWORD PTR SS:[ESP+4], EAX        ; |
00401626  |.  C70424 983040>MOV     DWORD PTR SS:[ESP], CodeVirt.004>; |ASCII "%d %d %d\n"
0040162D  |.  E8 56080000   CALL    <JMP.&msvcrt.printf>             ; \printf
00401632  |.  C9            LEAVE
00401633  \.  C3            RETN

004015F2  |$  55            PUSH    EBP
004015F3  |.  89E5          MOV     EBP, ESP
004015F5  |.  83EC 28       SUB     ESP, 28
004015F8  |.  E8 00000000   CALL    CodeVirt.004015FD
004015FD  \$^ EB B9         JMP     SHORT CodeVirt.004015B8
004015FF      1C            DB      1C
00401600      D4            DB      D4
00401601      0F            DB      0F
00401602      00            DB      00
00401603      00            DB      00
00401604      00            DB      00
00401605      1C            DB      1C
00401606      D8            DB      D8
00401607      08            DB      08
00401608      00            DB      00
00401609      00            DB      00
0040160A      00            DB      00
0040160B      21            DB      21                               ;  CHAR '!'
0040160C      D4            DB      D4
0040160D      1E            DB      1E
0040160E      D8            DB      D8
0040160F      32            DB      32                               ;  CHAR '2'
00401610      40            DB      40                               ;  CHAR '@'
00401611      28            DB      28                               ;  CHAR '('
00401612   .  DCF0          FDIVR   ST, ST                           ; |
00401614   .  8B45 F4       MOV     EAX, DWORD PTR SS:[EBP-C]        ; |
00401617   .  894424 0C     MOV     DWORD PTR SS:[ESP+C], EAX        ; |
0040161B   .  8B45 F8       MOV     EAX, DWORD PTR SS:[EBP-8]        ; |
0040161E   .  894424 08     MOV     DWORD PTR SS:[ESP+8], EAX        ; |
00401622   .  8B45 FC       MOV     EAX, DWORD PTR SS:[EBP-4]        ; |
00401625   .  894424 04     MOV     DWORD PTR SS:[ESP+4], EAX        ; |
00401629   .  C70424 983040>MOV     DWORD PTR SS:[ESP], CodeVirt.004>; |ASCII "%d %d %d\n"
00401630   .  E8 53080000   CALL    <JMP.&msvcrt.printf>             ; \printf
00401635   .  C9            LEAVE
00401636   .  C3            RETN

#include <windows.h>
 
char titulo[]="titulo";
char mensaje[]="un mensaje";
 
void funcionascanear(void){
  MessageBox(0,mensaje,titulo,0);
}
 
int main(void){
  funcionascanear();
  return 0;
}

004012D0  /$  55                 PUSH    EBP
004012D1  |.  89E5               MOV     EBP, ESP
004012D3  |.  83EC 18            SUB     ESP, 18
004012D6  |.  C74424 0C 00000000 MOV     DWORD PTR SS:[ESP+C], 0          ; |
004012DE  |.  C74424 08 00204000 MOV     DWORD PTR SS:[ESP+8], generico.0>; |ASCII "titulo"
004012E6  |.  C74424 04 07204000 MOV     DWORD PTR SS:[ESP+4], generico.0>; |ASCII "un mensaje"
004012EE  |.  C70424 00000000    MOV     DWORD PTR SS:[ESP], 0            ; |
004012F5  |.  E8 86080000        CALL    <JMP.&USER32.MessageBoxA>        ; \MessageBoxA
004012FA  |.  83EC 10            SUB     ESP, 10
004012FD  |.  C9                 LEAVE
004012FE  \.  C3                 RETN

char *findmsgbypattern(){
  unsigned char *p;
  //dirección inicio / fin del escaneo
  for(p=0x00401000;p<0x00401FFF;p++){
    //nuestro patron
    if(p[0]==0x55&&p[1]==0x89&&p[3]==0x83&&p[6]==0xC7&&p[14]==0xC7&&p[22]==0xC7){
      //dirección de la variable tomada del código
      return (char *)*(void**)&p[26];
    }
  }
  return NULL;
}

#include <windows.h>
 
char titulo[]="titulo";
char mensaje[]="un mensaje";
 
void funcionascanear(void){
  MessageBox(0,mensaje,titulo,0);
}
 
char *findmsgbypattern(){
  unsigned char *p;
  //dirección inicio / fin del escaneo
  for(p=0x00401000;p<0x00401FFF;p++){
    //nuestro patron
    if(p[0]==0x55&&p[1]==0x89&&p[3]==0x83&&p[6]==0xC7&&p[14]==0xC7&&p[22]==0xC7){
      //dirección de la variable tomada del código
      return (char *)*(void**)&p[26];
    }
  }
  return NULL;
}
 
int main(void){
  char *msg=findmsgbypattern();
  if(msg)
    strcpy(msg,"mi mensaje");
  funcionascanear();
  return 0;
}

findpattern(dirinicio,dirfin,"XX????XX??????XX????XX");

<?php /* antibot.php */
 
function checkBot(){
	//cookie params
	@ini_set('session.use_cookies',1);
	@ini_set('session.cookie_lifetime',31536000);//un año
	@ini_set('session.use_only_cookies',1);
	@ini_set('session.cookie_path','/');
	// configufación de variables PHP
	@ini_set('session.name',"AntiBot");//nombre de la cookie
	//otras opciones	  
	@ini_set('session.hash_function',0);
	@ini_set('session.use_trans_sid',0);
	@ini_set('session.save_path','/tmp');
	@session_start();
 
	if(!isset($_SESSION['bottime']))
		$_SESSION['bottime']=rand(100,999);
	$bottime=$_SESSION['bottime'];
 
	if(isset($_REQUEST['antibotkey']))
		$_SESSION['antibotkey']=$_REQUEST['antibotkey'];
	if(isset($_SESSION['antibotkey'])&&isset($_SESSION['bottime'])){
		$antibotkey=$_SESSION['antibotkey'];
		if(!empty($antibotkey)&&sha1($_SERVER['HTTP_USER_AGENT'].$bottime)==$antibotkey)
		  return null;
	}
 
	if(!isset($_SESSION['botcount']))
		$_SESSION['botcount']=0;
	else
		$_SESSION['botcount']++;
 
	if($_SESSION['botcount']>10){
		$_SESSION['botcount']=0;
		@session_write_close();
		@header("Location: http://www.google.com");
	}
 
	return sha1($_SERVER['HTTP_USER_AGENT'].$bottime);
}
 
?>

<?php /* index.php */
/********************************* Anti Bot ************************************/
 
include 'antibot.php';
$antibotkey=checkBot();
if(!empty($antibotkey))
	die("<a href='index.php?antibotkey=$antibotkey'>Haz Click Aquí para Entrar al Sitio</a><br/><br/>Este Mensaje es mostrado para evitar el ingreso de Bots y solo lo verás una vez.<br/><br/>Disculpe las molestias.");
 
/********************************* Anti Bot ************************************/

Address(0x431212) = 325
Offset(325) = 0x431212

/////////////////////////////////////////////////////////////////////////////
// Name:        PE simple crypter (FIX 1)
// Purpose:     Encriptador simple de Ficheros PE
// Author:      Karman
// Created:     2009-10-7
// Copyright:   (c) Exinferis Inc
// Web:         http://www.inexinferis.com.ar
// Vr. : 0.1.1
/////////////////////////////////////////////////////////////////////////////
 
#include <stdio.h>
#include "ExecAnalizer.h"
 
CCHAR DataDirectories[][24]={
  "Export Table",
  "Import Table",
  "Resource Table",
  "Exception Table",
  "Certificate Table",
  "Relocation Table",
  "Debug Table",
  "Architecture Table",
  "Machine Table",
  "Thread Local Storage",
  "Load Config Table",
  "Bound Import Table",
  "Import Address Table",
  "Delay Import Table",
  "COM+ Runtime Header"
};
 
BYTE ourcode[]={
  //push old entrypoint...
  0x68,0x00,0x00,0x00,0x00,
  //push size of code
  0x68,0x00,0x00,0x00,0x00,
  //push address of code
  0x68,0x00,0x00,0x00,0x00,
  //call decrypt
  0xE8,0x00,0x00,0x00,0x00,
  //Ret
  0xc3
};
 
DWORD WINAPI GetFunctionSize(PBYTE dwStart);
VOID  WINAPI descifrar(PBYTE address,INT size, DWORD oep);
VOID  WINAPI cifrar(PBYTE address,INT size);
 
int WINAPI WinMain(HINSTANCE hInst,HINSTANCE hPInst,LPSTR lpCmd,int nShow){
  DWORD nImageBase,nEntryPoint;
  PIMAGE_NT_HEADERS pINH;
  PIMAGE_SECTION_HEADER pISHCode;
  PCHAR forig="C:\\WINDOWS\\regedit.exe";
  PCHAR fcrytp="C:\\WINDOWS\\cifrado.exe";
  printf("Abriendo -> %s\n",forig);
  ExecAnalizer crypt(forig);
  //nos aseguramos que sea PE...
  if(crypt.GetDOSHeader()&&crypt.HasNewHeader()&&crypt.IsPE()){
    printf("\tFile Is -> PE\n");
    pINH = crypt.GetNTHeader();
    //datos básicos del ejecutable
    nEntryPoint=pINH->OptionalHeader.AddressOfEntryPoint;
    nImageBase=pINH->OptionalHeader.ImageBase;
    printf("\tEntryPoint -> %X\n",nEntryPoint);
    printf("\tImageBase -> %X\n",nImageBase);
    puts("Buscando Code Section:");
    //sección del código
    pISHCode=crypt.RVA2Section(nEntryPoint);
    if(pISHCode){
      printf("\tCode Section Found At -> %X\n",crypt.Address2Offset((PBYTE)pISHCode));
      DWORD codeStart=pISHCode->VirtualAddress;
      DWORD codeEnd=pISHCode->VirtualAddress+pISHCode->SizeOfRawData;
      printf("\tCode Section Start At -> %X\n",codeStart);
      printf("\tCode Section End At -> %X\n",codeEnd);
      //buscamos si alguna otra cosa se encuentra tb en el area de código
      puts("Buscando Tablas en Code Section (Calculando tamaño real del código)");
      for(int i=0;i<15;i++){
        if(pISHCode==crypt.RVA2Section(pINH->OptionalHeader.DataDirectory[i].VirtualAddress)){
          printf("\t%s is in Code Section At %X - %X\n",DataDirectories[i],
            pINH->OptionalHeader.DataDirectory[i].VirtualAddress,
            pINH->OptionalHeader.DataDirectory[i].Size
          );
          DWORD tAdress=pINH->OptionalHeader.DataDirectory[i].VirtualAddress;
          DWORD tSize=(pINH->OptionalHeader.DataDirectory[i].VirtualAddress+pINH->OptionalHeader.DataDirectory[i].Size);
          if(nEntryPoint<tAdress){
            if(codeEnd>tAdress)
              codeEnd=tAdress;
          }else{
            if(codeStart<tSize)
              codeStart=tSize;
          }
        }
      }
      puts("Tamaño real del código:");
      printf("\tCode Section Start At -> %X\n",codeStart);
      printf("\tCode Section End At -> %X\n",codeEnd);
      // Valores reales (en el archivo)
      DWORD rCodeStart=(DWORD)crypt.RVA2Offset(codeStart);
      DWORD rCodeEnd=(DWORD)crypt.RVA2Offset(codeEnd);
      //buscamos espacio libre dentro de la sección code para copiarnos...
      puts("Buscando Espacio para nuestro Código:");
      //tamaño de nuestro código...
      DWORD decrypcodefuncsize=GetFunctionSize((PBYTE)descifrar);
      DWORD decrypcodesize=decrypcodefuncsize+0x20;
      //Espacios libres???
      DWORD dwBlanks=0,dwAddress=(pISHCode->PointerToRawData+pISHCode->SizeOfRawData);
      for(;((dwAddress>rCodeEnd)&&(dwBlanks<decrypcodesize));dwAddress--)
        if(!*crypt.OffsetValue(dwAddress))dwBlanks++;else dwBlanks=0;
      //tiene espacio???
      printf("\tEspacio Necesario: %X - Espacio encontrado: %X\n",decrypcodesize,dwBlanks);
      if(decrypcodesize>=dwBlanks){
        printf("\tFree Space At -> %X\n",dwAddress);
        //ciframos...
        cifrar((PBYTE)crypt.RVAValue(codeStart),codeEnd-codeStart);
        //copiamos la función que descifra
        memcpy((PVOID)crypt.OffsetValue(dwAddress),(PVOID)descifrar,decrypcodefuncsize);
        //armamos cabecera...
        *(DWORD *)&ourcode[0x01]=nEntryPoint+nImageBase;
        *(DWORD *)&ourcode[0x06]=codeEnd-codeStart;
        *(DWORD *)&ourcode[0x0B]=codeStart+nImageBase;
        *(DWORD *)&ourcode[0x10]=-(decrypcodefuncsize+20);
        dwAddress+=decrypcodefuncsize;
        memcpy((PVOID)crypt.OffsetValue(dwAddress),(PVOID)ourcode,24);
        //calculamos nuevo entrypoint
        pINH->OptionalHeader.AddressOfEntryPoint=crypt.Offset2RVA(dwAddress);
        // Damos permiso de escritura a la sección. Si no hacemos esto nos dara error.
        pISHCode->Characteristics |= IMAGE_SCN_MEM_WRITE;
        // Corregimos tamaño de la sección virtual si insuficiente
        if(pISHCode->Misc.VirtualSize<(crypt.Offset2RVA(dwAddress)-pISHCode->VirtualAddress+24))
          pISHCode->Misc.VirtualSize=(crypt.Offset2RVA(dwAddress)-pISHCode->VirtualAddress+24);
        crypt.Save(fcrytp);
      }else
        puts("\tSin espacio Suficiente... :(");
    }
 
    system("pause");
  }
}
 
DWORD WINAPI GetFunctionSize(PBYTE dwStart){
  PBYTE dwEnd=dwStart;
	while(*dwEnd!=0xC3&&*dwEnd!=0xC2)dwEnd++;
	if(*dwEnd==0xC2)return (dwEnd-dwStart+3);
	return (dwEnd-dwStart+1);
}
 
VOID  WINAPI descifrar(PBYTE address,INT size, DWORD oep){
  while(size>0){
    *(address++)^=0x65;
    size--;
  }
  //set ret to old entry point
  asm("mov %0 , 0x04(%%esp)"::"r"(oep));
}
 
VOID  WINAPI cifrar(PBYTE address,INT size){
  while(size>0){
    *(address++)^=0x65;
    size--;
  }
}