R5Reloaded/r5sdk
1
0
Fork 0
mirror of https://github.com/Mauler125/r5sdk.git synced 2025-02-09 19:15:03 +01:00
Code Issues Packages Projects Releases Wiki Activity

Ban system improvements

Browse Source 
NucleusID/OriginID is an unsigned type, changed all types to uint64_t and cleaned up redundant code.
This commit is contained in:
Kawe Mazidjatari 2022-06-14 20:56:55 +02:00
parent 5683a928d0
commit ebf4921063
13 changed files with 116 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
r5dev/engine/client/client.cpp
View File

@ -30,7 +30,7 @@ int32_t CClient::GetUserID(void) const
//---------------------------------------------------------------------------------
// Purpose: gets the userID of this client
//---------------------------------------------------------------------------------
int64_t CClient::GetOriginID(void) const
uint64_t CClient::GetOriginID(void) const
{
return m_nOriginID;
}
@ -70,7 +70,7 @@ void CClient::SetUserID(std::int32_t nUserID)
//---------------------------------------------------------------------------------
// Purpose: sets the originID of this client
//---------------------------------------------------------------------------------
void CClient::SetOriginID(std::int64_t nOriginID)
void CClient::SetOriginID(uint64_t nOriginID)
{
m_nOriginID = nOriginID;
}

6
r5dev/engine/client/client.h
View File

@ -17,12 +17,12 @@ class CClient : INetChannelHandler, IClientMessageHandler
public:
CClient* GetClient(int nIndex) const;
int32_t GetUserID(void) const;
int64_t GetOriginID(void) const;
uint64_t GetOriginID(void) const;
SIGNONSTATE GetSignonState(void) const;
PERSISTENCE GetPersistenceState(void) const;
CNetChan* GetNetChan(void) const;
void SetUserID(int32_t nUserID);
void SetOriginID(int64_t nOriginID);
void SetOriginID(uint64_t nOriginID);
void SetSignonState(SIGNONSTATE nSignonState);
void SetPersistenceState(PERSISTENCE nPersistenceState);
void SetNetChan(CNetChan* pNetChan);
@ -51,7 +51,7 @@ private:
char pad_03A8[8]; //0x03A8
SIGNONSTATE m_nSignonState; //0x03B0
int32_t m_nDeltaTick; //0x03B4
int64_t m_nOriginID; //0x03B8
uint64_t m_nOriginID; //0x03B8
int32_t m_nStringTableAckTick; //0x03BC
int32_t m_nSignonTick; //0x03C0
char pad_03C0[464]; //0x03C4

2
r5dev/engine/net.h
View File

@ -32,7 +32,7 @@ void NET_SetKey(const string& svNetKey);
void NET_GenerateKey();
void NET_PrintFunc(const char* fmt, ...);
void NET_Shutdown(void* thisptr, const char* szReason, uint8_t bBadRep, bool bRemoveNow);
void NET_DisconnectClient(CClient* pClient, int nIndex, const char* szReason, uint8_t unk1, bool bRemoveNow);
void NET_DisconnectClient(CClient* pClient, int nIndex, const char* szReason, uint8_t bBadRep, bool bRemoveNow);
void NET_Attach();
void NET_Detach();

6
r5dev/engine/server/server.cpp
View File

