Protecting code from reverse engineering; freeware

[JamesWasil]

If it can be run, it can be reverse-engineered. However, there are a few tools that make it more difficult for people to do that out there. One of which is a free tool called ConfuserEx which can be found here if people want to use it for programs they write: https://github.com/yck1509/ConfuserEx

(The above link was one of the original continuations from ConfuserEx made for .NET platforms. It is no longer maintained or updated, but a fork of it which is is available here: https://github.com/mkaring/ConfuserEx
)

People who do reverse-engineering may want to study it too, so it really is for everyone lol

[Shelwien]

Unfortunately that only applies for C# and java.
New obfuscation schemes for interpreted/JIT languages are a rather strong protection, since there're no public low-level tools for their formats.
But on other hand, once obfuscation is defeated, there's plenty of information (and tools) to almost recover the source.

However, C#/java are mostly useless for data compression, since JIT compilation quality is pretty low comparing to gcc/clang.

But there're also some tools for "native" executables: https://vmpsoft.com/

http://web.archive.org/web/201603221...per-protection
https://webcache.googleusercontent.c...045/index.html
https://habr.com/ru/company/intel/blog/274045/

Unfortunately, obfuscated/compressed/protected executables produce a lot of AV alerts, so nobody would run them :)

[comp1]

I've looked into this a few times over the years. The conclusion is always the same, reverse engineering can't be prevented. Groups exist who spend countless hours working together to break new obfuscation methods.

That's not to say that it's not an interesting topic to dive into and research. But, I don't believe that true, full-proof obfuscation is possible.

I do think, though, that the constant cracking of new protection methods forces the continuation of thought and innovation.

[Shelwien]

> I don't believe that true, full-proof obfuscation is possible.

Its probably possible with hardware support, like https://en.wikipedia.org/wiki/Software_Guard_Extensions https://en.wikipedia.org/wiki/Truste...rdware_support

Its kinda like driver signing - may be not 100% secure, but requires too much resources to beat, so average hackers won't be able to deal with it.

[Jarek]

Reverse engineering got to next level: https://www.extremetech.com/computin...ng-game-engine

It might also come to data compression - many simple schemes could be automatically deduced from plaintext and compressedtext ...
A way to protect could be encryption e.g. this pseudorandom perturbation of tANS symbol spread.

[schnaader]

You can try to reverse engineer the code coming from this C compiler:

https://github.com/Battelle/movfuscator

Will be very hard as the binary will only contain mov instructions and has some (optional?) randomization applied, IIRC. On the other hand, performance of the programs compiled with this won't be very good. There's an example of DOOM 1 compiled this way that renders a frame around every 7 hours.

https://github.com/xoreaxeaxeax/movf...alidation/doom