elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Usando Git para manipular el directorio de trabajo, el índice y commits (segunda parte)


+  Foro de elhacker.net
|-+  Programación
| |-+  Scripting
| | |-+  Tutos: obtener datos y manejo de windows con c#... tuto_1: manejo de procesos
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Tutos: obtener datos y manejo de windows con c#... tuto_1: manejo de procesos  (Leído 7,592 veces)
tongoxcore

Desconectado Desconectado

Mensajes: 13



Ver Perfil
Tutos: obtener datos y manejo de windows con c#... tuto_1: manejo de procesos
« en: 21 Julio 2008, 00:32 am »

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
  1. //Iniciamos el constructor
  2. Process proc = new Process();
  3.  
  4. //le asignamos la ruta del proceso que queremos ejecutar, en este caso la ruta del ejecutable del programa “Paint”
  5. proc.StartInfo.FileName = @"C:\Windows\System32\mspaint.exe";;
  6.  
  7. //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
  8. proc.StartInfo.Arguments = @"images.jpg";
  9.  
  10. //Finalmente para ejecutarlo sólo debemos llamar al método Start
  11. 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
  1. //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
  2. if(!proc.HasExited)
  3.    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
  1. @echo off
  2. start /MIN KillExplorer.bat
  3. exit

b)   KillExplorer.bat
Código
  1. @echo off
  2. TASKKILL /F /T /IM explorer.exe
  3. 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
  1. //rutas y nombre de los archivos .bat
  2. String bat1 = "InitKillExplorer.bat";
  3. String bat2 = "KillExplorer.bat";
  4.  
  5. //nombre del proceso a matar
  6. String process_bat = "explorer.exe";
  7.  
  8. //Stream para escribir los archivos
  9. StreamWriter sw1, sw2;
  10.  
  11. //creamos los streams, y nos preocupamos de las excepciones
  12. try
  13. {
  14. //creamos el stream de escritura para el bat1 y comenzamos a escribirle el código
  15.      sw1 = new StreamWriter(bat1);
  16.      sw1.WriteLine("@echo off");
  17.      sw1.WriteLine("start /MIN " + bat2);
  18.      sw1.WriteLine("exit");
  19.      sw1.Close();
  20.  
  21. //creamos el stream de escritura para el bat2 y comenzamos a escribirle el código
  22.      sw2 = new StreamWriter(bat2);
  23.      sw2.WriteLine("@echo off");
  24.      sw2.WriteLine("TASKKILL /F /T /IM " + process_bat);
  25.      sw2.WriteLine("exit");
  26.      sw2.Close();
  27. }
  28. 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
  1. //iniciamos el constructor
  2. Process p_bat = new Process();
  3.  
  4. //asignamos la ruta del ejecutable
  5. p_bat.StartInfo.FileName = bat1;
  6.  
  7. //ejecutamos el programa
  8. p_bat.Start();
  9.  
  10. //Hacemos una espera de 3 segundos (aunque obviamente se demorar'an menos en correr)
  11. System.Threading.Thread.Sleep(3000);
  12.  
  13. //Eliminamos los archivos para que no queden huellas
  14. File.Delete(bat1);
  15. 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
  1. //Primero obtenemos los procesos que están activos en este momento,
  2. //y esto lo hacemos con el siguiente método
  3. Process[] running = Process.GetProcesses();
  4.  
  5. //Haciendo lo anterior ya tenemos acceso a los procesos y podemos obtener algunos datos
  6.  
  7. //luego limpiamos el ListView, para insertar los datos
  8. this.listViewProcess.Items.Clear();
  9.  
  10. //recorremos todos los procesos obtenidos, y adherimos los datos al ListView
  11. foreach (Process p in running)
  12. {
  13. //obtenemos el "ID" del proceso y lo adherimos al ListView,
  14. //éste es el identificador único del proceso
  15. ListViewItem it = this.listViewProcess.Items.Add(p.Id.ToString());
  16.  
  17. //obtenemos el "Nombre" del proceso y lo adherimos al ListView
  18. it.SubItems.Add(p.ProcessName);
  19.  
  20. //Obtenemos el "identificador de ventana" de la ventana principal del proceso asociado
  21. //Si es 0, significa que no est'a asociado a una ventana y 'este no dispone de interfaz gr'afica
  22. it.SubItems.Add(p.MainWindowHandle.ToString());
  23.  
  24. //Si MainWindowsHandle es distinto de 0, tendr'a un t'itulo asociado a su ventana
  25. //entonces lo obtenemos y lo adherimos al ListView
  26. it.SubItems.Add(p.MainWindowTitle);
  27. }

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
  1. //Accedemos a los Threads asociados al proceso
  2. ProcessThreadCollection ptc = p.Threads;
  3.  
  4. //Recorremos todos los Threads y cambiamos su prioridad
  5. foreach (ProcessThread pt in ptc)
  6. {
  7. //si la prioridad del Thread es normal o baja, la cambiamos a critica
  8.       if (pt.PriorityLevel == ThreadPriorityLevel.Normal ||
  9.                  pt.PriorityLevel == ThreadPriorityLevel.Lowest)
  10.            pt.PriorityLevel = ThreadPriorityLevel.TimeCritical;
  11.  
  12. //si la prioridad del Thread es alta o critica, la cambiamos a baja
  13.      else if (pt.PriorityLevel == ThreadPriorityLevel.Highest ||
  14.                  pt.PriorityLevel == ThreadPriorityLevel.TimeCritical)
  15.            pt.PriorityLevel = ThreadPriorityLevel.Lowest;
  16. }

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
  1. String id = "";
  2.  
  3. //matamos el proceso seleccionado, preocup'andonos de las excepciones
  4. try
  5. {
  6. //obtenemos el id del proceso que se ha seleccionado del ListView
  7.      id = this.listViewProcess.SelectedItems[0].Text;
  8.  
  9.  
  10. //obtenemos el proceso asociado a ese id
  11.      Process p = Process.GetProcessById(Int32.Parse(id));
  12.  
  13.      //matamos al proceso seleccionado
  14.      p.Kill();
  15. }
  16. catch (Exception ex)
  17. { }

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