@ -65,14 +65,14 @@ int CServer::GetNumFakeClients(void) const
//---------------------------------------------------------------------------------
CClient* CServer::Authenticate(CServer* pServer, user_creds_s* pInpacket)
{
std::string svIpAddress = pInpacket->m_nAddr.GetAddress();
string svIpAddress = pInpacket->m_nAddr.GetAddress();
if (sv_showconnecting->GetBool())
{
DevMsg(eDLL_T::SERVER, "\n");
DevMsg(eDLL_T::SERVER, "______________________________________________________________\n");
DevMsg(eDLL_T::SERVER, "] AUTHENTICATION ---------------------------------------------\n");
DevMsg(eDLL_T::SERVER, "] UID : | '%s'\n", pInpacket->m_nUserID);
DevMsg(eDLL_T::SERVER, "] OID : | '%lld'\n", pInpacket->m_nNucleusID);
DevMsg(eDLL_T::SERVER, "] OID : | '%llu'\n", pInpacket->m_nNucleusID);
DevMsg(eDLL_T::SERVER, "] ADR : | '%s'\n", svIpAddress.c_str());
DevMsg(eDLL_T::SERVER, "--------------------------------------------------------------\n");
}
@ -85,7 +85,7 @@ CClient* CServer::Authenticate(CServer* pServer, user_creds_s* pInpacket)
if (sv_showconnecting->GetBool())
{
Warning(eDLL_T::SERVER, "Connection rejected for '%s' ('%lld' is banned from this server!)\n", svIpAddress.c_str(), pInpacket->m_nNucleusID);
Warning(eDLL_T::SERVER, "Connection rejected for '%s' ('%llu' is banned from this server!)\n", svIpAddress.c_str(), pInpacket->m_nNucleusID);
}
return nullptr;
}

2
r5dev/engine/server/server.h
View File

@ -22,7 +22,7 @@ struct user_creds_s
int32_t m_nProtocolVer;
int32_t m_nchallenge;
uint8_t gap2[8];
int64_t m_nNucleusID;
uint64_t m_nNucleusID;
int64_t m_nUserID;
};

12
r5dev/engine/server/sv_main.cpp
View File

@ -6,18 +6,14 @@
//-----------------------------------------------------------------------------
// Purpose: checks if particular client is banned on the comp server
//-----------------------------------------------------------------------------
void SV_IsClientBanned(R5Net::Client* pR5net, const std::string svIPAddr, std::int64_t nNucleusID)
void SV_IsClientBanned(R5Net::Client* pR5net, const string svIPAddr, uint64_t nNucleusID)
{
std::string svError = std::string();
string svError = string();
bool bCompBanned = pR5net->GetClientIsBanned(svIPAddr, nNucleusID, svError);
if (bCompBanned)
{
DevMsg(eDLL_T::SERVER, "\n");
DevMsg(eDLL_T::SERVER, "______________________________________________________________\n");
DevMsg(eDLL_T::SERVER, "] PYLON_NOTICE -----------------------------------------------\n");
DevMsg(eDLL_T::SERVER, "] OriginID : | '%lld' IS PYLON BANNED.\n", nNucleusID);
DevMsg(eDLL_T::SERVER, "--------------------------------------------------------------\n");
DevMsg(eDLL_T::SERVER, "\n");
DevMsg(eDLL_T::SERVER, "Connection rejected for '%s' ('%llu' is banned from the master server!)\n", svIPAddr.c_str(), nNucleusID);
g_pBanSystem->AddConnectionRefuse(svError, nNucleusID); // Add to the vector.
}
}

2
r5dev/engine/server/sv_main.h
View File

@ -21,7 +21,7 @@ inline bool* s_bDedicated = nullptr;
///////////////////////////////////////////////////////////////////////////////
void SV_IsClientBanned(R5Net::Client* pR5net, const std::string svIPAddr, std::int64_t nNucleusID);
void SV_IsClientBanned(R5Net::Client* pR5net, const string svIPAddr, uint64_t nNucleusID);
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////

2
r5dev/networksystem/r5net.cpp
View File

