APEX: Taking a look at recent events
Many of you have probably already heard that Respawn has recently been doing some interesting things in terms of securing their games. It was big news for everybody when they announced that Apex would be switching from EAC to EA’s Javelin for their primary anti-cheat solution. I was initially pretty depressed, because I admittedly feared for the worst in terms of the changes it would induce. Luck was on my side though, and It happened to be quite easy to pick up the work where i had left it off.
That being said, I do suspect they are doing much more than just this, behind the scenes. At least when it comes to their operation of denying cheaters their entry, and constantly raising the bar for both cheat users and developers. Their campaign seems to rely on a multi-dimensional approach, targeting multiple different cheating setups, without necessarily detecting them by classic means. Although their client-sided detections still play an important role today, and they in fact still deploy their in-house R5AC solution for heuristic cheat detections within the game process itself. I’ll elaborate on this further in the next paragraphs.
Part 1 : Replacement of Easy Anti-Cheat with EA Javelin
So, as mentioned above, Apex is now using EA Javelin as its primary anti-cheat solution. It currently doesn’t require any of those fancy platform-based security features such as secure boot, TPM 2.0 or HVCI/VBS. Their enforcement of a minimum OS version doesn’t seem to have changed either. Meaning: if you’re using a somewhat recent build of Windows 10, chances are you might be able to play just fine.
Of course, this could change anytime, and it’s public knowledge that Javelin can enforce these requirements, just as EAC can if the game studio opts in for it. Nobody except respawn will be able to answer why they held back for so long with enforcing these platform security features on a larger scale. It would definitely make cheating more painful, especially for those people who just like to poke around things and have generally brittle setups.
In terms of actual detection capability, it is still too early for me to give accurate advice here. I have just started playing Apex again and delving deeper into this massive amount of changes, which is why i will resort to talking about things I definitely know. I haven’t had any trouble with Javelin’s address space protections so far. It does behave differently compared to EAC, but you can overcome it quite easily if you managed to handle the implementation they used before the switch to Javelin.
Do keep in mind though that this is only the tip of the iceberg, really. Just because you get in, doesn’t mean you will be able to persist without someone or something noticing. We’ll talk more about this in the following chapters. Until then, i will be sparing my breath about the new anti-cheat itself.
Update 2026/11/04: As someone who has previously dealt with EAC, i had my share of troubles when encountering some of EA’s tricks. In order to illustrate how funny it can get, let me introduce you to one of their memes. For this one, they will periodically overwrite the prologue of ntoskrnl’s MmCopyMemory function, while maintaining the hook for a relatively short period of time, before they then retire it by restoring the original bytes in the function prologue. When i checked who is writing to it, it was a generic memmove-like function inside eaanticheat.sys. For both the patch and restore operation. I’m not claiming i know exactly what they use it for, but it’s still interesting to note down.
What do they overwrite it with, you might ask? Let’s see for ourselves:
ntoskrnl.exe!MmCopyMemory:
Original: 48 89 5C 24 20 55 56 57 41 54 41 55
ASM:
mov [rsp+20h], rbx
push rbp
push rsi
push rdi
push r12
push r13
Patched: 48 B8 60 5A 44 B8 00 F8 FF FF FF E0
ASM:
mov rax, 0xFFFFF800B8445A60 ; this hook handler is within eaanticheat.sys
jmp rax
This is a classic way to redirect the program counter. It moves the destination into RAX register and then jumps to the contents of RAX. Which in this case, seems to be their hook handler for this specific target. Below is some pseudo code, beautified with GPT:
// RVA: eaanticheat.sys+0x1717CFE
NTSTATUS MmCopyMemory_HookHandler(
PVOID TargetAddress,
MM_COPY_ADDRESS SourceAddress,
SIZE_T NumberOfBytes,
ULONG Flags,
PSIZE_T NumberOfBytesTransferred
)
{
// RVA 0x1717D12
InterlockedIncrement(&g_ActiveCalls);
// RVA 0x1717D19
if (Flags == MM_COPY_MEMORY_PHYSICAL)
{
// RVA 0x1717D6F
RDI = TargetAddress;
RBX = SourceAddress;
R14 = NumberOfBytes;
EBP = Flags;
// RVA 0x1717D7B
R15 = OriginalCallerReturnAddress;
// RVA 0x1717E12
RAX = sub_192179A();
// RVA 0x1717E17
JMP_TO(RAX);
}
// RVA 0x1717F3E
else
{
void* slotA = RVA_TO_VA(0x69C868);
void* slotB = RVA_TO_VA(0x69C878);
BYTE selector =
*(BYTE*)RVA_TO_VA(0x69C8A9);
void* selectedSlot =
(selector == 0) ? slotA : slotB;
// RVA 0x1717F57
StackArgument5 = NumberOfBytesTransferred;
// RVA 0x1717FEF
NTSTATUS result =
CALL_FUNCTION_POINTER(
*(void**)selectedSlot,
TargetAddress,
SourceAddress,
NumberOfBytes,
Flags,
NumberOfBytesTransferred
);
// RVA 0x1718071
InterlockedDecrement(&g_ActiveCalls);
// RVA 0x17180E4
return result;
}
}
Note that the above code is just for illustrating it in a readable way. I couldn’t figure out what both alternative handlers are doing yet, it could do a stack walk or check the caller in some other, non-obvious way. All i know is that this code is being executed whenever someone calls MmCopyMemory in that short activity period of EA’s hook. When it comes to how long they keep this modification intact before removing it, during my own limited tests i have measured a time less than 10 seconds. Mostly around 6 seconds but the precision of my logger’s time component shouldn’t be over-trusted here. I’d verify this further later. For the meanwhile, below you can see some event graphs for the specific mechanism i use to track writes.


