EAC-Kernel-Packet-Fucker

No es mi código. Solo para guardarlo https://www.unknowncheats.me/forum/anti-cheat-bypass/503052-easy-anti-cheat-kernel-packet-fucker.html

Este es el Easy Anti-Cheat Kernel Packet Fucker (para abreviar, EACKPFucker). ¿Qué es esto? Básicamente, los paquetes a través de su controlador en modo kernel no se les van a enviar, lo que significa que tus bypasses FUD de pasta pasta 2023 kdmapper se pueden usar sin ningún problema.

Vale, me has dejado boquiabierto. ¿Cómo cojones funciona esto? Simplemente cambiando una dirección. Ahora, vamos a sumergirnos a fondo en cómo funciona realmente EAC.

Desde el principio, Easy Anti-Cheat tiene que obtener realmente tus datos para poder banearte. Estos paquetes se envían a través de su canal Hydra y están cifrados criptográficamente. Eso es todo lo que necesitas saber para este bypass, no entraré en más detalles sobre esto.

Echemos un vistazo a cómo funciona esto dentro de su controlador de kernel, con una violación aleatoria:

¿No te parece vulnerable? Porque a mí desde luego sí. Echemos un vistazo a nuestra primera función: kalloc_rt Hmm, vale. Saltemos a alloc_pool_with_tag Importa dinámicamente ExAllocatePoolWithTag. Hmmmm... me pregunto qué pasaría si alguien modificara ese qword por su función malloc modificada... (sí, funciona -- y como estás modificando una sección escribible, EAC no se entera de nada)

Vale, ahora tenemos control sobre la asignación de memoria. ¡Genial! ¿Qué podemos hacer con esto?

¡Me alegro de que lo preguntes! Aquí está el asunto: Todos los paquetes desde modo kernel son del tamaño de 33096i64.. yyy anteriormente, vimos que si la memoria no se asigna, EAC simplemente.. ignora la violación.

Vale, digamos que alguien simplemente.. hiciera esto:

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

}

después de volcar algunos informes y descifrar: