Pregunta:
Parcheo de un binario .Net 4.0 en Olly o CFF Explorer
4r4r4r
2013-06-14 22:07:23 UTC
view on stackexchange narkive permalink

Tengo un desafío compilado en C # .net 4.0. Puedo ver la fuente completamente bien en Reflector. Me gustaría cambiar la fuente. Supongo que hago esto parcheando algunos bytes en el binario.

El problema al que me enfrento es cuando carga el binario en Ildasm.exe no puedo convertir estas direcciones ID_xxxx a RVA o encontrar sus bytes correspondientes en CFF Explorador. ¿Cuál es la forma típica de parchear un exe .net de esta manera? Leí algunos de los tutoriales de Lena, así que normalmente los cargaba en Olly, e intenté esto, pero no puedo ver ningún código útil y la mayoría de las acciones parecen suceder en varios archivos .dll de Windows y no en el propio .exe.

Le agradecería mucho si alguien pudiera darme un consejo o indicarme un tutorial. Gracias.

Y más específicamente, quiero parchear una llamada dentro de un bloque de prueba. Ildasm.exe informa la dirección de IL_0039 (que no corresponde en CFF)
Un poco fuera de tema, pero lo que generalmente hago cuando el ensamblaje no está ofuscado es: usar ildasm para desmontar el ensamblaje, modificar el IL según sea necesario y volver a ensamblar usando ilasm.
Sí, parece una buena idea. No pude encontrar ningún tutorial o averiguar cómo modificar desde Ildasm.exe, ¿podría explicar un poco más?
Además, estoy tratando de NOP en una llamada. Los bytes en cuestión son 28 85. Entiendo que los 28 bytes implican una "LLAMADA". Intenté cambiarlos a 00, que creo que es un NOP (normal de 90 bytes) para este idioma, pero falló.
¡Te dejo descubrir cómo NOP la llamada tú mismo!
Tres respuestas:
Remko
2013-06-15 18:52:05 UTC
view on stackexchange narkive permalink

Hay un complemento llamado Reflexil para Reflector que hace que sea muy fácil parchear un binario .NET.

Reflexil es un editor de ensamblaje y se ejecuta como un complemento para Reflector de Red Gate y JustDecompile de Telerik. Reflexil utiliza Mono.Cecil, escrito por Jb Evain y es capaz de manipular el código IL y guardar los ensamblajes modificados en el disco. Reflexil también admite la inyección de código C # / VB.NET.

Hice una redacción en mi blog recientemente con un ejemplo.

Buen comentario. Creo que Reflexil es definitivamente la forma más fácil de hacer el trabajo, pero también es bueno saber cómo hacerlo de otras formas.
dna
2013-06-15 01:31:39 UTC
view on stackexchange narkive permalink

Considere la siguiente aplicación de consola .NET 4.5:

  using System; namespace ReversingMSIL101 {class Program {static void Main (string [] args) {if (args.Length > 0 && args [0] == "Secreto") Autenticado (); más Anónimo (); } vacío estático privado Authenticated () {Console.WriteLine ("¡Oro para la gente!"); } private static void Anonymous () {Console.WriteLine ("Dales cobre ..."); }}}  

Compile y abra Ildasm. Empezaremos cargando el ejecutable (Archivo-> Abrir). Una vez hecho esto: volcarlo (Archivo-> Volcar). Ildasm responde con un bonito diálogo lleno de casillas de verificación, ya que queremos tanta información como sea posible, ¡compruébalo todo!

Ahora echemos un vistazo a nuestras instrucciones IL desensambladas, inicie su editor preferido y abra el anterior volcado generado. Estamos especialmente interesados ​​en la instrucción if ya que controla si la contraseña proporcionada es correcta; tenga en cuenta que puede detectarlo fácilmente utilizando los comentarios generados.

  // 000009: if (args.Length > 0 && args [0] == "Secret") IL_0001: / * 02 | * / ldarg.0IL_0002: / * 8E | * / ldlenIL_0003: / * 69 | * / conv.i4IL_0004: / * 16 | * / ldc.i4.0IL_0005: / * 31 | 12 * / ble.s IL_0019IL_0007: / * 02 | * / ldarg.0IL_0008: / * 16 | * / ldc.i4.0IL_0009: / * 9A | * / ldelem.refIL_000a: / * 72 | (70) 000001 * / ldstr "Secreto" / * 70000001 * / IL_000f: / * 28 | (0A) 000011 * / call bool [mscorlib / * 23000001 * /] System.String / * 01000013 * / :: op_Equality (cadena, cadena) / * 0A000011 * / IL_0014: / * 16 | * / ldc.i4.0IL_0015: / * FE01 | * / ceq
IL_0017: / * 2B | 01 * / br.s IL_001aIL_0019: / * 17 | * / ldc.i4.1IL_001a: / * 00 | * / nopIL_001b: / * 0A | * / stloc.0IL_001c: / * 06 | * / ldloc.0IL_001d: / * 2D | 08 * / brtrue.s IL_0027  

Dejo al lector la tarea de revertir y analizar las instrucciones. Continuaremos mirando el último. Para resumir: si el primer argumento no es la cadena "Secret" , tomaremos la rama y terminaremos en IL_0027 :

  IL_0027: / * 28 | (06) 000003 * / call void ReversingMSIL101.Program / * 02000002 * / :: Anónimo () / * 06000003 * /  

Bastante mal, ¿eh? Así que simplemente modificaremos un poco la última instrucción, además de reemplazarla por brfalse.s :

  IL_001d: / * 2B | 08 * / brfalse.s IL_0027  

¡Y eso es todo, hemos terminado! Guarde el archivo y abra un shell, navegue hasta la carpeta que contiene el volcado de IL y emita ilasm ReversingMSIL101.il para volver a ensamblar el volcado en un ejecutable.

¡Ahora es el momento de verifique nuestro trabajo:

  C: \ Users \ dna \ Documents \ Visual Studio 2012 \ Projects \ ReversingMSIL101 \ ReversingMSIL101 \ bin \ Debug>ReversingMSIL101.exe ¡IdoNotKnowGold para la gente!  
¡Gran tutorial! Gracias por tomarse el tiempo de escribirlo. Terminé usando los gráficos de códigos de bytes en http://resources.infosecinstitute.com/dot-net-reverse-engineering-part-2/. A partir de ahí, es un esquema extraño, pero puede reconstruir las secuencias de bytes que se muestran en ILDasm.exe y buscarlas en un editor hexadecimal y cambiarlas, pero si no se cambian a un byte aceptable, se estropea el programa. Todavía nunca recibí la llamada para salir correctamente y continuaré buscando. ¡Es una locura cómo en estos programas .net puedes ver el código fuente desnudo!
Bueno, una instrucción CALL es 0x28 + por lo que tiene que NOP (0x00) 5 bytes en total.
Después de algunas pruebas, descubrí que, dependiendo de la llamada, no puede simplemente agregar los 5 bytes de llamada. Debe obtener las llamadas ldloc y stloc antes o lo que sea que presione args, especialmente si la función se parece a Test (test1, test2 (test3)). Testing () en .net. No me gusta tanto este idioma intermedio. También me gustaría saber cómo hacer análisis dinámico en Olly, no puedo encontrarle mucho sentido y creo que parchear cmp / jnz sería más fácil que esto.
Tiene sentido, me olvidé totalmente de mencionar cómo desenrollar la pila. Bueno, nunca hice esto en Olly, pero tendrás que detectar el JIT cuando compile los métodos MSIL en instrucciones nativas. Puede que no sea tan inteligente ya que perderá portabilidad y tiempo, pero debería ser bastante interesante :)
Reflexil maneja algún tipo de rutina de firma automáticamente, algo que MS puso allí para evitar parches que también deben ser direcciones cuando se cambian bytes como este.
Asumiendo que hablas de asambleas con nombres fuertes. SN (http://msdn.microsoft.com/en-us/library/k5b5tt23(v=vs.71).aspx) es tu amigo. Puede registrar un ensamblaje para omitir la verificación, volver a firmarlo con una nueva clave o retrasar la firma. Probablemente sea lo que Reflexil hace detrás de escena.
John.Rogers
2013-06-15 12:36:43 UTC
view on stackexchange narkive permalink

Por mucho que la respuesta de adn sea excelente y esté bien explicada, a menudo no es práctico para los ejecutables del mundo real, a menos que sean muy simples y breves. Vaciar algo, cambiarlo y "recompilarlo" es propenso a errores, especialmente en ensamblajes ofuscados, etc.

Le sugiero que descargue Reflexil, es un Reflector complemento: puede ver el IL de las funciones que está viendo a través de Reflector, cambiar lo que necesite cambiar de una manera muy simple y luego simplemente guardar el exe modificado. Esto es mucho menos propenso a errores, ya que no está volcando y reconstruyendo el programa desde cero. Además, puede inyectar cualquier cosa en el ensamblaje de esta manera, ya sean clases, nuevos métodos, estructuras.

El OP solicitó un ejemplo no ofuscado y en esa situación precisa, ¡confiar en el ensamblador es menos propenso a errores! Dado que se detectarán errores durante el proceso de montaje. La parte de inyección es interesante, generalmente confío en Cecil (http://www.mono-project.com/Cecil) ya que es de código abierto y te permite agregar / eliminar / modificar cualquier cosa en un ensamblaje y guardar el parcheado.
Solo un recordatorio rápido de que Reflexil no solo funciona con Reflector, sino también con ILSpy (que es de código abierto) y JustDecompile.


Esta pregunta y respuesta fue traducida automáticamente del idioma inglés.El contenido original está disponible en stackexchange, a quien agradecemos la licencia cc by-sa 3.0 bajo la que se distribuye.
Loading...