касперский и загрузка dll

все равно при проходе дебагером пишит

Unhandled exception at 0x7c9012b4 in dll_load.exe: 0xC0000005: Access violation reading location 0x6b637566.

 

vanilly_cpp
вы трейсить умеете?
push offset f_namep

 

ок! я понял!

просто думал f_namep и есть указатель, ну как в C!

только так не компилится

lea eax, f_namep
push eax

а так все нормально, спасибо!

 

Замучался я уже с этим ижектом! ))))))))))

Таки удалось сделать из dll лодера вроде как базонезависимый код!

Код (Text):

1. void MemLoadLibrary()
2. {
3.    
4.  
5.     DWORD size_of_IMAGE_FILE_HEADER = 20;//20sizeof(IMAGE_FILE_HEADER)
6.     DWORD size_of_IMAGE_BASE_RELOCATION = 8;//8sizeof(IMAGE_BASE_RELOCATION)
7.  
8.     CHAR f_name[] ={'c',':','/','W','I','N','D','O','W','S','/','s','y','s','t','e','m','3','2','/','d','l','l','.','d','l','l', 0};
9.  
10.  
11.     //BYTE data[192512];
12.  
13.     DWORD _load_libroary_ = 0x7c882f9c;
14.     DWORD virtual_protect = 0x7c801ad0;    
15.     DWORD exit_thread = 0x7c80cca9;
16.     DWORD virtual_alloc = 0x7c809a81;
17.     DWORD virtual_free = 0x7c809b14;
18.     DWORD _memcpy_ = 0x7c902200;
19.     DWORD get_proc_adress = 0x7c80ac28;
20.  
21.     PBYTE data;
22.     _asm
23.     {
24.             push PAGE_READWRITE
25.             push MEM_COMMIT
26.             push 192512
27.             push NULL
28.             call virtual_alloc
29.             mov data, eax
30.     }
31.  
32.     DWORD create_file = 0x7c801a24;
33.     DWORD read_file = 0x7c80180e;
34.     DWORD clase_handle = 0x7c809b77;
35.  
36.     HANDLE  hFile ;
37.     _asm
38.     {
39.         push NULL
40.         push NULL
41.         push OPEN_EXISTING
42.         push NULL
43.         push NULL
44.         push GENERIC_READ
45.         lea eax, f_name
46.         push eax
47.         call create_file
48.         mov hFile, eax
49.     }
50.     //HANDLE  hFile = CreateFile(f_name,GENERIC_READ,NULL,NULL,OPEN_EXISTING,NULL,NULL);    
51.     //if(hFile == INVALID_HANDLE_VALUE)
52.     //    _asm jmp konec;
53.     DWORD dw;
54.     _asm
55.     {
56.         push NULL
57.         lea eax, dw
58.         push eax
59.         push 192512
60.         //lea eax, data
61.         push data
62.         push hFile
63.         call read_file
64.     }
65.     //ReadFile(hFile,data,192512,&dw,NULL);
66.     _asm
67.     {
68.         push hFile
69.         call clase_handle
70.     }
71.     //CloseHandle(hFile);
72.    
73.         IMAGE_FILE_HEADER        *pFileHeader        = NULL;
74.         IMAGE_OPTIONAL_HEADER    *pOptionalHeader    = NULL;
75.         IMAGE_SECTION_HEADER    *pSectionHeader        = NULL;
76.         IMAGE_IMPORT_DESCRIPTOR *pImportDscrtr        = NULL;
77.         USHORT                    e_lfanew            = *((USHORT*)(data+0x3c));
78.         PCHAR                    ImageBase            = NULL;
79.         PCHAR                    SectionBase            = NULL;
80.    
81.         DWORD dwSize, dwOldProt, ImageBaseDelta;
82.         int i;
83.  
84.    
85.    
86.         pFileHeader = (IMAGE_FILE_HEADER *)(data+e_lfanew+4);
87.         pOptionalHeader = (IMAGE_OPTIONAL_HEADER *)(data+e_lfanew+4+size_of_IMAGE_FILE_HEADER);
88.         if (pOptionalHeader->Magic!=IMAGE_NT_OPTIONAL_HDR32_MAGIC)
89.            _asm jmp konec;
90.             // return NULL;
91.    
92.         //    Let's try to reserv memory
93.         DWORD t = pOptionalHeader->SizeOfImage;
94.         DWORD t1 = pOptionalHeader->ImageBase;
95.         _asm
96.         {
97.             push PAGE_NOACCESS
98.             push MEM_RESERVE
99.             push t
100.             push t1
101.             call virtual_alloc
102.             mov ImageBase, eax
103.         }
104.         //ImageBase = (PCHAR)VirtualAlloc(
105.         //    (PVOID)pOptionalHeader->ImageBase,
106.         //    pOptionalHeader->SizeOfImage,
107.         //    MEM_RESERVE,PAGE_NOACCESS);
108.    
109.         if(ImageBase==NULL)
110.         {
111.              t = pOptionalHeader->SizeOfImage;
112.             _asm
113.             {
114.                 push PAGE_NOACCESS
115.                 push MEM_RESERVE
116.                 push t
117.                 push 0
118.                 call virtual_alloc
119.                 mov ImageBase, eax
120.             }
121.             //ImageBase=(PCHAR)VirtualAlloc(NULL,
122.             //    pOptionalHeader->SizeOfImage,
123.             //    MEM_RESERVE,PAGE_NOACCESS);
124.             if(ImageBase==NULL)
125.                        _asm jmp konec;
126.                 //return NULL;
127.         }
128.    
129.         //    copy the header
130.          t = pOptionalHeader->SizeOfHeaders;
131.         _asm
132.         {
133.             push PAGE_READWRITE
134.             push MEM_COMMIT
135.             push t
136.             push ImageBase
137.             call virtual_alloc
138.             mov SectionBase, eax
139.         }
140.         //SectionBase=(PCHAR)VirtualAlloc(ImageBase,
141.         //    pOptionalHeader->SizeOfHeaders,
142.         //    MEM_COMMIT,PAGE_READWRITE);
143.          for(int z = 0; z <  pOptionalHeader->SizeOfHeaders; z ++)
144.          {
145.             SectionBase[z] = data[z];
146.          }
147.         //memcpy(SectionBase,data,pOptionalHeader->SizeOfHeaders);
148.         //    Do headers read-only (to be on the safe side)
149.         t = pOptionalHeader->SizeOfHeaders;
150.          _asm
151.         {
152.             lea eax, dwOldProt
153.             push eax
154.             push PAGE_READONLY
155.         push t
156.         push SectionBase
157.         call virtual_protect
158.     }
159.      //   VirtualProtect(SectionBase,pOptionalHeader->SizeOfHeaders,PAGE_READONLY,&dwOldProt);
160.  
161.     //    find sections ...
162.     pSectionHeader = (IMAGE_SECTION_HEADER *)(pOptionalHeader+1);
163.     for (i=0; i<pFileHeader->NumberOfSections; i++)
164.     {
165.         t = pSectionHeader[i].Misc.VirtualSize;
166.         t1 = (DWORD)ImageBase+pSectionHeader[i].VirtualAddress;
167.         _asm
168.         {
169.             push PAGE_READWRITE
170.             push MEM_COMMIT
171.             push t
172.             push t1
173.             call virtual_alloc
174.             mov SectionBase, eax
175.         }
176.         //SectionBase = (PCHAR)VirtualAlloc(
177.         //    ImageBase+pSectionHeader[i].VirtualAddress,
178.         //    pSectionHeader[i].Misc.VirtualSize,
179.         //    MEM_COMMIT,PAGE_READWRITE);
180.         if (SectionBase==NULL)
181.         {
182.             _asm
183.             {
184.                 push MEM_RELEASE
185.                 push 0
186.                 push ImageBase
187.                 call virtual_free
188.             }
189. //            VirtualFree(ImageBase, 0, MEM_RELEASE);
190. //            return NULL;
191.         }
192.         //    ... and copy initialization data
193.         SectionBase = ImageBase+pSectionHeader[i].VirtualAddress;
194.         dwSize = MIN(pSectionHeader[i].SizeOfRawData,pSectionHeader[i].Misc.VirtualSize);
195.         for(int z = 0; z <  dwSize; z ++)
196.         {
197.             SectionBase[z] = (data+pSectionHeader[i].PointerToRawData)[z];
198.         }
199.         //memcpy(SectionBase, data+pSectionHeader[i].PointerToRawData,dwSize);
200.     }
201.  
202.     //    check addersses
203.     ImageBaseDelta = (DWORD)ImageBase-pOptionalHeader->ImageBase;
204.     if (ImageBaseDelta!=0 &&
205.         pOptionalHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress!=0
206.         )
207.     {
208.         IMAGE_BASE_RELOCATION    *pBaseReloc    = (IMAGE_BASE_RELOCATION *)(ImageBase+
209.             pOptionalHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress);
210.         IMAGE_BASE_RELOCATION    *pBaseReloc0    = pBaseReloc;
211.         WORD *wPointer = NULL;
212.         DWORD dwModCount;
213.         int i;
214.  
215.         while ((DWORD)pBaseReloc0-(DWORD)pBaseReloc < pOptionalHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size)
216.         {
217.             dwModCount = (pBaseReloc0->SizeOfBlock-size_of_IMAGE_BASE_RELOCATION)/2;
218.             wPointer = (WORD *)(pBaseReloc+1);
219.             for (i=0; i<dwModCount; i++, wPointer++)
220.                 if ((*wPointer & 0xf000) !=0)
221.                 {
222.                     PDWORD pdw = (PDWORD)(ImageBase+pBaseReloc0->VirtualAddress+((*wPointer)&0xfff));
223.                     (*pdw)+=ImageBaseDelta;
224.                 }
225.                 pBaseReloc = (IMAGE_BASE_RELOCATION *)wPointer;
226.         }
227.     }
228.     else if (ImageBaseDelta!=0)
229.     {
230.         _asm
231.         {
232.             push MEM_RELEASE
233.                 push 0
234.                 push ImageBase
235.                 call virtual_free
236.         }
237.   //      VirtualFree(ImageBase, 0, MEM_RELEASE);
238.                _asm jmp konec;
239.         //return NULL;
240.     }
241.  
242.     pImportDscrtr = (IMAGE_IMPORT_DESCRIPTOR *)(ImageBase+
243.         pOptionalHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);
244.  
245.     for (;pImportDscrtr->Name!=0; pImportDscrtr++) 
246.             {  
247.                         PCHAR pLibName        = (PCHAR)(ImageBase+pImportDscrtr->Name);
248.                         PCHAR pImortName    = NULL;
249.                         HMODULE hLibModule;
250.                         _asm
251.                         {
252.                             push pLibName
253.                             call _load_libroary_
254.                             mov hLibModule,eax
255.                         }
256.                         //HMODULE hLibModule    = LoadLibrary(pLibName);   
257.                         DWORD    *pImport    = NULL,   
258.                                 *pAddress    = NULL;   
259.                         DWORD ProcAddress; 
260.                    
261.                             pAddress=(DWORD *)(ImageBase+pImportDscrtr->/*Original*/FirstThunk);   
262.                         if (pImportDscrtr->TimeDateStamp==0)   
263.                                 pImport=(DWORD *)(ImageBase+pImportDscrtr->FirstThunk);
264.                         else   
265.                                 pImport=(DWORD *)(ImageBase+pImportDscrtr->OriginalFirstThunk);
266.                         for (i=0; pImport[i]!=0; i++)  
267.                             {  
268.                                     if ((pImport[i] & IMAGE_ORDINAL_FLAG32)!=0)
269.                                     {
270.                                         PCHAR pcc = (PCHAR)(pImport[i]&0xFFFF);
271.                                         _asm
272.                                         {
273.                                             push pcc
274.                                             push hLibModule
275.                                             call get_proc_adress
276.                                             mov  ProcAddress, eax
277.                                         }
278.                                      //       ProcAddress=(DWORD)GetProcAddress(hLibModule, (PCHAR)(pImport[i]&0xFFFF));
279.                                     }
280.                                     else  // import by name
281.                                         {  
282.  
283.                                                 pImortName=(PCHAR)(ImageBase+(pImport[i])+2);  
284.                                                 _asm
285.                                                 {
286.                                                     push pImortName
287.                                                         push hLibModule
288.                                                         call get_proc_adress
289.                                                         mov  ProcAddress, eax
290.                                                 }        
291.                                                 //ProcAddress=(DWORD)GetProcAddress(hLibModule, pImortName);   
292.                                             }  
293.                                         pAddress[i]=ProcAddress;   
294.                                     }  
295.                         }
296.  
297.  
298.  
299.  
300. DWORD sc;
301. DWORD dwResult=0;
302.     //    set section protection
303.     for (i=0; i<pFileHeader->NumberOfSections; i++)
304.     {
305.         //***************************************************************************
306.         sc = pSectionHeader[i].Characteristics;
307.         dwResult=0;
308.     if (sc & IMAGE_SCN_MEM_NOT_CACHED)
309.         dwResult |= PAGE_NOCACHE;
310.  
311.     if (sc & IMAGE_SCN_MEM_EXECUTE)
312.     {
313.         if (sc & IMAGE_SCN_MEM_READ)
314.         {
315.             if (sc & IMAGE_SCN_MEM_WRITE)
316.                 dwResult |= PAGE_EXECUTE_READWRITE;
317.             else
318.                 dwResult |= PAGE_EXECUTE_READ;
319.         }
320.         else
321.         {
322.             if (sc & IMAGE_SCN_MEM_WRITE)
323.                 dwResult |= PAGE_EXECUTE_WRITECOPY;
324.             else
325.                 dwResult |= PAGE_EXECUTE;
326.         }
327.     }
328.     else
329.     {
330.         if (sc & IMAGE_SCN_MEM_READ)
331.         {
332.             if (sc & IMAGE_SCN_MEM_WRITE)
333.                 dwResult|=PAGE_READWRITE;
334.             else
335.                 dwResult|=PAGE_READONLY;
336.         }
337.         else
338.         {
339.             if (sc & IMAGE_SCN_MEM_WRITE)
340.                 dwResult|=PAGE_WRITECOPY;
341.             else
342.                 dwResult|=PAGE_NOACCESS;
343.         }
344.     }
345.     //***************************************************************************
346.     t = (DWORD)ImageBase+pSectionHeader[i].VirtualAddress;
347.     t1 = pSectionHeader[i].Misc.VirtualSize;
348.     _asm
349.     {
350.         lea eax, dwOldProt
351.         push eax
352.         push dwResult
353.         push t1
354.         push t
355.         call virtual_protect
356.     }
357.     }
358.         //VirtualProtect((PVOID)(ImageBase+pSectionHeader[i].VirtualAddress),
359.         //pSectionHeader[i].Misc.VirtualSize,
360.         //dwResult,
361.         //&dwOldProt);
362.  
363.      //   call DLLMain
364.     if (pOptionalHeader->AddressOfEntryPoint!=0)
365.     {
366.         //DLLMAIN dllMain=(DLLMAIN)(ImageBase+pOptionalHeader->AddressOfEntryPoint);
367.         t = (DWORD)(ImageBase+pOptionalHeader->AddressOfEntryPoint);
368.         _asm
369.         {
370.             push NULL
371.             push DLL_PROCESS_ATTACH
372.             push ImageBase
373.             call t
374.          //   cmp eax, 0
375.            // jz p_conec
376.            // jmp konec
377.         }
378.        // if (!dllMain((HMODULE)ImageBase, DLL_PROCESS_ATTACH, NULL))
379.       //  {
380. //            _asm
381. //            {
382. //p_conec:
383. //                push MEM_RELEASE
384. //                    push 0
385. //                    push ImageBase
386. //                    call virtual_free
387. //            }
388. //            //VirtualFree(ImageBase, 0, MEM_RELEASE);
389. //                   _asm jmp konec;
390. //            //return NULL;
391. //        //}
392.     }
393.  
394.     _asm
395.     {
396. konec:
397.         push 0
398.         call exit_thread
399.     }
400.  
401.  
402. }

