WardenWin Class Reference

#include "WardenWin.h"

Inheritance diagram for WardenWin:

Public Member Functions
	WardenWin ()
	~WardenWin () override
void	Init (WorldSession *session, SessionKey const &K) override
ClientWardenModule *	GetModuleForClient () override
void	InitializeModule () override
void	RequestHash () override
void	HandleHashResult (ByteBuffer &buff) override
void	RequestChecks () override
bool	IsCheckInProgress () override
	Gets the warden check state.
void	ForceChecks () override
	Force call RequestChecks() so they are sent immediately, this interrupts warden and breaks result.
void	HandleData (ByteBuffer &buff) override
Public Member Functions inherited from Warden
	Warden ()
virtual	~Warden ()
virtual bool	IsInitialized ()
bool	ProcessLuaCheckResponse (std::string const &msg)
void	SendModuleToClient ()
void	RequestModule ()
void	Update (uint32 const diff)
void	DecryptData (uint8 *buffer, uint32 length)
void	EncryptData (uint8 *buffer, uint32 length)
void	ApplyPenalty (uint16 checkId, std::string const &reason)
WardenPayloadMgr *	GetPayloadMgr ()

Private Member Functions
std::vector< uint8 >	GetExpectedResult (WardenCheck const &check) const

Private Attributes
uint32	_serverTicks
std::list< uint16 >	_ChecksTodo [MAX_WARDEN_CHECK_TYPES]
std::list< uint16 >	_CurrentChecks
std::list< uint16 >	_PendingChecks

Additional Inherited Members
Static Public Member Functions inherited from Warden
static bool	IsValidCheckSum (uint32 checksum, uint8 const *data, const uint16 length)
static uint32	BuildChecksum (uint8 const *data, uint32 length)

Detailed Description

Constructor & Destructor Documentation

WardenWin()

WardenWin::WardenWin

(

)

: Warden(), _serverTicks(0) { }

~WardenWin()

WardenWin::~WardenWin ( )

overridedefault

Member Function Documentation

ForceChecks()

void WardenWin::ForceChecks ( )

overridevirtual

Force call RequestChecks() so they are sent immediately, this interrupts warden and breaks result.

Implements Warden.

{
    if (_dataSent)
    {
        _interrupted = true;
        _interruptCounter++;
    }
 
    RequestChecks();
}

References Warden::_dataSent, Warden::_interruptCounter, Warden::_interrupted, and RequestChecks().

GetExpectedResult()

std::vector< uint8 > WardenWin::GetExpectedResult ( WardenCheck const &  check ) const

private

{
    std::size_t const length = check.Type == MPQ_CHECK
        ? Acore::Crypto::Constants::SHA1_DIGEST_LENGTH_BYTES : check.Length;
 
    std::vector<uint8> expected;
    if (sScriptMgr->OnWardenCheckExpectedResult(_session, check, expected))
    {
        if (expected.size() == length)
            return expected;
 
        LOG_ERROR("warden", "Script returned {} expected bytes for CheckId {}, {} required, using the stored result",
            expected.size(), check.CheckId, length);
    }
 
    // BigNumber drops leading zero bytes, pad to the check length so the comparison stays in bounds.
    return sWardenCheckMgr->GetWardenResultById(check.CheckId)->Result.ToByteVector(static_cast<int32>(length), false);
}

References Warden::_session, WardenCheck::CheckId, WardenCheck::Length, LOG_ERROR, MPQ_CHECK, Acore::Crypto::Constants::SHA1_DIGEST_LENGTH_BYTES, sScriptMgr, sWardenCheckMgr, and WardenCheck::Type.

Referenced by HandleData().

GetModuleForClient()

ClientWardenModule * WardenWin::GetModuleForClient ( )

overridevirtual

Implements Warden.

{
    auto mod = new ClientWardenModule;
 
    uint32 length = sizeof(Module.Module);
 
    // data assign
    mod->CompressedSize = length;
    mod->CompressedData = new uint8[length];
    memcpy(mod->CompressedData, Module.Module, length);
    memcpy(mod->Key.data(), Module.ModuleKey, 16);
 
    // md5 hash
    mod->Id = Acore::Crypto::MD5::GetDigestOf(mod->CompressedData, mod->CompressedSize);
 
    return mod;
}

