Cxrbon: AI Slop, a Borrowed Injector and a Lot of Talk

Release
#02
Date
Read time
17 min

Cxrbon.dev is a paid CS2 cheat. Its developer, Cat999 (py_nimbus), is a regular voice in the scene’s Discord servers. He calls other cheats “shit”, posts screenshots of the ones he claims to have cracked, and offers their developers “security reports”.

Since he values security reports, we wrote one for him.

Short version: Cxrbon is a 35 MB binary full of plaintext strings. It is wrapped in a commercial packer, injected by an open-source injector, hooked with an open-source hooking library, and, as far as we can tell, largely written by a language model. The only thing standing between the cheat and anyone with a disassembler is Themida. The one protection mechanism the developer built himself gave up all of its secrets in 51 milliseconds.

This article is based on our own analysis of two Cxrbon builds and on screenshots from the Cxrbon Discord and from DMs. Where something is our interpretation rather than an established fact, we say so.

Built in the Downloads folder

The debug information left in the binary reveals the project path:

C:\Users\[redacted]\Downloads\Cxrbon Internal\bin\Release\loader-full-source\CxrbonLoaderFull.pdb

The project lives in the Downloads folder, in a directory called loader-full-source. That is not where people usually set up a long-term project. It is where they unzip things. The most plausible reading is that an existing cheat source was downloaded and Cxrbon was built on top of it. A path alone doesn’t prove that, but nothing we found later contradicts it.

35 MB of “protected” cheat

The payload is called cxrbon_full.dll and exports a single function, CxrbonShutdown. We looked at two builds:

Linked (UTC)File sizeSHA-256 of the shipped file
2026-11-10 03:17:4435,262,480 bytesd5d9ac6133c0157c30b2f450aa62aced9dcfb348edc151c9f5e3f299aa0c60ec
2026-11-12 02:01:4935,570,192 bytes8c4ab8f1c793a460e933a85a43031a3b2598edd1ecfab6fafb1a315bcba82218

That is 35 MB on disk and about 89 MB in memory, which is a lot for an internal cheat. The DLL is packed with Themida. Two observations about how well that holds up once the cheat is running:

The loader leaves a full copy of the DLL in the game’s memory. Besides the mapped image, the complete file, byte for byte as shipped, sits in an executable memory region next to it. The hash is identical across sessions. A developer who collects other people’s builds is handing out his own.

Themida buys him about a second and a half. That is how long the code stays encrypted after injection. After that it is an ordinary MSVC binary, readable top to bottom. Not one of the cheat’s hook handlers is virtualized. He paid for a commercial protector and pointed it at nothing.

Plaintext strings everywhere

Open the unpacked image in IDA and look at the strings window. No digging required.

IDA string view filtered for "aimbot"

Dozens of UI strings for the aimbot, triggerbot, autowall and “Rage or Legit” badges, in English, Spanish and Portuguese, none of them encrypted.

Filtering for “cxrbon” turns up config file extensions, “Cxrbon cases” odds, Discord status strings, full HLSL shader sources for chams and the material preview, and JavaScript (CxrbonRadar) that gets injected into CS2’s Panorama UI.

IDA string view filtered for "cxrbon"

In total the unpacked image contains roughly 49,000 readable strings. Several hundred of them name a cheat feature outright. We found no string encryption anywhere: every menu label, tooltip and error message is plain text. Strings like these are among the easiest things for an anti-cheat to signature, and in our opinion this would not hold up long against an anti-cheat that was actively looking for it.

“Are you sure about that?”

Cxrbon’s loader does take one thing seriously: what else is running on your PC. According to the developer, running another cheat or a blacklisted program (debuggers, analysis tools and the like) gets you loader-banned automatically.

Cat999: "for that ye should be fine ... loading another cheat tho or some programs will loader ban u automatically"

So the loader scans your processes, and the idea is that nobody gets to look at Cxrbon with the wrong tools open.

Everything in this article was produced with exactly those tools.

The cheat that documents itself

Plaintext menu strings are one thing. Cxrbon goes further and ships its own documentation.

A full-sentence internal log. Every log message is compiled in as plain text:

license: runtime release key from the server does not unlock this build
movement: Air Stuck sent command {} as {}
visuals: the weapon icon atlas could not be uploaded
hud: Reveal Ranks: the server sent a rank for {} of {} players
inventory: {} item{} and {} equip{} added to the game's inventory

