Condivisione della memoria tra due processi (C, Windows)

StackOverflow https://stackoverflow.com/questions/1200998

Domanda

Dato che non ho trovato una risposta alla domanda posta precedentemente qui Sto provando un approccio diverso.

Esiste un modo per condividere la memoria tra due processi?

Il secondo processo ottiene le informazioni da un'iniezione poiché è un programma legacy che non è più supportato.

La mia idea è quella di iniettare un po 'di codice lì, nella struttura che sto passando al programma iniettato passare l'indirizzo (o qualunque altra cosa) nella memoria condivisa dove si trovano i dati che devo eseguire. Una volta ottenuti i dati, popolerò le mie variabili all'interno del thread iniettato.

È possibile? Come?

Il codice è apprezzato.

EDIT:

Penso che non sia chiaro, quindi chiarirò. So iniettare. Lo sto già facendo. Il problema qui è passare dati dinamici all'iniezione.

È stato utile?

Soluzione

Puoi provare un file mappato in memoria .

Questo fornisce un po 'più passaggi dettagli.

Altri suggerimenti

Sebbene Windows supporti la memoria condivisa tramite la API di mappatura dei file , non è possibile inserire facilmente un mapping di memoria condivisa direttamente in un altro processo, come MapViewOfFileEx non accetta un argomento di processo.

Tuttavia, è possibile inserire alcuni dati allocando la memoria in un altro processo utilizzando VirtualAllocEx e WriteProcessMemory . Se dovessi copiare in un handle utilizzando DuplicateHandle , quindi iniettare uno stub che chiama MapViewOfFileEx , tu potrebbe stabilire una mappatura della memoria condivisa in un altro processo. Dal momento che sembra che tu stia comunque iniettando codice, questo dovrebbe funzionare bene per te.

Per riassumere, dovrai:

  • Crea un handle di segmento di memoria condivisa anonimo chiamando CreateFileMapping con INVALID_HANDLE_VALUE per hFile e NULL per lpName.
  • Copia questo handle nel processo di destinazione con DuplicateHandle
  • Alloca un po 'di memoria per il codice usando VirtualAllocEx , con flAllocationType = MEM_COMMIT | MEM_RESERVE e flProtect = PAGE_EXECUTE_READWRITE
  • Scrivi il tuo codice stub in questa memoria, usando WriteProcessMemory . Questo troncone dovrà probabilmente essere scritto in assembler. Passa la MANIGLIA da DuplicateHandle scrivendola qui da qualche parte.
  • Esegui il tuo stub usando CreateRemoteThread . Lo stub deve quindi utilizzare la MANIGLIA ottenuta per chiamare MapViewOfFileEx . I processi avranno quindi un segmento di memoria condivisa comune.

Potresti trovare un po 'più semplice se il tuo stub carica una libreria esterna, ovvero chiamalo semplicemente LoadLibrary (trovare l'indirizzo di LoadLibrary viene lasciato come esercizio al lettore) e fare il tuo lavoro dalla voce dllmain della libreria punto. In questo caso è probabile che l'uso della memoria condivisa denominata sia più semplice che tentennare con DuplicateHandle. Consulta l'articolo MSDN su CreateFileMapping per ulteriori dettagli, ma, essenzialmente, passa INVALID_HANDLE_VALUE per hFile e un nome per lpName.

Modifica : poiché il tuo problema è il trasferimento di dati e non l'iniezione di codice effettiva, ecco alcune opzioni.

  1. Utilizza memoria condivisa di dimensioni variabili. Lo stub ottiene la dimensione e il nome o l'handle della memoria condivisa. Ciò è appropriato se è necessario scambiare dati una sola volta. Si noti che la dimensione di un segmento di memoria condivisa non può essere facilmente modificata dopo la creazione.
  2. Utilizza una pipe denominata . Il tuo stub ottiene il nome o una maniglia per la pipe. È quindi possibile utilizzare un protocollo appropriato per scambiare blocchi di dimensioni variabili, ad esempio scrivere un size_t per la lunghezza, seguito dal messaggio effettivo. Oppure utilizza PIPE_TYPE_MESSAGE e PIPE_READMODE_MESSAGE e osserva ERROR_MORE_DATA per determinare dove terminano i messaggi. Ciò è appropriato se è necessario scambiare dati più volte.

Modifica 2 : ecco uno schizzo di come implementare l'archiviazione handle o pointer per il tuo stub: 

.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...

Potresti anche semplicemente usare un nome fisso, che è probabilmente più semplice.

Hai provato a usare le pipe (per la memoria) o anche la serializzazione (per i tuoi oggetti)? È possibile utilizzare i file per gestire la memoria tra i processi. Anche i socket sono utili per ottenere la comunicazione tra i processi.

La mappatura della memoria è la strada da percorrere, non è nemmeno necessario creare uno spazio di memoria permanente, il settore della memoria esce dall'ambito quando tutti i processi che lo condividono vengono chiusi. Ci sono anche altri modi. Un modo rapido e sporco di passare i dati da un'app C all'altra è solo quello di utilizzare il sistema operativo. Alla riga di comando digitare app1 | app2 . Questo fa sì che app2 sia la destinazione di output di app1 o visualizzi un comando printf da app1 che lo invierebbe ad app2 (questo si chiama piping).

Puoi provare a utilizzare Boost.Interprocess comunicare tra due processi. Ma per iniettare il codice in un software precedentemente non supportato, probabilmente dovrai usare il modo di @ bdonlan usando WriteProcessMemory .

Se stai parlando di Windows, il roadblock principale è che elabora ogni live nel proprio spazio di indirizzi virtuale. Sfortunatamente non puoi passare i normali indirizzi di memoria da un processo all'altro e ottenere i risultati che ti aspetti. (D'altra parte, i thread vivono tutti nello stesso spazio degli indirizzi, motivo per cui i thread possono vedere la memoria allo stesso modo.)

Tuttavia, Windows ha uno spazio di memoria condiviso che devi fare molta attenzione per gestirlo correttamente. Qualsiasi processo che alloca spazio nello spazio di memoria condivisa è responsabile della liberazione esplicita di tale memoria. Ciò è in contrasto con la memoria locale, che svanisce più o meno quando il processo termina.

Consulta questo articolo di esempio MSDN per alcune idee su come potresti utilizzare lo spazio di memoria condivisa per conquistare il mondo. Ehm, interfaccia con software legacy. O qualunque cosa :) Buona fortuna qualunque cosa tu faccia finire!

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top