Tutos: obtener datos y manejo de windows con c#... tuto_1: manejo de procesos

[tongoxcore]

Tutos: obtener datos importantes y manejo de Windows Vista usando las librerías de C# y la API de Windows.

Hola, quiero hacer una serie de tutoriales en C# para acceder a las distintas partes del sistema operativo Windows, en cierto modo que podamos administrar y apoderarnos del sistema, yo probaré todo de antemano con Windows Vista y Visual C# Express 2005 (ya que esto es lo que uso en mi notebook ^_^! ), y al final subiré una aplicación mostrando los códigos.

De los códigos que quiero ir mostrando, muchos son míos y otros son extractos de artículos principalmente de las páginas: http://www.elguille.info (la mejor página que he encontrado con artículos y trucos en C#) y www.recursosvisualbasic.com.ar (una página que muestra trucos y códigos muy buenos hechos en visual basic). De los códigos que extraje de ellos, más bien lo que saqué fue la "idea", no el código completo en sí, sino que en la mayoría era cómo trabajar con las librerías de Windows (dll's) y tuve que transformar cosas de otros lenguajes a C#, bueno eso lo iré mostrando de a poco   Además algunas cosas que he probado funcionan en XP y no en Vista, y aquí quiero colocar todo para Vista, ya que es el último OS de Windows :-)

Espero que no cambien esto al subforo ".NET" del foro "Programación General", ya que el objetivo de estos tutoriales que deseo hacer no son para aprender a programar en C#, sino que son para poder acceder -  usando C# - a las distintas partes de Windows, y ser usado por los troyanos que quieran hacer, y así dar ideas para el diseño del malware, como por ejemplo:

1.   Obtener datos de los "procesos" que están corriendo.
2.   Obtener los datos de las "ventanas" que uno tiene abiertas y la ventana que está "activa".
3.   Obtener datos de los "discos" rígidos y ópticos que tiene una máquina.
4.   Administrar el portapapeles.
5.   Administrar la papelera de reciclaje.
6.   Conocer los roles del usuario actual, así como su nombre y nombre de la máquina.
7.   Apoderarse de la webcam.
8.   Conocer las pulsaciones de teclado y mouse y saber dónde está el mouse (un keylogger xd).

Estas cosas ya las han visto en algunos troyanos no?, bueno sabiendo todas estas cosas (y uff una pila de cosas más que tengo en mente), y que las he visto en otros lenguajes como C o Visual Basic, podremos crear nuestro súper troyano, y administrar o apoderarnos de lo que deseemos de la víctima, eso sí teniendo los códigos jjiijji y sabiendo C# (que es el requisito para estos tutos), que es el lenguaje con el cual decidí hacerlos ya que es uno de los lenguajes que más me manejo, y se pueden hacer cosas muy shoras con poco código.

Aaah!! Si alguien ha escrito tutos como estos, mm no los he visto en el foro, así que por eso me digne a aportar con esto para manejar el computador u obtener datos usando C#.

Recuerden para crear un buen malware, se debe conocer mucho sobre los siguientes puntos (aparte de tener creatividad ^_^):

1.   Auto-ejecución del malware al iniciar el sistema operativo o iniciar sesión.
2.   Ocultación del malware para la víctima y para los distintos antivirus y/o antispyware.
3.   Auto-duplicación y defensa contra los antivirus y/o antispyware.
4.   Propagación del malware (sólo si se desea).
5.   Conocer a fondo la API del Sistema operativo que se está atacando y las facilidades que el lenguaje con el que se está diseñando el malware nos pueda facilitar, para que así se elija bien el objetivo del malware que se está diseñando.

Nosotros aquí nos preocuparemos de ésta última

En este tuto comencemos con el primero de la lista que mencioné:

1.    Manejo de Procesos.

Empecemos con una definición de Proceso: "Un proceso básicamente es una instancia de un programa que está corriendo en una CPU.", para el que no sepa bien qué es o cómo se comporta un proceso que vaya a la gran Wikipedia http://es.wikipedia.org/wiki/Proceso_(inform%C3%A1tica). En Windows para ver los procesos que están corriendo sólo deben irse al Task Manager y ahí les aparecerá.

Basta de bla bla y comencemos con código:

Dividiremos esta parte en 3:

1.   Ejecución de un proceso cualquiera.
2.   Creación de un programa en batch y luego ejecutarlo con la clase Process.
3.   Procesos activos en el sistema.


1) Ejecución de un proceso usando la clase Process.