In the above picture, you can see a pair of 2 writes for each observed event spike. I classified the first one as a patch operation and the second as a restore operation. I’m still having my doubts with the patch actually being active for 6 seconds, as that seems quite long and i personally just think i’d need to look into some logging code to figure out if that’s realistic. Will edit this once i get more insight on it.
Either way, because both secondary handlers for the virtual and physical copy operation are within the hungarian packer’s section, aka .grfn1, i couldn’t really advance any further here. It’s something for the future because right now, what i got back from my read is just straight up zeros for that. Possibly it is only mapped when the hook is active, but i really have no idea honestly. It could be intentionally mapped as its needed, obfuscated in some way, packed or virtualized. I have zero experience with this packer. And honestly too lazy to spend additional time on it. I know it would probably answer a lot of our questions though. Skill issue IG.
Although we might not know how they use this hook and if they care about more than just return address, it’s safe to say that whatever is inside those secondary handlers has access to the arguments the caller passed into MmCopyMemory, plus the address that the MmCopyMemory call would have returned on. I would assume since they leave it installed for such a short time, maybe it is intended to detect obvious hooks on this specific API. It would make more sense if i could check if they fabricate any calls to MmCopyMemory from eaanticheat.sys, which could make this more plausible. They could also possibly be targeting people who are reading physical memory with it, either from the game or other stuff you aren’t supposed to access. I’ll stop here, hope it was enough to illustrate the point.
I was baffled when i figured out that they actually deploy this in their prod. It was hard to believe, and seems to cause issues for some people. What i find weird is that it doesn’t always seem to hook it. But at least one legit player has also seemingly experienced it. We’d need the crash dump to know for sure, but it does look highly weird. Why would the prologue of MmCopyMemory start with moving some address inside eaanticheat.sys into RAX? So i suspect it is either randomized or maybe conditionally triggered. I’d need to do more testing to get a better idea.

Do you notice anything? The player-posted crash dump seems to show the address of MmCopyMemory at the time of the crash. Including a disassembly of the first instruction that is currently located there. Let’s see what it is:
nt!MmCopyMemory+0:
mov rax, eaanticheat+0x335390
That’s definitely not what MmCopyMemory should look like. Also, taking a further look at the player-attached apex crash text file, i noticed something even more hilarious and memeworthy. So apparently, what actually happened was: Microsoft’s KPP just owned the player because the elite S.P.E.A.R team had installed a hook inside the player’s ntoskrnl!MmCopyMemory routine. LMFAO. You cant make this shit up.


You can see that arg4 of the bugcheck indicates “modification of a function or .pdata” (1). Additionally, arg3 which in PatchGuard is usually the address where corruption/patching was detected, exactly matches with the address of the player’s MmCopyMemory inside their ntoskrnl. Consider checking out this resource if your want to learn about how to interpret KPP crash dumps.
I don’t want to pretend like i know how often this issue actually arises during legitimate play. I myself have crashed a couple times under my own environment, also around MmCopyMemory, but it was because i was hooking MmCopyMemory as well. With the difference being that i didn’t smoke my computer whenever KPP ran its integrity check on it. I simply had a logic issue in how i handle conflicting writes to my own patches. Because i have never encountered anything like that on Easy Anti-Cheat, for the pages that i was interested in, it seems like i previously missed this bug in my implementation.
I didn’t even expect to find something like this in a production grade anti-cheat software. Don’t get me wrong, EAC and all the other anti-cheats also have their own nasty memes and tricks. But they’re usually not going as far as directly patching stuff inside your kernel. And if they do, they usually handle KPP in one way or another. Some examples for this are either disarming PatchGuard somehow, so that it doesn’t cause issues, blind a specific check or something similar in that direction. Possibly there is some 200 iq methods i haven’t thought of. My assumption is either they bypass PatchGuard’s checks somehow, but their approach is not preventing it from detecting them occasionally, or they’re racing it. I think the former would be more plausible, if we consider who has worked on Javelin and their technical backgrounds.
What caught me offguard with this one was simply the fact that it did something unexpected. I guess this worked out well for them if they actually use this for cheat detection, which again i can’t prove since i have no insights into what happens after execution is handed off to the to me inaccessible handlers that are responsible for taking care of different MmCopyMemory operations.
In some way i guess they smoked me since both of my accounts have been banned. I was able to do some additional testing and verification of what we’ve talked about. I temporarily disabled my own hook and simply looked who is doing what with the page inside ntoskrnl where the MmCopyMemory function resides. And then it clicked.