для тестов использовал следующий код на асме, предварительно сохранив вышеприведенный код в bin виде в файл

Код (Text):

1. .386
2. .model flat,stdcall
3. option casemap:none
4.  
5. include c:\masm32\include\windows.inc
6. include c:\masm32\include\kernel32.inc
7. include c:\masm32\include\user32.inc
8. includelib c:\masm32\lib\kernel32.lib
9. includelib c:\masm32\lib\user32.lib
10.  
11.  
12. .DATA
13.  
14.     f_name db '../code.cde', 0
15.     _proc db 20000 dup(0)
16.  
17. .CODE
18.  
19.  
20. p PROC
21.      mov eax, 0Fh
22.      mov ebx, eax  
23.      ret
24. p ENDP
25.  
26.  
27.  
28. start:
29.  
30.     invoke CreateFile, offset f_name, GENERIC_READ,NULL,NULL,OPEN_EXISTING,NULL,NULL   
31.     push eax
32.     invoke ReadFile, eax, offset _proc, 20000, ebx, NULL
33.     pop eax
34.     invoke CloseHandle, eax
35.  
36.     lea esi, _proc
37.     call esi
38.    
39.     invoke ExitProcess,0
40.  
41.  
42. END start

Здесь вроде все в шиколаде!
Точка входа dll отробатывает!

