Colocar Hardware BreakPoints en Windows x64

[aguml]

Bueno amigos, esto avanza poquito a poquito. Ahora me encuentro con el tema de los Hardware BreakPoints los cuales al pasar el codigo a x64 no funcionan y ademas el programa depurado da una excepcion y se acaba cerrando.
Para ponerlos en x32 tenia estas constantes:

Código PHP:

#define EXCEPTION_GUARD_PAGE_VIOLATION 0x80000001L

enum ModeBPM { BMP_WRITE, BMP_ACCESS,BMP_EXECUTION};
enum ModeHW { HW_WRITE, HW_ACCESS, HW_EXECUTION};
enum LenHW { HW_BYTE, HW_WORD, HW_DWORD};

//Constantes para los HW
#define HW_DR0        0x1
#define HW_DR1        0x2
#define HW_DR2        0x3
#define HW_DR3        0x4

#define DR0_LOCAL_EXACT_BPM_ENABLED    0x01
#define DR0_GLOBAL_EXACT_BPM_ENABLED   0x02

#define DR0_W      0x10000
#define DR0_IO      0x20000
#define DR0_RW          0x30000
#define DR0_EXECUTION    0x0

#define DR0_LEN1    0x0
#define DR0_LEN2    0x40000
#define DR0_LEN3    0x0C0000

#define DR1_LOCAL_EXACT_BPM_ENABLED  0x4
#define DR1_GLOBAL_EXACT_BPM_ENABLED 0x8

#define DR1_W      0x100000
#define DR1_IO      0x200000
#define DR1_RW      0x300000
#define DR1_EXECUTION          0x0

#define DR1_LEN1    0x0
#define DR1_LEN2    0x400000
#define DR1_LEN3    0x0C00000

#define DR2_LOCAL_EXACT_BPM_ENABLED  0x10
#define DR2_GLOBAL_EXACT_BPM_ENABLED 0x20

#define DR2_W      0x1000000
#define DR2_IO      0x2000000
#define DR2_RW      0x3000000
#define DR2_EXECUTION          0x0

#define DR2_LEN1    0x0
#define DR2_LEN2    0x4000000
#define DR2_LEN3    0x0C000000

#define DR3_LOCAL_EXACT_BPM_ENABLED   0x40
#define DR3_GLOBAL_EXACT_BPM_ENABLED  0x80

#define DR3_W      0x10000000
#define DR3_IO      0x20000000
#define DR3_RW      0x30000000
#define DR3_EXECUTION          0x0

#define DR3_LEN1    0x0
#define DR3_LEN2    0x40000000
#define DR3_LEN3    0x0C0000000

#define LOCAL_EXACT_BPM_ENABLED      0x100
#define LOCAL_EXACT_BPM_DISABLED    0x0
#define GLOBAL_EXACT_BPM_ENABLED    0x200
#define GLOBAL_EXACT_BPM_DISABLED   0x0
#define GENERAL_DETECT_ENABLED      0x2000
#define RESERVED_BIT10              0x400

#define CLEAR_DR0            0x0FFF0FFFC
#define CLEAR_DR1               0x0FF0FFFF3
#define CLEAR_DR2                   0x0F0FFFFCF
#define CLEAR_DR3                   0x0FFFFF3F 


Y esta funcion:

Código PHP:

