Warden Class Reference

#include "Warden.h"

Inheritance diagram for Warden:

Public Member Functions
	Warden ()
virtual	~Warden ()
virtual void	Init (WorldSession *session, SessionKey const &k)=0
virtual ClientWardenModule *	GetModuleForClient ()=0
virtual void	InitializeModule ()=0
virtual void	RequestHash ()=0
virtual void	HandleHashResult (ByteBuffer &buff)=0
virtual bool	IsCheckInProgress ()=0
virtual bool	IsInitialized ()
virtual void	ForceChecks ()=0
virtual void	RequestChecks ()=0
virtual void	HandleData (ByteBuffer &buff)=0
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 ()

Static Public Member Functions
static bool	IsValidCheckSum (uint32 checksum, const uint8 *data, const uint16 length)
static uint32	BuildChecksum (const uint8 *data, uint32 length)

Private Attributes
WorldSession *	_session
WardenPayloadMgr	_payloadMgr
uint8	_inputKey [16]
uint8	_outputKey [16]
uint8	_seed [16]
Acore::Crypto::ARC4	_inputCrypto
Acore::Crypto::ARC4	_outputCrypto
uint32	_checkTimer
uint32	_clientResponseTimer
bool	_dataSent
ClientWardenModule *	_module
bool	_initialized
bool	_interrupted
bool	_checkInProgress
uint32	_interruptCounter = 0

Friends
class	WardenWin
class	WardenMac

Detailed Description

Constructor & Destructor Documentation

Warden()

Warden::Warden

(

)

               : _session(nullptr), _checkTimer(10000/*10 sec*/), _clientResponseTimer(0),
    _dataSent(false), _module(nullptr), _initialized(false), _interrupted(false), _checkInProgress(false)
{
    memset(_inputKey, 0, sizeof(_inputKey));
    memset(_outputKey, 0, sizeof(_outputKey));
    memset(_seed, 0, sizeof(_seed));
}

References _inputKey, _outputKey, and _seed.

~Warden()

Warden::~Warden ( )

virtual

{
    delete[] _module->CompressedData;
    delete _module;
    _module = nullptr;
    _initialized = false;
}

References _initialized, _module, and ClientWardenModule::CompressedData.

Member Function Documentation

ApplyPenalty()

void Warden::ApplyPenalty	(	uint16	checkId,
		std::string const &	reason
	)

{
    WardenCheck const* checkData = sWardenCheckMgr->GetWardenDataById(checkId);
 
    uint32 action = WardenActions(sWorld->getIntConfig(CONFIG_WARDEN_CLIENT_FAIL_ACTION));
    std::string causeMsg;
    if (checkId && checkData)
    {
        action = checkData->Action;
 
        if (checkData->Comment.empty())
        {
            causeMsg = "Warden id " + std::to_string(checkId) + " violation";
        }
        else
        {
            causeMsg = "Warden: " + checkData->Comment;
        }
    }
    else
    {
        // if its not warden check id based, reason must be always provided
        ASSERT(!reason.empty());
        causeMsg = reason;
    }
 
    switch (action)
    {
        case WARDEN_ACTION_LOG:
            break;
        case WARDEN_ACTION_KICK:
        {
            _session->KickPlayer(causeMsg.find("Warden") != std::string::npos ? causeMsg : "Warden: " + causeMsg);
            break;
        }
        case WARDEN_ACTION_BAN:
        {
            std::stringstream duration;
            duration << sWorld->getIntConfig(CONFIG_WARDEN_CLIENT_BAN_DURATION) << "s";
            std::string accountName;
            AccountMgr::GetName(_session->GetAccountId(), accountName);
            sBan->BanAccount(accountName, duration.str(), causeMsg, "Server");
            break;
        }
    }
 
    std::string reportMsg;
    if (checkId)
    {
        if (Player const* plr = _session->GetPlayer())
        {
            std::string const reportFormat = "Player {} (guid {}, account id: {}) failed warden {} check ({}). Action: {}";
            reportMsg = Acore::StringFormatFmt(reportFormat, plr->GetName(), plr->GetGUID().GetCounter(), _session->GetAccountId(),
                                           checkId, ((checkData && !checkData->Comment.empty()) ? checkData->Comment : "<warden comment is not set>"),
                                           GetWardenActionStr(action));
        }
        else
        {
            std::string const reportFormat = "Account id: {} failed warden {} check. Action: {}";
            reportMsg = Acore::StringFormatFmt(reportFormat, _session->GetAccountId(), checkId, GetWardenActionStr(action));
        }
    }
    else
    {
        if (Player const* plr = _session->GetPlayer())
        {
            std::string const reportFormat = "Player {} (guid {}, account id: {}) triggered warden penalty by reason: {}. Action: {}";
            reportMsg = Acore::StringFormatFmt(reportFormat, plr->GetName(), plr->GetGUID().GetCounter(), _session->GetAccountId(), causeMsg, GetWardenActionStr(action));
        }
        else
        {
            std::string const reportFormat = "Account id: {} failed warden {} check. Action: {}";
            reportMsg = Acore::StringFormatFmt(reportFormat, _session->GetAccountId(), causeMsg, GetWardenActionStr(action));
        }
    }
 
    reportMsg = "Warden: " + reportMsg;
    LOG_INFO("warden", "> Warden: {}", reportMsg);
}