Each message labels the function that prints it. That names 236 functions for free, sorted by module: inventory, particles, recorder, movement, chams, hud, radar, license.

RTTI is still enabled. The binary keeps its C++ class names, 439 vtables’ worth: movement::dry_run::session, particles::world_cache, spotify::boombox.

The developer’s own function names are still inside. Because of how the code uses lambdas, the compiler embedded the names of the enclosing functions in the binary. 71 of them can be recovered, including the entire menu:

ui::draw_aim_page          ui::draw_esp_popup         ui::draw_recoil_page
ui::draw_radar_page        ui::draw_skin_tab          ui::draw_spotify_page
movement::recorder::on_level_init                    config::read_json

The dependency list is readable too. Hooking: safetyhook. JSON: nlohmann::json. Menu: Dear ImGui. Icons: Font Awesome. All of them written by other people.

Taken together, about 3,900 of the roughly 20,800 functions in the cheat identify themselves without any analysis effort.

74 hooks, no subtlety

Cxrbon patches the game with the most basic kind of inline hook: a jmp written over the start of a function. With VAC actively scanning, this alone would mean a detection and an instant ban.

ModuleHooks
client.dll53
d3d11.dll8
scenesystem.dll5
steamclient64.dll2
engine2.dll, DXGI.DLL, inputsystem.dll, particles.dll, materialsystem2.dll, steamnetworkingsockets.dll1 each

That is 74 hooks, give or take one or two between builds. Each one is a modified byte in game code that shows up when you compare the module in memory with its file on disk, and each one points straight back into the cheat. It even patches Steam’s own client DLL.

The signature vault that opens itself

This is the one area where real effort went in, which makes the result all the more notable. It is also where we can stop reading strings and open the decompiler, because the design is genuinely worth looking at.

A CS2 cheat needs byte patterns to locate game functions. Cxrbon has 250 of them, and the design around them is the best engineering in the product. Here is the whole scheme, and then the one line that undoes it.

The names are plaintext; the patterns are not. The 250 signature names sit in the binary as readable strings, so it tells you exactly what it hunts for:

FrameStageNotify
C_BaseEntity::EyePosition (vtable offset)
ClientModeCSNormal::OverrideView
CGamePhysicsQueryInterface::TraceShape
C_CSWeaponBase::UpdateSkin

The byte patterns themselves are encrypted, and this part he got right. IDA names the routine for us from the symbols left in the binary: license__decrypt_runtime_data_aes256gcm. Decompiled and trimmed to the parts that matter:

_BOOL8 license__decrypt_runtime_data_aes256gcm(void *key /* 32 bytes */)
{
    // Windows CNG: AES in GCM chaining mode
    BCryptOpenAlgorithmProvider(&alg, L"AES", 0, 0);
    BCryptSetProperty(alg, L"ChainingMode", L"ChainingModeGCM", 32, 0);
    BCryptGenerateSymmetricKey(alg, &hKey, 0, 0, key, 32, 0);
    memset(key, 0, 0x20);                       // key wiped immediately

    // 12-byte nonce, 16-byte tag, and an authenticated-data label:
    info.nonce      = &unk_1C13F94EBF0;  info.nonce_len = 12;
    info.tag        = &unk_1C13F947AC0;  info.tag_len   = 16;
    info.auth_data  =
        "CxrbonRuntimeData/v2/full/[censored]/"
        "[censored]";

    ok = BCryptDecrypt(hKey, &info, plaintext, size);
    // ... cleanup ...

    if (ok)
        runtime_data__parse_and_assign_signatures(plaintext, size);
    memset(plaintext, 0, size);                 // plaintext wiped
    memset(key, 0, 0x20);                        // key wiped again
    return result;
}

Read that on its own and it is a competent piece of work. AES-256 in GCM, so the patterns are both encrypted and authenticated. A 32-byte key that is never in the file — it arrives over the network — and is zeroed the moment the session key is built. A 96-bit nonce and a 128-bit tag, the textbook sizes. An authenticated-data label (CxrbonRuntimeData/v2/full/<build id>/…) that ties the ciphertext to this exact build, so a blob from one version will not decrypt in another. Both the key and the decrypted text are memset to zero on the way out. Whoever wrote this had read the GCM documentation.

The key is delivered through a “license channel” with its own apparatus, which the log strings lay out in full: a login proof, a heartbeat proof renewed before a 130-second timeout, a separate check that the loader is still alive within 35 seconds, a per-build “runtime release key”, and a “local security check” guarding the whole thing.