References ClientWardenModule::CompressedSize, Acore::Impl::GenericHash< HashCreator, DigestLength >::GetDigestOf(), Module_79C0768D657977D697E10BAD956CCED1::Module, Module, and Module_79C0768D657977D697E10BAD956CCED1::ModuleKey.

Referenced by Init().

HandleData()

void WardenWin::HandleData ( ByteBuffer &  buff )

overridevirtual

Todo:

: test it.

Implements Warden.

{
    LOG_DEBUG("warden", "Handle data");
 
    _dataSent = false;
    _clientResponseTimer = 0;
 
    uint16 Length;
    buff >> Length;
    uint32 Checksum;
    buff >> Checksum;
 
    if (Length != (buff.size() - buff.rpos()))
    {
        buff.rfinish();
 
        if (!_interrupted)
        {
            ApplyPenalty(0, "Failed size checks in HandleData");
        }
 
        return;
    }
 
    if (!IsValidCheckSum(Checksum, buff.contents() + buff.rpos(), Length))
    {
        buff.rpos(buff.wpos());
        LOG_DEBUG("warden", "CHECKSUM FAIL");
 
        if (!_interrupted)
        {
            ApplyPenalty(0, "Failed checksum in HandleData");
        }
 
        return;
    }
 
    // TIMING_CHECK
    {
        uint8 result;
        buff >> result;
        if (result == 0x00)
        {
            LOG_DEBUG("warden", "TIMING CHECK FAIL result 0x00");
            // ApplyPenalty(0, "TIMING CHECK FAIL result"); Commented out because of too many false postives. Mostly caused by client stutter.
            return;
        }
 
        uint32 newClientTicks;
        buff >> newClientTicks;
 
        uint32 ticksNow = GameTime::GetGameTimeMS().count();
        uint32 ourTicks = newClientTicks + (ticksNow - _serverTicks);
 
        LOG_DEBUG("warden", "ServerTicks {}", ticksNow);         // Now
        LOG_DEBUG("warden", "RequestTicks {}", _serverTicks);    // At request
        LOG_DEBUG("warden", "Ticks {}", newClientTicks);         // At response
        LOG_DEBUG("warden", "Ticks diff {}", ourTicks - newClientTicks);
    }
 
    uint16 checkFailed = 0;
 
    for (uint16 const checkId : _CurrentChecks)
    {
        WardenCheck const* rd = sWardenCheckMgr->GetWardenDataById(checkId);
 
        // Custom payload should be loaded in if equal to over offset.
        if (!rd && checkId >= WardenPayloadMgr::WardenPayloadOffsetMin)
        {
            rd = &_payloadMgr.CachedChecks.at(checkId);
        }
 
        uint8 const type = rd->Type;
        switch (type)
        {
        case MEM_CHECK:
        {
            uint8 Mem_Result;
            buff >> Mem_Result;
 
            if (Mem_Result != 0)
            {
                LOG_DEBUG("warden", "RESULT MEM_CHECK not 0x00, CheckId {} account Id {}", checkId, _session->GetAccountId());
                checkFailed = checkId;
                continue;
            }
 
            std::vector<uint8> const expected = GetExpectedResult(*rd);
            if (CRYPTO_memcmp(buff.contents() + buff.rpos(), expected.data(), rd->Length) != 0)
            {
                LOG_DEBUG("warden", "RESULT MEM_CHECK fail CheckId {} account Id {} locale {}", checkId,
                    _session->GetAccountId(), GetNameByLocaleConstant(_session->GetSessionDbLocaleIndex()));
                checkFailed = checkId;
                buff.rpos(buff.rpos() + rd->Length);
                continue;
            }
 
            buff.rpos(buff.rpos() + rd->Length);
            LOG_DEBUG("warden", "RESULT MEM_CHECK passed CheckId {} account Id {}", checkId, _session->GetAccountId());
            break;
        }
        case PAGE_CHECK_A:
        case PAGE_CHECK_B:
        case DRIVER_CHECK:
        case MODULE_CHECK:
        {
            uint8 const byte = 0xE9;
            if (CRYPTO_memcmp(buff.contents() + buff.rpos(), &byte, sizeof(uint8)) != 0)
            {
                if (type == PAGE_CHECK_A || type == PAGE_CHECK_B)
                {
                    LOG_DEBUG("warden", "RESULT PAGE_CHECK fail, CheckId {} account Id {}", checkId, _session->GetAccountId());
                }
 
                if (type == MODULE_CHECK)
                {
                    LOG_DEBUG("warden", "RESULT MODULE_CHECK fail, CheckId {} account Id {}", checkId, _session->GetAccountId());
                }
 
                if (type == DRIVER_CHECK)
                {
                    LOG_DEBUG("warden", "RESULT DRIVER_CHECK fail, CheckId {} account Id {}", checkId, _session->GetAccountId());
                }
 
                checkFailed = checkId;
                buff.rpos(buff.rpos() + 1);
                continue;
            }
 
            buff.rpos(buff.rpos() + 1);
 
            if (type == PAGE_CHECK_A || type == PAGE_CHECK_B)
            {
                LOG_DEBUG("warden", "RESULT PAGE_CHECK passed CheckId {} account Id {}", checkId, _session->GetAccountId());
            }
            else if (type == MODULE_CHECK)
            {
                LOG_DEBUG("warden", "RESULT MODULE_CHECK passed CheckId {} account Id {}", checkId, _session->GetAccountId());
            }
            else if (type == DRIVER_CHECK)
            {
                LOG_DEBUG("warden", "RESULT DRIVER_CHECK passed CheckId {} account Id {}", checkId, _session->GetAccountId());
            }
            break;
        }
        case LUA_EVAL_CHECK:
        {
            uint8 const result = buff.read<uint8>();
 
            if (result == 0)
            {
                buff.read_skip(buff.read<uint8>()); // discard attached string
            }
 
            LOG_DEBUG("warden", "LUA_EVAL_CHECK CheckId {} account Id {} got in-warden dummy response", checkId, _session->GetAccountId()/* , result */);
            break;
        }
        case MPQ_CHECK:
        {
            uint8 Mpq_Result;
            buff >> Mpq_Result;
 
            if (Mpq_Result != 0)
            {
                LOG_DEBUG("warden", "RESULT MPQ_CHECK not 0x00 account id {}", _session->GetAccountId());
                checkFailed = checkId;
                continue;
            }
 
            std::vector<uint8> const expected = GetExpectedResult(*rd);
            if (CRYPTO_memcmp(buff.contents() + buff.rpos(), expected.data(),
                Acore::Crypto::Constants::SHA1_DIGEST_LENGTH_BYTES) != 0)
            {
                LOG_DEBUG("warden", "RESULT MPQ_CHECK fail, CheckId {} account Id {} locale {}", checkId,
                    _session->GetAccountId(), GetNameByLocaleConstant(_session->GetSessionDbLocaleIndex()));
                checkFailed = checkId;
                buff.rpos(buff.rpos() + Acore::Crypto::Constants::SHA1_DIGEST_LENGTH_BYTES);            // 20 bytes SHA1
                continue;
            }
 
            buff.rpos(buff.rpos() + Acore::Crypto::Constants::SHA1_DIGEST_LENGTH_BYTES);                // 20 bytes SHA1
            LOG_DEBUG("warden", "RESULT MPQ_CHECK passed, CheckId {} account Id {}", checkId, _session->GetAccountId());
            break;
        }
        }
    }
 
    if (checkFailed > 0 && !_interrupted)
    {
        ApplyPenalty(checkFailed, "");
    }
 
    if (_interrupted)
    {
        LOG_DEBUG("warden", "Warden was interrupted by ForceChecks, ignoring results.");
 
        _interruptCounter--;
 
        if (_interruptCounter == 0)
        {
            _interrupted = false;
        }
    }
 
    // Set hold off timer, minimum timer should at least be 1 second
    uint32 const holdOff = sWorld->getIntConfig(CONFIG_WARDEN_CLIENT_CHECK_HOLDOFF);
    _checkTimer = (holdOff < 1 ? 1 : holdOff) * IN_MILLISECONDS;
 
    _checkInProgress = false;
}

References Warden::_checkInProgress, Warden::_checkTimer, Warden::_clientResponseTimer, _CurrentChecks, Warden::_dataSent, Warden::_interruptCounter, Warden::_interrupted, Warden::_payloadMgr, _serverTicks, Warden::_session, Warden::ApplyPenalty(), WardenPayloadMgr::CachedChecks, CONFIG_WARDEN_CLIENT_CHECK_HOLDOFF, ByteBuffer::contents(), DRIVER_CHECK, WorldSession::GetAccountId(), GetExpectedResult(), GameTime::GetGameTimeMS(), GetNameByLocaleConstant(), WorldSession::GetSessionDbLocaleIndex(), IN_MILLISECONDS, Warden::IsValidCheckSum(), WardenCheck::Length, LOG_DEBUG, LUA_EVAL_CHECK, MEM_CHECK, MODULE_CHECK, MPQ_CHECK, PAGE_CHECK_A, PAGE_CHECK_B, ByteBuffer::read(), ByteBuffer::read_skip(), ByteBuffer::rfinish(), ByteBuffer::rpos(), Acore::Crypto::Constants::SHA1_DIGEST_LENGTH_BYTES, ByteBuffer::size(), sWardenCheckMgr, sWorld, WardenCheck::Type, WardenPayloadMgr::WardenPayloadOffsetMin, and ByteBuffer::wpos().

HandleHashResult()

void WardenWin::HandleHashResult ( ByteBuffer &  buff )

overridevirtual

Implements Warden.

{
    buff.rpos(buff.wpos());
 
    // Verify key using constant-time comparison
    if (CRYPTO_memcmp(buff.contents() + 1, Module.ClientKeySeedHash, Acore::Crypto::Constants::SHA1_DIGEST_LENGTH_BYTES) != 0)
    {
        LOG_DEBUG("warden", "Request hash reply: failed");
        ApplyPenalty(0, "Request hash reply: failed");
        return;
    }
 
    LOG_DEBUG("warden", "Request hash reply: succeed");
 
    // Change keys here
    memcpy(_inputKey, Module.ClientKeySeed, 16);
    memcpy(_outputKey, Module.ServerKeySeed, 16);
 
    _inputCrypto.Init(_inputKey);
    _outputCrypto.Init(_outputKey);
 
    _initialized = true;
}

References Warden::_initialized, Warden::_inputCrypto, Warden::_inputKey, Warden::_outputCrypto, Warden::_outputKey, Warden::ApplyPenalty(), Module_79C0768D657977D697E10BAD956CCED1::ClientKeySeed, Module_79C0768D657977D697E10BAD956CCED1::ClientKeySeedHash, ByteBuffer::contents(), Acore::Crypto::ARC4::Init(), LOG_DEBUG, Module, ByteBuffer::rpos(), Module_79C0768D657977D697E10BAD956CCED1::ServerKeySeed, Acore::Crypto::Constants::SHA1_DIGEST_LENGTH_BYTES, and ByteBuffer::wpos().

Init()

void WardenWin::Init ( WorldSession *  session, SessionKey const &  K  )

overridevirtual

Implements Warden.

{
    _session = session;
    // Generate Warden Key
    SessionKeyGenerator<Acore::Crypto::SHA1> WK(k);
    WK.Generate(_inputKey, 16);
    WK.Generate(_outputKey, 16);
 
    memcpy(_seed, Module.Seed, 16);
 
    _inputCrypto.Init(_inputKey);
    _outputCrypto.Init(_outputKey);
    LOG_DEBUG("warden", "Server side warden for client {} initializing...", session->GetAccountId());
    LOG_DEBUG("warden", "C->S Key: {}", Acore::Impl::ByteArrayToHexStr(_inputKey, 16));
    LOG_DEBUG("warden", "S->C Key: {}", Acore::Impl::ByteArrayToHexStr(_outputKey,16));
    LOG_DEBUG("warden", "  Seed: {}", Acore::Impl::ByteArrayToHexStr(_seed, 16));
    LOG_DEBUG("warden", "Loading Module...");
 
    _module = GetModuleForClient();
 
    LOG_DEBUG("warden", "Module Key: {}", ByteArrayToHexStr(_module->Key));
    LOG_DEBUG("warden", "Module ID: {}", ByteArrayToHexStr(_module->Id));
    RequestModule();
}

References Warden::_inputCrypto, Warden::_inputKey, Warden::_module, Warden::_outputCrypto, Warden::_outputKey, Warden::_seed, Warden::_session, ByteArrayToHexStr(), Acore::Impl::ByteArrayToHexStr(), SessionKeyGenerator< Hash >::Generate(), WorldSession::GetAccountId(), GetModuleForClient(), ClientWardenModule::Id, Acore::Crypto::ARC4::Init(), ClientWardenModule::Key, LOG_DEBUG, Module, Warden::RequestModule(), and Module_79C0768D657977D697E10BAD956CCED1::Seed.

InitializeModule()

void WardenWin::InitializeModule ( )

overridevirtual

Implements Warden.

{
    LOG_DEBUG("warden", "Initialize module");
 
    // Create packet structure
    WardenInitModuleRequest Request{};
    Request.Command1 = WARDEN_SMSG_MODULE_INITIALIZE;
    Request.Size1 = 20;
    Request.Unk1 = 1;
    Request.Unk2 = 0;
    Request.Type = 1;
    Request.String_library1 = 0;
    Request.Function1[0] = 0x00024F80;                      // 0x00400000 + 0x00024F80 SFileOpenFile
    Request.Function1[1] = 0x000218C0;                      // 0x00400000 + 0x000218C0 SFileGetFileSize
    Request.Function1[2] = 0x00022530;                      // 0x00400000 + 0x00022530 SFileReadFile
    Request.Function1[3] = 0x00022910;                      // 0x00400000 + 0x00022910 SFileCloseFile
    Request.CheckSumm1 = BuildChecksum(&Request.Unk1, Acore::Crypto::Constants::SHA1_DIGEST_LENGTH_BYTES);
 
    Request.Command2 = WARDEN_SMSG_MODULE_INITIALIZE;
    Request.Size2 = 8;
    Request.Unk3 = 4;
    Request.Unk4 = 0;
    Request.String_library2 = 0;
    Request.Function2 = 0x00419210;                         // 0x00400000 + 0x00419210 FrameScript::Execute
    Request.Function2_set = 1;
    Request.CheckSumm2 = BuildChecksum(&Request.Unk3, 8);
 
    Request.Command3 = WARDEN_SMSG_MODULE_INITIALIZE;
    Request.Size3 = 8;
    Request.Unk5 = 1;
    Request.Unk6 = 1;
    Request.String_library3 = 0;
    Request.Function3 = 0x0046AE20;                         // 0x00400000 + 0x0046AE20 PerformanceCounter
    Request.Function3_set = 1;
    Request.CheckSumm3 = BuildChecksum(&Request.Unk5, 8);
 
    EndianConvert(Request.Size1);
    EndianConvert(Request.CheckSumm1);
    EndianConvert(Request.Function1[0]);
    EndianConvert(Request.Function1[1]);
    EndianConvert(Request.Function1[2]);
    EndianConvert(Request.Function1[3]);
    EndianConvert(Request.Size2);
    EndianConvert(Request.CheckSumm2);
    EndianConvert(Request.Function2);
    EndianConvert(Request.Size3);
    EndianConvert(Request.CheckSumm3);
    EndianConvert(Request.Function3);
 
    // Encrypt with warden RC4 key.
    EncryptData(reinterpret_cast<uint8*>(&Request), sizeof(WardenInitModuleRequest));
 
    WorldPacket pkt(SMSG_WARDEN_DATA, sizeof(WardenInitModuleRequest));
    pkt.append(reinterpret_cast<uint8*>(&Request), sizeof(WardenInitModuleRequest));
    _session->SendPacket(&pkt);
}

References Warden::_session, ByteBuffer::append(), Warden::BuildChecksum(), WardenInitModuleRequest::Command1, Warden::EncryptData(), EndianConvert(), LOG_DEBUG, WorldSession::SendPacket(), Acore::Crypto::Constants::SHA1_DIGEST_LENGTH_BYTES, SMSG_WARDEN_DATA, and WARDEN_SMSG_MODULE_INITIALIZE.

IsCheckInProgress()

bool WardenWin::IsCheckInProgress ( )

overridevirtual

Gets the warden check state.

Returns

The warden check state.

Implements Warden.

{
    return _checkInProgress;
}

