Compartir memoria entre dos procesos (C, Windows)

Como no he encontrado una respuesta a la pregunta hecha anteriormente , bash un enfoque diferente.

¿Hay alguna forma de compartir memoria entre dos procesos?

El segundo proceso obtiene la información de una inyección ya que es un progtwig heredado que ya no es compatible.

Mi idea es insertar algún código allí, en la estructura que paso al progtwig inyectado, paso la dirección (o lo que sea) a la memoria compartida donde se encuentran los datos que necesito ejecutar. Una vez que obtenga los datos, poblaré mis propias variables dentro del hilo inyectado.

es posible? ¿Cómo?

Código es apreciado.

EDITAR:

Creo que no está claro, así que lo aclararé. Sé cómo inyectar Ya lo estoy haciendo El problema aquí es pasar datos dynamics a la inyección.

Puede probar un archivo mapeado en memoria .

Esto da un poco más de detalle paso a paso.

Aunque Windows admite memoria compartida a través de su API de mapeo de archivos , no puede inyectar fácilmente una asignación de memoria compartida en otro proceso directamente, ya que MapViewOfFileEx no toma un argumento de proceso.

Sin embargo, puede inyectar algunos datos asignando memoria en otro proceso utilizando VirtualAllocEx y WriteProcessMemory . Si tuviera que copiar en un manipulador usando DuplicateHandle , luego inyectar un stub que llama a MapViewOfFileEx , podría establecer una asignación de memoria compartida en otro proceso. Como parece que de todos modos estarás inyectando código, esto debería funcionar bien para ti.

Para resumir, necesitarás:

  • Cree un identificador de segmento de memoria compartida anónimo llamando a CreateFileMapping con INVALID_HANDLE_VALUE para hFile y NULL para lpName.
  • Copie este identificador en el proceso de destino con DuplicateHandle
  • Asigne memoria para código usando VirtualAllocEx , con flAllocationType = MEM_COMMIT | MEM_RESERVE y flProtect = PAGE_EXECUTE_READWRITE
  • Escriba su código auxiliar en esta memoria, usando WriteProcessMemory . Es probable que este código deba escribirse en ensamblador. Pase el MANGO de DuplicateHandle escribiéndolo aquí en alguna parte.
  • Ejecute su stub usando CreateRemoteThread . El stub debe usar la HANDLE obtenida para llamar a MapViewOfFileEx . Los procesos tendrán un segmento común de memoria compartida.

Puede encontrarlo un poco más fácil si su stub carga una biblioteca externa, es decir, simplemente llame a LoadLibrary (encontrar la dirección de LoadLibrary como un ejercicio para el lector) y realice su trabajo desde el punto de entrada dllmain de la biblioteca. En este caso, usar la memoria compartida con nombre es más fácil que jugar con DuplicateHandle. Consulte el artículo de MSDN sobre CreateFileMapping para obtener más detalles, pero, esencialmente, pase INVALID_HANDLE_VALUE para hFile y un nombre para lpName.

Editar : dado que su problema es pasar datos y no la inyección de código real, aquí hay algunas opciones.

  1. Use memoria compartida de tamaño variable. Su stub obtiene el tamaño y el nombre o el identificador de la memoria compartida. Esto es apropiado si solo necesita intercambiar datos una vez. Tenga en cuenta que el tamaño de un segmento de memoria compartida no se puede cambiar fácilmente después de la creación.
  2. Use un tubo con nombre . Su talón recibe el nombre o un asa de la tubería. Luego puede usar un protocolo apropiado para intercambiar bloques de tamaño variable; por ejemplo, escriba un tamaño para la longitud, seguido del mensaje real. O use PIPE_TYPE_MESSAGE y PIPE_READMODE_MESSAGE, y busque ERROR_MORE_DATA para determinar dónde terminan los mensajes. Esto es apropiado si necesita intercambiar datos varias veces.

Edición 2 : Aquí hay un boceto de cómo podría implementar el manejo o el almacenamiento de puntero para su talón:

.db B8 ;; mov eax, imm32 .dl handle_value ;; fill this in (located at the start of the image + one byte) ;; handle value is now in eax, do with it as you will ;; more code follows... 

También podría usar un nombre fijo, que probablemente sea más simple.

Puede usar memoria compartida

¿Intentó usar tuberías (para memoria) o incluso serialización (para sus objetos)? Puede usar archivos para administrar la memoria entre procesos. Los zócalos también son buenos para obtener comunicación entre procesos.

Si hablamos de Windows, el principal obstáculo es que cada uno de los procesos vive en su propio espacio de direcciones virtuales. Desafortunadamente, no puede pasar las direcciones normales de memoria de un proceso a otro y obtener los resultados que espera. (Los subprocesos, por otro lado, todos viven en el mismo espacio de direcciones, por lo que los subprocesos pueden ver la memoria de la misma manera).

Windows, sin embargo, tiene un espacio de memoria compartido que debe tener mucho cuidado para administrar correctamente. Cualquier proceso que asigna espacio en el espacio de memoria compartida es responsable de liberar esa memoria de forma explícita. Esto está en contraste con la memoria local, que más o menos desaparece cuando el proceso muere.

Consulte este artículo de muestra de MSDN para obtener algunas ideas sobre cómo puede usar el espacio de memoria compartida para dominar el mundo. Er, interfaz con el software heredado. O lo que sea 🙂 ¡Buena suerte sea lo que sea que termines haciendo!

Puede intentar usar Boost.Interprocess para comunicarse entre dos procesos. Pero para inyectar código en un software previamente existente y no compatible, probablemente tendrá que usar la forma de @ bdonlan utilizando WriteProcessMemory .

La asignación de memoria es el camino a seguir, ni siquiera necesita crear un espacio de memoria permanente, el sector de la memoria queda fuera del scope cuando todos los procesos que lo comparten están apagados. También hay otras formas. Una manera rápida y sucia de pasar datos de una aplicación C a otra es simplemente usar el sistema operativo. En línea de comandos, escriba app1 | app2 app1 | app2 . Esto hace que app2 sea el destino de salida de app1 o iow, un comando printf de la aplicación 1 lo enviaría a la aplicación2 (esto se denomina canalización).