DWORD __fastcall THiloDebugger::OnSingleStepEventThread(EXCEPTION_DEBUG_INFO *info)
{
    pBP BPaux;
    int HWBySingleStep=0;

    DWORD Aux;

     /*-------------------------------------------------------------------------------------
    *
    * DEBUG REGISTER 7
    *
    * LEN3 R/W3 LEN2 R/W2 LEN1 R/W1 LEN0 R/W0 0 0 GD 0 0 1 GE LE G3 L3 G2 L2 G1 L1 G0 L0
    *
    *  00   00   00   00   00   00   00   00  0 0 0  0 0 0 0  1  0  1  0  1  0  1  0  1
    *
    *-------------------------------------------------------------------------------------*/

    if(RepairHW == true){
        switch(ItemHWRepair.DrW){

            case HW_DR0:
                con.Dr0 = ItemHWRepair.Address;
                break;

            case HW_DR1:
                con.Dr1 = ItemHWRepair.Address;
                break;

            case HW_DR2:
                con.Dr2 = ItemHWRepair.Address;
                break;

            case HW_DR3:
                con.Dr3 = ItemHWRepair.Address;
                break;

        }
        RepairHW = false;

        if(UserStepIn == true){
            UserStepIn = false;

            DisableBP(0); // Desactivamos todos los BPs para que si el usuario ve la memoria esta se muestre como debe
            ClearBMP(true); // reponemos las propiedades de la memoria

            Synchronize(SingleStepInSincronyze);
        }
    }
    else{

        // Verificamos si la parada fue por un HW
        if (con.Dr6 & 1) {
            HWBySingleStep = HW_DR0;
        }
        else if(con.Dr6 & 2){
            HWBySingleStep = HW_DR1;
        }
        else if(con.Dr6 & 4){
            HWBySingleStep = HW_DR2;
        }
        else if(con.Dr6 & 8){
            HWBySingleStep = HW_DR3;
        }

        if (HWBySingleStep != 0) {
            UserStepIn = false;
            // el sigle step fue originado por un HW
            DisableBP(0); // Desactivamos todos los BPs para que si el usuario ve la memoria esta se muestre como debe
            ClearBMP(true); // reponemos las propiedades de la memoria

            Aux = con.Dr7;
            switch(HWBySingleStep){

                case HW_DR0:
                        HWAddress = con.Dr0;
                        Aux >>=  16;
                        break;
                case HW_DR1:
                        HWAddress = con.Dr1;
                        Aux >>=  20;
                        break;
                case HW_DR2:
                        HWAddress = con.Dr2;
                        Aux >>= 24;
                        break;
                case HW_DR3:
                        HWAddress = con.Dr3;
                        Aux >>= 28;
                        break;

            }
            Aux &= 3;
            if( Aux == 00){ // por ejecución
                LastHWMode = HW_EXECUTION;
            }
            else if(Aux ==01){
                LastHWMode = HW_WRITE;
            }
            else{
                LastHWMode = HW_ACCESS;
            }

            // llamar al usuario
            Synchronize(HardwareBreakPointSincronyze);


            switch(HWBySingleStep){

                case HW_DR0:

                    if(con.Dr0 == LastExceptionAddress){ // por ejecución

                        ItemHWRepair.Address = LastExceptionAddress;
                        ItemHWRepair.DrW = HW_DR0;
                        con.Dr0 = 0; // hay que guardar el dato
                        RepairHW=true;
                    }
                    break;
                case HW_DR1:
                    if(con.Dr1 == LastExceptionAddress){ // por ejecución

                        ItemHWRepair.Address = LastExceptionAddress;
                        ItemHWRepair.DrW = HW_DR1;

                        con.Dr1 = 0; // hay que guardar el dato
                        RepairHW= true;

                    }
                    break;
                case HW_DR2:
                    if(con.Dr2 == LastExceptionAddress){ // por ejecución

                        ItemHWRepair.Address = LastExceptionAddress;
                        ItemHWRepair.DrW = HW_DR2;

                        con.Dr2 = 0; // hay que guardar el dato
                        RepairHW= true;

                    }
                    break;
                case HW_DR3:
                    if(con.Dr3 == LastExceptionAddress){ // por ejecución

                        ItemHWRepair.Address = LastExceptionAddress;
                        ItemHWRepair.DrW = HW_DR3;

                        con.Dr3 = 0; // hay que guardar el dato
                        RepairHW= true;

                    }
                    break;
            }
            if(RepairHW== true){
                SetSingleStep();
            }

        }
        else if( UserStepIn == true){
            UserStepIn = false;
            DisableBP(0); // Desactivamos todos los BPs para que si el usuario ve la memoria esta se muestre como debe
            ClearBMP(true); // reponemos las propiedades de la memoria

            Synchronize(SingleStepInSincronyze);

        }

         if(ItemBMP.Address != NULL){  // La excepción no fue por un BMP
            SetBMP(ItemBMP.Address,ItemBMP.Size,ItemBMP.Mode);
        }

        // Reponemos los BPs
        for(int i=0; i < ListaBPs->Count;i++){
            BPaux = (TBP*)ListaBPs->Items[i];
            if(BPaux->estado == false){
                SetBP(BPaux->dir);
            }
        }
    }
    return DBG_CONTINUE; // exception continuation

} 


El caso es que no se si los valores a usar en x64 son diferentes a los que se usan en x32. ¿Pueden echarme una mano?

[aguml]

Pongo un HBP en el EntryPoint y la siguiente excepción que tengo es EXCEPTION_DEBUG_EVENT justo en la siguiente dirección, o sea mi EntryPoint es 0x0000000000403280 y la excepción se produce en 0x0000000000403281 que es justo el siguiente byte del binario. El codigo de error que obtengo es 0x00000000c0000005 que es un EXCEPTION_ACCESS_VIOLATION la pregunta es ¿por que me da ese error justo después del EntryPoint si mi HBP lo tengo puesto en el inicio de MessageBoxW?
No lo entiendo
No para en EXCEPTION_SINGLE_STEP que es donde debería parar para el hbp sino que da la excepción de acceso de violación nada más salir del evento del EntryPoint.
Si no pongo el HBP no da esa excepción 😭
Por favor échenme una mano, si quieren el proyecto para revisarlo... sin problema, es para compartirlo.
Ya no se que más probar, estoy en un punto muerto que no voy ni para atrás .

[aguml]

Nadie sabría cómo ayudarme con este tema? Es lo único que me falta para terminar 😥