EAC-Kernel-Packet-Fucker

यह मेरा कोड नहीं है। केवल सहेजने के लिए https://www.unknowncheats.me/forum/anti-cheat-bypass/503052-easy-anti-cheat-kernel-packet-fucker.html

यह Easy Anti-Cheat Kernel Packet Fucker है (संक्षेप में, EACKPFucker)। यह क्या है? मूल रूप से, उनके kernel mode driver के माध्यम से packets उन्हें नहीं भेजे जाएंगे, जिसका अर्थ है कि आपके pasta pasta 2023 kdmapper FUD bypasses बिना किसी परेशानी के उपयोग किए जा सकते हैं।

ठीक है, तुमने मुझे हैरान कर दिया। यह कैसे काम करता है? बस एक address बदलकर। अब, आइए गहराई से जानें कि EAC वास्तव में कैसे काम करता है।

शुरुआत से, Easy Anti-Cheat को आपको ban करने के लिए वास्तव में आपका data प्राप्त करना होता है। ये packets उनके Hydra channel पर भेजे जाते हैं और cryptographically secure होते हैं। इस bypass के लिए बस इतना ही जानना आवश्यक है, मैं इसके बारे में अधिक विस्तार में नहीं जाऊंगा।

आइए देखें कि यह उनके kernel driver के अंदर कैसे काम करता है, एक random violation के साथ:

क्या यह आपको vulnerable नहीं लगता? क्योंकि मुझे तो बिल्कुल लगता है। आइए हमारे पहले function पर नज़र डालें: kalloc_rt हम्म, ठीक है। आइए alloc_pool_with_tag में जाएं यह dynamically ExAllocatePoolWithTag को import करता है। हम्म्म... मुझे आश्चर्य है कि क्या होगा अगर कोई उस qword को अपने modified malloc function में बदल दे... (हाँ, यह काम करता है -- और चूंकि आप एक writable section को modify कर रहे हैं, EAC को कुछ पता नहीं चलेगा)

ठीक है, अब हमारे पास memory allocation पर नियंत्रण है। बढ़िया! इसका उपयोग करके हम क्या कर सकते हैं?

मुझे खुशी है कि आपने पूछा! बात यह है: kernel mode से आने वाले सभी packets का size 33096i64 होता है.. और पहले, हमने देखा कि अगर memory allocate नहीं होती, तो EAC बस.. violation को ignore कर देता है।

ठीक है, मान लीजिए कोई बस.. ऐसा करता है:

---------------------------------------------------------------------------------------------------------------------------------------```C++ // report encryption looks like this (some parts may vary for each report, i believe they use key1, key2, key3 to use only 1 function for decryption) static report_t* encrypt(uint8_t* data, uint64_t size) {

report_t* packet = (report_t*)malloc(sizeof(report_t));
if (!packet) return nullptr;

uint32_t seed = 0x80BE5ED5 * ((uint64_t)&data >> 2);

memset(&packet->key1, 0, 0x8200);
packet->raw_size = 0;
packet->key1 = 0x66259F86; // gives key4?
packet->key2 = 0x21EBA81; // gives key5?
packet->key3 = 0xACE987AF; // gives key6?
packet->key4 = 0x50BFC583; // gives seed
packet->key5 = 0x3C61A927; // gives dynamic_key (from end)
packet->key6 = 0x70881859; // gives actual payload size

uint8_t* raw_data = packet->raw;
uint64_t raw_size = 24;
uint8_t* payload_data = packet->payload;
uint64_t payload_size = 0;

uint32_t dynamic_key = seed ^ 0x6957FDB6;
while (payload_size < size && payload_size < 0x8000) {

	uint32_t a = (dynamic_key << 0xD) ^ dynamic_key;
	uint32_t b = (a >> 0x11) ^ a;
	uint32_t c = (b << 0x5) ^ b;
	uint32_t d = _rotr(c, 2);

	uint8_t shift = 8 * (payload_size & 3);
	payload_data[payload_size] = data[payload_size] ^ (d >> shift);
	dynamic_key = data[payload_size] ^ d;

	payload_size++;
	raw_size++;
}

uint64_t aligned_size = (raw_size + 0xFF) & ~0xFF; // align up by 0x100
while (raw_size < aligned_size) {
	dynamic_key *= 0x80BE5ED5;
	raw_data[raw_size++] = dynamic_key;
}

packet->key4 ^= seed;
packet->key5 ^= dynamic_key;
packet->key6 ^= payload_size;
packet->raw_size = raw_size;
return packet;

}

// thus my decryption looks like this static void decrypt(report_t* packet) {

uint32_t seed = packet->key4 ^ 0x50BFC583;
uint32_t dynamic_key = seed ^ 0x6957FDB6;
//uint32_t dynamic_key = packet->key5 ^ 0x3C61A927;

uint8_t* payload_data = packet->payload;
uint32_t payload_size = packet->key6 ^ 0x70881859;


for (uint32_t i = 0; i < payload_size; i++) {
	uint32_t a = (dynamic_key << 0xD) ^ dynamic_key;
	uint32_t b = (a >> 0x11) ^ a;
	uint32_t c = (b << 0x5) ^ b;
	uint32_t d = _rotr(c, 2);

	uint8_t shift = 8 * (i & 3);
	payload_data[i] ^= (d >> shift);
	dynamic_key = payload_data[i] ^ d;
}

}

रिपोर्ट डंप करने और डिक्रिप्ट करने के बाद: