EAC-Kernel-Packet-Fucker

Non è il mio codice. Solo per conservarlo https://www.unknowncheats.me/forum/anti-cheat-bypass/503052-easy-anti-cheat-kernel-packet-fucker.html

Questo è l'Easy Anti-Cheat Kernel Packet Fucker (in breve, EACKPFucker). Cos'è? In pratica, i pacchetti tramite il loro driver in modalità kernel non verranno inviati a loro, il che significa che i tuoi bypass FUD pasta pasta 2023 kdmapper possono essere usati senza alcun problema.

Ok, mi hai fatto uscire dai gangheri. Come cazzo funziona? Semplicemente cambiando un indirizzo. Ora, immergiamoci a fondo in come funziona realmente EAC.

Dall'inizio, Easy Anti-Cheat deve effettivamente ottenere i tuoi dati per bannarti. Questi pacchetti vengono inviati attraverso il loro canale Hydra e sono crittograficamente sicuri. Questo è tutto ciò che devi sapere per questo bypass, non entrerò in maggiori dettagli al riguardo.

Diamo un'occhiata a come funziona all'interno del loro driver kernel, con una violazione casuale:

Non ti sembra vulnerabile? Perché a me sembra proprio di sì. Diamo un'occhiata alla nostra prima funzione: kalloc_rt Hmm, okay. Saltiamo dentro alloc_pool_with_tag Importa dinamicamente ExAllocatePoolWithTag. Hmmmm... mi chiedo cosa succederebbe se qualcuno modificasse quel qword con la propria funzione malloc modificata... (sì, funziona -- e dato che stai modificando una sezione scrivibile, EAC non se ne accorge)

Okay, ora abbiamo il controllo sull'allocazione di memoria. Figo! Cosa possiamo farci?

Sono contento che tu l'abbia chiesto! Ecco il punto: tutti i pacchetti dalla modalità kernel hanno la dimensione di 33096i64.. eee in precedenza, abbiamo visto che se la memoria non viene allocata, EAC semplicemente.. ignora la violazione.

Okay, diciamo che qualcuno semplicemente.. facesse questo:

---------------------------------------------------------------------------------------------------------------------------------------```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;
}

}

dopo aver scaricato alcuni report e averli decifrati: