They are making sure it works fine since they have to do the V3 as well
Same situation with synapse
1 Like
Well if they obfuscated it, then we definitely can. No one’s doing it yet.
Obfuscating does indeed work, you can’t unobfuscate code at all, the best thing exploiters can do is somehow get the constant (Their decompiler will still show the obfuscated result or just straight up crash)
Well is there a tutorial for it?
You can search obfuscators for lua around the internet
Well, is that the #1 client anticheat must-have?
Yeah, because then exploiters will bypass the anti cheat on 1 second, or just disable it and copy the handshake code aka replicate it.
Well, that’s great. Wonder why people don’t usually google this.
Probably because they can still hook or force the script to error with basics metamethods hooks that’s why I said the actor + hiding both actor and localscript solution is the best thing rn, also the environment is deleted after hiding the script, the script is just gone, I doubt nil:Destroy() would even work here lol.
You’re basically free to make anti cheats with that method without worrying about spoofs because NO free executor has run_on_actor, the free ones can’t execute before the local scripts hides the actor and hides itself aka set everysingle property to nil and lock it so they can’t move the script back to the game, or disable it.
if you call :Destroy() on something which is already parented to nil, then it doesn’t change.
When you run it, it literally sets the parent to nil anyway.
1 Like
Obfuscation doesn’t magically stop the script from being bypassed; all it does is “hide” the code so they can’t as easily find weak points.
Acutally, it is very possible to deobfuscate obfuscated code, depends on the obfuscator there are plenty of deobfuscators that are released.
3 Likes
Most deuobfuscators if not all beautify the code, and that’s pretty much all they do, they aren’t magically getting the variables and functions which is the important thing, exploiters still have to resolve the unreadable code.
The only way they could get the full source is if the obfuscator that the person used has an deobfuscate function, that resolves everything, then that obfuscator is pretty much useless, and they are many other options out there.
1 Like
so can ER:LC’s local anti-cheat be deobfuscated?
1 Like
With the right tools and knowledge it possibly could.
1 Like
It is technically possible, but most exploiters are skids so they don’t even know how to deobfucate, if exploiters can obfuscate their scripts, then so a local script can, the point of this is to make reverse as hard as possible similar to how BYFRON works, and main reason why they can’t add it to microsoft store version, because It’s code is obfuscated.
By obfuscating code you are basically protecting your scripts from getting stolen and so on.
This is only needed on clients anti cheats, server sides anti cheats bytecode stays on the server so It’s impossible to decompile.
1 Like
I did some test to see who is the fastest, using tick(), since os.time() gave me 0 in the result.
As you can see, they execute the code really fast, actor seems to be faster even though It had another line of code, this is the code of the actor:
local x = tick()
getfenv().script.Parent:Destroy()
getfenv().script:Destroy()
getfenv().script = nil
local result = tick() - x
print("ACTOR FINISHED IN " .. tostring(result))
And this is the code of the “normal local script”:
local x = tick()
getfenv().script:Destroy()
getfenv().script = nil
local result = tick() - x
print("NORMAL FINISHED IN " .. tostring(result))
So we can confirm that actors are faster than normal local scripts, this isn’t really that accurate, because the Environment code executes before printing the result, and not right after it finishes.
1 Like
Doesn’t your benchmark show that normal is faster lol?
1 Like
The actor was the first script that printed the result in everysingle test.
1 Like
Oh well, it’s a bit confusing since normal had a smaller time
1 Like