Warrock - Code Snippets

#pragma once

#include <system_error>
#include <utility> 
#include <Windows.h>
#include <excpt.h>
#include <eh.h>

class seh_exception : public std::system_error
{
	EXCEPTION_POINTERS *_ep;

	static __declspec(thread) _se_translator_function _old_translator;

	static void translator(unsigned int code, EXCEPTION_POINTERS *ep);
	seh_exception(unsigned int code, EXCEPTION_POINTERS *ep);

public:
	static void enable_for_this_thread();
	static void disable_for_this_thread();
	static bool is_enabled_for_this_thread();
	static void ignore(const seh_exception &e);
	
	template <typename TryBlock, typename CatchBlock = decltype(&ignore)>
	static bool handle(TryBlock &&try_block, CatchBlock &&catch_block = &ignore);

	virtual ~seh_exception();
	virtual const char *what() const override;
	virtual EXCEPTION_POINTERS *exception_pointers() const;
};

template <typename TryBlock, typename CatchBlock>
bool seh_exception::handle(TryBlock &&try_block, CatchBlock &&catch_block)
{
	bool was_enabled = seh_exception::is_enabled_for_this_thread();

	try
	{
		seh_exception::enable_for_this_thread();

		std::forward<TryBlock>(try_block)();
		return true;
	}
	catch(const seh_exception &e)
	{
		std::forward<CatchBlock>(catch_block)(e);
	
		if (!was_enabled)
			seh_exception::disable_for_this_thread();

		return false;
	}
	catch(...)
	{
		if (!was_enabled)
			seh_exception::disable_for_this_thread();
		throw;
	}
}

#include "seh_exception"

__declspec(thread) _se_translator_function seh_exception::_old_translator = &seh_exception::translator;

void seh_exception::translator(unsigned int code, EXCEPTION_POINTERS *ep)
{
	throw seh_exception(code, ep);
}

seh_exception::seh_exception(unsigned int code, EXCEPTION_POINTERS *ep) 
	: _ep(ep), std::system_error(code, std::generic_category())
{
}

void seh_exception::enable_for_this_thread()
{
	if (!is_enabled_for_this_thread())
		_old_translator = _set_se_translator(&translator);
}

void seh_exception::disable_for_this_thread()
{
	if (is_enabled_for_this_thread())
		_old_translator = _set_se_translator(_old_translator);
}

bool seh_exception::is_enabled_for_this_thread()
{
	return _old_translator != &translator;
}

void seh_exception::ignore(const seh_exception &)
{ 
}

seh_exception::~seh_exception()
{
}

const char *seh_exception::what() const
{
	return "seh_exception";
}

EXCEPTION_POINTERS *seh_exception::exception_pointers() const 
{
	return _ep;
}

#include <iostream>
#include "seh_exception.h"

int main(int argc, char *argv[])
{
	seh_exception::handle([]
	{
		int *p = nullptr;
		*p = 1; // raise EXCEPTION_ACCESS_VIOLATION
	}, [](const seh_exception &e)
	{
		std::cerr << e.code().value() << std::endl;
	});

	// keep cmd.exe alive
	std::cin.get();
	
	return 0;
}

// solange der cheat aktiv ist
while(cheat_is_enabled())
{
	// warte, bis der spieler ingame ist
	wait_until_player_is_ingame();

	// führe die player cheats aus
	player_cheats(); 
}

// solange der cheat aktiv ist
while(cheat_is_enabled())
{
	// warte, bis der spieler ingame ist
	wait_until_player_is_ingame();

	// jetzt kommt der spannende trick
	seh_exception::handle([]
	{
		// rufe player_cheats auf und breche bei einer seh_exception ab
		player_cheats();
	}, [](const seh_exception &err) 
	{
		// das wird aufgerufen, wenn eine seh_exception stattgefunden hat
		write_to_log(err.what());
	});
}

void CzytajFunkcjeMemory(void *adr, void *ptr, int size)
{
        DWORD dwback;
        VirtualProtect(adr,size,PAGE_EXECUTE_READWRITE, &dwback);
        memcpy(adr,ptr,size);
        VirtualProtect(adr,size,dwback, &dwback);
}
template <typename T>void WriteMEM(void* adr,T Vaule,T *Input = NULL)
{
        if(Input == 0)
                CzytajFunkcjeMemory((void*)adr,(void*)&Vaule,sizeof(T));
        else
                CzytajFunkcjeMemory((void*)Input,(void*)adr,sizeof(T));
}
void ObejsciePrzeciwAntyCheata (void)
{   
		int CzytajEhSvc;
		do
		{
			CzytajEhSvc = (int)GetModuleHandle("EhSvc.dll");
			Sleep(1000);
		}
		while(!CzytajEhSvc);
			CzytajFunkcjeMemory((void*)(CzytajEhSvc+0x008518E),(void *)"\xC2\x04\x00", 3);
			CzytajFunkcjeMemory((void*)(CzytajEhSvc+0x00A1A0),(void *)"\xC2\x04\x00", 3); 
			CzytajFunkcjeMemory((void*)0x5DA1BC, (void*)"\xC3", 1);
}

switch ( pPlayerHacks->WalkHeight )
			{
			default : MakeFloat(0x8C89A4,40.0f);break;
			case 1: MakeFloat(0x8C89A4,70.0f);break;
			case 2: MakeFloat(0x8C89A4,100.0f);break;
			case 3: MakeFloat(0x8C89A4,150.0f);break;
			case 4: MakeFloat(0x8C89A4,200.0f);break;
			case 5: MakeFloat(0x8C89A4,300.0f);break;

			}

oO ist VirtualJump other coders found it since 3years xD :)