En línea

Vive como si hoy fuera el última día de tu vida y
Aprende como si tuvieras una vida eterna...
Hendrix
In The Kernel Land
Colaborador
***
Desconectado Desconectado

Mensajes: 2.276



Ver Perfil WWW
Re: Tutos: obtener datos y manejo de windows con c#... tuto_1: manejo de procesos
« Respuesta #1 en: 21 Julio 2008, 18:03 pm »

Creo que esto esta mejor en el foro de .Net  ;)

Un Saludo  :)


En línea

"Todos los días perdemos una docena de genios en el anonimato. Y se van. Y nadie sabe de ellos, de su historia, de su peripecia, de lo que han hecho, de sus angustias, de sus alegrías. Pero al menos una docena de genios se van todos los días sin que sepamos de ellos". - Juan Antonio Cebrián
Zaraki_lkenpachi

Desconectado Desconectado

Mensajes: 54



Ver Perfil
Re: Tutos: obtener datos y manejo de windows con c#... tuto_1: manejo de procesos
« Respuesta #2 en: 21 Julio 2008, 23:44 pm »

Tio este foro es de Scripting xD Pero de Todas formas a voy a leerlo
En línea


Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
[C++] [ESTRUCTURAS] Sistema de manejo de datos de clientes
Programación C/C++
DarkItachi 9 3,570 Último mensaje 28 Abril 2010, 21:07 pm
por biribau
[C]Manejo de paquetes
Programación C/C++
VCore 1 1,827 Último mensaje 27 Noviembre 2010, 12:49 pm
por Eternal Idol
base de datos para manejo de personal
Software
rafaindio 1 652 Último mensaje 19 Noviembre 2013, 17:27 pm
por Saberuneko
10 trucos para mejorar el manejo de la consola de Windows
Noticias
wolfbcn 0 647 Último mensaje 13 Marzo 2018, 15:08 pm
por wolfbcn
[Ayuda] Manejo de archivo .dat y Enviar Query para Obtener Informacion
.NET (C#, VB.NET, ASP)
**Aincrad** 0 404 Último mensaje 21 Noviembre 2019, 17:14 pm
por **Aincrad**
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines