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


 


Tema destacado: Como proteger una cartera - billetera de Bitcoin


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación General
| | |-+  .NET (C#, VB.NET, ASP) (Moderador: kub0x)
| | | |-+  Marshal - Interactuando entre managed y unmanaged memory. (C++ CLI)
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Marshal - Interactuando entre managed y unmanaged memory. (C++ CLI)  (Leído 4,199 veces)
[D4N93R]
Wiki

Desconectado Desconectado

Mensajes: 1.647


My software never has bugs. Its just features!


Ver Perfil WWW
Marshal - Interactuando entre managed y unmanaged memory. (C++ CLI)
« en: 4 Agosto 2010, 21:49 »

Marshal - Interactuando entre managed y unmanaged memory.

Antes de comenzar con el tema tenemos que tener en cuenta que toda aplicación en .Net se ejecuta bajo una porción de memoria administrada por el CLR y no interactúa directamente con la memoria nativa. (Para conocer más, puedes revisar este post: Conceptos de la arquitectura .NET Framework escrito por Mace Windu.)  :)

Ahora que conocemos cómo funciona el framework, podemos entender qué es Marshal. Marshal es una clase que está en el namespace System.Runtime.InteropServices, que casi nadie habla de él y que no muchos han visto, y lo que hace es mediar entre ambos entornos. Imaginen un bar de lujo (Managed Memory), la calle (Unmanaged Memory) y el portero (Marshal), no es más que eso, si quieres entrar o salir del bar, vas a tener que pedirle permiso a Marshal. En pocas palabras marshal nos permite copiar data de un lado a otro.

Les voy a mostrar un cuadro que vi hace tiempo en msdn, y que ilustra muy bien las categorías de los miembros de la clase Marshal:



En este artículo utilizaremos principalmente los miembros de la categoría Data transformation, qué son los que nos permiten pasar data del entorno administrado al nativo y viceversa. Como vemos en la tabla, los métodos son bastante descriptivos, por ejemplo StringToHGlobalAnsi lo que hace es copiar el contenido de un string administrado a la memoria nativa, y te retorna la dirección en donde copió la data.

En esta página de msdn Marshal Members podrán ver bien qué hace cada miembro y si requiere de algún paso adicional, como es el caso de StringToHGlobalAnsi, el cual necesita llamar a la función FreeHGlobal (también de Marshal)

Veamos un ejemplo práctico del uso de Marshal:

Un amigo de acá del foro, [Zero], tiene una clase en C, es una especie de utilitario. Para el ejemplo usaremos la siguiente función del código de [Zero]:

Código
  1. //La funcion lo que hace es terminar un proceso en ejecucion.
  2. int cTerminateProcess(char* lpProcessName)
  3. {
  4. HANDLE hProcess=NULL;
  5. HANDLE hSnapshot=NULL;
  6. PROCESSENTRY32 *pInfo=NULL;
  7.  
  8. hSnapshot=CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0);
  9. if(!hSnapshot) return -1;
  10.  
  11. pInfo=(PROCESSENTRY32*)GlobalAlloc(GPTR,sizeof(PROCESSENTRY32));
  12. pInfo->dwSize=sizeof(PROCESSENTRY32);
  13.  
  14. //Obtenemos el PID del proceso
  15. Process32First(hSnapshot,pInfo);
  16. do
  17. {
  18. if(!lstrcmpA(pInfo->szExeFile,lpProcessName))
  19. {
  20. if(OpenProcess(PROCESS_TERMINATE,FALSE,pInfo->th32ProcessID))
  21. {
  22. hProcess=OpenProcess(PROCESS_TERMINATE,FALSE,pInfo->th32ProcessID);
  23. }
  24. }
  25. }while(Process32Next(hSnapshot,pInfo));
  26.  
  27. GlobalFree(pInfo);
  28.  
  29. if(!hProcess) return -1;
  30.  
  31. if(!TerminateProcess(hProcess,0))return -1;
  32.  
  33. Sleep(100);
  34.  
  35. return 1;
  36. }
  37.  


Supongamos que yo quiero usarlo desde .Net, ¿Cómo sería eso posible? No es muy dificil, ni requiere mucho tiempo. La idea es crear una librería en .Net la cual podamos referencia sin ningún problema, esto se llama wrapper, y lo haremos desde C++ CLI, el cual nos permite exactamente lo que queremos, interactuar entre entornos Administrados y Nativos mucho más fácil que desde C#, aunque sigue siendo posible, pero tendríamos que usar el keyword unsafe. En C++ tenemos mucho más fácil el acceso a la memoria nativa del sistema, y el mismo acceso al framework.

