WorldSession::DosProtection Class Reference

#include "WorldSession.h"

Public Types
enum class	Policy {   Process ,   Kick ,   Ban ,   Log ,   BlockingThrottle ,   DropPacket }

Public Member Functions
	DosProtection (WorldSession *s)
Policy	EvaluateOpcode (WorldPacket const &p, time_t const time) const

Protected Attributes
WorldSession *	Session

Private Types
typedef std::unordered_map< uint16, PacketCounter >	PacketThrottlingMap

Private Member Functions
	DosProtection (DosProtection const &right)=delete
DosProtection &	operator= (DosProtection const &right)=delete

Private Attributes
PacketThrottlingMap	_PacketThrottlingMap

Friends
class	World

Detailed Description

Member Typedef Documentation

PacketThrottlingMap

typedef std::unordered_map<uint16, PacketCounter> WorldSession::DosProtection::PacketThrottlingMap

private

Member Enumeration Documentation

Policy

enum class WorldSession::DosProtection::Policy

strong

Enumerator
Process
Kick
Ban
Log
BlockingThrottle
DropPacket

        {
            Process,
            Kick,
            Ban,
            Log,
            BlockingThrottle,
            DropPacket
        };

Constructor & Destructor Documentation

DosProtection() [1/2]

WorldSession::DosProtection::DosProtection

(

WorldSession *

s

)

                                                        :
    Session(s) { }

DosProtection() [2/2]

WorldSession::DosProtection::DosProtection ( DosProtection const &  right )

privatedelete

Member Function Documentation

EvaluateOpcode()

WorldSession::DosProtection::Policy WorldSession::DosProtection::EvaluateOpcode	(	WorldPacket const &	p,
		time_t const	time
	)		const

{
    AntiDosOpcodePolicy const* policy = sWorldGlobals->GetAntiDosPolicyForOpcode(p.GetOpcode());
    if (!policy)
        return WorldSession::DosProtection::Policy::Process; // Return true if there is no policy for the opcode
 
    uint32 const maxPacketCounterAllowed = policy->MaxAllowedCount;
    if (!maxPacketCounterAllowed)
        return WorldSession::DosProtection::Policy::Process; // Return true if there no limit for the opcode
 
    // packetCounter is opcodes handled in the same world second, so MaxAllowedCount is per second
    PacketCounter& packetCounter = _PacketThrottlingMap[p.GetOpcode()];
    if (packetCounter.lastReceiveTime != time)
    {
        packetCounter.lastReceiveTime = time;
        packetCounter.amountCounter = 0;
    }
 
    // Check if player is flooding some packets
    if (++packetCounter.amountCounter <= maxPacketCounterAllowed)
        return WorldSession::DosProtection::Policy::Process;
 
    if (WorldSession::DosProtection::Policy(policy->Policy) != WorldSession::DosProtection::Policy::BlockingThrottle)
    {
        LOG_WARN("network", "AntiDOS: Account {}, IP: {}, Ping: {}, Character: {}, flooding packet (opc: {} (0x{:X}), count: {})",
            Session->GetAccountId(), Session->GetRemoteAddress(), Session->GetLatency(), Session->GetPlayerName(),
            opcodeTable[static_cast<OpcodeClient>(p.GetOpcode())]->Name, p.GetOpcode(), packetCounter.amountCounter);
    }
 
    switch (WorldSession::DosProtection::Policy(policy->Policy))
    {
        case WorldSession::DosProtection::Policy::Kick:
        {
            LOG_INFO("network", "AntiDOS: Player {} kicked!", Session->GetPlayerName());
            Session->KickPlayer();
            break;
        }
        case WorldSession::DosProtection::Policy::Ban:
        {
            uint32 bm = sWorld->getIntConfig(CONFIG_PACKET_SPOOF_BANMODE);
            uint32 duration = sWorld->getIntConfig(CONFIG_PACKET_SPOOF_BANDURATION); // in seconds
            std::string nameOrIp = "";
            switch (bm)
            {
                case 0: // Ban account
                    (void)AccountMgr::GetName(Session->GetAccountId(), nameOrIp);
                    sBan->BanAccount(nameOrIp, std::to_string(duration), "DOS (Packet Flooding/Spoofing", "Server: AutoDOS");
                    break;
                case 1: // Ban ip
                    nameOrIp = Session->GetRemoteAddress();
                    sBan->BanIP(nameOrIp, std::to_string(duration), "DOS (Packet Flooding/Spoofing", "Server: AutoDOS");
                    break;
            }
 
            LOG_INFO("network", "AntiDOS: Player automatically banned for {} seconds.", duration);
            break;
        }
        case WorldSession::DosProtection::Policy::DropPacket:
        {
            LOG_INFO("network", "AntiDOS: Opcode packet {} from player {} will be dropped.", p.GetOpcode(), Session->GetPlayerName());
            break;
        }
        default: // invalid policy
            break;
    }
 
    return WorldSession::DosProtection::Policy(policy->Policy);
}

References _PacketThrottlingMap, PacketCounter::amountCounter, Ban, BlockingThrottle, CONFIG_PACKET_SPOOF_BANDURATION, CONFIG_PACKET_SPOOF_BANMODE, DropPacket, WorldSession::GetAccountId(), WorldSession::GetLatency(), AccountMgr::GetName(), WorldPacket::GetOpcode(), WorldSession::GetPlayerName(), WorldSession::GetRemoteAddress(), Kick, WorldSession::KickPlayer(), PacketCounter::lastReceiveTime, LOG_INFO, LOG_WARN, AntiDosOpcodePolicy::MaxAllowedCount, opcodeTable, AntiDosOpcodePolicy::Policy, Process, sBan, Session, sWorld, and sWorldGlobals.

Referenced by WorldSession::Update().

operator=()

DosProtection & WorldSession::DosProtection::operator= ( DosProtection const &  right )

privatedelete

Friends And Related Symbol Documentation

World

friend class World

friend

Member Data Documentation

_PacketThrottlingMap

PacketThrottlingMap WorldSession::DosProtection::_PacketThrottlingMap

mutableprivate

Referenced by EvaluateOpcode().

Session

WorldSession* WorldSession::DosProtection::Session

protected

Referenced by EvaluateOpcode().

---

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

• azerothcore-wotlk/src/server/game/Server/WorldSession.h
• azerothcore-wotlk/src/server/game/Server/WorldSession.cpp