license: runtime release key from the server does not unlock this build
no accepted heartbeat for 130 seconds
local security check refused a valid heartbeat

On paper it is the one part of Cxrbon you could call real security.

And here is the problem. To use a byte pattern, you have to have the byte pattern. runtime_data__parse_and_assign_signatures takes the decrypted blob, splits it into name<TAB>pattern lines, and hands each of the 250 table entries a view straight into that plaintext. For the length of the scan, all 250 patterns sit in memory, each one already labelled with the plaintext name next to it. The encryption bought nothing: the moment the data is useful, it is also readable.

The developer knew this, which is the part we find most telling. After the scan, a second routine — IDA names it runtime_data__wipe_signatures — walks the table and zeroes every pattern:

// Zeroes g_runtime_data_text, then clears each entry's
// pattern pointer (+0x20) and length (+0x28).
do {
    entry = *p++;
    *(entry + 32) = 0;      // pattern pointer
    *(entry + 40) = 0;      // pattern length
} while (p != table_end);

That wipe loop runs over exactly 250 entries. Someone understood that the plaintext signatures were sensitive and should not linger — so they built encryption at rest, a server-held key, authenticated data, and a scrub afterwards. Every piece is correct. The one thing none of it can change is that the plaintext has to exist, in full, in the window between decrypt and wipe.

So we waited in that window. We did not touch his key, his server, or the GCM — we let the cheat decrypt its own data, as it must, and read the table out of memory while the scan was running. 250 of 250 signatures, with their names, in 51 milliseconds. The “local security check” the log strings are so proud of noticed nothing.

The data the whole license channel exists to protect is therefore available to anyone with a license and a bit of patience: customers, competitors and anti-cheat vendors alike. We are not publishing the list. The point is that it cannot be kept private, and no amount of GCM will change that — it is the wrong defence for the problem.

AI-written code

The shader code embedded in the binary contains comments like this one:

Shader source with comments embedded in .rdata

// Signed distance to a box of half sides `extent` with corners rounded by `r`, negative inside.

Markdown backticks around variable names inside a C-style shader comment are a typical sign of LLM output. The rest of the code reads the same way: verbose, generic and over-explained.

The error messages make the contrast clearer. This is how the developer writes in Discord:

for that ye should be fine

And this is how the cheat’s error handling reads:

