Cita:
Iniciado por enrib72 
Y que la plataforma (framework) .NET, cada vez que ejecuta un .EXE de .Net, lo que ejecuta es ese pseudo-código, INTERPRETÁNDOLO cada vez al código máquina x86.
Más o menos, utiliza un compilador JIT para que cuando vayas a ejecutar el código sea "en modo nativo". Es decir, que más o menos lo pasa a código máquina antes de ejecutarlo.
Es lo que usan otros lenguajes (como Java) para evitar las penalizaciones por usar bytecodes:
http://msdn.microsoft.com/en-us/libr...=vs.90%29.aspx Cita:
Iniciado por enrib72 Obviamente para "intentar" que no me lo pirateen, al menos dificultarlo en lo posible.
Te lo preguntaré de otra manera... tu ofuscabas el código en VB6? Piensa que cuando lo pasa a código intermedio se hacen una serie de operaciones de forma que no es posible sacar los fuentes originales de forma exacta. Puedes intuir que hacía el código pero de la misma manera que lo puedes intuir viendo un código en ensamblador x86.
Cita:
Iniciado por enrib72 Hombre, mi abuela no, pero aunque suene duro, la respuesta es SÍ: Cualquiera, cualquier estudiante o aficionado a la programación que acaba de instalar Visual Studio (como yo novato en .Net), tendrá el Desensamblador de IL (IL DASM) en Microsoft Windows SDK Tools, del menú MS VS2010.
Antiguamente MS-DOS (y los primeros windows) tenía un programilla llamado debug.com que permitia desensamblar los ejecutables. Venía de serie con el sistema operativo. Que alguien tenga una herramienta a mano no quiere decir que tenga los conocimientos necesarios para usarla. Por ejemplo, en casa tengo llaves inglesas y eso no quiere decir que adquiera automágicamente conocimientos de lampisteria.
Por cierto, tampoco hay necesidad de usar el desensamblador de Visual Studio, hay herramientas mucho mejores al alcance de cualquiera, como por ejemplo IDA.
Cita:
Iniciado por enrib72 Lo demuestro y como ej. si le arrastro un .EXE de VB6.0 me da error "exe no valid" como era previsible. En cambio si le meto un .EXE generado con VB.NET en VS2010, me da lo siguiente:
Código:
// Source File 'C:\Users\Enrique\documents\visual studio 2010\Projects\TablaMultiplicar\TablaMultiplicar\Module1.vb'
//000003: Sub Main()
IL_0000: nop
//000004: Dim tabla As Integer
//000005: Dim n As Integer
//000006: Dim resultado As Integer
//000007:
//000008: Console.Write("Escriba la tabla de multiplicar que quiere calcular: ")
IL_0001: ldstr "Escriba la tabla de multiplicar que quiere calcula"
+ "r: "
IL_0006: call void [mscorlib]System.Console::Write(string)
IL_000b: nop
//000009: tabla = Console.ReadLine()
IL_000c: call string [mscorlib]System.Console::ReadLine()
IL_0011: call int32 [Microsoft.VisualBasic]Microsoft.VisualBasic.CompilerServices.Conversions::ToInteger(string)
IL_0016: stloc.2
//000010: Console.WriteLine("")
IL_0017: ldstr ""
IL_001c: call void [mscorlib]System.Console::WriteLine(string)
IL_0021: nop
//000011: 'Bucle de la tabla de multiplicar
//000012: For n = 0 To 10
IL_0022: ldc.i4.0
IL_0023: stloc.0
//000013: resultado = tabla * n
IL_0024: ldloc.2
IL_0025: ldloc.0
IL_0026: mul.ovf
IL_0027: stloc.1
//000014: 'Impresión en pantalla
//000015: Console.WriteLine(" {0} x {1} = {2}", tabla, n, resultado)
IL_0028: ldstr " {0} x {1} = {2}"
IL_002d: ldloc.2
IL_002e: box [mscorlib]System.Int32
IL_0033: ldloc.0
IL_0034: box [mscorlib]System.Int32
IL_0039: ldloc.1
IL_003a: box [mscorlib]System.Int32
IL_003f: call void [mscorlib]System.Console::WriteLine(string,
object,
object,
object)
IL_0044: nop
//000016: Next
IL_0045: nop
IL_0046: ldloc.0
IL_0047: ldc.i4.1
IL_0048: add.ovf
IL_0049: stloc.0
//000017:
//000018: Call salir()
//000019: End Sub
//000020:
//000021: Sub salir()
//000022: Console.WriteLine("")
//000023: Console.WriteLine("Pulsa intro para salir...")
//000024: Console.ReadLine()
//000025: End Sub
//000026:
//000027: End Module
IL_004a: ldloc.0
IL_004b: ldc.i4.s 10
IL_004d: stloc.3
IL_004e: ldloc.3
IL_004f: ble.s IL_0024
//000018: Call salir()
IL_0051: call void TablaMultiplicar.Module1::salir()
IL_0056: nop
//000019: End Sub
IL_0057: nop
IL_0058: ret
} // end of method Module1::Main
.method public static void salir() cil managed
{
// Code size 31 (0x1f)
.maxstack 8
//000020:
//000021: Sub salir()
IL_0000: nop
//000022: Console.WriteLine("")
IL_0001: ldstr ""
IL_0006: call void [mscorlib]System.Console::WriteLine(string)
IL_000b: nop
//000023: Console.WriteLine("Pulsa intro para salir...")
IL_000c: ldstr "Pulsa intro para salir..."
IL_0011: call void [mscorlib]System.Console::WriteLine(string)
IL_0016: nop
//000024: Console.ReadLine()
IL_0017: call string [mscorlib]System.Console::ReadLine()
IL_001c: pop
//000025: End Sub
IL_001d: nop
IL_001e: ret
} // end of method Module1::salir
} // end of class TablaMultiplicar.Module1
Como se ve es una mezcla de instrucciones código máquina MSIL con sus instrucciones equivalentes, variables originales... hasta los comentarios que hice en VB.NET y a continuación el listado original de dicho código fuente. Es un sencillo ejercicio que en consola muestra la tabla de multiplicar elegida por el usuario:
[CODE]
Module Module1
Sub Main()
Dim tabla As Integer
Dim n As Integer
Dim resultado As Integer
Console.Write("Escriba la tabla de multiplicar que quiere calcular: ")
tabla = Console.ReadLine()
Console.WriteLine("")
'Bucle de la tabla de multiplicar
For n = 0 To 10
resultado = tabla * n
'Impresión en pantalla
Console.WriteLine(" {0} x {1} = {2}", tabla, n, resultado)
Next
Call salir()
End Sub
Sub salir()
Console.WriteLine("")
Console.WriteLine("Pulsa intro para salir...")
Console.ReadLine()
End Sub
End Module
Seguramente estés compilando en modo debug y con código incrustado en el ejecutable, lo que se puede configurar por configuración.
Cita:
Iniciado por enrib72 OK, de acuerdo, pero una cosa es descompilar a código máquina, que no lo entiendo ni yo a pesar de que hace ya mucho estudié y trabajé el Zilog Z80, y otra muy diferente descompilar a MSIL con el código fuente VB.NET al lado o entremezclado.
En realidad el descompilar al final es lo mismo. Con los conocimientos son igual de entendibles ambos.
Cita:
Iniciado por enrib72 No obstante, si conoces o alquien más, alguna forma de evitar esto, alguna opción que evite el código fuente visible dentro del ejecutable distribuible, quizás en nuevas versiones de Visual Studio, yo las desconozco, bienvenidas sean. Como bien dices, un tema importante es la curva de aprendizaje y VB.NET me interesaría por eso, pero lo descarté por lo ya expuesto.
Saludos
Revisa las opciones de compilación, seguro que estás incluyendo información de depuración en el ejecutable. Mira que no tengas ningún ".pdb" ni nada parecido, etc.