PAKET SÜZGEÇ VE BLOKE SİSTEMİ

[CoderPia]

HERAKLES Otomatik Avlı kalıcı sunucu. 19 Haziran'da açılıyor. Atius & Wizard güvencesiyle hemen kayıt ol, ön kayıt ödülleri aktif. HEMEN TIKLA!

Merhabalar,


aşağıda paylaştığım paket süzgecini server dosyalarınıza entegre ederek sunucu tabanlı DDOS kalkanı oluşturabilirsiniz.
Böylelikle paket göndererek dosyalarınızı şişirip oyunu patlama olayı son bulacaktır.

Sistem mantığı
1000 baytı geçen paketler süzgece takılır. (packet.payload.size() > 1000) kısmından kendinize göre ayarlayabilirsiniz.
İlk dört girişimde 1 dakika boyunca IP engeli alır.
Beşinci girişimde sınırsız IP engeli alır.



[CODE title="SÜZGEÇ"]#include <iostream>
#include <unordered_map>
#include <chrono>
#i#includefstream>
#include#includem>
#includ#includeINIReader.h#includede "inih/IN#includeh"

// Paket yapısı
#includeacket {
std::string sourceIP;
std::string destinationIP;
std::string payload;
};

// IP engelleme süreleri
const int initialBlockDurationSeconds = 60; // İlk engelleme süresi (örneğin 60 saniye)
const int maxAttemptsBeforeBlock = 5; // Bloklamadan önce izin verilen maksimum girişim sayısı

// IP engelleme veri yapısı
std::unordered_map<std::string, std:air<int, std::chrono::time_point<std::chrono::steady_clock>>> blockedIPs;

// Engellenmiş IP'leri dosyaya yazma işlevi
void writeBlockedIPsToIni(const std::string& filename) {
INIWriter writer(filename);

for (const auto& entry : blockedIPs) {
std:stringstream blockInfo;
blockInfo << entry.second.first << "," << std::chrono::duration_cast<std::chrono::seconds>(entry.second.second.time_since_epoch()).count();
writer.SetLongValue("BlockedIPs", entry.first, blockInfo.str());
}

writer.WriteFile();
}

// Engellenmiş IP'leri dosyadan okuma işlevi
void readBlockedIPsFromIni(const std::string& filename) {
INIReader reader(filename);

if (reader.ParseError() < 0) {
std::cout << "Error: Could not load " << filename << std::endl;
return;
}

for (const auto& section : reader.Sections()) {
if (section.first == "BlockedIPs") {
for (const auto& entry : section.second) {
std::istringstream blockInfo(entry.second);
std::string token;
std::getline(blockInfo, token, ',');
int attemptCount = std::stoi(token);
std::getline(blockInfo, token);
auto blockEndTime = std::chrono::steady_clock::time_point(std::chrono::seconds(std::stoi(token)));

blockedIPs[entry.first] = {attemptCount, blockEndTime};
}
}
}
}

// Paket süzme işlevi
bool filterPacket(const Packet& packet) {
// Önce kaynak IP'yi kontrol et
if (blockedIPs.find(packet.sourceIP) != blockedIPs.end()) {
auto& blockInfo = blockedIPs[packet.sourceIP];
auto currentTime = std::chrono::steady_clock::now();

// Eğer engelleme süresi dolmuşsa IP'yi kaldır
if (currentTime >= blockInfo.second) {
blockedIPs.erase(packet.sourceIP);
} else {
// IP hala engelli, paketi reddet
std::cout << "Engellenen IP: " << packet.sourceIP << std::endl;
return false;
}
}

// Burada paketin içeriğini inceleyerek fazla paketleri tespit edebilirsiniz.
// Örneğin, bazı koşullara göre bir IP'yi engelleyebilirsiniz.
// Bu örnekte sadece örnek olarak süre tabanlı bir engelleme gösterildi.

// Örneğin, bir koşul kontrolü
if (packet.payload.size() > 1000) {
// Fazla paket algılandı, IP'yi cezalandır
if (blockedIPs.find(packet.sourceIP) == blockedIPs.end()) {
blockedIPs[packet.sourceIP] = {1, std::chrono::steady_clock::now() + std::chrono::seconds(initialBlockDurationSeconds)};
} else {
auto& blockInfo = blockedIPs[packet.sourceIP];
blockInfo.first++; // Girişim sayısını arttır

if (blockInfo.first >= maxAttemptsBeforeBlock) {
// Maksimum girişim sayısına ulaşıldı, IP'yi süresiz engelle
std::cout << "Maksimum girişim sayısına ulaşıldı. Engellenen IP: " << packet.sourceIP << std::endl;
blockedIPs[packet.sourceIP].second = std::chrono::steady_clock::now() + std::chrono::hours(24); // Örneğin 24 saat engelle
} else {
// Daha fazla süre ekleyebilirsiniz, örneğin initialBlockDurationSeconds kadar
blockedIPs[packet.sourceIP].second += std::chrono::seconds(initialBlockDurationSeconds);
std::cout << "Fazla paket algılandı. Engellenen IP: " << packet.sourceIP << std::endl;
}
}

return false;
}

// Paketi kabul et
return true;
}

int main() {
// Test için bir paket oluşturalım
Packet testPacket {"192.168.1.1", "8.8.8.8", "Lorem ipsum dolor sit amet, consectetur adipiscing elit"};

// Engellenmiş IP'leri dosyadan oku
readBlockedIPsFromIni("blocked_ips.ini");

// Paketi süz
if (filterPacket(testPacket)) {
std::cout << "Paket kabul edildi." << std::endl;
} else {
std::cout << "Paket engellendi." << std::endl;
}

// Engellenmiş IP'leri dosyaya yaz
writeBlockedIPsToIni("blocked_ips.ini");

// Engellenmiş IP'leri gösterelim
std::cout << "Engellenmiş IP'ler:" << std::endl;
for (const auto& entry : blockedIPs) {
std::cout << entry.first << std::endl;
}

return 0;
}[/CODE]