Как выгрузить DLL из чужого процесса

coocky
Нельзя ли сформулировать первоначальную задачу?
К какому процессу нужно прилипнуть? На каком этапе?
Что нужно подгрузить? Что выполнить?
Какие условия выгрузки? и прочее... если, конечно, нужна помощь.

ps/
Чем точнее постановка задачи, тем проще находится решение.

pps/ можно в РМ....

 

DMD
Да без проблем.
Работаю только из User mode
1.Нужно внедрят длл во все процессы,для перехвата функций для работы с файлами.Это для криворукой безопасности на моей фирме для бухгалтеров.Для перехвата испоьлзую либу Detours.
2.Я умею внедрять через CreateRemoteThread (запуском LoadLibrary()) в уже открытые процессы. Проблем нет.
3.Для внедрения во вновь создаваемые процессы я пользовался ключиком AppInit_Dlls.Но оказалось он не всегда справлялся..Решил пойти путем перехвата CreateProccess ( ведь при старте программы своей я всегда внедрюсь во все запущеные процессы,которые в свою очередь могут создать другие процессы) и внедрение во вновь создаваемый процесс своей длл функцией из либы Detours DetourCreateProcessWithDll. Она все делает красиво,никаких глюков.
4.Однако,мои длл НЕ ВЫГРУЖАЮТСЯ через CreateRemoteThread (FreeLibrary) из ТЕХ приложений,куда я внедрился путем функции DetourCreateProcessWithDll ,а выгружаются только из процессов,куда внедрился через CreateRemoteThread (запуском LoadLibrary()).Хотя все функции отрабатывают окейно..Но длл находится в процессе..
5.Мне нужно позарез выгружать либы,т.к. вторичный старт исключен,т.к. загрузчик не внедряет мою длл в те процессы,где есть уже не выгуженая длл.Сами понимаете почему.
Вот вообщем и все. Жаль ,что это моя работа.. Если б баловство-я б плюнул давно..

 

На вся кий случай исходник

Код (Text):

1. BOOL WINAPI DetourCreateProcessWithDllA(LPCSTR lpApplicationName,
2.                                         __in_z LPSTR lpCommandLine,
3.                                         LPSECURITY_ATTRIBUTES lpProcessAttributes,
4.                                         LPSECURITY_ATTRIBUTES lpThreadAttributes,
5.                                         BOOL bInheritHandles,
6.                                         DWORD dwCreationFlags,
7.                                         LPVOID lpEnvironment,
8.                                         LPCSTR lpCurrentDirectory,
9.                                         LPSTARTUPINFOA lpStartupInfo,
10.                                         LPPROCESS_INFORMATION lpProcessInformation,
11.                                         LPCSTR lpDetouredDllFullName,
12.                                         LPCSTR lpDllName,
13.                                         PDETOUR_CREATE_PROCESS_ROUTINEA pfCreateProcessA)
14. {
15.     DWORD dwMyCreationFlags = (dwCreationFlags | CREATE_SUSPENDED);
16.     PROCESS_INFORMATION pi;
17.  
18.     if (pfCreateProcessA == NULL) {
19.         pfCreateProcessA = CreateProcessA;
20.     }
21.  
22.     if (!pfCreateProcessA(lpApplicationName,
23.                           lpCommandLine,
24.                           lpProcessAttributes,
25.                           lpThreadAttributes,
26.                           bInheritHandles,
27.                           dwMyCreationFlags,
28.                           lpEnvironment,
29.                           lpCurrentDirectory,
30.                           lpStartupInfo,
31.                           &pi)) {
32.         return FALSE;
33.     }
34.  
35.     LPCSTR rlpDlls[2];
36.     DWORD nDlls = 0;
37.     if (lpDetouredDllFullName != NULL) {
38.         rlpDlls[nDlls++] = lpDetouredDllFullName;
39.     }
40.     if (lpDllName != NULL) {
41.         rlpDlls[nDlls++] = lpDllName;
42.     }
43.  
44.     if (!UpdateImports(pi.hProcess, rlpDlls, nDlls)) {
45.         return FALSE;
46.     }
47.  
48.     if (lpProcessInformation) {
49.         CopyMemory(lpProcessInformation, &pi, sizeof(pi));
50.     }
51.  
52.     if (!(dwCreationFlags & CREATE_SUSPENDED)) {
53.         ResumeThread(pi.hThread);
54.     }
55.     return TRUE;
56. }

Все не сложно,особый интерес здесь может представить функция UpdateImports

Код (Text):

1. static BOOL UpdateImports(HANDLE hProcess, LPCSTR *plpDlls, DWORD nDlls)
2. {
3.     BOOL fSucceeded = FALSE;
4.     BYTE * pbNew = NULL;
5.     DETOUR_EXE_RESTORE der;
6.     DWORD i;
7.  
8.     ZeroMemory(&der, sizeof(der));
9.     der.cb = sizeof(der);
10.  
11.     PBYTE pbModule = (PBYTE)FindExe(hProcess);
12.  
13.     IMAGE_DOS_HEADER idh;
14.     ZeroMemory(&idh, sizeof(idh));
15.  
16.     if (!ReadProcessMemory(hProcess, pbModule, &idh, sizeof(idh), NULL)) {
17.         DETOUR_TRACE(("ReadProcessMemory(idh) failed: %d\n", GetLastError()));
18.  
19.       finish:
20.         if (pbNew != NULL) {
21.             delete[] pbNew;
22.             pbNew = NULL;
23.         }
24.         return fSucceeded;
25.     }
26.     CopyMemory(&der.idh, &idh, sizeof(idh));
27.     der.pidh = (PIMAGE_DOS_HEADER)pbModule;
28.  
29.     if (idh.e_magic != IMAGE_DOS_SIGNATURE) {
30.         goto finish;
31.     }
32.  
33.     IMAGE_NT_HEADERS inh;
34.     ZeroMemory(&inh, sizeof(inh));
35.  
36.     if (!ReadProcessMemory(hProcess, pbModule + idh.e_lfanew, &inh, sizeof(inh), NULL)) {
37.         DETOUR_TRACE(("ReadProcessMemory(inh) failed: %d\n", GetLastError()));
38.         goto finish;
39.     }
40.     CopyMemory(&der.inh, &inh, sizeof(inh));
41.     der.pinh = (PIMAGE_NT_HEADERS)(pbModule + idh.e_lfanew);
42.  
43.     if (inh.Signature != IMAGE_NT_SIGNATURE) {
44.         goto finish;
45.     }
46.  
47.     if (inh.IMPORT_DIRECTORY.VirtualAddress == 0) {
48.         DETOUR_TRACE(("No IMAGE_DIRECTORY_ENTRY_IMPORT\n"));
49.         goto finish;
50.     }
51.  
52.     // Zero out the bound table so loader doesn't use it instead of our new table.
53.     inh.BOUND_DIRECTORY.VirtualAddress = 0;
54.     inh.BOUND_DIRECTORY.Size = 0;
55.  
56.     // Find the size of the mapped file.
57.     DWORD dwFileSize = 0;
58.     DWORD dwSec = idh.e_lfanew +
59.         FIELD_OFFSET( IMAGE_NT_HEADERS, OptionalHeader ) +
60.         inh.FileHeader.SizeOfOptionalHeader;
61.  
62.     for (i = 0; i < inh.FileHeader.NumberOfSections; i++) {
63.         IMAGE_SECTION_HEADER ish;
64.         ZeroMemory(&ish, sizeof(ish));
65.  
66.         if (!ReadProcessMemory(hProcess, pbModule + dwSec + sizeof(ish) * i, &ish,
67.                                sizeof(ish), NULL)) {
68.             DETOUR_TRACE(("ReadProcessMemory(inh) failed: %d\n", GetLastError()));
69.             goto finish;
70.         }
71.  
72.         DETOUR_TRACE(("ish[%d] : va=%p sr=%d\n", i, ish.VirtualAddress, ish.SizeOfRawData));
73.  
74.         // If the file didn't have an IAT_DIRECTORY, we create one...
75.         if (inh.IAT_DIRECTORY.VirtualAddress == 0 &&
76.             inh.IMPORT_DIRECTORY.VirtualAddress >= ish.VirtualAddress &&
77.             inh.IMPORT_DIRECTORY.VirtualAddress < ish.VirtualAddress + ish.SizeOfRawData) {
78.  
79.             inh.IAT_DIRECTORY.VirtualAddress = ish.VirtualAddress;
80.             inh.IAT_DIRECTORY.Size = ish.SizeOfRawData;
81.         }
82.  
83.         // Find the end of the file...
84.         if (dwFileSize < ish.PointerToRawData + ish.SizeOfRawData) {
85.             dwFileSize = ish.PointerToRawData + ish.SizeOfRawData;
86.         }
87.     }
88.     DETOUR_TRACE(("dwFileSize = %08x\n", dwFileSize));
89.  
90.     // Find the current checksum.
91.     WORD wBefore = ComputeChkSum(hProcess, pbModule, &inh);
92.     DETOUR_TRACE(("ChkSum: %04x + %08x => %08x\n", wBefore, dwFileSize, wBefore + dwFileSize));
93.  
94.     DETOUR_TRACE(("     Imports: %8p..%8p\n",
95.                   (DWORD_PTR)pbModule + inh.IMPORT_DIRECTORY.VirtualAddress,
96.                   (DWORD_PTR)pbModule + inh.IMPORT_DIRECTORY.VirtualAddress +
97.                   inh.IMPORT_DIRECTORY.Size));
98.  
99.     DWORD obRem = sizeof(IMAGE_IMPORT_DESCRIPTOR) * nDlls;
100.     DWORD obTab = PadToDwordPtr(obRem + inh.IMPORT_DIRECTORY.Size);
101.     DWORD obDll = obTab + sizeof(DWORD_PTR) * 4 * nDlls;
102.     DWORD obStr = obDll;
103.     DWORD cbNew = obStr;
104.     DWORD n;
105.     for (n = 0; n < nDlls; n++) {
106.         cbNew += PadToDword((DWORD)strlen(plpDlls[n]) + 1);
107.     }
108.  
109.     pbNew = new BYTE [cbNew];
110.     if (pbNew == NULL) {
111.         DETOUR_TRACE(("new BYTE [cbNew] failed.\n"));
112.         goto finish;
113.     }
114.     ZeroMemory(pbNew, cbNew);
115.  
116.     PBYTE pbBase = pbModule;
117.     PBYTE pbNext = pbBase
118.         + inh.OptionalHeader.BaseOfCode
119.         + inh.OptionalHeader.SizeOfCode
120.         + inh.OptionalHeader.SizeOfInitializedData
121.         + inh.OptionalHeader.SizeOfUninitializedData;
122.     if (pbBase < pbNext) {
123.         pbBase = pbNext;
124.     }
125.     DETOUR_TRACE(("pbBase = %p\n", pbBase));
126.  
127.     PBYTE pbNewIid = FindAndAllocateNearBase(hProcess, pbBase, cbNew);
128.     if (pbNewIid == NULL) {
129.         DETOUR_TRACE(("FindAndAllocateNearBase failed.\n"));
130.         goto finish;
131.     }
132.  
133.     DWORD dwProtect = 0;
134.     der.impDirProt = 0;
135.     if (!VirtualProtectEx(hProcess,
136.                           pbModule + inh.IMPORT_DIRECTORY.VirtualAddress,
137.                           inh.IMPORT_DIRECTORY.Size, PAGE_EXECUTE_READWRITE, &dwProtect)) {
138.         DETOUR_TRACE(("VirtualProtextEx(import) write failed: %d\n", GetLastError()));
139.         goto finish;
140.     }
141.     DETOUR_TRACE(("IMPORT_DIRECTORY perms=%x\n", dwProtect));
142.     der.impDirProt = dwProtect;
143.  
144.     DWORD obBase = (DWORD)(pbNewIid - pbModule);
145.  
146.     if (!ReadProcessMemory(hProcess,
147.                            pbModule + inh.IMPORT_DIRECTORY.VirtualAddress,
148.                            pbNew + obRem,
149.                            inh.IMPORT_DIRECTORY.Size, NULL)) {
150.         DETOUR_TRACE(("ReadProcessMemory(imports) failed: %d\n", GetLastError()));
151.         goto finish;
152.     }
153.  
154.     PIMAGE_IMPORT_DESCRIPTOR piid = (PIMAGE_IMPORT_DESCRIPTOR)pbNew;
155.     DWORD_PTR *pt;
156.  
157.     for (n = 0; n < nDlls; n++) {
158.         HRESULT hrRet = StringCchCopyA((char*)pbNew + obStr, cbNew - obStr, plpDlls[n]);
159.         if (FAILED(hrRet))
160.         {
161.             DETOUR_TRACE(("StringCchCopyA failed: %d\n", GetLastError()));
162.             goto finish;
163.         }
164.  
165.         DWORD nOffset = obTab + (sizeof(DWORD_PTR) * (4 * n));
166.         piid[n].OriginalFirstThunk = obBase + nOffset;
167.         pt = ((DWORD_PTR*)(pbNew + nOffset));
168.         pt[0] = IMAGE_ORDINAL_FLAG + 1;
169.         pt[1] = 0;
170.  
171.         nOffset = obTab + (sizeof(DWORD_PTR) * ((4 * n) + 2));
172.         piid[n].FirstThunk = obBase + nOffset;
173.         pt = ((DWORD_PTR*)(pbNew + nOffset));
174.         pt[0] = IMAGE_ORDINAL_FLAG + 1;
175.         pt[1] = 0;
176.         piid[n].TimeDateStamp = 0;
177.         piid[n].ForwarderChain = 0;
178.         piid[n].Name = obBase + obStr;
179.  
180.         obStr += PadToDword((DWORD)strlen(plpDlls[n]) + 1);
181.     }
182.  
183.     for (i = 0; i < nDlls + (inh.IMPORT_DIRECTORY.Size / sizeof(*piid)); i++) {
184.         DETOUR_TRACE(("%8d. Look=%08x Time=%08x Fore=%08x Name=%08x Addr=%08x\n",
185.                       i,
186.                       piid[i].OriginalFirstThunk,
187.                       piid[i].TimeDateStamp,
188.                       piid[i].ForwarderChain,
189.                       piid[i].Name,
190.                       piid[i].FirstThunk));
191.         if (piid[i].OriginalFirstThunk == 0 && piid[i].FirstThunk == 0) {
192.             break;
193.         }
194.     }
195.  
196.     if (!WriteProcessMemory(hProcess, pbNewIid, pbNew, obStr, NULL)) {
197.         DETOUR_TRACE(("WriteProcessMemory(iid) failed: %d\n", GetLastError()));
198.         goto finish;
199.     }
200.  
201.     DETOUR_TRACE(("obBase = %p..%p\n",
202.                   inh.IMPORT_DIRECTORY.VirtualAddress,
203.                   inh.IMPORT_DIRECTORY.VirtualAddress + inh.IMPORT_DIRECTORY.Size));
204.     DETOUR_TRACE(("obBase = %p..%p\n", obBase, obBase + obStr));
205.  
206.     inh.IMPORT_DIRECTORY.VirtualAddress = obBase;
207.     inh.IMPORT_DIRECTORY.Size = cbNew;
208.  
209.     /////////////////////////////////////////////////// Update the CLR header.
210.     //
211.     if (inh.CLR_DIRECTORY.VirtualAddress != 0 &&
212.         inh.CLR_DIRECTORY.Size != 0) {
213.  
214.         DETOUR_CLR_HEADER clr;
215.         PBYTE pbClr = pbModule + inh.CLR_DIRECTORY.VirtualAddress;
216.  
217.         if (!ReadProcessMemory(hProcess, pbClr, &clr, sizeof(clr), NULL)) {
218.             DETOUR_TRACE(("ReadProcessMemory(clr) failed: %d\n", GetLastError()));
219.             goto finish;
220.         }
221.  
222.         der.pclrFlags = (PULONG)(pbClr + offsetof(DETOUR_CLR_HEADER, Flags));
223.         der.clrFlags = clr.Flags;
224.  
225.         clr.Flags &= 0xfffffffe;    // Clear the IL_ONLY flag.
226.  
227.         if (!VirtualProtectEx(hProcess, pbClr, sizeof(clr), PAGE_READWRITE, &dwProtect)) {
228.             DETOUR_TRACE(("VirtualProtextEx(clr) write failed: %d\n", GetLastError()));
229.             goto finish;
230.         }
231.  
232.         if (!WriteProcessMemory(hProcess, pbClr, &clr, sizeof(clr), NULL)) {
233.             DETOUR_TRACE(("WriteProcessMemory(clr) failed: %d\n", GetLastError()));
234.             goto finish;
235.         }
236.  
237.         if (!VirtualProtectEx(hProcess, pbClr, sizeof(clr), dwProtect, &dwProtect)) {
238.             DETOUR_TRACE(("VirtualProtextEx(clr) restore failed: %d\n", GetLastError()));
239.             goto finish;
240.         }
241.     }
242.  
243.     /////////////////////// Update the NT header for the import new directory.
244.     /////////////////////////////// Update the DOS header to fix the checksum.
245.     //
246.     if (!VirtualProtectEx(hProcess, pbModule, inh.OptionalHeader.SizeOfHeaders,
247.                           PAGE_EXECUTE_READWRITE, &dwProtect)) {
248.         DETOUR_TRACE(("VirtualProtextEx(inh) write failed: %d\n", GetLastError()));
249.         goto finish;
250.     }
251.  
252.     idh.e_res[0] = 0;
253.     if (!WriteProcessMemory(hProcess, pbModule, &idh, sizeof(idh), NULL)) {
254.         DETOUR_TRACE(("WriteProcessMemory(idh) failed: %d\n", GetLastError()));
255.         goto finish;
256.     }
257.  
258.     if (!WriteProcessMemory(hProcess, pbModule + idh.e_lfanew, &inh, sizeof(inh), NULL)) {
259.         DETOUR_TRACE(("WriteProcessMemory(inh) failed: %d\n", GetLastError()));
260.         goto finish;
261.     }
262.  
263.     WORD wDuring = ComputeChkSum(hProcess, pbModule, &inh);
264.     DETOUR_TRACE(("ChkSum: %04x + %08x => %08x\n", wDuring, dwFileSize, wDuring + dwFileSize));
265.  
266.     idh.e_res[0] = detour_sum_minus(idh.e_res[0], detour_sum_minus(wDuring, wBefore));
267.  
268.     if (!WriteProcessMemory(hProcess, pbModule, &idh, sizeof(idh), NULL)) {
269.         DETOUR_TRACE(("WriteProcessMemory(idh) failed: %d\n", GetLastError()));
270.         goto finish;
271.     }
272.  
273.     if (!VirtualProtectEx(hProcess, pbModule, inh.OptionalHeader.SizeOfHeaders,
274.                           dwProtect, &dwProtect)) {
275.         DETOUR_TRACE(("VirtualProtextEx(idh) restore failed: %d\n", GetLastError()));
276.         goto finish;
277.     }
278.  
279.     WORD wAfter = ComputeChkSum(hProcess, pbModule, &inh);
280.     DETOUR_TRACE(("ChkSum: %04x + %08x => %08x\n", wAfter, dwFileSize, wAfter + dwFileSize));
281.     DETOUR_TRACE(("Before: %08x, After: %08x\n", wBefore + dwFileSize, wAfter + dwFileSize));
282.  
283.     if (wBefore != wAfter) {
284.         DETOUR_TRACE(("Restore of checksum failed %04x != %04x.\n", wBefore, wAfter));
285.         goto finish;
286.     }
287.  
288.     if (!DetourCopyPayloadToProcess(hProcess, DETOUR_EXE_RESTORE_GUID, &der, sizeof(der))) {
289.         DETOUR_TRACE(("DetourCopyPayloadToProcess failed: %d\n", GetLastError()));
290.         goto finish;
291.     }
292.  
293.     fSucceeded = TRUE;
294.     goto finish;
295. }

и последняя

Код (Text):

1. BOOL WINAPI DetourCopyPayloadToProcess(HANDLE hProcess,
2.                                        REFGUID rguid,
3.                                        PVOID pData,
4.                                        DWORD cbData)
5. {
6.     DWORD cbTotal = (sizeof(IMAGE_DOS_HEADER) +
7.                      sizeof(IMAGE_NT_HEADERS) +
8.                      sizeof(IMAGE_SECTION_HEADER) +
9.                      sizeof(DETOUR_SECTION_HEADER) +
10.                      sizeof(DETOUR_SECTION_RECORD) +
11.                      cbData);
12.  
13.     PBYTE pbBase = (PBYTE)VirtualAllocEx(hProcess, NULL, cbTotal,
14.                                          MEM_COMMIT, PAGE_READWRITE);
15.     if (pbBase == NULL) {
16.         DETOUR_TRACE(("VirtualAllocEx(%d) failed: %d\n", cbTotal, GetLastError()));
17.         return FALSE;
18.     }
19.  
20.     PBYTE pbTarget = pbBase;
21.     IMAGE_DOS_HEADER idh;
22.     IMAGE_NT_HEADERS inh;
23.     IMAGE_SECTION_HEADER ish;
24.     DETOUR_SECTION_HEADER dsh;
25.     DETOUR_SECTION_RECORD dsr;
26.     SIZE_T cbWrote = 0;
27.  
28.     ZeroMemory(&idh, sizeof(idh));
29.     idh.e_magic = IMAGE_DOS_SIGNATURE;
30.     idh.e_lfanew = sizeof(idh);
31.     if (!WriteProcessMemory(hProcess, pbTarget, &idh, sizeof(idh), &cbWrote) ||
32.         cbWrote != sizeof(idh)) {
33.         DETOUR_TRACE(("WriteProcessMemory(idh) failed: %d\n", GetLastError()));
34.         return FALSE;
35.     }
36.     pbTarget += sizeof(idh);
37.  
38.     ZeroMemory(&inh, sizeof(inh));
39.     inh.Signature = IMAGE_NT_SIGNATURE;
40.     inh.FileHeader.SizeOfOptionalHeader = sizeof(inh.OptionalHeader);
41.     inh.FileHeader.Characteristics = IMAGE_FILE_DLL;
42.     inh.FileHeader.NumberOfSections = 1;
43.     if (!WriteProcessMemory(hProcess, pbTarget, &inh, sizeof(inh), &cbWrote) ||
44.         cbWrote != sizeof(inh)) {
45.         return FALSE;
46.     }
47.     pbTarget += sizeof(inh);
48.  
49.     ZeroMemory(&ish, sizeof(ish));
50.     memcpy(ish.Name, ".detour", sizeof(ish.Name));
51.     ish.VirtualAddress = (DWORD)((pbTarget + sizeof(ish)) - pbBase);
52.     ish.SizeOfRawData = (sizeof(DETOUR_SECTION_HEADER) +
53.                          sizeof(DETOUR_SECTION_RECORD) +
54.                          cbData);
55.     if (!WriteProcessMemory(hProcess, pbTarget, &ish, sizeof(ish), &cbWrote) ||
56.         cbWrote != sizeof(ish)) {
57.         return FALSE;
58.     }
59.     pbTarget += sizeof(ish);
60.  
61.     ZeroMemory(&dsh, sizeof(dsh));
62.     dsh.cbHeaderSize = sizeof(dsh);
63.     dsh.nSignature = DETOUR_SECTION_HEADER_SIGNATURE;
64.     dsh.nDataOffset = sizeof(DETOUR_SECTION_HEADER);
65.     dsh.cbDataSize = (sizeof(DETOUR_SECTION_HEADER) +
66.                       sizeof(DETOUR_SECTION_RECORD) +
67.                       cbData);
68.     if (!WriteProcessMemory(hProcess, pbTarget, &dsh, sizeof(dsh), &cbWrote) ||
69.         cbWrote != sizeof(dsh)) {
70.         return FALSE;
71.     }
72.     pbTarget += sizeof(dsh);
73.  
74.     ZeroMemory(&dsr, sizeof(dsr));
75.     dsr.cbBytes = cbData + sizeof(DETOUR_SECTION_RECORD);
76.     dsr.nReserved = 0;
77.     dsr.guid = rguid;
78.     if (!WriteProcessMemory(hProcess, pbTarget, &dsr, sizeof(dsr), &cbWrote) ||
79.         cbWrote != sizeof(dsr)) {
80.         return FALSE;
81.     }
82.     pbTarget += sizeof(dsr);
83.  
84.     if (!WriteProcessMemory(hProcess, pbTarget, pData, cbData, &cbWrote) ||
85.         cbWrote != cbData) {
86.         return FALSE;
87.     }
88.     pbTarget += cbData;
89.  
90.     DETOUR_TRACE(("Copied %d bytes into target process at %p\n",
91.                   cbTotal, pbTarget - cbTotal));
92.     return TRUE;
93. }

Понимаю, что код,мало кто будет смотреть,но все же..
Вообщем ничего нового они не делают..

Вот что они пишут в мануале

 

У всех своя работа, бывает и не такое..

Если я все правильно понял, имеет место такая цепочка:

потом по неким определенным условиям - выгрузка длл из процесса с возвратом в процесс или завершение оного {этого я не понял, но это не очень принципиально}..

Ок, может быть такой путь будет проще в реализации:
1) начало:

{в этом случае нет гарантии, что процесс не работал с security-файлами до старта программы}
2) внедряясь в запущенные процессы оставляем в каждом сторожа, который перехватывает две составляющие (лучше через некую добавочную Mini-длл):
а) CreateProccess
б) апи работы с файлами (на собственное усмотрение)
и отрабатывает загрузку/выгрузку базовой длл
если выловили а) -> п.2
если выловили б) -> собственные действия
Если условия для выгрузки определяется по неким внешним факторам - предусматриваем в базовой длл возврат в код сторожа и выполнение выгрузки базовой длл.

При попытке вторичного "прохода" после выгрузки базовой длл или ищем наличие сторожа (дальше все прозрачно) или клеем его и дальше тоже все ясно..

сторож для каждого процесса размещаем в AllocMemory. в "его" длл две функции: hook api + loadlibrary/freelibrary.

такой сценарий подойдет?

ps/ мне не понятно вот что: как из user mode ты мониторишь создание всех процессов в системе, отсеивая системные процессы? к системникам же клеиться не нужно?