Jugando con el SoftICE me encontré con que muchas veces la mejor protección
contra la descompilación es programar de una majera muy complicada la parte
que uno no quiere que otro vea. De todos modos como dice Angel se puede
levantar el código y modificarlo on the fly (tal vez con Mono.Cecil) y
grabarlo de nuevo, ahora, menos mal que no trabajo en la empresa X que dice
Oscar :-)
Saludos
2008/4/30 Leonardo Micheloni <[EMAIL PROTECTED]>:
> Ah sí, ya veo, pero es lo mismo que se hace con el SofIce, ves el código
> descompilado bien crudo, o sea la ofuscación no es tal sino es un poco de
> pérdida de información nomás por lo que me decís. No veo que sea de mucha
> utilidad, pensé que era algo más sofisticado. Yo he descompilado programas
> hechos en assembler (para microcontroladores) a C y es entendible, o sea, es
> entendible si lo que buscás es saltar una protección, no copiarte una lógica
> compleja, bueno no sé, por lo que entiendo (y corregime si me equivoco) no
> es muy distinto a cuando a uno le toca modificar la aplicación que hizo otra
> persona y no dejo ni un comentario y escribió el código de un
> modo....ofuscado digamos :-) ...habría que ver qué es lo que queda al
> descompilar el código de Oscar...
>
> Bytes!
>
>
> 2008/4/30 Diego Jancic <[EMAIL PROTECTED]>:
>
> > Hola Leo,
> > Es justamente de lo que estoy hablando... el tema es que el IL no es
> > el mismo... estas perdiendo todos los nombres de las cosas...
> > Vos lo podrias descompilar a C# o a lo que quieras, pero verias algo
> > asi (por inventar algo):
> >
> > public class a
> > {
> > private int a(string a, int b)
> > {
> > return b + b.d.e(b,a);
> > }
> > }
> >
> >
> > Obviamente eso esta bien.. pero nadie sabe lo que hace porque no se
> > entiende...
> > El IL es el mismo a nivel logico (usar una variable llamada a o
> > llamada Id no va a cambiar la logica), pero es diferente para un
> > humano que quiere entenderlo...
> >
> > Es por eso que es muy facil descompilarlo, pero muy dificil (o
> > imposible) hacerlo entendible...
> >
> > saludos!
> >
> > 2008/4/30 Leonardo Micheloni <[EMAIL PROTECTED]>:
> > > Diego, lo que creo que dice Oscar es que estamos de acuerdo con el el
> > IL es
> > > el mismo y que el CLI lo interpreta, ahora, si esto es así, por qué no
> > lo
> > > puedo descompilar de un modo legible?
> > >
> > >
> > > 2008/4/30 Diego Jancic <[EMAIL PROTECTED]>:
> > > >
> > > >
> > > >
> > > > Oscar,
> > > > Te pego aca un IL sin obfuscar:
> > > >
> > > > IL_0011: brtrue.s IL_001e
> > > > IL_0013: ldstr ".\\Private$\\AccuMessages"
> > > > IL_0018: newobj instance void
> > > >
> > >
> > [ProcessingServer.Common]ProcessingServer.Common.QueueNotExistsException::.ctor(string)
> > > > IL_001d: throw
> > > > IL_001e: ldc.i4.1
> > > > IL_001f: stsfld bool
> > ProcessingServer.Client.Helper::isValidQueue
> > > > IL_0024: ldstr ".\\Private$\\AccuMessages"
> > > >
> > > >
> > > >
> > > >
> > > > Y despues el mismo IL, obfuscado a mano:
> > > >
> > > > IL_0011: brtrue.s IL_001e
> > > > IL_0013: ldstr ".\\Private$\\AccuMessages"
> > > > IL_0018: newobj instance void [a]a.b.c::.ctor(string)
> > > > IL_001d: throw
> > > > IL_001e: ldc.i4.1
> > > > IL_001f: stsfld bool a.b.d::x
> > > > IL_0024: ldstr ".\\Private$\\AccuMessages"
> > > >
> > > >
> > > >
> > > > No obfusque el string porque es mas complicado, pero: podes decirme
> > > > que hace el primer y el segundo bloque de IL ??
> > > > El primero es facil... sabes que tenes un servidor que hace
> > > > procesamiento (ProcessingServer), que esta validando el nombre de
> > una
> > > > Queue y que tira una excepcion... del segundo no podes saber nada,
> > > > pero para el CLR es exactamente lo mismo, por eso anda...
> > > >
> > > > Espero que se entienda..
> > > >
> > > > Saludos
> > > >
> > > >
> > > >
> > > >
> > > >
> > > >
> > > >
> > > >
> > > > 2008/4/30 Oscar Onorato <[EMAIL PROTECTED]>:
> > > > >
> > > > >
> > > > > Claro, es eso justamente.
> > > > >
> > > > > Por eso no termino de entender cómo hace el NetFx para
> > reinterpretarlo.
> > > Por eso en el email inicial preguntaba sobre uno o unos buenos textos
> > sobre
> > > la arquitectura interna del NetFramework. Para conocer qué pasa
> > internamente
> > > en este tipo de casos.
> > > > >
> > > > > Gracias Luis
> > > > >
> > > > >
> > > > > El día 30 de abril de 2008 12:37, Luis Farzati <[EMAIL PROTECTED]
> > >
> > > escribió:
> > > > >
> > > > > >
> > > > > > Acá tenés una página interesante:
> > > > > >
> > > > > >
> > >
> > http://www.lesser-software.com/en/content/products/LSW%20DotNet-Tools/LSW_DotNet_IL-Obfuscator.htm
> > > > > >
> > > > > > "Decompilation of Assemblies to human readable source-code is
> > possible
> > > because of the containment of meta data in the Assemblies and because
> > of the
> > > higher level of the compiled "MSIL" code.
> > > > > > The LSW IL-Obfuscator ( LSW-ILOBF ) is a tool to make the
> > > Decompilation "useless" because it destroys the Metadata information
> > by
> > > replacing meaningful Names by meaningless ones."Esto último es lo que
> > te
> > > está pasando a vos?
> > > > > >
> > > > > > Un saludo,
> > > > > >
> > > > > > Luis
> > > > > >
> > > > > >
> > > > > >
> > > > > > 2008/4/30 Luis Farzati <[EMAIL PROTECTED]>:
> > > > > >
> > > > > > >
> > > > > > >
> > > > > > >
> > > > > > > Hola Oscar,
> > > > > > >
> > > > > > > Me parece que hay una confusión, el IL no se puede obfuscar...
> > O sea
> > > no hay un IL obfuscado y un IL no obfuscado, ya que es lo que ejecuta
> > el
> > > runtime del framework. Sería como querer obfuscar el binario de un
> > EXE, no
> > > funcionaría.
> > > > > > >
> > > > > > > Cuando decompilás, te encontrás con código que pareciera haber
> > > estado obfuscado por la simple razón de que el descompilador no tiene
> > idea
> > > de la vida :P excepto saber la lógica del programa. No te va a poner
> > los
> > > nombres de variables (ya que esa info no se guarda en IL) y va a
> > generar
> > > nombres aleatorios o secuenciales (a, b, c, a1, b1) y cualquier otro
> > > syntactic sugar que puedas usar en C# / VB.NET tampoco lo vas a ver en
> > el
> > > código fuente generado por un descompilador.
> > > > > > >
> > > > > > > Un saludo!
> > > > > > >
> > > > > > > Luis
> > > > > > >
> > > > > > >
> > > > > > >
> > > > > > >
> > > > > > >
> > > > > > > 2008/4/30 Diego Jancic <[EMAIL PROTECTED]>:
> > > > > > >
> > > > > > >
> > > > > > >
> > > > > > >
> > > > > > > >
> > > > > > > >
> > > > > > > >
> > > > > > > > Hola Oscar,
> > > > > > > > No se cuales son tus objetivos, pero me parece que bien no
> > se
> > > puede hacer...
> > > > > > > > Es decir, si tenes un metodo que se llama ObtenerPorId y
> > cuando lo
> > > obfuscas se llama "a", obviamente estas perdiendo informacion y no lo
> > podes
> > > desobfuscar...
> > > > > > > > Ahora, podrias inventar un nuevo nombre en base al
> > contenido...
> > > pero no lo veo muy exacto..
> > > > > > > >
> > > > > > > >
> > > > > > > >
> > > > > > > >
> > > > > > > > 2008/4/30 Oscar Onorato <[EMAIL PROTECTED]>:
> > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > > > Gracias Diego,
> > > > > > > > >
> > > > > > > > > Gracias por la herramienta, había perdido el Link. La
> > había
> > > usado en la versión .NET 1.1
> > > > > > > > >
> > > > > > > > > Aunque en realidad quiero hacer una App para que
> > "desofusque".
> > > Es decir, si estoy viendo una DLL decompilada -el IL- y está ofuscada,
> > > quiero cargar esa parte ofuscada en una App propia para que traduzca
> > esa
> > > parte a un IL no ofuscado.
> > > > > > > > >
> > > > > > > > > Por eso antes necesito entender el IL como si fuese C#.
> > Aunque
> > > sé que me va a costar un poco más.
> > > > > > > > >
> > > > > > > > > Salutti
> > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > > > El día 30 de abril de 2008 11:38, Diego Jancic
> > > <[EMAIL PROTECTED]> escribió:
> > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > > > >
> > > > > > > > > >
> > > > > > > > > > Si tu idea es solamente ver el codigo obfuscado, podes
> > usar
> > > reflector y verlo en C# o cualquier otro lenguaje sin ser un dios...
> > > > > > > > > > La obfuscacion basicamente lo que hace es renombra las
> > cosas
> > > para hacerlo mas complicado y en algunos casos puede cambiar forma de
> > hacer
> > > algo manteniendo la misma logica...
> > > > > > > > > > Si no lo tenes podes bajartelo de aca:
> > > http://www.aisto.com/roeder/dotnet/
> > > > > > > > > >
> > > > > > > > > > O sino el viejo ildasm, pero es solo para IL
> > > > > > > > > >
> > > > > > > > > > Saludos,
> > > > > > > > > > Diego
> > > > > > > > > >
> > > > > > > > > >
> > > > > > > > > >
> > > > > > > > > > 2008/4/30 Oscar Onorato <[EMAIL PROTECTED]>:
> > > > > > > > > >
> > > > > > > > > >
> > > > > > > > > >
> > > > > > > > > >
> > > > > > > > > > >
> > > > > > > > > > >
> > > > > > > > > > > Cumpas,
> > > > > > > > > > >
> > > > > > > > > > > Necesito conocer el framework a fondo para interpretar
> > el
> > > IL.
> > > > > > > > > > >
> > > > > > > > > > > El motivo se que quiero saber cómo lo interpreto
> > cuando
> > > decompilo y me encuentro con código ofuscado.
> > > > > > > > > > > Quizás este pifiado en el razonamiento, pero ese mismo
> > > código ofuscado está siendo interpretado ¿del mismo modo que el no
> > ofuscado?
> > > > > > > > > > > Por eso necesito conocer a fondo el Core y la
> > arquitectura
> > > de NetFx, en el mejor de los casos desde la versión 2.0 en adelante.
> > > > > > > > > > >
> > > > > > > > > > > ¿Me podrían recomendar algun/os buenos textos?
> > > > > > > > > > >
> > > > > > > > > > > Saludos
> > > > > > > > > >
> > > > > > > > > >
> > > > > > > > >
> > > > > > > > >
> > > > > > > >
> > > > > > > >
> > > > > > >
> > > > > > >
> > > > > >
> > > > > >
> > > > >
> > > > >
> > > >
> > > >
> > >
> > >
> > >
> > > --
> > > Leonardo Micheloni.
> > >
> > > http://leomicheloni.blogspot.com/
> >
> >
>
>
> --
> Leonardo Micheloni.
>
> http://leomicheloni.blogspot.com/
>
--
Leonardo Micheloni.
http://leomicheloni.blogspot.com/
