cBreakpoint

I am AndrewThomas\Jetamay and thus I have authorized myself to post this here.



Project Download Link:
Look @ attachments








Warning : Hardware breakpoints, or any for that matter, can cause applications to crash if they're not handled safely.

Notice : Only compile this code in debug mode. When compiling this code in release mode, the optimization process screws it up a bit. Thus avoid compiling this in release mode if you plan to make use of hardware breakpoints. I am in the process of fixing this.

Notice : When running this application through a debugger, like the one provided in MSVS2003, hardware breakpoints will cause the EIP to freeze, along with registers, etc, however no exception is throw for it to be handled inside the debugger, thus the exception handler does not catch the exception, leaving the thread at a dead stand-still. This may only be a fault only in the software I am using to debug the class. Please report back about this.

Notice : This class was designed for 32 bit machines only, and an unexpected result may occur when used otherwise. Thus I have forced PC32BIT to be defined before you make use of the class. This is to inform all 64 bit users that the code they're running was not meant for their machine.

Notice : If you intend to use hardware breakpoints in hacks, make sure you're not overwriting breakpoints in the target's threads(if it makes use of them). Also assure that your target isn't scanning the thread's debug registers for protection purposes. If it is, you may have to write a local hook for the API.

Notice : Reffer to the constants defined below. There are two types of breakpoints defined below, global, and local, you are not able to set global breakpoints in the windows operating system, however I have included the global definition for the sake of education.
[highlight=cpp]const char CHWBP_BP_LOCAL = 0x01;
const char CHWBP_BP_GLOBAL = 0x02;[/highlight]

Notice : When setting INT3 breakpoints, the Breakpoint::bBpSize members MUST be 1 byte(CHWBP_BP_SIZE_1B), as well as Breakpoint::bBpType set to BpType_Execution, otherwise the method you passed this to will return error(-1).

Notice : When setting a hardware breakpoint on execution, the size MUST be 1 byte, otherwise the method you passed this to will return error(-1). I'm going to explain to you how the class I wrote(cBreakpoint) works, and how you can use it in your programs. Before asking questions about this post, please assure you've read on vectored exception handlers, Hardware breakpoints, and the first eight pages of the Intel Developers Manual Volume 3. As well as a basic understanding of bits and bitwise operators in C++, intermediate C++ knowledge, and an understanding of how the windows paging system and multi-threading system works.

bitTools.h

bitTools.h is a group of methods used to perform bitwise operations with ease. I included these methods so I could debug and write my class without having to worry if I set a bit incorrectly. It doesn't include all the operations, just the ones needed for the cBreakpoint class. As you will soon see, these methods could have been merged into a single function, while adding a flag param to determine which sort of bitwise operation to perform, but I decided, for organizations sake, I should leave them separated, you may merge them if you'd like. As you can see they're all templated, and because of this, their definition and body remain in a header file. The templating allows you to use various data types. They're all pretty self explanatory, if you need to me to explain, just say so.

Notice :Some characters may be hidden or removed by php tags. Refer to actual copy of source provided in download for use.
[highlight=cpp]
#pragma once

template<typename T>
int OrBit(T& inBuf, int shiftCount, T bitState, int bitBaseBits, bool inverse = false)
{
int bitShift = 0;
if(inverse)
{
int totalSize = sizeof(T) * 8;
bitShift = totalSize - shiftCount - bitBaseBits;
}else
bitShift = shiftCount;

T bitWord = bitState;

bitWord = bitWord<<bitShift;

inBuf = inBuf | bitWord;

return 1;
}

template<typename T>
int XorBit(T& inBuf, int shiftCount, T bitState, int bitBaseBits, bool inverse = false)
{
int bitShift = 0;
if(inverse)
{
int totalSize = sizeof(T) * 8;
bitShift = totalSize - shiftCount - bitBaseBits;
}else
bitShift = shiftCount;

T bitBuffer = bitState;

bitBuffer = bitWord<<bitShift;

inBuf = inBuf ^ bitBuffer;

return 1;
}

template<typename T>
int AndBit(T& inBuf, int shiftCount, T bitState, int bitBaseBits, bool inverse = false)
{
int bitShift = 0;
if(inverse)
{
int totalSize = sizeof(T) * 8;
bitShift = totalSize - shiftCount - bitBaseBits;
}else
bitShift = shiftCount;

T bitBuffer = bitState;

bitBuffer = bitBuffer<<bitShift;

inBuf = inBuf & bitBuffer;

return 1;
}

template<typename T>
int GetSetBitCount(T inBuf)
{
int size = sizeof(T) * 8;
int bitCount = 0;

T bitBuffer = inBuf;
for(unsigned int i = 0; i < size; i++)
{
if((bool) bitBuffer & 1)
bitCount++;

bitBuffer = inBuf<<1;
}

return bitCount;
}

template<typename T>
int IsBitSet(T inBuf, int bitCount)
{
T bitBuffer = 1;
bitBuffer = bitBuffer << bitCount;

T ret = inBuf & bitBuffer;
return (bool) ret;
}
[/highlight]