@ -301,7 +301,7 @@ bool R5Net::Client::GetServerByToken(ServerListing& slOutServer, std::string& sv
// &svOutErrCl -
// Output : Returns true if banned, false if not banned.
//-----------------------------------------------------------------------------
bool R5Net::Client::GetClientIsBanned(const std::string svIpAddress, std::int64_t nOriginID, std::string& svOutErrCl)
bool R5Net::Client::GetClientIsBanned(const string svIpAddress, uint64_t nOriginID, string& svOutErrCl)
{
nlohmann::json jsRequestBody = nlohmann::json::object();
jsRequestBody["ip"] = svIpAddress;

2
r5dev/networksystem/r5net.h
View File

@ -14,7 +14,7 @@ namespace R5Net
std::vector<ServerListing> GetServersList(std::string& svOutMessage);
bool PostServerHost(std::string& svOutMessage, std::string& svOutToken, const ServerListing& slServerListing);
bool GetServerByToken(ServerListing& slOutServer, std::string& svOutMessage, const std::string svToken);
bool GetClientIsBanned(std::string svIpAddress, int64_t nOriginID, std::string& svOutErrCl);
bool GetClientIsBanned(std::string svIpAddress, uint64_t nOriginID, std::string& svOutErrCl);
std::string GetSDKVersion();
Client* pR5net = nullptr;

159
r5dev/public/bansystem.cpp
View File

@ -20,8 +20,9 @@ CBanSystem::CBanSystem(void)
//-----------------------------------------------------------------------------
// Purpose:
// Input : pair -
//-----------------------------------------------------------------------------
void CBanSystem::operator[](std::pair<std::string, std::int64_t> pair)
void CBanSystem::operator[](std::pair<string, uint64_t> pair)
{
AddEntry(pair.first, pair.second);
}
@ -34,16 +35,16 @@ void CBanSystem::Load(void)
fs::path path = std::filesystem::current_path() /= "platform\\banlist.json";
nlohmann::json jsIn;
std::ifstream banFile(path, std::ios::in);
ifstream banFile(path, std::ios::in);
int nTotalBans = 0;
if (banFile.good() && banFile) // Check if it parsed.
if (banFile.good() && banFile)
{
banFile >> jsIn; // Into json.
banFile.close();
if (!jsIn.is_null()) // Check if json is valid
if (!jsIn.is_null())
{
if (!jsIn["totalBans"].is_null())
{
@ -53,16 +54,16 @@ void CBanSystem::Load(void)
for (int i = 0; i < nTotalBans; i++)
{
nlohmann::json jsEntry = jsIn[std::to_string(i).c_str()]; // Get Entry for current ban.
if (jsEntry.is_null()) // Check if entry is valid.
nlohmann::json jsEntry = jsIn[std::to_string(i).c_str()];
if (jsEntry.is_null())
{
continue;
}
std::int64_t nOriginID = jsEntry["originID"].get<std::int64_t>(); // Get originID field from entry.
std::string svIpAddress = jsEntry["ipAddress"].get<std::string>(); // Get ipAddress field from entry.
uint64_t nOriginID = jsEntry["originID"].get<uint64_t>();
string svIpAddress = jsEntry["ipAddress"].get<string>();
vsvBanList.push_back(std::make_pair(svIpAddress, nOriginID));
m_vBanList.push_back(std::make_pair(svIpAddress, nOriginID));
}
}
}
@ -74,65 +75,70 @@ void CBanSystem::Save(void) const
{
nlohmann::json jsOut;
for (int i = 0; i < vsvBanList.size(); i++)
for (int i = 0; i < m_vBanList.size(); i++)
{
jsOut["totalBans"] = vsvBanList.size(); // Populate totalBans field.
jsOut[std::to_string(i).c_str()]["ipAddress"] = vsvBanList[i].first; // Populate ipAddress field for this entry.
jsOut[std::to_string(i).c_str()]["originID"] = vsvBanList[i].second; // Populate originID field for this entry.
jsOut["totalBans"] = m_vBanList.size();
jsOut[std::to_string(i).c_str()]["ipAddress"] = m_vBanList[i].first;
jsOut[std::to_string(i).c_str()]["originID"] = m_vBanList[i].second;
}
fs::path path = std::filesystem::current_path() /= "platform\\banlist.json";
std::ofstream outFile(path, std::ios::out | std::ios::trunc); // Write config file..
ofstream outFile(path, std::ios::out | std::ios::trunc); // Write config file..
outFile << jsOut.dump(4); // Dump it into config file..
outFile.close(); // Close the file handle.
outFile << jsOut.dump(4);
}
//-----------------------------------------------------------------------------
// Purpose: adds a banned player entry to the banlist
// Input : svIpAddress -
// nOriginID -
//-----------------------------------------------------------------------------
void CBanSystem::AddEntry(std::string svIpAddress, std::int64_t nOriginID)
void CBanSystem::AddEntry(string svIpAddress, uint64_t nOriginID)
{
if (!svIpAddress.empty() && nOriginID > 0) // Check if args are valid.
if (!svIpAddress.empty())
{
auto it = std::find(vsvBanList.begin(), vsvBanList.end(), std::make_pair(svIpAddress, nOriginID)); // Check if we have this entry already.
if (it == vsvBanList.end()) // We don't have that entry?
auto it = std::find(m_vBanList.begin(), m_vBanList.end(), std::make_pair(svIpAddress, nOriginID));
if (it == m_vBanList.end())
{
vsvBanList.push_back(std::make_pair(svIpAddress, nOriginID)); // Add it.
m_vBanList.push_back(std::make_pair(svIpAddress, nOriginID));
}
}
}
//-----------------------------------------------------------------------------
// Purpose: deletes an entry in the banlist
// Input : svIpAddress -
// nOriginID -
//-----------------------------------------------------------------------------
void CBanSystem::DeleteEntry(std::string svIpAddress, std::int64_t nOriginID)
void CBanSystem::DeleteEntry(string svIpAddress, uint64_t nOriginID)
{
for (int i = 0; i < vsvBanList.size(); i++) // Loop through vector.
for (size_t i = 0; i < m_vBanList.size(); i++)
{
if (svIpAddress.compare(vsvBanList[i].first) == NULL || nOriginID == vsvBanList[i].second) // Do any entries match our vector?
if (svIpAddress.compare(m_vBanList[i].first) == NULL || nOriginID == m_vBanList[i].second)
{
vsvBanList.erase(vsvBanList.begin() + i); // If so erase that vector element.
m_vBanList.erase(m_vBanList.begin() + i);
}
}
}
//-----------------------------------------------------------------------------
// Purpose: adds a connect refuse entry to the refuselist
// Input : svError -
// nOriginID -
//-----------------------------------------------------------------------------
void CBanSystem::AddConnectionRefuse(std::string svError, std::int64_t nOriginID)
void CBanSystem::AddConnectionRefuse(string svError, uint64_t nOriginID)
{
if (vsvrefuseList.empty())
if (m_vRefuseList.empty())
{
vsvrefuseList.push_back(std::make_pair(svError, nOriginID));
m_vRefuseList.push_back(std::make_pair(svError, nOriginID));
}
else
{
for (int i = 0; i < vsvrefuseList.size(); i++) // Loop through vector.
for (size_t i = 0; i < m_vRefuseList.size(); i++)
{
if (vsvrefuseList[i].second != nOriginID) // Do any entries match our vector?
if (m_vRefuseList[i].second != nOriginID)
{
vsvrefuseList.push_back(std::make_pair(svError, nOriginID)); // Push it back into the vector.
m_vRefuseList.push_back(std::make_pair(svError, nOriginID));
}
}
}
@ -140,55 +146,19 @@ void CBanSystem::AddConnectionRefuse(std::string svError, std::int64_t nOriginID
//-----------------------------------------------------------------------------
// Purpose: deletes an entry in the refuselist
// Input : nOriginID -
//-----------------------------------------------------------------------------
void CBanSystem::DeleteConnectionRefuse(std::int64_t nOriginID)
void CBanSystem::DeleteConnectionRefuse(uint64_t nOriginID)
{
for (int i = 0; i < vsvrefuseList.size(); i++) // Loop through vector.
for (size_t i = 0; i < m_vRefuseList.size(); i++)
{
if (vsvrefuseList[i].second == nOriginID) // Do any entries match our vector?
if (m_vRefuseList[i].second == nOriginID)
{
vsvrefuseList.erase(vsvrefuseList.begin() + i); // If so erase that vector element.
m_vRefuseList.erase(m_vRefuseList.begin() + i);
}
}
}
//-----------------------------------------------------------------------------
// Purpose: checks if specified ip address or necleus id is banned
// Input : svIpAddress -
// nOriginID -
// Output : true if banned, false if not banned
//-----------------------------------------------------------------------------
bool CBanSystem::IsBanned(std::string svIpAddress, std::int64_t nOriginID) const
{
for (int i = 0; i < vsvBanList.size(); i++)
{
std::string ipAddress = vsvBanList[i].first; // Get first pair entry.
std::int64_t originID = vsvBanList[i].second; // Get second pair entry.
if (ipAddress.empty()) // Check if ip is empty.
{
continue;
}
if (originID <= 0) // Is originID below 0?
{
continue;
}
if (ipAddress.compare(svIpAddress) == NULL) // Do they match?
{
return true;
}
if (nOriginID == originID) // Do they match?
{
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: Check refuse list and kill netchan connection.
//-----------------------------------------------------------------------------
@ -196,7 +166,7 @@ void CBanSystem::BanListCheck(void)
{
if (IsRefuseListValid())
{
for (int i = 0; i < vsvrefuseList.size(); i++)
for (size_t i = 0; i < m_vRefuseList.size(); i++)
{
for (int c = 0; c < MAX_PLAYERS; c++) // Loop through all possible client instances.
{
@ -208,28 +178,57 @@ void CBanSystem::BanListCheck(void)
continue;
}
if (pClient->GetOriginID() != vsvrefuseList[i].second) // See if NucleusID matches entry.
if (pClient->GetOriginID() != m_vRefuseList[i].second)
{
continue;
}
std::string svIpAddress = pNetChan->GetAddress();
string svIpAddress = pNetChan->GetAddress();
Warning(eDLL_T::SERVER, "Connection rejected for '%s' ('%lld' is banned from this server!)\n", svIpAddress.c_str(), pClient->GetOriginID());
AddEntry(svIpAddress, pClient->GetOriginID()); // Add local entry to reserve a non needed request.
Warning(eDLL_T::SERVER, "Connection rejected for '%s' ('%llu' is banned from this server!)\n", svIpAddress.c_str(), pClient->GetOriginID());
AddEntry(svIpAddress, pClient->GetOriginID());
Save(); // Save banlist to file.
NET_DisconnectClient(pClient, c, vsvrefuseList[i].first.c_str(), 0, 1);
NET_DisconnectClient(pClient, c, m_vRefuseList[i].first.c_str(), false, true);
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: checks if specified ip address or necleus id is banned
// Input : svIpAddress -
// nOriginID -
// Output : true if banned, false if not banned
//-----------------------------------------------------------------------------
bool CBanSystem::IsBanned(string svIpAddress, uint64_t nOriginID) const
{
for (size_t i = 0; i < m_vBanList.size(); i++)
{
string ipAddress = m_vBanList[i].first;
uint64_t originID = m_vBanList[i].second;
if (ipAddress.empty() ||
!originID) // Cannot be null.
{
continue;
}
if (ipAddress.compare(svIpAddress) == NULL ||
nOriginID == originID)
{
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose: checks if refuselist is valid
//-----------------------------------------------------------------------------
bool CBanSystem::IsRefuseListValid(void) const
{
return !vsvrefuseList.empty();
return !m_vRefuseList.empty();
}
//-----------------------------------------------------------------------------
@ -237,7 +236,7 @@ bool CBanSystem::IsRefuseListValid(void) const
//-----------------------------------------------------------------------------
bool CBanSystem::IsBanListValid(void) const
{
return !vsvBanList.empty();
return !m_vBanList.empty();
}
///////////////////////////////////////////////////////////////////////////////
CBanSystem* g_pBanSystem = new CBanSystem();

23
r5dev/public/include/bansystem.h
View File

@ -4,25 +4,26 @@ class CBanSystem
{
public:
CBanSystem(void);
void operator[](std::pair<std::string, std::int64_t> pair);
void operator[](std::pair<string, uint64_t> pair);
void Load(void);
void Save(void) const;
void AddEntry(std::string svIpAddress, std::int64_t nOriginID);
void DeleteEntry(std::string svIpAddress, std::int64_t nOriginID);
void AddEntry(string svIpAddress, uint64_t nOriginID);
void DeleteEntry(string svIpAddress, uint64_t nOriginID);
void AddConnectionRefuse(std::string svError, std::int64_t nOriginID);
void DeleteConnectionRefuse(std::int64_t nUserID);
bool IsBanned(std::string svIpAddress, std::int64_t nOriginID) const;
bool IsRefuseListValid(void) const;
bool IsBanListValid(void) const;
void AddConnectionRefuse(string svError, uint64_t nOriginID);
void DeleteConnectionRefuse(uint64_t nUserID);
void BanListCheck(void);
bool IsBanned(string svIpAddress, uint64_t nOriginID) const;
bool IsRefuseListValid(void) const;
bool IsBanListValid(void) const;
private:
std::vector<std::pair<std::string, std::int64_t>> vsvrefuseList = {};
std::vector<std::pair<std::string, std::int64_t>> vsvBanList = {};
vector<std::pair<string, uint64_t>> m_vRefuseList = {};
vector<std::pair<string, uint64_t>> m_vBanList = {};
};
extern CBanSystem* g_pBanSystem;

4
r5dev/server/vengineserver_impl.cpp
View File

@ -24,13 +24,13 @@ bool HIVEngineServer__PersistenceAvailable(void* entidx, int clienthandle)
string svClientName = pNetChan->GetName();
string svIpAddress = pNetChan->GetAddress();
int64_t nOriginID = pClient->GetOriginID();
uint64_t nOriginID = pClient->GetOriginID();
DevMsg(eDLL_T::SERVER, "______________________________________________________________\n");
DevMsg(eDLL_T::SERVER, "+- NetChannel:\n");
DevMsg(eDLL_T::SERVER, " |- IDX : | '#%d'\n", clienthandle);
DevMsg(eDLL_T::SERVER, " |- UID : | '%s'\n", svClientName.c_str());
DevMsg(eDLL_T::SERVER, " |- OID : | '%lld'\n", nOriginID);
DevMsg(eDLL_T::SERVER, " |- OID : | '%llu'\n", nOriginID);
DevMsg(eDLL_T::SERVER, " |- ADR : | '%s'\n", svIpAddress.c_str());
DevMsg(eDLL_T::SERVER, " -------------------------------------------------------------\n");

12
r5dev/vstdlib/callback.cpp
View File

@ -131,10 +131,10 @@ void Host_KickID_f(const CCommand& args)
if (bOnlyDigits)
{
int64_t nTargetID = static_cast<int64_t>(std::stoll(args.Arg(1)));
uint64_t nTargetID = static_cast<int64_t>(std::stoll(args.Arg(1)));
if (nTargetID > MAX_PLAYERS) // Is it a possible originID?
{
int64_t nOriginID = pClient->GetOriginID();
uint64_t nOriginID = pClient->GetOriginID();
if (nOriginID != nTargetID)
{
continue;
@ -240,10 +240,10 @@ void Host_BanID_f(const CCommand& args)
if (bOnlyDigits)
{
int64_t nTargetID = static_cast<int64_t>(std::stoll(args.Arg(1)));
if (nTargetID > MAX_PLAYERS) // Is it a possible originID?
uint64_t nTargetID = static_cast<uint64_t>(std::stoll(args.Arg(1)));
if (nTargetID > static_cast<uint64_t>(MAX_PLAYERS)) // Is it a possible originID?
{
int64_t nOriginID = pClient->GetOriginID();
uint64_t nOriginID = pClient->GetOriginID();
if (nOriginID != nTargetID)
{
continue;
@ -303,7 +303,7 @@ void Host_Unban_f(const CCommand& args)
}
else
{
g_pBanSystem->DeleteEntry(args.Arg(1), 1); // Delete ban entry.
g_pBanSystem->DeleteEntry(args.Arg(1), 0); // Delete ban entry.
g_pBanSystem->Save(); // Save modified vector to file.
}
}