La clase "Process" es la que proporciona acceso a los procesos locales y remotos, y la que permite iniciar y detener procesos del sistema local, para información sobre atributos, delegados, etc., ir a http://msdn.microsoft.com/es-es/library/system.diagnostics.process_members(VS.80).aspx.  EL espacio de nombres a usar es: System.Diagnostics.

Nuestro objetivo en esta primera sección es sólo ejecutar un programa,  así que lo que haremos es ejecutar el programa "Paint" y pasarle como argumento una imagen.
El código es el siguiente:

Código (csharp) [Seleccionar] Expandir

//Iniciamos el constructor
Process proc = new Process();

//le asignamos la ruta del proceso que queremos ejecutar, en este caso la ruta del ejecutable del programa "Paint"
proc.StartInfo.FileName = @"C:\Windows\System32\mspaint.exe";;

//le asignamos la ruta del argumento que queremos darle al proceso, en este caso una imagen en formato JPEG que está en el directorio de ejecución del proyecto
proc.StartInfo.Arguments = @"images.jpg";

//Finalmente para ejecutarlo sólo debemos llamar al método Start
proc.Start();

Nota: Este código está en el método buttonExecute_Click asignado al evento de hacer click al botón buttonExecute, que corresponde al botón "Ejecutar" de la Interfaz gráfica.

Código (csharp) [Seleccionar] Expandir

//Y para matar al proceso debemos llamar al método Kill, cerciorándonos siempre que el proceso siga en ejecución para no provocar una excepción
if(!proc.HasExited)
    proc.Kill();

Nota: Este código está en el método buttonKill_Click asignado al evento de hacer click al botón buttonKill, que corresponde al botón "Matar" de la Interfaz gráfica.


No confundir los métodos Kill() con Close(), ya que Close sólo libera los recursos asociados al proceso, no matándolo, en cambio Kill, mata al proceso deteniéndolo inmediatamente.

Bueno, esto fue algo simple (muchos ya saben como hacerlo), pero con esto se pueden hacer cosas interesantes, yo creo que ya se les debe estar ocurriendo algunas cosas no?, bueno.. a mí se me ocurió lo siguiente:


2) Creación de un programa en Batch y luego ejecutarlo.

Antes de empezar aquí, si no saben lo que es un programa hecho en Batch, pueden ir a los siguientes post (que a mí me sirvieron mucho):

•   Tutorial básico, hecho por "zhynar_x": http://foro.elhacker.net/scripting/programacion_batch_basica_tutorial-t167525.0.html
•   Tutorial avanzado, hecho por "sirdarckdat" http://foro.elhacker.net/scripting/programacion_batch_avanzada_nuevo-t132924.0.html

Lo que haré (para seguir con lo de los procesos) será simplemente matar un proceso por su nombre, es más que nada para mostrar que del mismo C# podemos crear un .bat y ejecutarlo, aunque obviamente se pueden hacer cosas muy interesantes con los .bat, yo quise matar el proceso "explorer.exe", ya que si lo hacía de la forma que lo voy a mostrar en el apartado 3), lo mataba y se volvía a ejecutar xd.

Veamos el código Batch:

Crearé 2 .bat, el bat_1 (InitKillExplorer.bat) que llamará de forma minimizada al bat_2  (KillExplorer.bat) que contendrá el código de matar al proceso "explorer.exe".

a)   InitKillExplorer.bat

Código (bash) [Seleccionar] Expandir

@echo off
start /MIN KillExplorer.bat
exit

b)   KillExplorer.bat

Código (bash) [Seleccionar] Expandir

@echo off
TASKKILL /F /T /IM explorer.exe
exit

@echo off: Es para que no se muestre el código en pantalla.

Start: Inicia otra ventana para ejecutar el programa KillExplorer.bat, el parámetro /MIN la inicia minimizada.

Taskkill: termina las tareas o procesos, /F hace que se termine forzosamente el proceso,  /T aparte de terminar el proceso,  termina todos los procesos secundarios a él (en el caso de "explorer.exe" por ejemplo todas las ventanas de las carpetas abiertas), /IM especifica el nombre de imagen del proceso.

Ahora hagámoslo desde C#:

a)  Crear los archivos:

Para crear los archivos .bat, se hace lo mismo que crear un archivo cualquiera, usando el espacio de nombres System.IO:

Código (csharp) [Seleccionar] Expandir

//rutas y nombre de los archivos .bat
String bat1 = "InitKillExplorer.bat";
String bat2 = "KillExplorer.bat";

//nombre del proceso a matar
String process_bat = "explorer.exe";

//Stream para escribir los archivos
StreamWriter sw1, sw2;

//creamos los streams, y nos preocupamos de las excepciones
try
{
//creamos el stream de escritura para el bat1 y comenzamos a escribirle el código
      sw1 = new StreamWriter(bat1);
      sw1.WriteLine("@echo off");
      sw1.WriteLine("start /MIN " + bat2);
      sw1.WriteLine("exit");
      sw1.Close();

//creamos el stream de escritura para el bat2 y comenzamos a escribirle el código
      sw2 = new StreamWriter(bat2);
      sw2.WriteLine("@echo off");
      sw2.WriteLine("TASKKILL /F /T /IM " + process_bat);
      sw2.WriteLine("exit");
      sw2.Close();
}
catch (Exception ex){}

Nota: Este código está en el método buttonCreateBat_Click asignado al evento de hacer click al botón buttonCreateBat, que corresponde al botón "Crear bat" de la Interfaz gráfica.


Y así nuestros archivos .bat están creados.


b) Ejecutar los archivos

Ahora sólo basta con ejecutarlos como lo habíamos mostrado antes:

Código (csharp) [Seleccionar] Expandir

//iniciamos el constructor
Process p_bat = new Process();

//asignamos la ruta del ejecutable
p_bat.StartInfo.FileName = bat1;

//ejecutamos el programa
p_bat.Start();

//Hacemos una espera de 3 segundos (aunque obviamente se demorar'an menos en correr)
System.Threading.Thread.Sleep(3000);

//Eliminamos los archivos para que no queden huellas
File.Delete(bat1);
File.Delete(bat2);

Nota: Este código está en el método buttonExecuteBat_Click asignado al evento de hacer click al botón buttonExecuteBat, que corresponde al botón "Ejecutar bat" de la Interfaz gráfica.


Y listo, puedes crear lo que quieras en batch u otro lenguaje de scripting desde C#, dinámicamente (esto es lo bueno) y luego sólo lo ejecutas, ya que hay cosas que se pueden acceder sólo desde estos lenguajes o más bien es más fácil hacerlo con ellos.


3) Procesos corriendo en el sistema

No creo que deba decir que ésta es la parte más importante del tutorial ^_^!, bueno, aquí aprenderemos de forma sencilla cómo saber los procesos que están corriendo en el sistema y alguna información ellos, que no es mucha ya que como estoy corriendo en modo usuario, marca "accedo denegado" para acceder a algunos parámetros. Yo sé que se puede acceder a esto mediante alguna librería de windows, pero por el momento no sé cual es la que se preocupa de ello, así que cuando lo sepa bien, lo postearé (en C# para seguir con estos tutos :-) )

Ahora veamos el código:

a) Mostraremos cómo obtener los datos de todos los procesos que están corriendo en el sistema, y los iremos adheriendo a un ListView.

El ListView se llama "listViewProcess" y sus columnas con 4:

•   Id: muestra el "ID" del proceso.
•   Nombre: muestra el "nombre" del proceso.
•   Handle MW: muestra el "identificador de ventana" de la ventana principal asociada a ese proceso (sólo para procesos locales).
•   Titulo MW: muestra el "titulo de ventana" de la ventana principal asociada a ese proceso (sólo para procesos locales).

Aunque esto último, lo de las ventanas asociadas a los procesos lo veremos en mayor detalle en el próximo tutorial

Código (csharp) [Seleccionar] Expandir

//Primero obtenemos los procesos que están activos en este momento,
//y esto lo hacemos con el siguiente método
Process[] running = Process.GetProcesses();

//Haciendo lo anterior ya tenemos acceso a los procesos y podemos obtener algunos datos

//luego limpiamos el ListView, para insertar los datos
this.listViewProcess.Items.Clear();

//recorremos todos los procesos obtenidos, y adherimos los datos al ListView
foreach (Process p in running)
{
//obtenemos el "ID" del proceso y lo adherimos al ListView,
//éste es el identificador único del proceso
ListViewItem it = this.listViewProcess.Items.Add(p.Id.ToString());

//obtenemos el "Nombre" del proceso y lo adherimos al ListView
it.SubItems.Add(p.ProcessName);

//Obtenemos el "identificador de ventana" de la ventana principal del proceso asociado
//Si es 0, significa que no est'a asociado a una ventana y 'este no dispone de interfaz gr'afica
it.SubItems.Add(p.MainWindowHandle.ToString());
               
//Si MainWindowsHandle es distinto de 0, tendr'a un t'itulo asociado a su ventana
//entonces lo obtenemos y lo adherimos al ListView
it.SubItems.Add(p.MainWindowTitle);
}