Пытаюсь инжектить код приложение тупо закрывается, причем если убрать из кода вызов самой точки в хода длл,

Код (Text):

1.        t = (DWORD)(ImageBase+pOptionalHeader->AddressOfEntryPoint);
2.         _asm
3.         {
4.             push NULL
5.             push DLL_PROCESS_ATTACH
6.             push ImageBase
7.             call t
8.         }

то все проходит нормально!

Вчем я напартачил?

 

t = (DWORD)(ImageBase+pOptionalHeader->AddressOfEntryPoint)
Код не смотрел, но судя по всему в ImageBase трабла.

Ты берешь базу РЕАЛЬНУЮ, или ту, которая прописана в РЕ-хидере?
ДЛЛ - не ЕХЕ, и база образа у них часто не та, которая прописана в хидере.

ПЫСЫ: а зачем вызывать точку входа в длл? разве при ЛоадЛибрари она не вызывается автоматом?

 

Код (Text):

1. а зачем вызывать точку входа в длл? разве при ЛоадЛибрари она не вызывается автоматом?

Я вроде как и пытался эту лоад либрари релизовать! )

Я немогу понять такого прикола, что когда я зачитываю сей код в другой программе и передаю не него упровление, то все в ожуре!

Но когда инжектю, дрова!
Хотя по сути то разжецы не должнобыть?

Что в первом, что во втором случаи код поподает в адресное пространство другого процесса, и выполняется!

 

>>zoool

Походу если бы трабля была в нем, то с ней бы я столкнулся бы еще не доходя до вызова dllmain, так как она используется всюду в коде, а парится лишь в одном месте!

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

и
2) зачитал код из файла, записал в процесс(WriteVirtualMemory), и выполнил(CreateRemoteThread) - инжект

а она походу есть, иначе бы у меня все работоло бы?

 

неужели никто не сталкивался с такой проблемой?

 

А разве в ПЕБ добавлять наш модуль не нужно?
гм...

 

Попробуй в ОЛЛЕ найти ошибку.
Значит открываешь ехе в отладчике, далее инжектишь свою либу.
А потом жмешь F9 в ольке.
Она тебе выдаст еррорс.
Там и определишь, что да как..

 

>>zoool
Спасибо! Все так и сделал!

И того:

Такая ошибка имеет место лиш в программах имеющих окна(GUI)
если консольное приложение, или win32 но без окон, инжектится нормально!

Так вот, беру calc.exe, запускаю, открываю в ольке, делаю инжект, нахожу(с горем пополам ))) ) свой проинжектированый код, дохожу до зловещего перехода, который должен вазвать dllmain, F7, далее вижу

Код (Text):