Ahora sigamos los siguientes pasos para crear nuestro Wrapper:

1.- Creamos una Solución en Blanco en Visual Studio
Le ponen un nombre y click en aceptar. Eso es todo.!

2.- Ahora agregamos Un Proyecto C++ (Static Library)
Este proyecto es donde va el código en C, es decir, las funciones a las cuales les queremos hacer el wrapper (en español es algo como envoltorio, ya veremos por qué). Para crear el proyecto le dan botón derecho en la solución, en el explorador de soluciones. Luego Agregar Nuevo Proyecto. En la ventana seleccionen Visual C++ y en el listado escojan Win32 Project, le dan un nombre y Click en Aceptar.

Aquí es donde va la función cTerminateProcess del código de [Zero].

3.- Creamos un Proyecto C++ CLI (Dynamic Library)
Este va a ser nuestro Wrapper, por lo que crearemos un proyecto en C++ CLI de tipo Dynamic Library, es decir una DLL. De la misma forma que con el proyecto anterior, agregamos un nuevo proyecto seleccionamos igual Visual C++ pero esta vez el tipo de Proyecto será Class Library. Nombramos el proyecto y aceptamos.

Ahora tenemos que hacer dos cosas, la primera es agregar el directorio en donde está el .h del proyecto de C, esto se hace yendo a las propiedades del proyecto > Propiedades de Configuración > C/C++ > General, y dónde dice Additional Include Directories agregar el directorio correspondiente. El segundo paso es agregar a la lista de dependencias la dirección en donde está el .lib que es el resultado del static library en C. Pueden hacerlo yendo a Propiedades de Configuración > Linker > Input, agregandolo en donde dice Dependencias Adicionales.

Ya tenemos todo listo para comenzar a hacer el wrapper.

Creamos una clase y le ponemos el nombre que quieras ponerle cuando la vayan a utilizar, por lo que debe ser un nombre que haga referencia a la función del código. En nuestro caso le pondremos DemoClass. Se crearán dos archivos uno .h y otro .cpp, Abrimos el .h para definir la clase y el método que queremos.

El código del .h quedaría así:
Código
  1. // DemoClass.h
  2.  
  3. #pragma once
  4.  
  5. using namespace System;
  6.  
  7. namespace Demo{
  8.  
  9. public ref class DemoClass
  10. {
  11. public:
  12. int TerminateProcess(String^ ProcessName);
  13. };
  14. }
  15.  

Si recordamos la función en C se llama cTerminateProcess, entonces en nuestro wrapper se llamará simplemente TerminateProcess, los parámetros es algo que hay que tener en cuenta, la funcion original pide char*, en .Net la idea es NO usar punteros por lo que usaremos String, y vale la pena recalcar el uso del simbolo ^ que es simplemente para identificar las referencias a código administrado y código nativo.

Ya tenemos el .h listo, vamos a codificar el cpp:

Código
  1. // This is the main DLL file.
  2.  
  3. #include "stdafx.h"
  4. #include <vcclr.h>
  5. #include "DemoClass.h"
  6.  
  7. using namespace System;
  8. using namespace System::Runtime::InteropServices;
  9.  
  10. namespace Demo{
  11.        int DemoClass::TerminateProcess(String^ ProcessName)
  12. {
  13.                //Validamos :)
  14. if(!ProcessName)
  15. throw gcnew ArgumentNullException;
  16.  
  17.                //Utilizamos StringToHGlobalAnsi el cual pide String como parametro
  18.                //como retorna un puntero, y sabemos que es un string, le hacemos un
  19.                //cast a char*
  20. char* lpProcessName = (char*)(void*)Marshal::StringToHGlobalAnsi(ProcessName);
  21.  
  22.                //ejecutamos cTerminateProcess y le pasamos lpProcessName
  23. int result = AmC::cTerminateProcess(lpProcessName);
  24.  
  25.                //liberamos la memoria usada por lpProcessName , y retornamos
  26. Marshal::FreeHGlobal((System::IntPtr)(void*)lpProcessName);
  27. return result;
  28. }
  29. }
  30.  

Como pueden ver no es nada complicado, aunque hay que hacerlo muy bien para no dejar punteros sin liberar ni funciones sin validar.


3.- Por último agregamos un Proyecto C# en Windows
Usaremos el proyecto para testear la libería. Al Form1 le agregamos un botón y un textbox.

