WardenMac Class Reference

#include "WardenMac.h"

Inheritance diagram for WardenMac:

Public Member Functions
	WardenMac ()
	~WardenMac () 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
void	HandleData (ByteBuffer &buff) override
Public Member Functions inherited from Warden
	Warden ()
virtual	~Warden ()
virtual bool	IsCheckInProgress ()=0
virtual bool	IsInitialized ()
virtual void	ForceChecks ()=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 ()

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

WardenMac()

WardenMac::WardenMac

(

)

                     : Warden()
{
}

~WardenMac()

WardenMac::~WardenMac ( )

overridedefault

Member Function Documentation

GetModuleForClient()

ClientWardenModule * WardenMac::GetModuleForClient ( )

overridevirtual

Implements Warden.

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

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

Referenced by Init().

HandleData()

void WardenMac::HandleData ( ByteBuffer &  buff )

overridevirtual

Implements Warden.

{
    LOG_DEBUG("warden", "Handle data");
 
    _dataSent = false;
    _clientResponseTimer = 0;
 
    //uint16 Length;
    //buff >> Length;
    //uint32 Checksum;
    //buff >> Checksum;
 
    //if (!IsValidCheckSum(Checksum, buff.contents() + buff.rpos(), Length))
    //{
    //    buff.rpos(buff.wpos());
    //    if (sWorld->getBoolConfig(CONFIG_BOOL_WARDEN_KICK))
    //        Client->KickPlayer();
    //    return;
    //}
 
    //bool found = false;
 
    std::string str = "Test string!";
 
    Acore::Crypto::SHA1 sha1;
    sha1.UpdateData(str);
    uint32 magic = 0xFEEDFACE;                              // unsure
    sha1.UpdateData((uint8*)&magic, 4);
    sha1.Finalize();
 
    Acore::Crypto::SHA1::Digest sha1Hash{};
    buff.read(sha1Hash.data(), sha1Hash.size());
 
    if (sha1Hash != sha1.GetDigest())
    {
        LOG_DEBUG("warden", "Handle data failed: SHA1 hash is wrong!");
        //found = true;
    }
 
    auto ourMD5Hash = Acore::Crypto::MD5::GetDigestOf(str);
    Acore::Crypto::MD5::Digest theirsMD5Hash{};
    buff.read(theirsMD5Hash);
 
    if (ourMD5Hash != theirsMD5Hash)
    {
        LOG_DEBUG("warden", "Handle data failed: MD5 hash is wrong!");
        //found = true;
    }
 
    _session->KickPlayer("WardenMac::HandleData");
}

References Warden::_clientResponseTimer, Warden::_dataSent, Warden::_session, Acore::Impl::GenericHash< HashCreator, DigestLength >::Finalize(), Acore::Impl::GenericHash< HashCreator, DigestLength >::GetDigest(), Acore::Impl::GenericHash< HashCreator, DigestLength >::GetDigestOf(), WorldSession::KickPlayer(), LOG_DEBUG, ByteBuffer::read(), and Acore::Impl::GenericHash< HashCreator, DigestLength >::UpdateData().

HandleHashResult()

void WardenMac::HandleHashResult ( ByteBuffer &  buff )

overridevirtual

Implements Warden.