References _session, WardenCheck::Action, ASSERT, WardenCheck::Comment, CONFIG_WARDEN_CLIENT_BAN_DURATION, CONFIG_WARDEN_CLIENT_FAIL_ACTION, WorldSession::GetAccountId(), AccountMgr::GetName(), WorldSession::GetPlayer(), GetWardenActionStr(), WorldSession::KickPlayer(), LOG_INFO, sBan, Acore::StringFormatFmt(), sWardenCheckMgr, sWorld, WARDEN_ACTION_BAN, WARDEN_ACTION_KICK, and WARDEN_ACTION_LOG.

Referenced by WardenWin::HandleData(), WardenMac::HandleHashResult(), WardenWin::HandleHashResult(), and ProcessLuaCheckResponse().

BuildChecksum()

uint32 Warden::BuildChecksum ( const uint8 *  data, uint32  length  )

static

{
    keyData hash{};
    hash.bytes = Acore::Crypto::SHA1::GetDigestOf(data, size_t(length));
    uint32 checkSum = 0;
 
    for (uint8 i = 0; i < 5; ++i)
    {
        checkSum = checkSum ^ hash.ints[i];
    }
 
    return checkSum;
}

References keyData::bytes, and Acore::Impl::GenericHash< HashCreator, DigestLength >::GetDigestOf().

Referenced by WardenWin::InitializeModule(), and IsValidCheckSum().

DecryptData()

void Warden::DecryptData	(	uint8 *	buffer,
		uint32	length
	)

{
    _inputCrypto.UpdateData(buffer, length);
}

References _inputCrypto, and Acore::Crypto::ARC4::UpdateData().

EncryptData()

void Warden::EncryptData	(	uint8 *	buffer,
		uint32	length
	)

{
    _outputCrypto.UpdateData(buffer, length);
}

References _outputCrypto, and Acore::Crypto::ARC4::UpdateData().

Referenced by WardenWin::InitializeModule(), WardenMac::RequestChecks(), WardenWin::RequestChecks(), WardenMac::RequestHash(), WardenWin::RequestHash(), RequestModule(), and SendModuleToClient().

ForceChecks()

virtual void Warden::ForceChecks ( )

pure virtual

Implemented in WardenWin.

GetModuleForClient()

virtual ClientWardenModule * Warden::GetModuleForClient ( )

pure virtual

Implemented in WardenMac, and WardenWin.

GetPayloadMgr()

WardenPayloadMgr * Warden::GetPayloadMgr

(

)

{
    return &_payloadMgr;
}

References _payloadMgr.

HandleData()

virtual void Warden::HandleData ( ByteBuffer &  buff )

pure virtual

Implemented in WardenMac, and WardenWin.

HandleHashResult()

virtual void Warden::HandleHashResult ( ByteBuffer &  buff )

pure virtual

Implemented in WardenMac, and WardenWin.

Init()

virtual void Warden::Init ( WorldSession *  session, SessionKey const &  k  )

pure virtual

Implemented in WardenMac, and WardenWin.

InitializeModule()

virtual void Warden::InitializeModule ( )

pure virtual

Implemented in WardenMac, and WardenWin.

IsCheckInProgress()

virtual bool Warden::IsCheckInProgress ( )

pure virtual

Implemented in WardenWin.

IsInitialized()

bool Warden::IsInitialized ( )

virtual

{
    return _initialized;
}

References _initialized.

IsValidCheckSum()

bool Warden::IsValidCheckSum ( uint32  checksum, const uint8 *  data, const uint16  length  )

static

{
    uint32 newChecksum = BuildChecksum(data, length);
 
    if (checksum != newChecksum)
    {
        LOG_DEBUG("warden", "CHECKSUM IS NOT VALID");
        return false;
    }
    else
    {
        LOG_DEBUG("warden", "CHECKSUM IS VALID");
        return true;
    }
}

References BuildChecksum(), and LOG_DEBUG.

Referenced by WardenWin::HandleData().

ProcessLuaCheckResponse()

bool Warden::ProcessLuaCheckResponse

(

std::string const &

msg

)

{
    static constexpr char WARDEN_TOKEN[] = "_TW\t";
    // if msg starts with WARDEN_TOKEN
    if (msg.rfind(WARDEN_TOKEN, 0) != 0)
    {
        return false;
    }
 
    uint16 id = 0;
 
    {
        std::stringstream msg2(msg);
        std::string temp;
        while (msg2 >> temp)
        {
            // Found check id - stop loop
            if (std::stringstream(temp) >> id)
                break;
        }
    }
 
    if (id < sWardenCheckMgr->GetMaxValidCheckId())
    {
        WardenCheck const* check = sWardenCheckMgr->GetWardenDataById(id);
        if (check && check->Type == LUA_EVAL_CHECK)
        {
            ApplyPenalty(id, "");
            return true;
        }
    }
 
    ApplyPenalty(0, "Sent bogus Lua check response for Warden");
    return true;
}

References ApplyPenalty(), LUA_EVAL_CHECK, sWardenCheckMgr, and WardenCheck::Type.

RequestChecks()

virtual void Warden::RequestChecks ( )

pure virtual

Implemented in WardenMac, and WardenWin.

Referenced by Update().

RequestHash()

virtual void Warden::RequestHash ( )

pure virtual

Implemented in WardenMac, and WardenWin.

RequestModule()

void Warden::RequestModule

(

)

{
    LOG_DEBUG("warden", "Request module");
 
    // Create packet structure
    WardenModuleUse request{};
    request.Command = WARDEN_SMSG_MODULE_USE;
 
    memcpy(request.ModuleId, _module->Id.data(), 16);
    memcpy(request.ModuleKey, _module->Key.data(), 16);
    request.Size = _module->CompressedSize;
 
    EndianConvert(request.Size);
 
    // Encrypt with warden RC4 key.
    EncryptData((uint8*)&request, sizeof(WardenModuleUse));
 
    WorldPacket pkt(SMSG_WARDEN_DATA, sizeof(WardenModuleUse));
    pkt.append((uint8*)&request, sizeof(WardenModuleUse));
    _session->SendPacket(&pkt);
}

References _module, _session, ByteBuffer::append(), WardenModuleUse::Command, ClientWardenModule::CompressedSize, EncryptData(), EndianConvert(), ClientWardenModule::Id, ClientWardenModule::Key, LOG_DEBUG, WorldSession::SendPacket(), SMSG_WARDEN_DATA, and WARDEN_SMSG_MODULE_USE.

Referenced by WardenMac::Init(), and WardenWin::Init().

SendModuleToClient()

void Warden::SendModuleToClient

(

)

{
    LOG_DEBUG("warden", "Send module to client");
 
    // Create packet structure
    WardenModuleTransfer packet;
 
    uint32 sizeLeft = _module->CompressedSize;
    uint32 pos = 0;
    uint16 burstSize;
    while (sizeLeft > 0)
    {
        burstSize = sizeLeft < 500 ? sizeLeft : 500;
        packet.Command = WARDEN_SMSG_MODULE_CACHE;
        packet.DataSize = burstSize;
        memcpy(packet.Data, &_module->CompressedData[pos], burstSize);
        sizeLeft -= burstSize;
        pos += burstSize;
 
        EncryptData((uint8*)&packet, burstSize + 3);
        WorldPacket pkt1(SMSG_WARDEN_DATA, burstSize + 3);
        pkt1.append((uint8*)&packet, burstSize + 3);
        _session->SendPacket(&pkt1);
    }
}

References _module, _session, ByteBuffer::append(), WardenModuleTransfer::Command, ClientWardenModule::CompressedData, ClientWardenModule::CompressedSize, WardenModuleTransfer::Data, WardenModuleTransfer::DataSize, EncryptData(), LOG_DEBUG, WorldSession::SendPacket(), SMSG_WARDEN_DATA, and WARDEN_SMSG_MODULE_CACHE.