1. 100149D0   55               PUSH EBP
2. 100149D1   8BEC             MOV EBP,ESP
3. 100149D3   6A FF            PUSH -1
4. 100149D5   68 28440310      PUSH 10034428
5. 100149DA   68 A3120110      PUSH 100112A3
6. 100149DF   64:A1 00000000   MOV EAX,DWORD PTR FS:[0]
7. 100149E5   50               PUSH EAX
8. 100149E6   64:8925 00000000 MOV DWORD PTR FS:[0],ESP
9. 100149ED   83C4 E8          ADD ESP,-18
10. 100149F0   53               PUSH EBX
11. 100149F1   56               PUSH ESI
12. 100149F2   57               PUSH EDI
13. 100149F3   8965 E8          MOV DWORD PTR SS:[EBP-18],ESP
14. 100149F6   C745 E4 01000000 MOV DWORD PTR SS:[EBP-1C],1
15. 100149FD   837D 0C 00       CMP DWORD PTR SS:[EBP+C],0
16. 10014A01   75 10            JNZ SHORT 10014A13
17. 10014A03   833D 68BD0310 00 CMP DWORD PTR DS:[1003BD68],0
18. 10014A0A   75 07            JNZ SHORT 10014A13
19. 10014A0C   33C0             XOR EAX,EAX
20. 10014A0E   E9 1F010000      JMP 10014B32
21. 10014A13   C745 FC 00000000 MOV DWORD PTR SS:[EBP-4],0
22. 10014A1A   837D 0C 01       CMP DWORD PTR SS:[EBP+C],1
23. 10014A1E   74 06            JE SHORT 10014A26
24. 10014A20   837D 0C 02       CMP DWORD PTR SS:[EBP+C],2
25. 10014A24   75 54            JNZ SHORT 10014A7A
26. 10014A26   833D BCDB0310 00 CMP DWORD PTR DS:[1003DBBC],0
27. 10014A2D   74 15            JE SHORT 10014A44
28. 10014A2F   8B45 10          MOV EAX,DWORD PTR SS:[EBP+10]
29. 10014A32   50               PUSH EAX
30. 10014A33   8B4D 0C          MOV ECX,DWORD PTR SS:[EBP+C]
31. 10014A36   51               PUSH ECX
32. 10014A37   8B55 08          MOV EDX,DWORD PTR SS:[EBP+8]
33. 10014A3A   52               PUSH EDX
34. 10014A3B   FF15 BCDB0310    CALL DWORD PTR DS:[1003DBBC]
35. 10014A41   8945 E4          MOV DWORD PTR SS:[EBP-1C],EAX
36. 10014A44   837D E4 00       CMP DWORD PTR SS:[EBP-1C],0
37. 10014A48   74 14            JE SHORT 10014A5E
38. 10014A4A   8B45 10          MOV EAX,DWORD PTR SS:[EBP+10]
39. 10014A4D   50               PUSH EAX
40. 10014A4E   8B4D 0C          MOV ECX,DWORD PTR SS:[EBP+C]
41. 10014A51   51               PUSH ECX
42. 10014A52   8B55 08          MOV EDX,DWORD PTR SS:[EBP+8]
43. 10014A55   52               PUSH EDX
44. 10014A56   E8 0BCEFFFF      CALL 10011866
45. 10014A5B   8945 E4          MOV DWORD PTR SS:[EBP-1C],EAX
46. 10014A5E   837D E4 00       CMP DWORD PTR SS:[EBP-1C],0
47. 10014A62   75 16            JNZ SHORT 10014A7A
48. 10014A64   C745 DC 00000000 MOV DWORD PTR SS:[EBP-24],0
49. 10014A6B   C745 FC FFFFFFFF MOV DWORD PTR SS:[EBP-4],-1
50. 10014A72   8B45 DC          MOV EAX,DWORD PTR SS:[EBP-24]
51. 10014A75   E9 B8000000      JMP 10014B32
52. 10014A7A   8B45 10          MOV EAX,DWORD PTR SS:[EBP+10]
53. 10014A7D   50               PUSH EAX
54. 10014A7E   8B4D 0C          MOV ECX,DWORD PTR SS:[EBP+C]
55. 10014A81   51               PUSH ECX
56. 10014A82   8B55 08          MOV EDX,DWORD PTR SS:[EBP+8]
57. 10014A85   52               PUSH EDX
58. 10014A86   E8 E2C6FFFF      CALL 1001116D

иду вниз по коду, но на строке "10014A26 833D BCDB0310 00 CMP DWORD PTR DS:[1003DBBC],0" олька замирает, а в строке состояния пишет
Access violation when reading [1003DBBC]

пробую добраться до строки 1003DBBC с помошью ctrl+g но такой действительно нет!
//*************
если делаю инжект в консольное или без оконно приложение то прохожу по вышеприведенному коду до строки "10014A86 E8 E2C6FFFF CALL 1001116D" и моя dllmain срабатывает, и если пробую искать строку 1003DBBC с помошью ctrl+g то такая строка присутствует и все нормально!
//**************
Почему так?

 

Вообще было бы неплохо, если бы Вы показали оригинальный код DllMain. По тому, что есть в 31-м посте, я (хотя на меня лучше не ориентироваться, я - чайник ) смею предположить, что Вы скорее всего в своей DllMain вызываете какую-то апи, экспортируемую НЕ kernel32.dll (и, возможно, в этом Ваша ошибка) с параметрами hInstance, fdReason и pvReserved, адрес которой к моменту вызова не был проинициализирован загрузчиком. Хотя это и не удивительно, если Вы вместо вызова LoadLibrary просто передавали управление на DllMain.

 

>>l_inc
Спасибо!