I exited apex that day, after completing my experiments on Nov 5 and went to the dentist. When i came back i had a beautiful ban email from EA,. It was for my second account that i created on Nov 2. It could’ve been anything at this point, and after seeing how mentally insane EA’s S.P.E.A.R team is, i think at this point they could’ve been hooking other stuff too. And possibly doing much more outrageous things. I’d rather wave the white flag instead of bothering any further.
The issue would not even be finding or disarming their hooks. For this specific technique of EA, you could do the following:
- Take a look at your ntoskrnl.exe, which can be different across OS builds. Locate the MmCopyMemory function.
- If you’re on Windows 10, you will most likely see a bunch of MOV and PUSH instructions at its prologue.
- If you don’t need it to support different OS builds, you can now simply build a little stub that basically simulates the real prologue of MmCopyMemory, and then jump to the actual MmCopyMemory function with an offset, so that you don’t execute the first 12 bytes at all on the real one. Since we know exactly which gadget they’re using, it’s quite easy.
- So, the flow basically is: you invoke your MmCopyMemory wrapper —> it runs the same instructions of the known-good prologue that you have recovered from your ntoskrnl —> then jumps to ( ntoskrnl.MmCopyMemory + <instructions to skip from the potentially patched real prologue>. The idea is that you’d execute enough of the prologue that you can skip EA’s hook entirely, and jump a little further than their meme inline hook, so if you call your wrapper it won’t trigger it at all.
Even though you could detect this too, one could simply stop relying on this API for memory access, and use other means to achieve the same thing. Or simply disable EA’s hook, check if its hooked by reading the prologue, restore the site around the patched function to a known good value, right before calling it, etc… However these would mostly just be a fat race condition. And it’s unnecessary unless EA starts hooking the mid or end of a function, or deploys more sophisticated methods of intercepting execution.
What you’d actually need to do in order to have a chance against them, though, is finding every other technique they’re using, confirm it’s used for cheat detection, and somehow either avoid or blind them one by one. I know you can simplify this process if your goal is to stay below ban thresholds instead of achieving perfectly clean telemetry measurements. But it’s still time consuming and in the end you will possibly be clapped by their raw input measurement AI, regardless of how sophisticated your approach is. Again, only assuming Anybrain is actually worth its salt.
Part 2: Possible removal of Theia
I don’t know if they completely got rid of everything related to Theia, which used to be their anti-tamper/packer hybrid solution. But Apex seems to no longer be using a dynamic scheme for keeping stale code pages encrypted. Previously, you’d have to deal with incomplete dumps and a lot of issues with your disassembler, due to scenarios like a page in the midst of others being encoded, while the others are in decoded state. So if your using something like IDA Pro, it might confuse perfectly valid code that is surrounding this encoded block as data, even if it is perfectly valid instructions.
I previously dealt with this by building a script that attempts to automate this process of marking these adjacent valid instructions as code. It worked fine for thwe most part, and with some manual intervention here and there, it was mostly manageable. Most of the time, if i had a goal of understanding how something works, i was able to achieve it using my old method of dumping. It was everything BUT convenient, but it was manageable. Even if sometimes i had important code in these cold pages which would have been a blessing to be allowed to inspect.
When it comes to attacking Theia itself or leveraging a flaw within its components and their design, i have tried it but ultimately gave up. In my case, my tooling and current knowledge was simply not mature enough to progress in reasonable speed while working on understanding it. I was able to reconstruct some parts like their exception handling mechanism, and some of the other protections they have offered. Also taken a look at their hardware identification methods, and inspected some interesting system calls they were making. Some of it has lead to a dead end, while others have taught me a lot of useful knowledge about it.

Part 3: Possible Integration of an AI solution for Player Input Measuring
Okay, so let’s get to the fun part. In Season 29, when Apex had still used EAC, i decided to poke around r5apex_dx12.exe. I didn’t have a specific goal in mind, except for some game cheats related stuff. But then, as i was deep in the trenches trying to discover some old stuff that had now changed, i found something that was initially hard to believe: Anybrain. I immediately checked all sorts of social media for any announcements, but there was none i could find. Surely someone must have talked about it on cheating forums, right? Nope.
.rdata:0000000002CEF5E2 0000000E C anybrain.proto
.rdata:0000000002CEF5F1 00000017 C \bAnybrain\"U\n\nPlayerData
.rdata:0000000002CEF61C 00000012 C .Anybrain.Metadata
.rdata:0000000002CEF63E 00000014 C .Anybrain.InputData\"
.rdata:0000000002CEF6AE 00000014 C .Anybrain.ScreenInfo
.rdata:0000000002CEF6DF 00000019 C .Anybrain.InputDeviceInfo
.rdata:0000000002CEF70F 00000022 C .Anybrain.ClientInfo\"\\\n\nScreenInfo
.rdata:0000000002CEF7D9 00000020 C .Anybrain.MouseSens\"-\n\tMouseSens
.rdata:0000000002CEF846 00000019 C .Anybrain.OperatingSystem
.rdata:0000000002CEF876 00000015 C .Anybrain.Environment
.rdata:0000000002CEF8A2 00000014 C .Anybrain.FormFactor
.rdata:0000000002CEF912 00000014 C .Anybrain.MouseInput
.rdata:0000000002CEF93A 00000017 C .Anybrain.KeyboardInput
.rdata:0000000002CEF962 00000014 C .Anybrain.TouchInput
.rdata:0000000002CEF98C 0000001A C .Anybrain.ControllerInput\"
.rdata:0000000002CEF9E6 0000001A C .Anybrain.MouseEventButton
.rdata:0000000002CEFA17 00000019 C .Anybrain.MouseEventMove\"
.rdata:0000000002CEFA5B 00000019 C .Anybrain.MouseButtonType
.rdata:0000000002CEFADE 00000012 C .Anybrain.EventRLE
.rdata:0000000002CEFAFD 00000012 C .Anybrain.EventRLE
.rdata:0000000002CEFB1F 00000012 C .Anybrain.EventRLE
.rdata:0000000002CEFB45 00000012 C .Anybrain.EventRLE
.rdata:0000000002CEFB70 0000001E C .Anybrain.EventRLE\"+\n\bEventRLE
.rdata:0000000002CEFBED 00000028 C .Anybrain.KeyboardEvent\"J\n\rKeyboardEvent
.rdata:0000000002CEFC86 00000014 C .Anybrain.TouchEvent
.rdata:0000000002CEFCA8 00000014 C .Anybrain.TouchEvent
.rdata:0000000002CEFCCA 00000022 C .Anybrain.TouchEvent\"d\n\nTouchEvent
.rdata:0000000002CEFDA3 0000001F C .Anybrain.ControllerEventButton
.rdata:0000000002CEFDD2 00000025 C (\v2!.Anybrain.ControllerEventJoystick
.rdata:0000000002CEFE07 00000027 C (\v2 .Anybrain.ControllerEventTrigger\"h\n
.rdata:0000000002CEFE5B 0000001E C .Anybrain.ControllerButtonType
.rdata:0000000002CEFEBE 00000017 C .Anybrain.JoystickEvent
.rdata:0000000002CEFEE3 00000028 C .Anybrain.JoystickEvent\"3\n\rJoystickEvent
.rdata:0000000002CEFF57 00000016 C .Anybrain.TriggerEvent
.rdata:0000000002CEFF7B 00000019 C .Anybrain.TriggerEvent\",\n
.rdata:0000000002CF0358 0000002C C c:\\depot\\r5-301\\src\\security\\anybrain.pb.cc
.rdata:0000000002CF0388 0000000F C anybrain.proto
.rdata:0000000002CF1208 0000001A C Anybrain.Metadata.user_id
.rdata:0000000002CF1228 0000001D C Anybrain.Metadata.session_id
.rdata:0000000002CF1248 0000001D C Anybrain.Metadata.ip_address
.rdata:0000000002CF1268 00000025 C Anybrain.InputDeviceInfo.device_name
.rdata:0000000002CF1290 0000001D C Anybrain.InputDeviceInfo.vid
.rdata:0000000002CF12B0 0000001D C Anybrain.InputDeviceInfo.pid
.rdata:0000000002CF12D0 0000001E C Anybrain.ClientInfo.device_id
.rdata:0000000002CF12F0 00000021 C Anybrain.ClientInfo.device_model
.rdata:0000000002CF1318 0000001F C Anybrain.ClientInfo.user_agent
.rdata:0000000002CF1338 0000001C C Anybrain.KeyboardEvent.code
.rdata:0000000002FF51E0 00000012 C 8-1-anyb-rollout
I was under disbelief for a long time, until i discovered some code which seems to be some form of A/B testing system. Basically, your Apex client requests a list of so called Experiments from their servers. It submits some fields including your account/nucleus-ID, your platform and some other stuff. And then receives back a list of experiments, with what i assume is their internal identifiers and the current state of the experiment. If an experiment has a state of “EXPERIMENT_ONGOING”, it is considered as active.
In case of the Experiment with internal identifier “8-1-anyb-rollout”, if your Apex client receives “treatment-a” from the A/B testing backend response, it will set up some extra stuff and also set a ConVar named “raw_input_client_send_enable” to a certain value, based on the result of the above checks. In order to understand why this ConVar matters, let’s take a look at who is using it:
void __fastcall R5::InputTelemetry::DrainQueue(__int64 a1)
{
if ( dword_3623E2C == 0
&& *((_DWORD *)cvar::r5::raw_input_collection_disable + 23) == 0
&& *((_DWORD *)cvar::r5::raw_input_client_send_enable + 23) != 0 )
{
if ( qword_3623DE8 == 0 || dword_36240B0 == 1 || *(_BYTE *)(qword_3623DE8 + 3) != 0 )
{
v11 = *(_DWORD *)(a1 + 65616);
*(_DWORD *)(a1 + 65624) = 0;
*(_BYTE *)(a1 + 66284) = 0;
*(_DWORD *)(a1 + 65620) = v11;
}
else if ( TryEnterCriticalSection(lpCriticalSection: (LPCRITICAL_SECTION)(a1 + 66288)) )
{
LeaveCriticalSection(lpCriticalSection: (LPCRITICAL_SECTION)(a1 + 66288));
if ( 2048 - *(_DWORD *)(a1 + 65628) > 128 )
{
v2 = *(_DWORD *)(a1 + 65620);
if ( v2 == *(_DWORD *)(a1 + 65616) )
{
*(_DWORD *)(a1 + 65620) = 0;
v2 = 0;
}
if ( v2 != *(_DWORD *)(a1 + 65624) )
{
v3 = 32LL * v2;
if ( *(_DWORD *)(a1 + 65632) == 0 )
*(_DWORD *)(a1 + 65632) = *(_DWORD *)(v3 + a1 + 80);
v4 = *(_DWORD *)(v3 + a1 + 80);
do
{
v5 = (unsigned int *)(a1 + 32LL * v2 + 80);
v6 = *v5;
v7 = R5::InputTelemetry::ProcessData(a1, a2: v5);
v8 = *(_DWORD *)(a1 + 65628);
++*(_DWORD *)(a1 + 65620);
v9 = v7 + v8;
v2 = *(_DWORD *)(a1 + 65620);
*(_DWORD *)(a1 + 65628) = v9;
if ( v2 == *(_DWORD *)(a1 + 65616) )
{
*(_DWORD *)(a1 + 65620) = 0;
v2 = 0;
}
}
while ( 2048 - v9 > 128 && v2 != *(_DWORD *)(a1 + 65624) );
v10 = *(_DWORD *)(a1 + 24);
if ( v10 == 0 )
{
*(_DWORD *)(a1 + 24) = v4;
v10 = v4;
}
*(_DWORD *)(a1 + 28) = v6;
*(_DWORD *)(a1 + 32) = v10;
if ( 2048 - v9 <= 128 )
sub_1A36B90(a1: 2, a2: 0, a3: (__int64)R5::SendInputTelemetry2, a4: 0);
}
}
}
}
}
In this beautiful code snippet, you can see that sub_1A36B90 is used to dispatch the execution of a certain function later on named R5::SendInputTelemetry2. Its job is to check the ConVar raw_input_client_send_enable, and if its value in the convar system is not zero, it will serialize some data and then transmit it to the game server via the same connection ordinary gameplay/engine related traffic passes through. In order to understand it better, lets take a look at SendInputTelemetry2. And yes, as the name suggests, there is at least one different path that accomplishes something very similar. You could call it redundancy or simply they are different in semantics.
void __fastcall R5::SendPlayerInputTelemetry2(__int64 a1)
{
EnterCriticalSection(lpCriticalSection: (LPCRITICAL_SECTION)(a1 + 66288));
v2 = *(_DWORD *)(a1 + 28) - *(_DWORD *)(a1 + 24);
v11 = 256;
*(_DWORD *)(a1 + 24) = 0;
v12 = 0;
v8 = &unk_9A7ED20;
v9 = 2048;
v10 = 0x4000;
R5Net::WriteBits(a1: (__int64)&v8, a2: 1u, a3: 16);
v19 = *(_QWORD *)(a1 + 8);
R5Net::WriteBits(a1: (__int64)&v8, a2: v19, a3: 32);
R5Net::WriteBits(a1: (__int64)&v8, a2: HIDWORD(v19), a3: 32);
if ( R5::SerializeSomeNetBufferBits(a1: a1 + 65632, a2: (__int64)&v8) )
{
v3 = HIDWORD(v10) + 7;
*(_DWORD *)(a1 + 65632) = 0;
v4 = v3 >> 3;
*(_QWORD *)(a1 + 65648) = 0;
Utils::EnsureCapacity16(a1: a1 + 65656, a2: 0);
*(_DWORD *)(a1 + 65664) = 0;
Utils::EnsureCapacity16(a1: a1 + 65688, a2: 0);
*(_DWORD *)(a1 + 65696) = 0;
Utils::EnsureCapacity16(a1: a1 + 65720, a2: 0);
*(_DWORD *)(a1 + 65728) = 0;
Utils::EnsureCapacity16(a1: a1 + 65752, a2: 0);
*(_DWORD *)(a1 + 65760) = 0;
Utils::EnsureCapacity16(a1: a1 + 65784, a2: 0);
*(_DWORD *)(a1 + 65792) = 0;
Utils::EnsureCapacity16(a1: a1 + 65816, a2: 0);
*(_DWORD *)(a1 + 65824) = 0;
resize_and_copy_buf(a1: a1 + 65848, a2: 0);
*(_DWORD *)(a1 + 65856) = 0;
resize_and_copy_buf(a1: a1 + 65880, a2: 0);
*(_DWORD *)(a1 + 65888) = 0;
resize_and_copy_buf(a1: a1 + 65912, a2: 0);
*(_DWORD *)(a1 + 65920) = 0;
sub_1B6A1D0(a1: a1 + 65944, a2: 0);
*(_DWORD *)(a1 + 65952) = 0;
sub_1B6A1D0(a1: a1 + 65976, a2: 0);
*(_DWORD *)(a1 + 65984) = 0;
resize_and_copy_buf(a1: a1 + 66008, a2: 0);
*(_DWORD *)(a1 + 66016) = 0;
resize_and_copy_buf(a1: a1 + 66040, a2: 0);
*(_DWORD *)(a1 + 66048) = 0;
*(_DWORD *)(a1 + 65628) = 0;
if ( v2 != 0 )
v5 = (double)v4 / ((double)v2 / 1000.0);
else
v5 = 0.0;
*(_DWORD *)(a1 + 66272) += v4;
*(_DWORD *)(a1 + 66276) += v2;
v6 = v5;
if ( v6 > *(float *)(a1 + 66280) )
*(float *)(a1 + 66280) = v6;
v7 = gpNetChan;
v14 = 0;
v16 = 0;
netMsg = off_3007568;
v15 = 0;
v17 = &unk_9A7ED20;
v18 = v4;
C_NetChan::SendNetMsg(a1: gpNetChan, a2: (__int64)&netMsg, a3: 0, a4: 0);
C_NetChan::SendDatagram(a1: v7, a2: 0);
}
LeaveCriticalSection(lpCriticalSection: (LPCRITICAL_SECTION)(a1 + 66288));
}
Let’s take a look at the second variant. It makes use of a different serialization function.
void __fastcall R5AC::CollectInputTelemetryAndSend(LARGE_INTEGER *lpPerformanceCount)
{
if ( dword_3623E2C == 0 )
{
v2 = cvar::r5::raw_input_collection_disable;
if ( *((_DWORD *)cvar::r5::raw_input_collection_disable + 23) == 0 )
{
bEnableClientSend = cvar::r5::raw_input_client_send_enable;
if ( *((_DWORD *)cvar::r5::raw_input_client_send_enable + 23) != 0 )
{
if ( lpPerformanceCount[8277].LowPart == 0 )
{
(*((void (__fastcall **)(_UNKNOWN **, __int64 (__fastcall *)()))off_6ACB810 + 39))(
a1: &off_6ACB810,
a2: R5::SomeCallbackAnticheat);
v4 = WORD6(xmmword_36EC9B0);
v5 = xmmword_36EC9C0;
QueryPerformanceCounter(lpPerformanceCount: &PerformanceCount);
v6 = PerformanceCount.QuadPart - ::PerformanceCount.QuadPart;
WORD2(PerformanceCount.QuadPart) = v5;
HIWORD(PerformanceCount.QuadPart) = v4;
PerformanceCount.LowPart = v6 / qword_6EFA2E0;
v7 = GrowArrayAndAppendSlot(a1: &lpPerformanceCount[8276], a2: v6 % qword_6EFA2E0);
v8 = lpPerformanceCount[8276];
InterfaceClassGuid[0] = 932045900;
InterfaceClassGuid[1] = 298931951;
*(LARGE_INTEGER *)(v8.QuadPart + 8LL * v7) = PerformanceCount;
InterfaceClassGuid[2] = -1610576708;
LODWORD(InterfaceClassGuid_12) = -586869559;
R5::EnumerateHidDevicesAndExtractVidAndPid((GUID *)InterfaceClassGuid);
InterfaceClassGuid[0] = -2008312125;
InterfaceClassGuid[1] = 298931951;
InterfaceClassGuid[2] = -1610576708;
LODWORD(InterfaceClassGuid_12) = -586869559;
R5::EnumerateHidDevicesAndExtractVidAndPid((GUID *)InterfaceClassGuid);
lpPerformanceCount[1].QuadPart = 1000 * sub_2C26BD8(a1: 0);
QueryPerformanceCounter(lpPerformanceCount);
if ( dword_3623E2C != 0 )
{
LABEL_13:
BYTE4(lpPerformanceCount[8285].QuadPart) = 1;
return;
}
v2 = cvar::r5::raw_input_collection_disable;
bEnableClientSend = cvar::r5::raw_input_client_send_enable;
}
if ( v2[23] == 0 && bEnableClientSend[23] != 0 )
{
v12 = 256;
v13 = 0;
*(_QWORD *)InterfaceClassGuid = &unk_9A7ED20;
InterfaceClassGuid[2] = 2048;
InterfaceClassGuid_12 = 0x4000;
R5Net::WriteBits(a1: InterfaceClassGuid, a2: 2, a3: 16);
PerformanceCount = lpPerformanceCount[1];
((void (__fastcall *)(_QWORD, _QWORD, _QWORD))R5Net::WriteBits)(
a1: InterfaceClassGuid,
a2: (LARGE_INTEGER)PerformanceCount.QuadPart,
a3: 32);
R5Net::WriteBits(a1: InterfaceClassGuid, a2: (unsigned int)PerformanceCount.HighPart, a3: 32);
if ( (unsigned __int8)R5::SerializeInputTelemetryMaybe(a1: &lpPerformanceCount[8263], a2: InterfaceClassGuid) != 0 )
{
if ( (_BYTE)v12 != 0 )
{
sub_1C1BFF0(a1: "anticheat.raw_input.match.send_buffer_overflow:1|c\n");
}
else
{
v9 = gpNetChan;
v14 = off_3007568;
v15 = 0;
v19 = (HIDWORD(InterfaceClassGuid_12) + 7) >> 3;
v17 = 0;
v18 = &unk_9A7ED20;
v16 = 1;
C_NetChan::SendNetMsg(a1: gpNetChan, a2: (__int64)&v14, a3: 1, a4: 0);
C_NetChan::SendDatagram(a1: v9, a2: 0);
}
}
}
goto LABEL_13;
}
}
}
}
This one seems interesting because alongside the usual input telemetry bullshit, you also encounter a function that seems to enumerate all HID devices via SetupAPI, and then extract their Vendor-ID and Product-ID to then save it in a global, dynamic array through another helper function. Our next steps in understanding this better would be inspecting what kind of data it actually sends. This is on my todo list and i will release a second part of this post once i have gotten around to do all of this extra work. Until then, you can view the serialization functions yourself here. If you care about how the data is processed before sending, feel free to check this out. It contains some very good stuff specifically for handling the processing of different input methods.
I additionally was interested in determining whether this A/B testing mechanism for Anybrain even executed at all. If you read closely, i have previously been targeting the network dispatch path instead of the A/B testing bootstrapper function. The latter would only lead to an observable execution if i managed to land within the target activation group in their testing system. Or more precisely, whether the experiment is even ongoing at all. In order to do this reliably, i decided to leverage a breakpoint. Let’s first take a look at the raw assembly for the check:
.text:0000000001AC86F9 loc_1AC86F9: ; CODE XREF: R5__Experiments__CheckAndBootstrapAnybrainAB+29F↑j
.text:0000000001AC86F9 ; R5__Experiments__CheckAndBootstrapAnybrainAB+2AD↑j ...
.text:0000000001AC86F9 48 85 F6 test rsi, rsi
.text:0000000001AC86FC 0F 84 59 05 00 jz loc_1AC8C5B
.text:0000000001AC86FC 00
.text:0000000001AC8702 0F B6 16 movzx edx, byte ptr [rsi]
.text:0000000001AC8705 4C 8D 05 4D CA lea r8, aExperimentOngo+1 ; "XPERIMENT_ONGOING"
.text:0000000001AC8705 52 01
.text:0000000001AC870C 38 15 46 CA 52 cmp byte ptr cs:aExperimentOngo, dl ; "EXPERIMENT_ONGOING"
.text:0000000001AC870C 01
.text:0000000001AC8712 49 8B C8 mov rcx, r8
.text:0000000001AC8715 75 1D jnz short loc_1AC8734
.text:0000000001AC8717 48 8B C6 mov rax, rsi
.text:0000000001AC871A 49 2B C0 sub rax, r8
.text:0000000001AC871D 4C 8D 40 01 lea r8, [rax+1]
.text:0000000001AC8721
.text:0000000001AC8721 KEEP_COMPARING_NEXT: ; CODE XREF: R5__Experiments__CheckAndBootstrapAnybrainAB+302↓j
.text:0000000001AC8721 84 D2 test dl, dl
.text:0000000001AC8723 74 4C jz short DO_FURTHER_CHECKS_AND_TOGGLE_ANYB
.text:0000000001AC8725 41 0F B6 14 08 movzx edx, byte ptr [r8+rcx]
.text:0000000001AC872A 0F B6 01 movzx eax, byte ptr [rcx]
.text:0000000001AC872D 48 FF C1 inc rcx
.text:0000000001AC8730 3A C2 cmp al, dl
.text:0000000001AC8732 74 ED jz short KEEP_COMPARING_NEXT
.text:0000000001AC8734
.text:0000000001AC8734 loc_1AC8734: ; CODE XREF: R5__Experiments__CheckAndBootstrapAnybrainAB+2E5↑j
.text:0000000001AC8734 48 8D 56 F0 lea rdx, [rsi-10h]
.text:0000000001AC8738 41 8B C5 mov eax, r13d
.text:0000000001AC873B F0 0F C1 42 08 lock xadd [rdx+8], eax
.text:0000000001AC8740 83 F8 01 cmp eax, 1
.text:0000000001AC8743 75 09 jnz short loc_1AC874E
.text:0000000001AC8745 48 8B 02 mov rax, [rdx]
.text:0000000001AC8748 48 8B C8 mov rcx, rax
.text:0000000001AC874B
.text:0000000001AC874B FF 50 08 call qword ptr [rax+8]
Let’s take a look what path it actually took during a real session of Apex Legends today:
; string comparision loops starts to happen...
[40.3] [MSG] [Slot] (282) PID:10232, TID:23256, RIP:r5apex_dx12.exe+0x1ac8721, AccessType:X
[40.3] [MSG] [Slot] (283) PID:10232, TID:23256, RIP:r5apex_dx12.exe+0x1ac8723, AccessType:X
[40.3] [MSG] [Slot] (284) PID:10232, TID:23256, RIP:r5apex_dx12.exe+0x1ac8725, AccessType:X
[40.3] [MSG] [Slot] (285) PID:10232, TID:23256, RIP:r5apex_dx12.exe+0x1ac872a, AccessType:X
[40.3] [MSG] [Slot] (286) PID:10232, TID:23256, RIP:r5apex_dx12.exe+0x1ac872d, AccessType:X
[40.3] [MSG] [Slot] (287) PID:10232, TID:23256, RIP:r5apex_dx12.exe+0x1ac8730, AccessType:X
[40.3] [MSG] [Slot] (288) PID:10232, TID:23256, RIP:r5apex_dx12.exe+0x1ac8732, AccessType:X
[40.3] [MSG] [Slot] (289) PID:10232, TID:23256, RIP:r5apex_dx12.exe+0x1ac8721, AccessType:X
[40.3] [MSG] [Slot] (290) PID:10232, TID:23256, RIP:r5apex_dx12.exe+0x1ac8723, AccessType:X
[40.3] [MSG] [Slot] (291) PID:10232, TID:23256, RIP:r5apex_dx12.exe+0x1ac8725, AccessType:X
[40.3] [MSG] [Slot] (292) PID:10232, TID:23256, RIP:r5apex_dx12.exe+0x1ac872a, AccessType:X
[40.3] [MSG] [Slot] (293) PID:10232, TID:23256, RIP:r5apex_dx12.exe+0x1ac872d, AccessType:X
[40.3] [MSG] [Slot] (294) PID:10232, TID:23256, RIP:r5apex_dx12.exe+0x1ac8730, AccessType:X
[40.3] [MSG] [Slot] (295) PID:10232, TID:23256, RIP:r5apex_dx12.exe+0x1ac8732, AccessType:X
; destination of the jump to on-failure branch (anybrain will not be enabled)
[40.3] [MSG] [Slot] (303) PID:10232, TID:23256, RIP:r5apex_dx12.exe+0x1ac8734, AccessType:X
As you can see, the string compare did in fact execute 😀 If you’re wondering where 0x1ac8734 leads to: It basically is located at the epilogue of the function, and it jumps there inside the EXPERIMENT_ONGOING string compare with the current experiment status.
This is usually happening when they havent toggled the experiment as ongoing/active yet, i.e the experiment status is NOT of value “EXPERIMENT_ONGOING”. I was additionally able to observe the functions responsible for doing the POST request to fetch experiments from the server, and also the function that sends the currently active experiments from client to server, actually execute.
// around ~0x1AC8721
while (v26 != 0) {
v26 = v27[(char *)v22 - "XPERIMENT_ONGOING" + 1];
v28 = *v27++;
if (v28 != v26) goto LABEL_52; // <--- this branch was taken on my machine.
}
// around ~0x1ac8734
else {
LABEL_52:
if (_InterlockedExchangeAdd(v22 - 2, 0xFFFFFFFF) == 1)
(*(void(__fastcall **)(_QWORD))(*((_QWORD *)v22 - 2) + 8LL))(
a1
: *((_QWORD *)v22 - 2));
if (_InterlockedExchangeAdd(v16 - 2, 0xFFFFFFFF) == 1)
(*(void(__fastcall **)(_QWORD))(*((_QWORD *)v16 - 2) + 8LL))(
a1
: *((_QWORD *)v16 - 2));
}
v13 = v60 + 1;
++v72;
++v60;
if (v72 >= v73) goto LABEL_128;
}
v59 = 0;
}
else {
LABEL_128:
v59 = 1;
}
ReleaseSRWLockExclusive(SRWLock : &stru_5C49AB0);
return v59;
}
This means that respawn could really just flip a switch and if anybrain is really that sophisticated, it would make a lot of aim related cheats obsolete. Especially if they handle cases where somebody just manipulates this input telemetry system, i.e to not send out any data, or send out some kind of normalized fake data that avoids tripping it. They could use multiple approaches to harden it further, and it would quickly turn out to be annoying as hell.
If you want to take a look at some unfinished work, check out this git repository of mine. It’s still a work in progress and just intended to greate an incomplete map of their stuff, so that further work becomes easier.
Conclusion
As you can see, there is quite a lot of work to do for me. I’m currently playing with 0.7 Aim Assist override, on a controller. So far, i have not been hammered. But this means very little nowadays because now we’re righting multiple systems that theoretically should reinforce each other independently. Still, i really enjoy playing Apex and being back to playing it is very exciting. I must say that for now, i’m staying away from the maintenance of invasive multihacks and larger cheat projects. Playing without walls is pretty rough at times, but its also much more fun in its own way.
Update 2026/10/26: My account just got clapped so this will be my first ban on their new AC. Reached level 23 and ~600 kills in mixtape. Account was created on 2026/10/15. I haven’t used any wallhacks and also haven’t done anything obvious like spam memory access externally. My approach was modifying the game’s own gamepad aim assistance feature. I enabled target compensation on mouse and keyboard, and also removed restrictions for certain weapons, like grenades. The aim assist force was modified to be roughly 0.8 (80%). Just for the reference: aim assist in Apex used to be 0.4 on PC, and 0.6 on Console.
Since our previous dive into Anybrain has suggested that its in a dormant state, i would guess that i was banned either based on client-side detection thresholds being reached or possibly a combination of that and high accuracy. I didn’t get many high kill games, but since i had no ESP, i was relying on w keying everything and just forcing gun fights wherever i can. This would lead to a lot of situations where i one clipped multiple people back to back. Keep in mind that in my last 5 days of play before being banned, i also enabled aim assist while not playing on an actual controller, and at times i even had my roller unplugged because i just made it so that the game thinks im on controller when it runs the aim assist check.
{"name":"stats.kills_any_mode","value":"611"}
{"name":"stats.kills_or_assists_any_mode","value":"996"}
{"name":"stats.damage_done_any_mode","value":"126228"}
{"name":"stats.npp_damage_done_any_mode","value":"126228"}
{"name":"stats.weapon_damage_done_any_mode","value":"125958"}
{"Event_Type":"accountChangeLog","Account_Change":"[endDate=2094-10-09T17:42Z(null)&reasons=null(null)&readOnly=null(false)&comments=null(null)]","Timestamp":"2026-10-26T17:42:42.626Z","Event_Status":"SUCCEEDED"}
And i would try to compensate for my loss of information advantage due to the lack of ESP by simply outputting high damage numbers using the aim assist. This made my efficiency much worse because i have 10k hours of gameplay with ESP, but practically 0 hours of gameplay without it. So you simply lack the intuition and standard prediction and game sense that legit people posess.
We will never know why i was banned but i’ll say it was most likely warranted. Another possibility could be that since i didn’t continuously monitor the experiment fetcher for Anybrain, it could have just flipped to active state and possibly have landed on the activation treatment group if i was very unlucky. But i personally don’t think this is very likely, as the master switch for the experiment was disabled during my tests. So in order for this scenario to become likely, they would’ve had to flip the master switch IN ADDITION to me having to fall into the target activation group.
My approach was also more of an analysis environment than a stealth cheat, and i did a lot of silly shit like debugging stuff within the game, fixing up the standard functions like MmCopyVirtualMemory to work despite EA Javelin’s fake DTB, and then using that to just read and write stuff for just messing around. If i were to continue this in a sustainable way, i would have to switch some things up and invest some time into further reversal of their new stuff.
I’m currently not interested enough in that and kind of feel like it would be a lot of work to sustain something worthwhile, like an internal cheat. And should they actually go forward with their anybrain implementation and enable it, it would become even more pointless in my opinion. I might keep Apex as something i occasionally visit and play whenever there is something worth investigating, and something that is realistic with my current time budget and capability.
Also, being banned sucks especially if you cant even last more than a couple weeks. I think the real thrill in this comes when you can be blatant but still have a stacked account. But yeah, either i have regressed or times might have changed. Who knows…