Foro de elhacker.net

Hola!!

Veréis, tengo un proyecto en C#, que tiene algo así:

Lo que me gustaría saber es si puedo obtener lo que tiene "info" sin modificar el proyecto (es decir, sin ningún tipo de log, sino obtener directamente de la RAM)

Saludos!

Efectivamente, las variables tanto globales, locales, etc. todas se encuentran en memoria (solo que en distintos lugares, sección .DATA, pila, etc.), saludos.

Sí, ya sé que se puede, lo que quiero es saber cómo  :laugh:

Visualizando la memoria con un debugger, por ejemplo si sabes que hay un string que dice "Registrado", basta con buscarlo en toda la memoria virtual del ejecutable, ya localizándolo, le puedes poner un breakpoint, de esta forma podrás detectar en que momento se toma la variable (MessageBoxA por ejemplo o alguna función encargada de mostrar tal mensaje), saludos.

PD: OllyDbg = ALT + M (muestra memoria) y luego ALT + B (Search in memory).

El problema es que lo que contiene esa variable es un .exe (un C# compilado) y no tengo ni la más mínima idea de qué buscar  :silbar:

¿la variable contiene un .exe? yo diría más bien que quieres decir que el ejecutable es un .exe y este contiene variables.

Y sé a que te refieres con que esté compilado, eso es lo que se hace en ingeniería inversa, sin el source y solo el ejecutable, intentar descubrir el funcionamiento interno.


http://foro.elhacker.net/ingenieria_inversa/faq_iquesteres_nuevo-t345798.0.html
 (http://foro.elhacker.net/ingenieria_inversa/faq_iquesteres_nuevo-t345798.0.html)

No.
Quiero decir que es un .exe que tiene un .dll dentro de sí mismo (embedded) y lo saca, el código fuente es así:

byte[] executableSource = doSomethingToGetExecutableSource();

Lo que hace es convertirlo a PE e inyectarlo a un proceso.
Por eso, quiero saber qué tiene ese DLL antes de ser convertido a PE (PortableExecutable)

No logro entender tu explicación, desconozco de C# pero la instrucción:

byte[] executableSource = doSomethingToGetExecutableSource();

En todos los lenguajes de programación que conozco retornaría un valor tras llamar a una función, esta variable es tipo byte, lo más lógico es que solo se retorne un código de notificación (sin errores o con errores), esto es utilizado para verificar si la función se logró ejecutar sin problemas:

FuncionA(){
 if(a!=b){
  return ERROR1  // constante ERROR1 que simboliza a un simple número.
 }else{
  ...
  ...
  return SUCCESS // constante SUCCESS que simboliza a un simple número.
}

y si es como tu dices, entonces tomas el source y borras todo pero todo y solo dejas la función:

doSomethingToGetExecutableSource();

Compilas, luego con un debugger, analizas las instrucciones de la función.

Las anotas en un notepad o lo que sea de tu agrado.

Vuelves a compilar pero con todo el source, ya con eso buscas la secuencia de instrucciones (estarías buscando en donde se encuentra la función en ejecutable).

ya localizada la función debes poner un BP en el inicio de ella para saber en que lugar es llamada, obteniendo ese lugar, lo más probable es que logres localizar el puntero a executableSource, en donde debería tener el source del . EXE que se convierte en no se qué o no se qué.

Sabiendo que tienes el source por qué no generas un error luego de llamar a la función?

...
..
..
.
byte[] executableSource = doSomethingToGetExecutableSource();
byte[] test = 0/0;
....
..
.

Esto generaría un error de división por cero, de esta forma con el debugger puedes manejar la excepción, anterior a la instrucción en donde se generó el error, está la secuencia en donde se tendrá el puntero de executableSource.

Alternativa 2:
Usar MASM dentro de C# y usar la instrucción INT 3 (este generará un error).

Alternativa 3: Leer el source, si sabes de C# no debería por que indagar con debugger y sobre todo si se tiene el source.

Lo que pasa es que no tengo el source completo y no puedo compilarlo.
La parte que "descifra" la DLL no la tengo y al sacarla con Reflector veo que está ofuscada con Crypto Obfuscator (una versión nueva que ningún deobfuscator de momento soporta)

Es decir: no puedo compilar (si pudiese, directamente hacía un File.WriteAllBytes(execurableSource) y así de fácil lo lograría).

Por eso, estoy intentando leer lo que tiene desde la RAM.
Descarto tu siguiente respuesta ya que se trata sobre compilar el código fuente y es una opción que he descartado.

Se supone que el array de bytes se obtiene con un método, así que ... ¿Qué tal si cargas el ejecutable por reflection y ejecutas el método? :P

Saludos

Qué coño. Lo he hecho y me ha salido.
Muchas gracias!!!  ;-) ;-)

Excelente, ya había dado el tema por perdido ;-)