Update()

void Warden::Update

(

uint32 const

diff

)

{
    if (!_initialized)
    {
        return;
    }
 
    if (_dataSent)
    {
        uint32 maxClientResponseDelay = sWorld->getIntConfig(CONFIG_WARDEN_CLIENT_RESPONSE_DELAY);
        if (maxClientResponseDelay > 0)
        {
            if (_clientResponseTimer > maxClientResponseDelay * IN_MILLISECONDS)
            {
                _session->KickPlayer("Warden: clientResponseTimer > maxClientResponseDelay (Warden::Update)");
            }
            else
            {
                _clientResponseTimer += diff;
            }
        }
    }
    else
    {
        if (diff >= _checkTimer)
        {
            RequestChecks();
        }
        else
        {
            _checkTimer -= diff;
        }
    }
}

References _checkTimer, _clientResponseTimer, _dataSent, _initialized, _session, CONFIG_WARDEN_CLIENT_RESPONSE_DELAY, IN_MILLISECONDS, WorldSession::KickPlayer(), RequestChecks(), and sWorld.

Friends And Related Function Documentation

WardenMac

friend class WardenMac

friend

WardenWin

friend class WardenWin

friend

Member Data Documentation

_checkInProgress

bool Warden::_checkInProgress

private

Referenced by WardenWin::HandleData(), WardenWin::IsCheckInProgress(), and WardenWin::RequestChecks().

_checkTimer

uint32 Warden::_checkTimer

private

Referenced by WardenWin::HandleData(), and Update().

_clientResponseTimer

uint32 Warden::_clientResponseTimer

private

Referenced by WardenMac::HandleData(), WardenWin::HandleData(), and Update().

_dataSent

bool Warden::_dataSent

private

Referenced by WardenWin::ForceChecks(), WardenMac::HandleData(), WardenWin::HandleData(), WardenMac::RequestChecks(), WardenWin::RequestChecks(), and Update().

_initialized

bool Warden::_initialized

private

Referenced by WardenMac::HandleHashResult(), WardenWin::HandleHashResult(), IsInitialized(), Update(), and ~Warden().

_inputCrypto

Acore::Crypto::ARC4 Warden::_inputCrypto

private

Referenced by DecryptData(), WardenMac::HandleHashResult(), WardenWin::HandleHashResult(), WardenMac::Init(), and WardenWin::Init().

_inputKey

uint8 Warden::_inputKey[16]

private

Referenced by WardenMac::HandleHashResult(), WardenWin::HandleHashResult(), WardenMac::Init(), WardenWin::Init(), WardenWin::RequestChecks(), and Warden().

_interruptCounter

uint32 Warden::_interruptCounter = 0

private

Referenced by WardenWin::ForceChecks(), and WardenWin::HandleData().

_interrupted

bool Warden::_interrupted

private

Referenced by WardenWin::ForceChecks(), and WardenWin::HandleData().

_module

ClientWardenModule* Warden::_module

private

Referenced by WardenMac::Init(), WardenWin::Init(), RequestModule(), SendModuleToClient(), and ~Warden().

_outputCrypto

Acore::Crypto::ARC4 Warden::_outputCrypto

private

Referenced by EncryptData(), WardenMac::HandleHashResult(), WardenWin::HandleHashResult(), WardenMac::Init(), and WardenWin::Init().

_outputKey

uint8 Warden::_outputKey[16]

private

Referenced by WardenMac::HandleHashResult(), WardenWin::HandleHashResult(), WardenMac::Init(), WardenWin::Init(), and Warden().

_payloadMgr

WardenPayloadMgr Warden::_payloadMgr

private

Referenced by GetPayloadMgr(), WardenWin::HandleData(), and WardenWin::RequestChecks().

_seed

uint8 Warden::_seed[16]

private

Referenced by WardenMac::Init(), WardenWin::Init(), WardenMac::RequestHash(), WardenWin::RequestHash(), and Warden().

_session

WorldSession* Warden::_session

private

Referenced by ApplyPenalty(), WardenMac::HandleData(), WardenWin::HandleData(), WardenMac::Init(), WardenWin::Init(), WardenWin::InitializeModule(), WardenMac::RequestChecks(), WardenWin::RequestChecks(), WardenMac::RequestHash(), WardenWin::RequestHash(), RequestModule(), SendModuleToClient(), and Update().