BanMe
August 2nd, 2010, 10:34
So this is my first real class,and I dont want to HAVE to use mscrt et al.
I dont want the code that uses my code to use new or delete so thats how this is built..
I wanted to be able to manage both local and remote threads also both User threads(ones that connect to User32) and Native Threads(the ones in a console app)...
*removed* old code...
I dont want the code that uses my code to use new or delete so thats how this is built..
I wanted to be able to manage both local and remote threads also both User threads(ones that connect to User32) and Native Threads(the ones in a console app)...
*removed* old code...
Code:
//Thread Manager Class..experimenting with 'Self Contained' classes
//Currently this can only manage 0x4b0 /0xc = 100 threads
class ThreadManager {
public:
//no need for new or delete operators...
ThreadManager() {
_ThisHeap = HeapCreate(HEAP_ZERO_MEMORY|HEAP_GROWABLE,0x4b0,0);
_ThisThreadHeap = HeapAlloc(_Heap,0,0x4b0);
memset(_ThisThreadHeap,INVALID_HANDLE_VALUE,0x4b0);
}
~ThreadManager() {
for(ULONG i = 0;i < _CurrentIndex;i++)
{
if(getThisHeapThreadHandle(i) != INVALID_HANDLE_VALUE)
{
if(!::CloseHandle(getThisThreadHandle(i)))
{
return;
}
}
}
::HeapFree(_ThisHeap,0,_ThisThreadHeap);
::HeapDestroy(_ThisHeap);
}
HANDLE OpenThisThread(ULONG ThreadId){
Index = IsThisThreadManaged(ThreadId);
if(Index)
{
if(getThisHeapThreadHandle(Index) == INVALID_HANDLE_VALUE)
{
if(!dbgEnabled)
{
if(!NT_SUCCESS(::RtlAdjustPrivilege(20L,true,false,&dbgEnabled)))
{
return INVALID_HANDLE_VALUE;
}
}
_threadHandle = ::OpenThread(THREAD_ALL_ACCESS,false,ThreadId);
if(_threadHandle != INVALID_HANDLE_VALUE)
{
setThisHeapThreadHandle(Index,_threadHandle);
return _threadHandle;
}
else
{
return INVALID_HANDLE_VALUE;
}
}
else
{
return getThisHeapThreadHandle(Index);
}
}
else
{
if(!dbgEnabled)
{
if(!NT_SUCCESS(::RtlAdjustPrivilege(20L,true,false,&dbgEnabled)))
{
return INVALID_HANDLE_VALUE;
}
}
_threadHandle = ::OpenThread(THREAD_ALL_ACCESS,false,ThreadId);
if(_threadHandle != INVALID_HANDLE_VALUE)
{
setThisHeapThreadId(_CurrentIndex,ThreadId);
setThisHeapThreadHandle(_CurrentIndex,_threadHandle);
_CurrentIndex++;
_NextIndex++;
return _threadHandle;
}
else
{
return INVALID_HANDLE_VALUE;
}
}
}
HANDLE CreateThisThread(bool CreateSuspended,bool IsUserThread,HANDLE ThisProcess,ULONG Start,PVOID Param){
if(IsUserThread)
{
if(CreateSuspended)
{
setThisHeapThreadHandle(_CurrentIndex,::CreateThread(0,0x4096,(LPTHREAD_START_ROUTINE)Start,Param,CR EATE_SUSPENED,&getThisHeapThreadAddress(Index)));
_CurrentIndex++;
_NextIndex++;
return getThisHeapThreadHandle(_CurrentIndex - 1);
}
else
{
setThisHeapThreadHandle(_CurrentIndex,::CreateThread(0,0x4096,(LPTHREAD_START_ROUTINE)Start,Param,0,&getThisHeapThreadAddress(Index)));
_CurrentIndex++;
_NextIndex++;
return getThisHeapThreadHandle(_CurrentIndex - 1);
}
}
else
{
if(CreateSuspended)
{
if(NT_SUCCESS(::RtlCreateUserThread(ThisProcess,0,TRUE,0,0,0,(PUSER_THREAD_START_ROUTINE)Start,Param ,&getThisHeapHandleAddress(_CurrentIndex),0)))
{
_CurrentIndex++;
_NextIndex++;
return getThisHeapThreadHandle(_CurrentIndex - 1);
}
return INVALID_HANDLE_VALUE;
}
else
{
if(NT_SUCCESS(::RtlCreateUserThread(ThisProcess,0,FALSE,0,0,0,(PUSER_THREAD_START_ROUTINE)Start,Para m,&getThisHeapHandleAddress(_CurrentIndex),0)))
{
_CurrentIndex++;
_NextIndex++;
return getThisHeapThreadHandle(_CurrentIndex - 1);
}
return INVALID_HANDLE_VALUE;
}
}
}
bool SuspendThisThread(){
if(::SuspendThread(getThisHeapThreadHandle(_CurrentIndex)) == -1)
{
return false;
}
return true;
}
bool ResumeThisThread(){
if(::ResumeThread(getThisHeapThreadHandle(_CurrentIndex)) == -1)
{
return false;
}
return true;
}
bool ResumeThisThreadById(ULONG ThreadId){
Index = IsThisThreadManaged(ThreadId);
if(Index)
{
if(::ResumeThread(getThisHeapThreadHandle(Index)) == - 1)
{
return false;
}
return true;
}
else
{
_threadHandle = OpenThisThread(ThreadId);
if(_threadHandle != INVALID_HANDLE_VALUE)
{
if(::ResumeThread(_threadHandle) == -1)
{
return false;
}
return true;
}
return false;
}
}
bool SuspendThisThreadById(ULONG ThreadId){
Index = IsThisThreadManaged(ThreadId);
if(Index)
{
if(::SuspendThread(getThisHeapThreadHandle(Index)) == - 1)
{
return false;
}
return true;
}
else
{
_threadHandle = OpenThisThread(ThreadId);
if(_threadHandle != INVALID_HANDLE_VALUE)
{
if(::SuspendThread(_threadHandle) == -1)
{
return false;
}
return true;
}
return false;
}
}
bool getContext(ULONG ThreadId){
Index = IsThisThreadManaged(ThreadId);
if(Index)
{
if(getThisHeapThreadHandle(Index) != INVALID_HANDLE_VALUE)
{
if(::GetThreadContext(getThisHeapThreadHandle(Index),&_context) != TRUE)
{
return false;
}
return true;
}
else
{
_threadHandle = OpenThisThread(ThreadId);
if(_threadHandle != INVALID_HANDLE_VALUE)
{
if(::GetThreadContext(_threadHandle, &Context) != TRUE)
{
- return false;
}
return true;
}
return false;
}
}
else
{
_threadHandle = OpenThisThread(ThreadId);
if(_threadHandle != INVALID_HANDLE_VALUE)
{
if(::GetThreadContext(_threadHandle, &Context) != TRUE)
{
return false;
}
return true;
}
return false;
}
}
bool setContext(ULONG ThreadId,CONTEXT *_ccontext){
Index = IsThisThreadManaged(ThreadId);
if(Index)
{
if(getThisHeapThreadHandle(Index) != INVALID_HANDLE_VALUE)
{
if(::SetThreadContext(getThisHeapThreadHandle(Index),&_ccontext) != TRUE)
{
return false;
}
return true;
}
else
{
_threadHandle = OpenThisThread(ThreadId);
if(::SetThreadContext(_threadHandle,&_ccontext) != TRUE)
{
return false;
}
return true;
}
}
else
{
_threadHandle = OpenThisThread(ThreadId);
if(::SetThreadContext(_threadHandle,&_ccontext) != TRUE)
{
return false;
}
return true;
}
}
ULONG getThisHeapThreadId(ULONG Index){
return (*(ULONG*)((ULONG)_threadHandleHeap + (Index * 0xc)+0x4));
}
ULONG IsThisThreadManaged(ULONG ThreadId){
Index = 0;
do
{
if(getThisHeapThreadId(Index) == ThreadId)
{
return Index;
}
Index++;
}while(Index <= CurrentIndex);
return Index > 0 ? 0:0;
}
HANDLE getThisHeapThreadHandle(ULONG Index){
return ((HANDLE)*(ULONG*)((ULONG)_threadHandleHeap + (Index *0xc)+0x8));
}
void setThisHeapThreadId(ULONG Index,ULONG ThreadId) {
*(ULONG*)((ULONG)_threadHandleHeap + (Index * 0xc)+0x4) = ThreadId;
}
void setThisHeapThreadHandle(ULONG Index,ULONG ThreadHandle) {
*(ULONG*)((ULONG)_threadHandleHeap + (Index * 0xc)+0x8) = ThreadHandle;
}
ULONG getThisHeapThreadAddress(ULONG Index){
return ((ULONG)_threadHandleHeap + (Index * 0xc)+0x4);
}
ULONG getThisHeapHandleAddress(ULONG Index){
return ((ULONG)_threadHandleHeap + (Index * 0xc)+0x8);
}
protected:
NSTATUS _status = 0;
ULONG Index = 0,_CurrentIndex = 0,_NextIndex = 1;
PVOID _ThisHeap, _ThisThreadHeap;
HANDE _threadHandle = INVALID_HANDLE_VALUE;
int _dbgEnabled = 0;
CONTEXT _context;
};