shutdown: Air Stuck was used on this server, which reports command numbers the game cannot take until you leave; image stays resident
radar: the extras over the minimap are unavailable (got active offset {:#x}); Engine Radar is not affected

There are hundreds of these: complete, polite, carefully punctuated sentences for every failure path. We can’t prove who or what wrote them, but the difference in style is hard to miss.

It would also explain the feature bloat: a Spotify boombox, pets, case-opening odds, weather sounds, photo skyboxes, a movement recorder with its own file format. Our assessment: a large part of these 35 MB is AI-generated.

Cat999 has since answered the AI claim himself, in a Discord message apparently aimed at a competing cheat developer:

Cat999: "You keep claiming we use AI for Cxrbon like it's some kind of gotcha. I was part of Reflex Engine over 9 years ago, back when this AI shit wasn't even around like it is today"

Nobody said he started last year. The question is how the code in this build was written, and nine years of history don’t change what is in it.

A rebranded open-source injector

Cxrbon ships a “Cxrbon Injector” DLL (cxrboninjector-x64.dll). Its version info and strings:

GH Injector Library source next to CxrbonInjector-x64.dll in IDA and VirusTotal

  • Copyright: Broihon (C) 1987 - 2035
  • Product: Cxrbon Injector
  • Strings such as injector\DotNetInjection.cpp, injector\FakeVEH WOW64.cpp, SR_FakeVEH, DotNet_Inject_Internal

This is the open-source GH Injector Library by Broihon (Guided Hacking). The product name was changed, and the original author’s copyright was left in place.

Using a public library is legitimate. Selling it under your own brand while lecturing other developers about their security is a different matter. The manual mapper is the part of a cheat that actually requires an understanding of Windows internals, and it is the part he didn’t write.

Bugs

On top of everything else, the cheat doesn’t work particularly well.

Deathmatch has to be enabled by hand. The ESP can’t detect on its own that you are playing Deathmatch. You have to tick a separate “Deathmatch” checkbox before it shows players correctly.

ESP menu with a "Deathmatch" toggle

The game mode is right there in memory. Instead of reading it, the cheat leaves the job to the customer.

Rapid Fire only works on local servers. On a local server it does what it says. On official or community servers online, it does nothing. A feature that only works where nobody is playing against you is mostly a demo.

Death effects freeze the game. With death effects enabled, the game freezes for around five seconds on your first kill, long enough that you think it has crashed. That is the moment the shader code for the effect is initialized for the first time, instead of when the feature is turned on or the map loads. Five seconds of freeze right after a kill is not what you want in a live round.

The binary seems to be aware of its own reliability, too: it contains more than 200 strings with the word “unavailable”, a ready-made excuse for every feature that might fail.

“I never release cracks”

Now to the developer himself. Cat999 says he cracks other cheats and talks about it often. His explanation: he does it “for fun” and then writes a security report so the developers can fix their issues.

Cat999: "i do for fun ... write a security report ... i never release cracks unless they rat"

Cat999: "i dont release the cracks i jus do em for fun then release security report for them to fix their shit"

The first screenshot also shows the tone of his server: a slur-laden “joke” about the next target, posted in a public channel by the developer.

His own messages don’t fit the researcher image very well. He lists his trophies: “hvh gods, jamware, project infinty, ovix, interium so far, want to do some private ones now”.

Cat999 showing a cracked Ovix

Cat999 showing a cracked Interium

And when someone asks him about an Impresa crack, he doesn’t say he never releases cracks. He offers one:

Cat999: "U want impress crack? ... Imp u want?"

Did he crack anything at all?

There is a simpler explanation for why none of these cracks ever get released: we don’t believe they exist.

Look at what Cxrbon itself tells us about its developer’s skills. The injector is Guided Hacking’s, the hooking is safetyhook, the protection is Themida, and large parts of the remaining code read like LLM output. Someone who couldn’t write his own manual mapper is now supposed to have defeated the protection of half a dozen competing cheats in his spare time, “for fun”. A language model will happily write you a convincing security analysis. It will not crack a protected binary for you.

His own screenshots don’t help. Here is his supposed RedEngine “crack”:

Cat999 showing a RedEngine menu: "no loll gemini menu"

Look at the bottom left of the menu: the account Cat999_23 with a subscription time, valid till 11/19/2026. A cracked cheat has no reason to show a running subscription for the person who cracked it. A legitimately purchased one does.

And when someone asks whether he pulled the menu strings to rename things, his reply is “no loll gemini menu”.

Our assessment: what he shows off are cheats he either bought or had an AI rebuild the menu of, not cracks. That would also explain why he “never releases” them. You can’t release something that doesn’t exist.

How he talks about other developers

Other cheats and their users get similar treatment. Asked whether rapid fire is possible in CS2, his answer is “if ur not retarded, yeah”. On the Fatality and Neverlose developers: “they are retarded”.

Cat999 on Fatality and Neverlose

Those developers wrote their own cheats. He renamed an injector.

Carried by Themida

So what actually protects Cxrbon? Even people who dislike the project give the same answer: the Themida-packed loader.

DM mentioning Cxrbon's Themida-packed loader

That is the entire security story: one commercial packer, bought off the shelf, which holds for about a second and a half. Behind it:

  • the code is unprotected and no hook handler is virtualized;
  • strings, log messages, class names and 71 of the developer’s own function names are readable;
  • the complete shipped DLL is left in memory;
  • all 74 hooks are trivially visible;
  • the one custom protection gives up all 250 signatures in 51 milliseconds.

Cat999 claims to crack other developers’ cheats and lectures them about security. His own product is a downloaded base, a borrowed injector, a borrowed hooking library, a licensed packer and a large amount of generated code, with his name on the front.

He offered the scene security reports. This one is free. If you are considering buying Cxrbon, you now know what you would be paying for.

Showcase

Our recommendation

If you are going to pay for a cheat, pay for a track record, not for talk. Pick a product that has proven itself in the scene over years, built by developers who have been around just as long and whose history you can check: how they handled detections, how quickly they shipped updates after game patches, and how they treated their customers when something went wrong.

A cheat that has survived several years of anti-cheat updates shows that the people behind it know what they are doing. A new product with a loud developer, a feature list that grows every week and nothing underneath but a commercial packer has shown nothing yet, apart from what you just read.

Download

Are you sure about that?

Are you sure about that?

Download

Password: crackstreetboys