{
    // test
    int keyIn[4];
 
    keyData mod_seed = { { { { 0x4D, 0x80, 0x8D, 0x2C, 0x77, 0xD9, 0x05, 0xC4, 0x1A, 0x63, 0x80, 0xEC, 0x08, 0x58, 0x6A, 0xFE } } } };
 
    for (int i = 0; i < 4; ++i)
    {
        keyIn[i] = mod_seed.ints.ints[i];
    }
 
    int keyOut[4];
    int keyIn1, keyIn2;
    keyOut[0] = keyIn[0];
    keyIn[0] ^= 0xDEADBEEFu;
    keyIn1 = keyIn[1];
    keyIn[1] -= 0x35014542u;
    keyIn2 = keyIn[2];
    keyIn[2] += 0x5313F22u;
    keyIn[3] *= 0x1337F00Du;
    keyOut[1] = keyIn1 - 0x6A028A84;
    keyOut[2] = keyIn2 + 0xA627E44;
    keyOut[3] = 0x1337F00D * keyIn[3];
    // end test
 
    buff.rpos(buff.wpos());
 
    Acore::Crypto::SHA1 sha1;
    sha1.UpdateData((uint8*)keyIn, 16);
    sha1.Finalize();
 
    //const uint8 validHash[20] = { 0x56, 0x8C, 0x05, 0x4C, 0x78, 0x1A, 0x97, 0x2A, 0x60, 0x37, 0xA2, 0x29, 0x0C, 0x22, 0xB5, 0x25, 0x71, 0xA0, 0x6F, 0x4E };
 
    // Verify key using constant-time comparison
    if (CRYPTO_memcmp(buff.contents() + 1, sha1.GetDigest().data(), 20) != 0)
    {
        LOG_DEBUG("warden", "Request hash reply: failed");
        ApplyPenalty(0, "Request hash reply: failed");
        return;
    }
 
    LOG_DEBUG("warden", "Request hash reply: succeed");
 
    // client 7F96EEFDA5B63D20A4DF8E00CBF48304
    //const uint8 client_key[16] = { 0x7F, 0x96, 0xEE, 0xFD, 0xA5, 0xB6, 0x3D, 0x20, 0xA4, 0xDF, 0x8E, 0x00, 0xCB, 0xF4, 0x83, 0x04 };
 
    // server C2B7ADEDFCCCA9C2BFB3F85602BA809B
    //const uint8 server_key[16] = { 0xC2, 0xB7, 0xAD, 0xED, 0xFC, 0xCC, 0xA9, 0xC2, 0xBF, 0xB3, 0xF8, 0x56, 0x02, 0xBA, 0x80, 0x9B };
 
    // change keys here
    memcpy(_inputKey, keyIn, 16);
    memcpy(_outputKey, keyOut, 16);
 
    _inputCrypto.Init(_inputKey);
    _outputCrypto.Init(_outputKey);
 
    _initialized = true;
}

References Warden::_initialized, Warden::_inputCrypto, Warden::_inputKey, Warden::_outputCrypto, Warden::_outputKey, Warden::ApplyPenalty(), ByteBuffer::contents(), Acore::Impl::GenericHash< HashCreator, DigestLength >::Finalize(), Acore::Impl::GenericHash< HashCreator, DigestLength >::GetDigest(), Acore::Crypto::ARC4::Init(), keyData::ints, LOG_DEBUG, ByteBuffer::rpos(), Acore::Impl::GenericHash< HashCreator, DigestLength >::UpdateData(), and ByteBuffer::wpos().

Init()

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

overridevirtual

Implements Warden.

{
    _session = pClient;
    // Generate Warden Key
    SessionKeyGenerator<Acore::Crypto::SHA1> WK(K);
    WK.Generate(_inputKey, 16);
    WK.Generate(_outputKey, 16);
    /*
    Seed: 4D808D2C77D905C41A6380EC08586AFE (0x05 packet)
    Hash: <?> (0x04 packet)
    Module MD5: 0DBBF209A27B1E279A9FEC5C168A15F7
    New Client Key: <?>
    New Cerver Key: <?>
    */
    uint8 mod_seed[16] = { 0x4D, 0x80, 0x8D, 0x2C, 0x77, 0xD9, 0x05, 0xC4, 0x1A, 0x63, 0x80, 0xEC, 0x08, 0x58, 0x6A, 0xFE };
 
    memcpy(_seed, mod_seed, 16);
 
    _inputCrypto.Init(_inputKey);
    _outputCrypto.Init(_outputKey);
 
    LOG_DEBUG("warden", "Server side warden for client {} initializing...", pClient->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, and Warden::RequestModule().

InitializeModule()

void WardenMac::InitializeModule ( )

overridevirtual

Implements Warden.

{
    LOG_DEBUG("warden", "Initialize module");
}

References LOG_DEBUG.

RequestChecks()

void WardenMac::RequestChecks ( )

overridevirtual

Implements Warden.

{
    LOG_DEBUG("warden", "Request data");
 
    ByteBuffer buff;
    buff << uint8(WARDEN_SMSG_CHEAT_CHECKS_REQUEST);
 
    std::string str = "Test string!";
 
    buff << uint8(str.size());
    buff.append(str.c_str(), str.size());
 
    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;
}

References Warden::_dataSent, Warden::_session, ByteBuffer::append(), ByteBuffer::contents(), Warden::EncryptData(), ByteBuffer::hexlike(), LOG_DEBUG, WorldSession::SendPacket(), ByteBuffer::size(), SMSG_WARDEN_DATA, and WARDEN_SMSG_CHEAT_CHECKS_REQUEST.

RequestHash()

void WardenMac::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((uint8*)&Request, sizeof(WardenHashRequest));
 
    WorldPacket pkt(SMSG_WARDEN_DATA, sizeof(WardenHashRequest));
    pkt.append((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.

---

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

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