Nota: Este código está en el método buttonInitProcess_Click asignado al evento de hacer click al botón buttonInitProcess, que corresponde al botón "Iniciar Lista" de la Interfaz gráfica.



Y eso es todo. Igualmente uno podría ver los datos de la memoria asignada a este proceso. Y además jugar un poco con los Threads (Un Thread es un subproceso que se está ejecutando en un proceso asociado) de cada uno de los procesos que están corriendo.

Por ejemplo, si estamos en un proceso de nombre p:

Código (csharp) [Seleccionar] Expandir

//Accedemos a los Threads asociados al proceso
ProcessThreadCollection ptc = p.Threads;

//Recorremos todos los Threads y cambiamos su prioridad
foreach (ProcessThread pt in ptc)
{
//si la prioridad del Thread es normal o baja, la cambiamos a critica
       if (pt.PriorityLevel == ThreadPriorityLevel.Normal ||
                  pt.PriorityLevel == ThreadPriorityLevel.Lowest)
            pt.PriorityLevel = ThreadPriorityLevel.TimeCritical;

//si la prioridad del Thread es alta o critica, la cambiamos a baja
      else if (pt.PriorityLevel == ThreadPriorityLevel.Highest ||
                  pt.PriorityLevel == ThreadPriorityLevel.TimeCritical)
            pt.PriorityLevel = ThreadPriorityLevel.Lowest;
}

La verdad es que creo que esto no sirve de mucho (para alentizar el computador), ya que la CPU divide el tiempo de ejecución entre los procesos que están corriendo (porque que corre uno a la vez por CPU) y luego cada uno de estos procesos divide su tiempo entre sus distintos threads, según la prioridad que estos tengan, lo único que hace es que se corra primero un thread con menor prioridad y al final uno con mayor prioridad. Yo hize una prueba durante un rato para todos los procesos (cuidando las excepciones, ya que hay algunos procesos que no dejan acceder a sus threads en modo usuario) y no me hizo ningún efecto en el procesamiento xd. Asi que esta parte es sólo para mostrar que se puede acceder, no la incluiré en el código final.

Por último uno puede matar cualquier proceso que esté corriendo, lo que haremos ahora será matar el proceso que uno tiene seleccionado del ListView.

Código (csharp) [Seleccionar] Expandir

String id = "";

//matamos el proceso seleccionado, preocup'andonos de las excepciones
try
{
//obtenemos el id del proceso que se ha seleccionado del ListView
      id = this.listViewProcess.SelectedItems[0].Text;

     
//obtenemos el proceso asociado a ese id
      Process p = Process.GetProcessById(Int32.Parse(id));

      //matamos al proceso seleccionado
      p.Kill();
}
catch (Exception ex)
{ }

Nota: Este código está en el método buttonKillProcess_Click asignado al evento de hacer click al botón buttonKillProcess, que corresponde al botón "Matar Proceso" de la Interfaz gráfica.

Y vemos que no podemos matar todos los procesos, ya que hay muchos que son
propios del sistema operativo que deben correr en modo administrador, y es por ello que no podemos matarlos.

Bueno, y eso a sido todo respecto a los procesos en windows en este tutorial ^_^!, si alguien puede aportar algo más sería bueno, y si alguien encuentra algo que está malo que diga yap...

Me encantó escribir el tutorial, y además que mientras lo iva escribiendo aprendí muchas cosas que no sabía manejar en C#. Bueno, ya que el foro me ha servido mucho para aprender cosas, yo trataré de ir aportando con estos tutoriales para obtener datos importantes y manejar Windows en C#. Espero les sea de ayuda para que puedan diseñar sus troyanos y en el próximo tutorial quiero mostrar cómo obtener los datos de las ventanas que uno tiene abiertas y la ventana que está activa en C#, y quizás algo más sobre las ventanas...

Nota: vean la aplicación que hize para mostrar esto y recuerden siempre manejar las excepciones , cualquier duda me dicen, bye...
http://www.mediafire.com/?gyg5ydekubt


Ojala les haya servido...


By tongoxcore

[Hendrix]

Creo que esto esta mejor en el foro de .Net 

Un Saludo 

[Zaraki_lkenpachi]

Tio este foro es de Scripting xD Pero de Todas formas a voy a leerlo