functions.h

#include <Windows.h>

#define jmp(frm, to) (int)(((int)to - (int)frm) - 5)




// don't do anything, it's not a functioni

DWORD ReadPointer1(CONST LPDWORD lpdwBase, CONST INT iOffset)

{

    __try { return *(LPDWORD)(*lpdwBase + iOffset); }

    __except (EXCEPTION_EXECUTE_HANDLER) { return NULL; }

}


//Reads a Pointer
unsigned long ReadPointer(unsigned long ulBase, int iOffset) //Now look at my read pointer.
{
   __try { return *(unsigned long*)(*(unsigned long*)ulBase + iOffset); }
   __except (EXCEPTION_EXECUTE_HANDLER) { return 0; }
}

//Reads Negative Pointers
int ReadNegativePointer(int ulBase, int iOffset)
{
   __try { return *(int*)(*(int*)ulBase + iOffset); }
   __except (EXCEPTION_EXECUTE_HANDLER) { return 0; }
}
//Writes a Pointer
bool WritePointer(unsigned long ulBase, int iOffset, int iValue)
{
   __try { *(int*)(*(unsigned long*)ulBase + iOffset) = iValue; return true; }
   __except (EXCEPTION_EXECUTE_HANDLER) { return false; }
}

unsigned long GetPointedAddress(unsigned long ulBase, int iOffset)
{
    __try { return *(unsigned long*)ulBase + iOffset; }
    __except (EXCEPTION_EXECUTE_HANDLER) { return 0; }
}


bool WriteValue(unsigned long ulBase, int iOffset, int iValue)
{
    __try { *(int*)(ulBase + iOffset) = iValue; return true; }
    __except (EXCEPTION_EXECUTE_HANDLER) { return false; }
}
//WritePointer Function
void Memory(PVOID address, void* val, int bytes)
{
    DWORD d, ds;
    VirtualProtect(address, bytes, PAGE_EXECUTE_READWRITE, &d);
    memcpy(address, val, bytes);
    VirtualProtect(address,bytes,d,&ds);
}

//waitn
void MakePageWritable(unsigned long ulAddress, unsigned long ulSize)
{
        MEMORY_BASIC_INFORMATION* mbi = new MEMORY_BASIC_INFORMATION;
        VirtualQuery((void*)ulAddress, mbi, ulSize);
        if (mbi->Protect != PAGE_EXECUTE_READWRITE)
        {
                unsigned long* ulProtect = new unsigned long;
                VirtualProtect((void*)ulAddress, ulSize, PAGE_EXECUTE_READWRITE, ulProtect);
      delete ulProtect;
        }

   delete mbi;
}



//CALL Function
bool Call(unsigned long ulAddress, void* Function, unsigned long ulNops)
        {
           __try
           {
          *(unsigned char*)ulAddress = 0xE8;
              *(unsigned long*)(ulAddress + 1) = jmp(ulAddress, Function);
          memset((void*)(ulAddress + 5), 0x90, ulNops);
              return true;
           }
           __except (EXCEPTION_EXECUTE_HANDLER) { return false; }
        }
//JMPCALL Function
        inline DWORD_PTR jmpcall(LPCVOID lpcvSrc, LPCVOID lpcvDest)
        {
           return reinterpret_cast<DWORD_PTR>(lpcvDest) - reinterpret_cast<DWORD_PTR>(lpcvSrc) - 5;
        }


//MakePageRWX Function
        bool MakePageRWX(LPCVOID lpcvMemory)
        {
           MEMORY_BASIC_INFORMATION mbiInfo;
           SecureZeroMemory(&mbiInfo, sizeof(MEMORY_BASIC_INFORMATION));

           if (VirtualQuery(lpcvMemory, &mbiInfo, sizeof(mbiInfo)) == 0)
              return false;

           if (mbiInfo.Protect != PAGE_EXECUTE_READWRITE)
           {
              DWORD dwProtect = 0;
              return (VirtualProtect(const_cast<LPVOID>(lpcvMemory), mbiInfo.RegionSize, PAGE_EXECUTE_READWRITE, &dwProtect) != FALSE);
           }

           return true;
        }




//JUMPCALL Function
        bool JumpCall(bool fJump, const LPBYTE lpbAddress, LPCVOID lpcvHook, const LPBYTE lpbBuffer, size_t cNops)
        {
           if (MakePageRWX(reinterpret_cast<LPCVOID>(lpbAddress)))
           {
              if (lpbBuffer != NULL)
                 memcpy(reinterpret_cast<void*>(lpbBuffer), reinterpret_cast<const void*>(lpbAddress), cNops + 5);

              *lpbAddress = (fJump ? 0xE9 : 0xE8);
              *reinterpret_cast<LPDWORD>(lpbAddress + 1) = jmpcall(lpbAddress, lpcvHook);

              if (cNops)
                 memset(reinterpret_cast<void*>(lpbAddress + 5), 0x90, cNops);

              return true;
           }

           return false;
        }


        void WriteMemory( unsigned long ulAddress, unsigned char ucAmount, ...)
{
   //MakePageWritable(ulAddress, (unsigned long)ucAmount); //Make memory writable before any modifications are attempted
     DWORD dwOldProtect;
     VirtualProtect((void*)ulAddress, ucAmount, PAGE_EXECUTE_READWRITE, &dwOldProtect);//Unprotect memory

   va_list* va = new va_list;
   va_start(*va, ucAmount);

   for (unsigned char ByteToWrite = va_arg(*va, unsigned char), ucIndex = 0; ucIndex < ucAmount; ucIndex++, ByteToWrite = va_arg(*va, unsigned char))
   {
      *(unsigned char*)(ulAddress + ucIndex) = ByteToWrite;
   }

   va_end(*va);
   delete va;

   VirtualProtect((void*)ulAddress, ucAmount, dwOldProtect, &dwOldProtect);//revert back to the original.
}