DotNet, is that possible to prevent reverse engineering?

[Guest]

me was sorry if this question are present before

DotNet, no matter VB.Net or C# all they are compiled to IL,
and yes, that IL will totally same as "open-sourse",
every IL will easy to decompile and get the source nicety,
although there have comeout with some "obfuscators" solution,
but the structure still remain exactly same as the source after obfuscate.

me unable to understand what the benefit will IL bring to me,
is that benefit of "cross-platformable" provided with IL?
if is that so, me rather to protect my intellectual property than make my
project "cross-platformable"

and yes, me know all the programming language are able to reverse engineering,
but at least they are not as easy as decompile the IL, so please don't
debate such trouble

will this problem solved in next version of .Net?

or maybe .Net should comeout with option that allow developer to choice :
compile to IL
compile to native code


sry about my poor English
and thnx for reading my post

 

[Olaf Baeyens]

and yes, me know all the programming language are able to reverse
engineering,

but at least they are not as easy as decompile the IL, so please don't
debate such trouble

I am afraid that reverse engineering of none-NET programs is as easy as
reverse engineering an IL.
There exist mulitple disasseemblers that have a dictionary aproach and
extract parts of the commercial C++ libraries and actually gives it the
original name of that function.

IDA pro is such an example: http://www.datarescue.com/idabase/
The disassebled code is as readable as the original source code if you know
something about assembler language.
The biggest mistake people make is not to encode their strings, so the
disassembler can point you in a fast way where that particular string is
used, so the executable code will be near that string usage.

Typically this way, programs gets hacked in 30 minutes to 2 hours no more.

I propose not to take too much energie into avoiding reverse engineering but
to put your energy to create much better code, so the competition will
always lag behind.

A few techniques that could help to slow down reverse engineering is to
encrypt all your strings so they become unreadable and thus harder to find.
Maybe to add honey pot strings with names that looks like security related
information but actually are used to draw away the attention from the real
security code. Also give your functions misleading names (e.g. call your
security test AboutMe(). And store any key in a stupid name that normally
does not get associated with security (e.g.: string sMyWife="xxxx". Also try
to randomize the detection of the security thing. When you detect that
something is wrong, wait an random interval before you report the
messagebox.

 

[Cor Ligthert]

Xiao,

Every program language that uses a kind of runtimer is using a kind of IL.

The only problem/advance in fact is that it is now a standarized IL for more
program languages.

For the rest search almost every dotNet newsgroup for "obfuscate" and you
find tons of messages.

Cor

 

[Sean Hederman]

[Snip]

me unable to understand what the benefit will IL bring to me,
is that benefit of "cross-platformable" provided with IL?

Yes, along with verification. This verification allows .NET to guarantee
that the program is not hijacked by such things as buffer overruns. Such a
guarantee requires that the CLR can easily analyze the code, therefore it is
easy to reverse engineer.

if is that so, me rather to protect my intellectual property than make my
project "cross-platformable"

Due to the nature of .NET's design this is not possible. If protecting your
IP is your main concern, I'm afraid that you're fighting a doomed battle no
matter what programming platform you use. .NET may make reverse engineering
easier, but the corollary is that it makes development easier and your
programs more secure and stable. As with all things computer-related there's
trade-offs.

and yes, me know all the programming language are able to reverse
engineering,
but at least they are not as easy as decompile the IL, so please don't
debate such trouble

will this problem solved in next version of .Net?

It will never be "solved". Since the verifiable nature of .NET requires a
fairly simple byte-code, it will always be easy to reverse engineer it.

or maybe .Net should comeout with option that allow developer to choice :
compile to IL
compile to native code

NGEN does create a native code DLL, but it includes the IL as well since it
is required for the verification.

sry about my poor English

It's a damn sight better than my Chinese ;-)

 

[Guest]

as what Olaf Baeyens said, yes that is true, no matter what language also can
be disassemble, but those action only possible done by really pro people, but
not for normal user or normal programmer like myself.
although that disassembler can disassemble it to p-code or something
assemble language, but that totally hard to understand except those pro
familiar with it.

but in .Net, no matter who also can decompile it and get the
structure/design/anything else of my program with nicety,
although there can obfuscate, but after obfuscate, there only add tiny hard
readable to the code, because obfuscators (at least all the obfuscators me
have try) only change the variable/function name to non-meaning style, but
the structure still remian unchanged.

so, if that problem exist, there was no meaning to use .Net to create
application such as games, system tools and others, because finished product
cant hide any secret from users/players.

although like what was Sean Hederman say::"development easier and the
programs more secure and stable"
but me still have to protect my intellectual property...
else there was nothing impetus to make us spend times to design something
"special". What for to spend lot time to develop, but get expose to everyone
in few sec?


is that C++.Net have same happen with VB.Net or C#?


again, thnx for you all reply my post

 

[Sean Hederman]

as what Olaf Baeyens said, yes that is true, no matter what language also
can
be disassemble, but those action only possible done by really pro people,
but
not for normal user or normal programmer like myself.
although that disassembler can disassemble it to p-code or something
assemble language, but that totally hard to understand except those pro
familiar with it.

Actually, some disassemblers can decompile to C++ or C.

but in .Net, no matter who also can decompile it and get the
structure/design/anything else of my program with nicety,
although there can obfuscate, but after obfuscate, there only add tiny
hard
readable to the code, because obfuscators (at least all the obfuscators me
have try) only change the variable/function name to non-meaning style, but
the structure still remian unchanged.

Obfuscators mangle the internal names, often mess around with class
hierarchies, and call chains. They also encrypt and scatter strings around.
Finally, they litter the code with "honey pots".

so, if that problem exist, there was no meaning to use .Net to create
application such as games, system tools and others, because finished
product
cant hide any secret from users/players.

Yes, but even if one has the unobfuscated source of a program it's still
very tricky to work out exactly whats going on without the documentation and
comments. When obfuscated it's even more difficult since you don't have the
names of the internal members to guide you as to what they do.

although like what was Sean Hederman say::"development easier and the
programs more secure and stable"
but me still have to protect my intellectual property...
else there was nothing impetus to make us spend times to design something
"special". What for to spend lot time to develop, but get expose to
everyone
in few sec?

If you're more concerned about reverse engineering than delivering features,
can I suggest that you write your application as a web app hosted on servers
you control, since that's the only way to really stop it, no matter what
language you use. If you're trying to stop casual reverse engineering,
obfuscation is the way to go. If you're trying to stop professional hackers,
you can forget it, if they want to crack your code they will (as long as
they have access to it).

In my experience, reverse engineering is not really done by your competitors
since they generally feel that their tech is better. I have seen Reflector
used to extract the public interfaces, so that a high-level idea of the
functionality and components can be gleaned, but that's it.

 

[Olaf Baeyens]

In my experience, reverse engineering is not really done by your
competitors

since they generally feel that their tech is better. I have seen Reflector
used to extract the public interfaces, so that a high-level idea of the
functionality and components can be gleaned, but that's it.

This is my experience too. Even though I have the knowledge to reverse
engineer stuff, I never use that since I can think of far better ways to
create the code. Reverse engineering is just a waste of time if you are a
good programmer. And you are stuck on ideas other people create.

One exception is if you create a program that must be compatible with
another program for example sharing files.
But even then you do not look at the code, but you look at the file
structure to determine what byte should be where.

 

[Jon Skeet [C# MVP]]

<"=?Utf-8?B?eGlhbyB6aGFuZyB5dQ==?=" <xiao zhang

me was sorry if this question are present before

DotNet, no matter VB.Net or C# all they are compiled to IL,
and yes, that IL will totally same as "open-sourse",

No, it's not. Open source is an entirely different philosophy to "by
reverse engineering you can get some kind of source code, which may be
illegal to do in the first place and won't get you the same source code
the original was compiled from".

<snip>

 

[Jon Skeet [C# MVP]]

but in .Net, no matter who also can decompile it and get the
structure/design/anything else of my program with nicety,
although there can obfuscate, but after obfuscate, there only add tiny hard
readable to the code, because obfuscators (at least all the obfuscators me
have try) only change the variable/function name to non-meaning style, but
the structure still remian unchanged.

I suggest you try to understand the decompiled code of a significant
application which has been obfuscated - something more than just a test
class.

Even without obfuscation, understanding a largish application is
difficult without any comments, documentation or anything like that.