Вы правы! Я сначала действительно вызывал в dlmain ф-ю из user32 - MessageBoxA, но потом я ее убрал, но проблеме ни чуть не изменилась ((((

Сейчас dllmain выглядит так:

Код (Text):

1. // dll.cpp : Defines the entry point for the DLL application.
2. //
3.  
4. #include "stdafx.h"
5. #include "windows.h"
6.  
7. int WINAPI DllMain(HINSTANCE hInstance, DWORD fdReason, PVOID pvReserved)
8. {
9.    //switch(fdReason)
10.    // {
11.    // case DLL_PROCESS_ATTACH:
12.    //       MessageBox(NULL, "hook dll loded", "good", MB_OK);
13.    //     break;
14.  
15.    // case DLL_PROCESS_DETACH:
16.  
17.    //     MessageBox(NULL, "hook dll unloded", "good", MB_OK);
18.    //     break;
19.    // }
20.  
21.     return true;
22. }

Моя задача написать загрузчик dll, тоесть что-то типо LoadLibroary, но я так понял, что в моем загрузчике походу чего-то нехватает, привожу еще раз код

Код (Text):

1. void MemLoadLibrary()
2. {
3.    
4.  
5.     DWORD size_of_IMAGE_FILE_HEADER = 20;//20sizeof(IMAGE_FILE_HEADER)
6.     DWORD size_of_IMAGE_BASE_RELOCATION = 8;//8sizeof(IMAGE_BASE_RELOCATION)
7.  
8.     CHAR f_name[] ={'c',':','/','W','I','N','D','O','W','S','/','s','y','s','t','e','m','3','2','/','d','l','l','.','d','l','l', 0};
9.     CHAR user32[] = {'u','s','e','r','3','2', 0};
10.     CHAR ch_mes_box[] = {'M','e','s','s','a','g','e','B','o','x', 'A', 0};
11.  
12.     //BYTE data[192512];
13.    
14.     DWORD _load_libroary_ = 0x7c801d77;
15.     DWORD virtual_protect = 0x7c801ad0;    
16.     DWORD exit_thread = 0x7c80cca9;
17.     DWORD virtual_alloc = 0x7c809a81;
18.     DWORD virtual_free = 0x7c809b14;
19.     DWORD _memcpy_ = 0x7c902200;
20.     DWORD get_proc_adress = 0x7c80ac28;
21.  
22.     PBYTE data;
23.     _asm
24.     {
25.             push PAGE_READWRITE
26.             push MEM_COMMIT
27.             push 192512
28.             push NULL
29.             call virtual_alloc
30.             mov data, eax
31.     }
32.  
33.     DWORD create_file = 0x7c801a24;
34.     DWORD read_file = 0x7c80180e;
35.     DWORD clase_handle = 0x7c809b77;
36.  
37.     HANDLE  hFile ;
38.     _asm
39.     {
40.         push NULL
41.         push NULL
42.         push OPEN_EXISTING
43.         push NULL
44.         push NULL
45.         push GENERIC_READ
46.         lea eax, f_name
47.         push eax
48.         call create_file
49.         mov hFile, eax
50.     }
51.     //HANDLE  hFile = CreateFile(f_name,GENERIC_READ,NULL,NULL,OPEN_EXISTING,NULL,NULL);    
52.     //if(hFile == INVALID_HANDLE_VALUE)
53.     //    _asm jmp konec;
54.     DWORD dw;
55.     _asm
56.     {
57.         push NULL
58.         lea eax, dw
59.         push eax
60.         push 192512
61.         //lea eax, data
62.         push data
63.         push hFile
64.         call read_file
65.     }
66.     //ReadFile(hFile,data,192512,&dw,NULL);
67.     _asm
68.     {
69.         push hFile
70.         call clase_handle
71.     }
72.     //CloseHandle(hFile);
73.    
74.         IMAGE_FILE_HEADER        *pFileHeader        = NULL;
75.         IMAGE_OPTIONAL_HEADER    *pOptionalHeader    = NULL;
76.         IMAGE_SECTION_HEADER    *pSectionHeader        = NULL;
77.         IMAGE_IMPORT_DESCRIPTOR *pImportDscrtr        = NULL;
78.         USHORT                    e_lfanew            = *((USHORT*)(data+0x3c));
79.         PCHAR                    ImageBase            = NULL;
80.         PCHAR                    SectionBase            = NULL;
81.    
82.         DWORD dwSize, dwOldProt, ImageBaseDelta;
83.         int i;
84.  
85.    
86.    
87.         pFileHeader = (IMAGE_FILE_HEADER *)(data+e_lfanew+4);
88.         pOptionalHeader = (IMAGE_OPTIONAL_HEADER *)(data+e_lfanew+4+size_of_IMAGE_FILE_HEADER);
89.         if (pOptionalHeader->Magic!=IMAGE_NT_OPTIONAL_HDR32_MAGIC)
90.            _asm jmp konec;
91.             // return NULL;
92.    
93.         //    Let's try to reserv memory
94.         DWORD t = pOptionalHeader->SizeOfImage;
95.         DWORD t1 = pOptionalHeader->ImageBase;
96.         _asm
97.         {
98.             push PAGE_NOACCESS
99.             push MEM_RESERVE
100.             push t
101.             push t1
102.             call virtual_alloc
103.             mov ImageBase, eax
104.         }
105.         //ImageBase = (PCHAR)VirtualAlloc(
106.         //    (PVOID)pOptionalHeader->ImageBase,
107.         //    pOptionalHeader->SizeOfImage,
108.         //    MEM_RESERVE,PAGE_NOACCESS);
109.    
110.         if(ImageBase==NULL)
111.         {
112.              t = pOptionalHeader->SizeOfImage;
113.             _asm
114.             {
115.                 push PAGE_NOACCESS
116.                 push MEM_RESERVE
117.                 push t
118.                 push 0
119.                 call virtual_alloc
120.                 mov ImageBase, eax
121.             }
122.             //ImageBase=(PCHAR)VirtualAlloc(NULL,
123.             //    pOptionalHeader->SizeOfImage,
124.             //    MEM_RESERVE,PAGE_NOACCESS);
125.             if(ImageBase==NULL)
126.                        _asm jmp konec;
127.                 //return NULL;
128.         }
129.    
130.         //    copy the header
131.          t = pOptionalHeader->SizeOfHeaders;
132.         _asm
133.         {
134.             push PAGE_READWRITE
135.             push MEM_COMMIT
136.             push t
137.             push ImageBase
138.             call virtual_alloc
139.             mov SectionBase, eax
140.         }
141.         //SectionBase=(PCHAR)VirtualAlloc(ImageBase,
142.         //    pOptionalHeader->SizeOfHeaders,
143.         //    MEM_COMMIT,PAGE_READWRITE);
144.          for(int z = 0; z <  pOptionalHeader->SizeOfHeaders; z ++)
145.          {
146.             SectionBase[z] = data[z];
147.          }
148.         //memcpy(SectionBase,data,pOptionalHeader->SizeOfHeaders);
149.         //    Do headers read-only (to be on the safe side)
150.         t = pOptionalHeader->SizeOfHeaders;
151.          _asm
152.         {
153.             lea eax, dwOldProt
154.             push eax
155.             push PAGE_READONLY
156.         push t
157.         push SectionBase
158.         call virtual_protect
159.     }
160.      //   VirtualProtect(SectionBase,pOptionalHeader->SizeOfHeaders,PAGE_READONLY,&dwOldProt);
161.  
162.     //    find sections ...
163.     pSectionHeader = (IMAGE_SECTION_HEADER *)(pOptionalHeader+1);
164.     for (i=0; i<pFileHeader->NumberOfSections; i++)
165.     {
166.         t = pSectionHeader[i].Misc.VirtualSize;
167.         t1 = (DWORD)ImageBase+pSectionHeader[i].VirtualAddress;
168.         _asm
169.         {
170.             push PAGE_READWRITE
171.             push MEM_COMMIT
172.             push t
173.             push t1
174.             call virtual_alloc
175.             mov SectionBase, eax
176.         }
177.         //SectionBase = (PCHAR)VirtualAlloc(
178.         //    ImageBase+pSectionHeader[i].VirtualAddress,
179.         //    pSectionHeader[i].Misc.VirtualSize,
180.         //    MEM_COMMIT,PAGE_READWRITE);
181.         if (SectionBase==NULL)
182.         {
183.             _asm
184.             {
185.                 push MEM_RELEASE
186.                 push 0
187.                 push ImageBase
188.                 call virtual_free
189.             }
190. //            VirtualFree(ImageBase, 0, MEM_RELEASE);
191. //            return NULL;
192.         }
193.         //    ... and copy initialization data
194.         SectionBase = ImageBase+pSectionHeader[i].VirtualAddress;
195.         dwSize = MIN(pSectionHeader[i].SizeOfRawData,pSectionHeader[i].Misc.VirtualSize);
196.         for(int z = 0; z <  dwSize; z ++)
197.         {
198.             SectionBase[z] = (data+pSectionHeader[i].PointerToRawData)[z];
199.         }
200.         //memcpy(SectionBase, data+pSectionHeader[i].PointerToRawData,dwSize);
201.     }
202.  
203.     //    check addersses
204.     ImageBaseDelta = (DWORD)ImageBase-pOptionalHeader->ImageBase;
205.     if (ImageBaseDelta!=0 &&
206.         pOptionalHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress!=0
207.         )
208.     {
209.         IMAGE_BASE_RELOCATION    *pBaseReloc    = (IMAGE_BASE_RELOCATION *)(ImageBase+
210.             pOptionalHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].VirtualAddress);
211.         IMAGE_BASE_RELOCATION    *pBaseReloc0    = pBaseReloc;
212.         WORD *wPointer = NULL;
213.         DWORD dwModCount;
214.         int i;
215.  
216.         while ((DWORD)pBaseReloc0-(DWORD)pBaseReloc < pOptionalHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_BASERELOC].Size)
217.         {
218.             dwModCount = (pBaseReloc0->SizeOfBlock-size_of_IMAGE_BASE_RELOCATION)/2;
219.             wPointer = (WORD *)(pBaseReloc+1);
220.             for (i=0; i<dwModCount; i++, wPointer++)
221.                 if ((*wPointer & 0xf000) !=0)
222.                 {
223.                     PDWORD pdw = (PDWORD)(ImageBase+pBaseReloc0->VirtualAddress+((*wPointer)&0xfff));
224.                     (*pdw)+=ImageBaseDelta;
225.                 }
226.                 pBaseReloc = (IMAGE_BASE_RELOCATION *)wPointer;
227.         }
228.     }
229.     else if (ImageBaseDelta!=0)
230.     {
231.         _asm
232.         {
233.             push MEM_RELEASE
234.                 push 0
235.                 push ImageBase
236.                 call virtual_free
237.         }
238.   //      VirtualFree(ImageBase, 0, MEM_RELEASE);
239.                _asm jmp konec;
240.         //return NULL;
241.     }
242.  
243.     pImportDscrtr = (IMAGE_IMPORT_DESCRIPTOR *)(ImageBase+
244.         pOptionalHeader->DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT].VirtualAddress);
245.  
246.     for (;pImportDscrtr->Name!=0; pImportDscrtr++) 
247.             {  
248.                         PCHAR pLibName        = (PCHAR)(ImageBase+pImportDscrtr->Name);
249.                         PCHAR pImortName    = NULL;
250.                         HMODULE hLibModule;
251.                         _asm
252.                         {
253.                             push pLibName
254.                             call _load_libroary_
255.                             mov hLibModule,eax
256.                         }
257.                         //HMODULE hLibModule    = LoadLibrary(pLibName);   
258.                         DWORD    *pImport    = NULL,   
259.                                 *pAddress    = NULL;   
260.                         DWORD ProcAddress; 
261.                    
262.                             pAddress=(DWORD *)(ImageBase+pImportDscrtr->/*Original*/FirstThunk);   
263.                         if (pImportDscrtr->TimeDateStamp==0)   
264.                                 pImport=(DWORD *)(ImageBase+pImportDscrtr->FirstThunk);
265.                         else   
266.                                 pImport=(DWORD *)(ImageBase+pImportDscrtr->OriginalFirstThunk);
267.                         for (i=0; pImport[i]!=0; i++)  
268.                             {  
269.                                     if ((pImport[i] & IMAGE_ORDINAL_FLAG32)!=0)
270.                                     {
271.                                         PCHAR pcc = (PCHAR)(pImport[i]&0xFFFF);
272.                                         _asm
273.                                         {
274.                                             push pcc
275.                                             push hLibModule
276.                                             call get_proc_adress
277.                                             mov  ProcAddress, eax
278.                                         }
279.                                      //       ProcAddress=(DWORD)GetProcAddress(hLibModule, (PCHAR)(pImport[i]&0xFFFF));
280.                                     }
281.                                     else  // import by name
282.                                         {  
283.  
284.                                                 pImortName=(PCHAR)(ImageBase+(pImport[i])+2);  
285.                                                 _asm
286.                                                 {
287.                                                     push pImortName
288.                                                         push hLibModule
289.                                                         call get_proc_adress
290.                                                         mov  ProcAddress, eax
291.                                                 }        
292.                                                 //ProcAddress=(DWORD)GetProcAddress(hLibModule, pImortName);   
293.                                             }  
294.                                         pAddress[i]=ProcAddress;   
295.                                     }  
296.                         }
297.  
298.  
299.  
300.  
301. DWORD sc;
302. DWORD dwResult=0;
303.     //    set section protection
304.     for (i=0; i<pFileHeader->NumberOfSections; i++)
305.     {
306.         //***************************************************************************
307.         sc = pSectionHeader[i].Characteristics;
308.         dwResult=0;
309.     if (sc & IMAGE_SCN_MEM_NOT_CACHED)
310.         dwResult |= PAGE_NOCACHE;
311.  
312.     if (sc & IMAGE_SCN_MEM_EXECUTE)
313.     {
314.         if (sc & IMAGE_SCN_MEM_READ)
315.         {
316.             if (sc & IMAGE_SCN_MEM_WRITE)
317.                 dwResult |= PAGE_EXECUTE_READWRITE;
318.             else
319.                 dwResult |= PAGE_EXECUTE_READ;
320.         }
321.         else
322.         {
323.             if (sc & IMAGE_SCN_MEM_WRITE)
324.                 dwResult |= PAGE_EXECUTE_WRITECOPY;
325.             else
326.                 dwResult |= PAGE_EXECUTE;
327.         }
328.     }
329.     else
330.     {
331.         if (sc & IMAGE_SCN_MEM_READ)
332.         {
333.             if (sc & IMAGE_SCN_MEM_WRITE)
334.                 dwResult|=PAGE_READWRITE;
335.             else
336.                 dwResult|=PAGE_READONLY;
337.         }
338.         else
339.         {
340.             if (sc & IMAGE_SCN_MEM_WRITE)
341.                 dwResult|=PAGE_WRITECOPY;
342.             else
343.                 dwResult|=PAGE_NOACCESS;
344.         }
345.     }
346.     //***************************************************************************
347.     t = (DWORD)ImageBase+pSectionHeader[i].VirtualAddress;
348.     t1 = pSectionHeader[i].Misc.VirtualSize;
349.     _asm
350.     {
351.         lea eax, dwOldProt
352.         push eax
353.         push dwResult
354.         push t1
355.         push t
356.         call virtual_protect
357.     }
358.     }
359.         //VirtualProtect((PVOID)(ImageBase+pSectionHeader[i].VirtualAddress),
360.         //pSectionHeader[i].Misc.VirtualSize,
361.         //dwResult,
362.         //&dwOldProt);
363.  
364.      //   call DLLMain
365.     if (pOptionalHeader->AddressOfEntryPoint!=0)
366.     {
367.         //DLLMAIN dllMain=(DLLMAIN)(ImageBase+pOptionalHeader->AddressOfEntryPoint);
368.         t = (DWORD)(ImageBase+pOptionalHeader->AddressOfEntryPoint);
369.  
370.         HMODULE hm_user;
371.         DWORD messge_box;
372.         _asm
373.         {
374.             lea eax, user32
375.                 push eax
376.                 call _load_libroary_
377.                 mov hm_user, eax
378.         }
379.         _asm
380.         {
381.             lea eax, ch_mes_box
382.                 push eax
383.                 push hm_user
384.                 call get_proc_adress
385.                 mov messge_box, eax
386.         }
387.         _asm
388.         {
389.             push 0
390.                 push 0
391.                 push 0
392.                 push 0
393.                 call messge_box
394.         }
395.  
396.         _asm
397.         {
398.             push NULL
399.             push DLL_PROCESS_ATTACH
400.             push ImageBase
401.             call t
402.          //   cmp eax, 0
403.            // jz p_conec
404.            // jmp konec
405.         }
406.        // if (!dllMain((HMODULE)ImageBase, DLL_PROCESS_ATTACH, NULL))
407.       //  {
408. //            _asm
409. //            {
410. //p_conec:
411. //                push MEM_RELEASE
412. //                    push 0
413. //                    push ImageBase
414. //                    call virtual_free
415. //            }
416. //            //VirtualFree(ImageBase, 0, MEM_RELEASE);
417. //                   _asm jmp konec;
418. //            //return NULL;
419. //        //}
420.     }
421.  
422.     _asm
423.     {
424. konec:
425.         push 0
426.         call exit_thread
427.     }
428.  
429.  
430. }

и возможно из-за этого все бока?

 

vanilly_cpp
Мда... спасибо... это я уже на предыдущей странице видел. С моими знаниями я в этом минимум дня три разбираться буду.
Можно поинтересоваться? А зачем вам своя реализация LoadLibrary?

 

>>l_inc

Ну как оговаривалось выше, для того, чтоб каспер не палил загрузку dll мене посоветовали грузить ее собственным dll лодером, пердвирительно проижектя его код в целевой процесс, вот его и пытаюсь реализовать!

 

vanilly_cpp
ЛОЛ. Извращение. Касперский обходится гораздо легче. Правда я при этом инжектирую просто код, а не dll. Если заинтересует, напишу, хотя метод - не Бог весть что... первое, что в голову приходит.

 

vanilly_cpp
проще инжекть асмовый код, который снимет хук с LoadLibrary или юзай LdrLoadDll.

 

EvilPhreak
А Касперский случайно не SDT правит? Тут простым снятием хука из юзермода не обойтись.

 

l_inc
А как он тогда по твоему делает WriteProcessMemory. Афтар явно сказал что он снял хуки SDT.

 

EvilPhreak

http://indetails.info/?module=detailed&id=593