Doble Click al botón para subscribirnos al evento Click, y colocamos esto:

Código
  1. DemoClass m_amNet = new DemoClass();
  2. m_amNet.TerminateProcess(m_terminateProcessTextBox.Text);
  3.  

Simplemente creamos una instancia de la clase DemoClass y llamamos al método TerminateProcess que a su vez llama al cTerminateProcess en la liberia en C.

Presionamos F5 para compilar y ejecutar nuestra solución, ejecutamos la calculadora, colocamos ese nombre calc.exe (el nombre del proceso de la calculadora) en el textbox, por último hacemos click en el botón y si todo sale bien debería cerrarse el proceso.



Espero les sirva de ayuda, si hay algún error me avisas y lo corregimos.

Un saludo!


« Última modificación: 23 Agosto 2010, 16:23 por [D4N93R] » En línea

[Zero]
Wiki

Desconectado Desconectado

Mensajes: 1.082


CALL DWORD PTR DS:[0]


Ver Perfil WWW
Re: Marshal - Interactuando entre managed y unmanaged memory. (C++ CLI)
« Respuesta #1 en: 4 Agosto 2010, 22:00 »

Te quedó bien la explicación, hasta yo la entendí  ;D. Hiciste que odiara un poco menos .Net ( no mucho xD), desconocía completamente que .Net contara con esto  :P.

Saludos


En línea


“El Hombre, en su orgullo, creó a Dios a su imagen y semejanza.”
Nietzsche
[D4N93R]
Wiki

Desconectado Desconectado

Mensajes: 1.647


My software never has bugs. Its just features!


Ver Perfil WWW
Re: Marshal - Interactuando entre managed y unmanaged memory. (C++ CLI)
« Respuesta #2 en: 4 Agosto 2010, 22:05 »

Vale, gracias [Zero]. Ya sabes que tienes una herramienta acá, aunque no sea C# sigue siendo .Net hehe
En línea

raul338


Desconectado Desconectado

Mensajes: 2.633


La sonrisa es la mejor forma de afrontar las cosas


Ver Perfil WWW
Re: Marshal - Interactuando entre managed y unmanaged memory. (C++ CLI)
« Respuesta #3 en: 5 Agosto 2010, 00:19 »

La verdad: espectacular! La verdad sabia poco y nada de marshal :D

Esta vez si que aprendi algo nuevo :xD
En línea

Fajbuszak

Desconectado Desconectado

Mensajes: 1


Ver Perfil
Re: Marshal - Interactuando entre managed y unmanaged memory. (C++ CLI)
« Respuesta #4 en: 14 Julio 2014, 16:12 »

como puedo instanciar una clase de codigo administrado desde uno no administrado en forma de variable global.
ejemplo:
clase de codigo administrado :
miRSA::miRSA(void)
{
   RSA = gcnew RSACryptoServiceProvider;

   publicOnlyKeyXML = RSA->ToXmlString(false) ;
   publicPrivateKeyXML = RSA->ToXmlString(true);
   int desde = publicOnlyKeyXML->IndexOf("<Modulus>",0)+9;
   int iHasta=publicOnlyKeyXML->IndexOf("</Modulus>",0);
   LaPublica = publicOnlyKeyXML->Substring(desde, iHasta  - desde);
   desde = publicOnlyKeyXML->IndexOf("<Exponent>",0)+10;
   iHasta=publicOnlyKeyXML->IndexOf("</Exponent>",0);
   sExponente = publicOnlyKeyXML->Substring(desde, iHasta  - desde);
   sPublicaExponente = LaPublica + sExponente;
   
}

desde codigo no administrado prog.cpp:
// Prueba.cpp: define las funciones exportadas de la aplicación DLL.
//

#include "stdafx.h"
#include "Prueba.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif


     miRSA^ laRSA;      //da error de compilacion 3145
     laRSA = gcnew miRSA;


En línea

Eleкtro
Ex-Staff
*
Desconectado Desconectado

Mensajes: 9.709



Ver Perfil
Re: Marshal - Interactuando entre managed y unmanaged memory. (C++ CLI)
« Respuesta #5 en: 14 Julio 2014, 16:31 »

No se deben revivir posts antiguos para formular preguntas.

Tema cerrado.
En línea


Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Review Msi Marshal P67 1155
Hardware
[DRACO] 6 3,717 Último mensaje 24 Mayo 2011, 14:47
por imoen
Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines