EAC-Kernel-Packet-Fucker

Pas mon code. Uniquement pour le sauvegarder https://www.unknowncheats.me/forum/anti-cheat-bypass/503052-easy-anti-cheat-kernel-packet-fucker.html

Voici l'Easy Anti-Cheat Kernel Packet Fucker (en abrégé, EACKPFucker). Qu'est-ce que c'est ? En gros, les paquets passant par leur pilote en mode noyau ne leur seront pas envoyés, ce qui signifie que vos contournements FUD kdmapper pasta pasta 2023 peuvent être utilisés sans aucun problème.

Ok, tu m'as eu. Comment ça marche, bordel ? En changeant simplement une adresse. Maintenant, plongeons en profondeur dans le fonctionnement réel d'EAC.

Depuis le début, Easy Anti-Cheat doit réellement obtenir vos données pour pouvoir vous bannir. Ces paquets sont envoyés via leur canal Hydra et sont cryptographiquement sécurisés. C'est tout ce que vous devez savoir pour ce contournement, je n'entrerai pas plus dans les détails à ce sujet.

Regardons comment cela fonctionne à l'intérieur de leur pilote noyau, avec une violation aléatoire :

Cela ne vous semble pas vulnérable ? Parce que pour moi, ça l'est clairement. Regardons notre première fonction : kalloc_rt Hmm, ok. Sautons dans alloc_pool_with_tag Il importe dynamiquement ExAllocatePoolWithTag. Hmmmm... Je me demande ce qui se passerait si quelqu'un modifiait ce qword pour pointer vers sa fonction malloc modifiée... (ouais, ça marche -- et comme vous modifiez une section inscriptible, EAC n'y voit que du feu)

Ok, maintenant nous avons le contrôle sur l'allocation mémoire. Cool ! Que pouvons-nous faire avec ça ?

Je suis content que vous posiez la question ! Voici le truc : tous les paquets provenant du mode noyau ont une taille de 33096i64.. et précédemment, nous avons vu que si la mémoire n'est pas allouée, EAC.. ignore simplement la violation.

Ok, disons que quelqu'un faisait simplement.. ceci :

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

}

après avoir vidé quelques rapports et déchiffré :