References Warden::_checkInProgress.

RequestChecks()

void WardenWin::RequestChecks ( )

overridevirtual

Implements Warden.

{
    LOG_DEBUG("warden", "Request data");
 
    _checkInProgress = true;
 
    // If all checks were done, fill the todo list again
    for (uint8 i = 0; i < MAX_WARDEN_CHECK_TYPES; ++i)
    {
        if (_ChecksTodo[i].empty())
            _ChecksTodo[i].assign(sWardenCheckMgr->CheckIdPool[i].begin(), sWardenCheckMgr->CheckIdPool[i].end());
    }
 
    _serverTicks = GameTime::GetGameTimeMS().count();
    _CurrentChecks.clear();
 
    // Erase any nullptrs.
    Acore::Containers::EraseIf(_PendingChecks,
        [this](uint16 id)
        {
            WardenCheck const* check = sWardenCheckMgr->GetWardenDataById(id);
 
            // Custom payload should be loaded in if equal to over offset.
            if (!check && id >= WardenPayloadMgr::WardenPayloadOffsetMin)
            {
                if (_payloadMgr.CachedChecks.find(id) != _payloadMgr.CachedChecks.end())
                {
                    check = &_payloadMgr.CachedChecks.at(id);
                }
            }
 
            if (!check)
            {
                return true;
            }
 
            return false;
        }
    );
 
    // No pending checks
    if (_PendingChecks.empty())
    {
        for (uint8 checkType = 0; checkType < MAX_WARDEN_CHECK_TYPES; ++checkType)
        {
            for (uint32 y = 0; y < sWorld->getIntConfig(GetMaxWardenChecksForType(checkType)); ++y)
            {
                // If todo list is done break loop (will be filled on next Update() run)
                if (_ChecksTodo[checkType].empty())
                {
                    break;
                }
 
                // Load in any custom payloads if available.
                if (checkType == WARDEN_CHECK_LUA_TYPE && !_payloadMgr.QueuedPayloads.empty())
                {
                    uint16 payloadId = _payloadMgr.QueuedPayloads.front();
 
                    LOG_DEBUG("warden", "Adding custom warden payload '{}' to CurrentChecks.", payloadId);
 
                    _payloadMgr.QueuedPayloads.pop_front();
                    _CurrentChecks.push_front(payloadId);
 
                    continue;
                }
 
                // Get check id from the end and remove it from todo
                uint16 const id = _ChecksTodo[checkType].back();
                _ChecksTodo[checkType].pop_back();
 
                // Insert check to queue
                if (checkType == WARDEN_CHECK_LUA_TYPE)
                {
                    _CurrentChecks.push_front(id);
                }
                else
                {
                    _CurrentChecks.push_back(id);
                }
            }
        }
    }
    else
    {
        bool hasLuaChecks = false;
        for (uint16 const checkId : _PendingChecks)
        {
            WardenCheck const* check = sWardenCheckMgr->GetWardenDataById(checkId);
 
            // Custom payload should be loaded in if equal to over offset.
            if (!check && checkId >= WardenPayloadMgr::WardenPayloadOffsetMin)
            {
                check = &_payloadMgr.CachedChecks.at(checkId);
            }
 
            if (!hasLuaChecks && check->Type == LUA_EVAL_CHECK)
            {
                hasLuaChecks = true;
            }
 
            _CurrentChecks.push_back(checkId);
        }
 
        // Always include lua checks
        if (!hasLuaChecks)
        {
            for (uint32 i = 0; i < sWorld->getIntConfig(GetMaxWardenChecksForType(WARDEN_CHECK_LUA_TYPE)); ++i)
            {
                // If todo list is done break loop (will be filled on next Update() run)
                if (_ChecksTodo[WARDEN_CHECK_LUA_TYPE].empty())
                {
                    break;
                }
 
                // Get check id from the end and remove it from todo
                uint16 const id = _ChecksTodo[WARDEN_CHECK_LUA_TYPE].back();
                _ChecksTodo[WARDEN_CHECK_LUA_TYPE].pop_back();
 
                // Lua checks must be always in front
                _CurrentChecks.push_front(id);
            }
        }
    }
 
    // Filter too high checks queue
    // Filtered checks will get passed in next checks
    uint16 expectedSize = 4;
    _PendingChecks.clear();
    Acore::Containers::EraseIf(_CurrentChecks,
        [this, &expectedSize](uint16 id)
        {
            WardenCheck const* check = sWardenCheckMgr->GetWardenDataById(id);
 
            // Custom payload should be loaded in if equal to over offset.
            if (!check && id >= WardenPayloadMgr::WardenPayloadOffsetMin)
            {
                check = &_payloadMgr.CachedChecks.at(id);
            }
 
            // Remove nullptr if it snuck in from earlier check.
            if (!check)
            {
                return true;
            }
 
            uint16 const thisSize = GetCheckPacketSize(check);
            if ((expectedSize + thisSize) > 500) // warden packets are truncated to 512 bytes clientside
            {
                _PendingChecks.push_back(id);
                return true;
            }
            expectedSize += thisSize;
            return false;
        }
    );
 
    ByteBuffer buff;
    buff << uint8(WARDEN_SMSG_CHEAT_CHECKS_REQUEST);
 
    for (uint16 const checkId : _CurrentChecks)
    {
        WardenCheck const* check = sWardenCheckMgr->GetWardenDataById(checkId);
 
        // Custom payloads do not have prefix, midfix, postfix.
        if (!check && checkId >= WardenPayloadMgr::WardenPayloadOffsetMin)
        {
            check = &_payloadMgr.CachedChecks.at(checkId);
 
            buff << uint8(check->Str.size());
            buff.append(check->Str.data(), check->Str.size());
 
            continue;
        }
 
        switch (check->Type)
        {
            case LUA_EVAL_CHECK:
            {
                buff << uint8(sizeof(_luaEvalPrefix) - 1 + check->Str.size() + sizeof(_luaEvalMidfix) - 1 + check->IdStr.size() + sizeof(_luaEvalPostfix) - 1);
                buff.append(_luaEvalPrefix, sizeof(_luaEvalPrefix) - 1);
                buff.append(check->Str.data(), check->Str.size());
                buff.append(_luaEvalMidfix, sizeof(_luaEvalMidfix) - 1);
                buff.append(check->IdStr.data(), check->IdStr.size());
                buff.append(_luaEvalPostfix, sizeof(_luaEvalPostfix) - 1);
                break;
            }
            case MPQ_CHECK:
            case DRIVER_CHECK:
            {
                buff << uint8(check->Str.size());
                buff.append(check->Str.c_str(), check->Str.size());
                break;
            }
        }
    }
 
    uint8 const xorByte = _inputKey[0];
 
    // Add TIMING_CHECK
    buff << uint8(0x00);
    buff << uint8(TIMING_CHECK ^ xorByte);
 
    uint8 index = 1;
 
    for (uint16 const checkId : _CurrentChecks)
    {
        WardenCheck const* check = sWardenCheckMgr->GetWardenDataById(checkId);
 
        // Custom payload should be loaded in if equal to over offset.
        if (!check && checkId >= WardenPayloadMgr::WardenPayloadOffsetMin)
        {
            check = &_payloadMgr.CachedChecks.at(checkId);
        }
 
        buff << uint8(check->Type ^ xorByte);
        switch (check->Type)
        {
            case MEM_CHECK:
            {
                buff << uint8(0x00);
                buff << uint32(check->Address);
                buff << uint8(check->Length);
                break;
            }
            case PAGE_CHECK_A:
            case PAGE_CHECK_B:
            {
                std::vector<uint8> data = check->Data.ToByteVector(24, false);
                buff.append(data.data(), data.size());
                buff << uint32(check->Address);
                buff << uint8(check->Length);
                break;
            }
            case MPQ_CHECK:
            case LUA_EVAL_CHECK:
            {
                buff << uint8(index++);
                break;
            }
            case DRIVER_CHECK:
            {
                std::vector<uint8> data = check->Data.ToByteVector(24, false);
                buff.append(data.data(), data.size());
                buff << uint8(index++);
                break;
            }
            case MODULE_CHECK:
            {
                std::array<uint8, 4> seed = Acore::Crypto::GetRandomBytes<4>();
                buff.append(seed);
                buff.append(Acore::Crypto::HMAC_SHA1::GetDigestOf(seed, check->Str));
                break;
            }
            /*case PROC_CHECK:
            {
                buff.append(wd->i.AsByteArray(0, false).get(), wd->i.GetNumBytes());
                buff << uint8(index++);
                buff << uint8(index++);
                buff << uint32(wd->Address);
                buff << uint8(wd->Length);
                break;
            }*/
        }
    }
    buff << uint8(xorByte);
    buff.hexlike();
 
    // Encrypt with warden RC4 key
    EncryptData(buff.contents(), buff.size());
 
    WorldPacket pkt(SMSG_WARDEN_DATA, buff.size());
    pkt.append(buff);
    _session->SendPacket(&pkt);
 
    _dataSent = true;
 
    std::stringstream stream;
    stream << "Sent check id's: ";
    for (uint16 checkId : _CurrentChecks)
    {
        stream << checkId << " ";
    }
 
    LOG_DEBUG("warden", "{}", stream.str());
}

References Warden::_checkInProgress, _ChecksTodo, _CurrentChecks, Warden::_dataSent, Warden::_inputKey, _luaEvalMidfix, _luaEvalPostfix, _luaEvalPrefix, Warden::_payloadMgr, _PendingChecks, _serverTicks, Warden::_session, WardenCheck::Address, ByteBuffer::append(), WardenPayloadMgr::CachedChecks, WardenCheck::Data, DRIVER_CHECK, Warden::EncryptData(), Acore::Containers::EraseIf(), GetCheckPacketSize(), Acore::Impl::GenericHMAC< HashCreator, DigestLength >::GetDigestOf(), GameTime::GetGameTimeMS(), GetMaxWardenChecksForType(), WardenCheck::IdStr, WardenCheck::Length, LOG_DEBUG, LUA_EVAL_CHECK, MAX_WARDEN_CHECK_TYPES, MEM_CHECK, MODULE_CHECK, MPQ_CHECK, PAGE_CHECK_A, PAGE_CHECK_B, WardenPayloadMgr::QueuedPayloads, WorldSession::SendPacket(), SMSG_WARDEN_DATA, WardenCheck::Str, sWardenCheckMgr, sWorld, TIMING_CHECK, BigNumber::ToByteVector(), WardenCheck::Type, WARDEN_CHECK_LUA_TYPE, WARDEN_SMSG_CHEAT_CHECKS_REQUEST, and WardenPayloadMgr::WardenPayloadOffsetMin.

Referenced by ForceChecks().

RequestHash()

void WardenWin::RequestHash ( )

overridevirtual

Implements Warden.

{
    LOG_DEBUG("warden", "Request hash");
 
    // Create packet structure
    WardenHashRequest Request{};
    Request.Command = WARDEN_SMSG_HASH_REQUEST;
    memcpy(Request.Seed, _seed, 16);
 
    // Encrypt with warden RC4 key.
    EncryptData(reinterpret_cast<uint8*>(&Request), sizeof(WardenHashRequest));
 
    WorldPacket pkt(SMSG_WARDEN_DATA, sizeof(WardenHashRequest));
    pkt.append(reinterpret_cast<uint8*>(&Request), sizeof(WardenHashRequest));
    _session->SendPacket(&pkt);
}

References Warden::_seed, Warden::_session, ByteBuffer::append(), WardenHashRequest::Command, Warden::EncryptData(), LOG_DEBUG, WorldSession::SendPacket(), SMSG_WARDEN_DATA, and WARDEN_SMSG_HASH_REQUEST.

Member Data Documentation

_ChecksTodo

std::list<uint16> WardenWin::_ChecksTodo[MAX_WARDEN_CHECK_TYPES]

private

Referenced by RequestChecks().

_CurrentChecks

std::list<uint16> WardenWin::_CurrentChecks

private

Referenced by HandleData(), and RequestChecks().

_PendingChecks

std::list<uint16> WardenWin::_PendingChecks

private

Referenced by RequestChecks().

_serverTicks

uint32 WardenWin::_serverTicks

private

Referenced by HandleData(), and RequestChecks().

---

The documentation for this class was generated from the following files:

• azerothcore-wotlk/src/server/game/Warden/WardenWin.h
• azerothcore-wotlk/src/server/game/Warden/WardenWin.cpp