对AntiRK的逆向

元始天尊

简单的分析了，所以很多地方比较草，有兴趣的可以细化：

函数标记如下：
wsprintfW                     .text 00010CD6 0000005A 00000004 0000000D R . . . B T .
nop8                          .text 00013500 00000003                   R . . . . . .
nop7                          .text 000134B8 00000012                   R . . . . . .
nop6                          .text 000134E4 00000017 00000004 00000008 R . . . . . .
nop5                          .text 000134CA 0000001A 00000010 00000000 R . . . B . .
nop4                          .text 000134A1 00000017 00000010 00000000 R . . . . . .
nop3                          .text 0001343F 00000046 00000000 00000010 R . . . . . .
nop2                          .text 000133BC 00000083 00000020 0000000C R . . . . . .
nop                           .text 00013200 00000154 00000024 0000000C R . . . B . .
memset                        .text 0001210C 00000006                   R . . . . T .
memcpy                        .text 00012100 00000006                   R . . . . T .
md5_encrypt9                  .text 0001399A 00000022 00000004 00000008 R . . . . . .
md5_encrypt8                  .text 00012F79 00000081 0000001C 00000008 R . . . B T .
md5_encrypt7                  .text 00012ECA 000000AA 00000010 0000000C R . . . B . .
md5_encrypt6                  .text 000127BE 0000002F 00000004 00000004 R . . . B . .
md5_encrypt5                  .text 00013598 00000058 0000000C 0000000C R . . . . . .
md5_encrypt4                  .text 000135F5 000000F7 00000014 00000010 R . . . B . .
md5_encrypt3                  .text 000136F1 0000004A 00000010 0000000C R . . . B . .
md5_encrypt25                 .text 000127F2 00000031                   R . . . . . .
md5_encrypt24                 .text 00012828 0000069D 00000058 00000004 R . . . B . .
md5_encrypt23                 .text 0001386C 0000005A 00000018 00000008 R . . . B . .
md5_encrypt22                 .text 000138CB 00000022 00000000 00000008 R . . . . . .
md5_encrypt21                 .text 00013809 0000005E 00000000 00000008 R . . . . . .
md5_encrypt20                 .text 00013D75 0000008F 00000018 00000008 R . . . B . .
md5_encrypt2                  .text 00012117 0000004A 00000068 0000000C R . . . B . .
md5_encrypt19                 .text 000138F2 0000004B 00000004 00000008 R . . . . . .
md5_encrypt18                 .text 00013E09 00000085 0000001C 00000008 R . . . B . .
md5_encrypt17                 .text 00013C4B 0000009B 00000014 00000010 R . . . B . .
md5_encrypt16                 .text 00013740 00000056 00000008 00000008 R . . . . . .
md5_encrypt15                 .text 0001395A 00000010 00000000 00000004 R . . . . . .
md5_encrypt14                 .text 0001396F 00000026 00000004 00000008 R . . . . . .
md5_encrypt13                 .text 000139C1 00000285 00000048 00000010 R . . . B . .
md5_encrypt12                 .text 00013CEB 00000085 00000014 0000000C R . . . B . .
md5_encrypt11                 .text 00013942 00000013                   R . . . . . .
md5_encrypt10                 .text 0001379B 00000069 00000010 00000008 R . . . B . .
md5_encrypt1                  .text 00013513 00000080 00000010 00000010 R . . . B . .
init_security_cookie          INIT  00015B85 00000034                   R . . . . . .
freebuf                       .text 00011B36 0000001D 00000004 00000004 R . . . B T .
_aullshr                      .text 00013EA0 00000006                   R . . . . . .
_aulldiv                      .text 00013EAC 00000006                   R . . . . . .
_allshl                       .text 00013E94 00000006                   R . . . . . .
_allmul                       .text 00013EB8 00000006                   R . . . . . .
__security_check_cookie(x)    .text 000120B4 0000003A                   R . L . . . .
__SEH_prolog4_GS              .text 0001319C 00000048 00000000 00000008 R . L . . . .
__SEH_prolog4                 .text 0001335C 00000045 00000000 00000008 R . L . . . .
__SEH_epilog4_GS              .text 000131E4 0000000F                   R . L . . . .
__SEH_epilog4                 .text 000133A1 00000014                   R . L . . . .
UnRegisterShutdown            .text 0001088C 0000002C 00000004 00000004 R . . . B T .
UnInitPowerCallback           .text 00010C12 00000038                   R . . . . . .
UnInitCmFunc                  .text 00011FC4 0000002A                   R . . . . . .
UnInit                        .text 000110C4 00000022 00000004 00000004 R . . . B T .
TranVerseDeleteReg            .text 00011888 000001E1 00000044 0000000C R . . . B T .
ShutdownDispatch              .text 0001078C 0000001F 00000004 00000008 R . . . B T .
ShowDenyServices              .text 00010EF4 00000015                   R . . . . . .
ShowDenyFiles                 .text 00010632 00000015                   R . . . . . .
ShowDemandServices            .text 00010666 00000015                   R . . . . . .
SetServices                   .text 000110B2 0000000D 00000000 00000004 R . . . . T .
SetRegVal                     .text 00011CE2 00000145 0000003C 00000014 R . . . B T .
SetDenyService                .text 0001064C 00000015                   R . . . . . .
SetDemandServices             .text 00010F0E 00000015                   R . . . . . .
SetDeleteFiles                .text 0001144C 00000015                   R . . . . . .
RtlUnwind                     .text 00013508 00000006 00000000 00000000 R . . . . . .
ResetDenyServices             .text 00010EDA 00000015                   R . . . . . .
ReadFile                      .text 000122F9 00000114 00000050 00000014 R . . . B T .
PowerCallbackFunction         .text 0001162E 00000059 00000004 0000000C R . . . B T .
IsSameDir                     .text 00012412 000001DF 00000054 00000004 R . . . B T .
IsDirCorrect                  .text 00010AFE 000000DD 00000020 00000004 R . . . B T .
IsAbsolutePath                .text 00010BE0 0000002C 00000004 00000004 R . . . B T .
InitShutdown                  .text 00010854 00000033 00000008 00000004 R . . . B T .
InitServiceList               .text 00011246 00000201 0000003C 00000000 R . . . B . .
InitReg                       .text 0001168C 0000008C 00000014 00000000 R . . . B . .
InitPowerCallback             .text 0001171E 000000A9 0000002C 00000000 R . . . B . .
InitInitialRoutine            .text 00011804 00000021 00000004 00000004 R . . . B T .
InitCmFuncs                   .text 00012034 0000007B 00000008 00000008 R . . . B T .
Init                          .text 0001182A 00000058 00000008 0000000C R . . . B T .
GetSectionBaseAddress         .text 00012FFF 0000006A 00000004 00000000 R . . . . . .
GetRegValue                   .text 000121E5 0000010F 00000040 00000010 R . . . B T .
GetRegServicePath             .text 00010D36 0000019F 00000250 00000000 R . . . B . .
GetObjectName                 .text 00011B58 000000C7 00000224 0000000C R . . . B T .
GetNtProcAddress              .text 00011FF4 0000003B 00000010 00000004 R . . . B T .
GetFileObjectFromProcess      .text 0001306E 0000008E 0000000C 00000008 R . . . B T .
GetFileNameFromProcess        .text 00013101 00000095 00000014 00000004 R . . . B T .
GetAntiRKRegVal               .text 00011E2C 0000011D 00000040 0000000C R . . . B T .
FindService                   .text 000110EC 00000154 00000018 00000004 R . . . B T .
FindRegDirDepth_0             .text 00010AAC 0000004C 00000008 00000010 R . . . B T .
ExecFunc                      .text 00010A08 0000009F 0000000C 0000000C R . . . B T .
DriverReinitializationRoutine .text 000117CC 00000033 00000008 0000000C R . . . B T .
DriverEntry_0                 .text 000107B0 0000009E 00000008 00000008 R . . . B T .
DriverEntry                   INIT  00015BBE 00000010 00000004 00000008 R . . . B T .
DoDeleteFile                  .text 00011F4E 00000071 0000002C 00000004 R . . . B T .
DeviceIoControlDispatch       .text 000106F4 00000092 0000000C 00000008 R . . . B T .
DeleteService1                .text 00010966 0000009D 00000010 0000000C R . . . B T .
DeleteService                 .text 00011C24 000000B9 0000003C 00000004 R . . . B T .
DelRegKey                     .text 00011A6E 000000C3 0000003C 00000008 R . . . B T .
DbgPrint                      .text 000120F4 00000006                   R . . . . T .
CreateDeviceAndSymbol         .text 00010486 000000AA 00000020 0000000C R . . . B T .
CreateCloseDispatch           .text 00010680 0000006E 0000000C 00000008 R . . . B T .
CompleteRequest               .text 00010536 0000002D 00000004 0000000C R . . . B T .
CmCallBackFunc                .text 00011466 000001B9 00000450 0000000C R . . . B T .
ClearList                     .text 00010C50 00000080 0000000C 00000000 R . . . . . .
CheckRegKeyValid              .text 00010FD8 000000D5 0000022C 00000008 R . . . B T .
CheckPrcoessValid             .text 000125F6 000001C3 000000CC 00000008 R . . . B T .
CheckNtImageValid             .text 00012166 0000007A 00000030 00000004 R . . . B T .
CallbackService               .text 000108BE 000000A3 00000010 0000000C R . . . B T .
CallbackDelete                .text 00010F28 000000AA 0000000C 0000000C R . . . B T .
CallBackShowInfo              .text 00010568 000000C5 00000004 0000000C R . . . B T .

1. 
   
2. char __stdcall UnRegisterShutdown(PDEVICE_OBJECT DeviceObject)
   
3. {
   
4.   char result; // al@1
   
5. 
   
6.   result = 0;
   
7.   if ( DeviceObject )
   
8.   {
   
9.     if ( IsRegisterShutdown == 1 )
   
10.     {
    
11.       IoUnregisterShutdownNotification(DeviceObject);
    
12.       IsRegisterShutdown = 0;
    
13.     }
    
14.     result = 1;
    
15.   }
    
16.   return result;
    
17. }
    
18. 
    
19. char UnInitPowerCallback()
    
20. {
    
21.   if ( CallbackObject )
    
22.   {
    
23.     ObfDereferenceObject((PVOID)CallbackObject);
    
24.     CallbackObject = 0;
    
25.   }
    
26.   if ( CallbackRegistration )
    
27.   {
    
28.     ExUnregisterCallback(CallbackRegistration);
    
29.     CallbackRegistration = 0;
    
30.   }
    
31.   IsPowerCallbackInit = 0;
    
32.   return 1;
    
33. }
    
34. 
    
35. char UnInitCmFunc()
    
36. {
    
37.   if ( IsCmFuncInit == 1 && CmUnRegisterCallback )
    
38.     CmUnRegisterCallback(Cookie.LowPart, Cookie.HighPart);
    
39.   IsCmFuncInit = 0;
    
40.   return 1;
    
41. }
    
42. 
    
43. char __stdcall sub_110C4(PDEVICE_OBJECT DeviceObject)
    
44. {
    
45.   UnRegisterShutdown(DeviceObject);
    
46.   UnInitPowerCallback();
    
47.   UnInitCmFunc();
    
48.   ClearList();
    
49.   return 1;
    
50. }
    
51. 
    
52. int __stdcall TranVerseDeleteReg(PUNICODE_STRING KeyName, int Depth, HANDLE RootHandle)
    
53. {
    
54.   LSA_UNICODE_STRING *ValueName; // edi@1
    
55.   struct _KEY_BASIC_INFORMATION *v4; // eax@6
    
56.   WCHAR *v5; // eax@7
    
57.   unsigned int v6; // edi@8
    
58.   unsigned int v7; // edi@8
    
59.   NTSTATUS v8; // eax@12
    
60.   OBJECT_ATTRIBUTES ObjectAttributes; // [sp+Ch] [bp-34h]@4
    
61.   UNICODE_STRING v11; // [sp+24h] [bp-1Ch]@1
    
62.   unsigned __int32 LowLimit; // [sp+2Ch] [bp-14h]@3
    
63.   int v13; // [sp+30h] [bp-10h]@1
    
64.   ULONG ResultLength; // [sp+34h] [bp-Ch]@1
    
65.   HANDLE KeyHandle; // [sp+38h] [bp-8h]@1
    
66.   PKEY_BASIC_INFORMATION KeyInformation; // [sp+3Ch] [bp-4h]@1
    
67. 
    
68.   v11.Length = 0;
    
69.   *(_DWORD *)&v11.MaximumLength = 0;
    
70.   HIWORD(v11.Buffer) = 0;
    
71.   ValueName = KeyName;
    
72.   v13 = -1073741823;
    
73.   KeyHandle = 0;
    
74.   KeyInformation = 0;
    
75.   ResultLength = 0;
    
76.   if ( KeyName )
    
77.   {
    
78.     if ( (KeyName->Length & 0xFFFEu) < 0x208 )
    
79.     {
    
80.       IoGetStackLimits(&LowLimit, (PULONG_PTR)&KeyName);
    
81.       if ( (unsigned int)((char *)&KeyName - LowLimit) >= 0xE00 )
    
82.       {
    
83.         ObjectAttributes.RootDirectory = RootHandle;
    
84.         ObjectAttributes.Length = 24;
    
85.         ObjectAttributes.Attributes = 832;
    
86.         ObjectAttributes.ObjectName = ValueName;
    
87.         ObjectAttributes.SecurityDescriptor = 0;
    
88.         ObjectAttributes.SecurityQualityOfService = 0;
    
89.         if ( ZwOpenKey(&KeyHandle, 0xF003Fu, &ObjectAttributes) >= 0
    
90.           || (ObjectAttributes.RootDirectory = RootHandle,
    
91.               ObjectAttributes.Length = 24,
    
92.               ObjectAttributes.Attributes = 576,
    
93.               ObjectAttributes.ObjectName = ValueName,
    
94.               ObjectAttributes.SecurityDescriptor = 0,
    
95.               ObjectAttributes.SecurityQualityOfService = 0,
    
96.               ZwOpenKey(&KeyHandle, 0xF003Fu, &ObjectAttributes) >= 0) )
    
97.         {
    
98.           v4 = (struct _KEY_BASIC_INFORMATION *)ExAllocatePoolWithTag(0, 0x300u, 0x5441524Bu);
    
99.           KeyInformation = v4;
    
100.           if ( v4 )
     
101.           {
     
102.             memset(v4, 0, 0x300u);
     
103.             v5 = (WCHAR *)ExAllocatePoolWithTag(0, 0x300u, 0x5441524Bu);
     
104.             v11.Buffer = v5;
     
105.             if ( !v5 )
     
106.               goto LABEL_17;
     
107.             memset(v5, 0, 0x300u);
     
108.             v6 = ValueName->Length;
     
109.             v11.MaximumLength = 768;
     
110.             v7 = v6 >> 1;
     
111.             while ( 1 )
     
112.             {
     
113.               v8 = ZwEnumerateKey(KeyHandle, 0, 0, KeyInformation, 0x300u, &ResultLength);
     
114.               if ( v8 == 0x8000001A )
     
115.                 break;
     
116.               if ( v8 >= 0 && (KeyInformation->NameLength >> 1) + v7 + 2 <= 0x300 )
     
117.               {
     
118.                 wcsncpy(v11.Buffer, KeyInformation->Name, KeyInformation->NameLength >> 1);
     
119.                 v11.Length = LOWORD(KeyInformation->NameLength);
     
120.                 if ( TranVerseDeleteReg(&v11, Depth + 1, KeyHandle) >= 0 )
     
121.                   continue;
     
122.               }
     
123.               goto LABEL_15;
     
124.             }
     
125.             if ( ZwDeleteKey(KeyHandle) >= 0 )
     
126.               v13 = 0;
     
127.           }
     
128.         }
     
129.       }
     
130.     }
     
131.   }
     
132. LABEL_15:
     
133.   if ( v11.Buffer )
     
134.   {
     
135.     ExFreePoolWithTag(v11.Buffer, 'TARK');
     
136.     v11.Buffer = 0;
     
137.   }
     
138. LABEL_17:
     
139.   if ( KeyInformation )
     
140.     ExFreePoolWithTag(KeyInformation, 'TARK');
     
141.   if ( KeyHandle )
     
142.     ZwClose(KeyHandle);
     
143.   return v13;
     
144. }
     
145. 
     
146. int __stdcall ShutdownDispatch(PDEVICE_OBJECT DeviceObject, PIRP Irp)
     
147. {
     
148.   SetServices(DeviceObject);
     
149.   CompleteRequest(Irp, 0, 0);
     
150.   return 0;
     
151. }
     
152. 
     
153. char ShowDenyServices()
     
154. {
     
155.   return ExecFunc('DKs', L"DenyServices", (FARPROC)CallbackService);
     
156. }
     
157. 
     
158. char ShowDenyFiles()
     
159. {
     
160.   return ExecFunc('DFs', L"DenyFiles", (FARPROC)CallBackShowInfo);
     
161. }
     
162. 
     
163. char ShowDemandServices()
     
164. {
     
165.   return ExecFunc('DemK', L"DemandServices", (FARPROC)CallBackShowInfo);
     
166. }
     
167. 
     
168. //  0 引导 1 系统 2 自动 3 手动 4 禁用
     
169. int __stdcall SetServices(PDEVICE_OBJECT DeviceObject)
     
170. {
     
171.   int result; // eax@1
     
172. 
     
173.   ShowDenyServices();
     
174.   LOBYTE(result) = SetDemandServices();
     
175.   return result;
     
176. }
     
177. 
     
178. char __stdcall SetRegVal(WCHAR *serviceName, PCWSTR SourceString, PVOID Data, ULONG DataSize, ULONG Type)
     
179. {
     
180.   WCHAR *v5; // eax@1
     
181.   WCHAR v6; // cx@4
     
182.   int v7; // eax@5
     
183.   unsigned int v8; // esi@6
     
184.   PVOID v9; // eax@6
     
185.   wchar_t *v10; // edi@6
     
186.   OBJECT_ATTRIBUTES ObjectAttributes; // [sp+8h] [bp-30h]@1
     
187.   UNICODE_STRING ValueName; // [sp+20h] [bp-18h]@1
     
188.   UNICODE_STRING DestinationString; // [sp+28h] [bp-10h]@1
     
189.   HANDLE KeyHandle; // [sp+30h] [bp-8h]@1
     
190.   char v16; // [sp+37h] [bp-1h]@1
     
191. 
     
192.   DestinationString.Length = 0;
     
193.   *(_DWORD *)&DestinationString.MaximumLength = 0;
     
194.   HIWORD(DestinationString.Buffer) = 0;
     
195.   ValueName.Length = 0;
     
196.   *(_DWORD *)&ValueName.MaximumLength = 0;
     
197.   HIWORD(ValueName.Buffer) = 0;
     
198.   ObjectAttributes.Length = 0;
     
199.   ObjectAttributes.RootDirectory = 0;
     
200.   ObjectAttributes.ObjectName = 0;
     
201.   ObjectAttributes.Attributes = 0;
     
202.   ObjectAttributes.SecurityDescriptor = 0;
     
203.   ObjectAttributes.SecurityQualityOfService = 0;
     
204.   v5 = serviceName;
     
205.   v16 = 0;
     
206.   KeyHandle = 0;
     
207.   if ( serviceName && SourceString && Data )
     
208.   {
     
209.     do
     
210.     {
     
211.       v6 = *v5;
     
212.       ++v5;
     
213.     }
     
214.     while ( v6 );
     
215.     v7 = v5 - (serviceName + 1);
     
216.     if ( v7 )
     
217.     {
     
218.       v8 = 2 * v7 + 520;
     
219.       v9 = ExAllocatePoolWithTag(0, v8, 0x5441524Bu);
     
220.       v10 = (wchar_t *)v9;
     
221.       if ( v9 )
     
222.       {
     
223.         memset(v9, 0, v8);
     
224.         wsprintfW(v10, v8 >> 1, L"%s\\%s", L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\services", serviceName);
     
225.         RtlInitUnicodeString(&DestinationString, v10);
     
226.         ObjectAttributes.ObjectName = &DestinationString;
     
227.         ObjectAttributes.Length = 24;
     
228.         ObjectAttributes.RootDirectory = 0;
     
229.         ObjectAttributes.Attributes = 576;
     
230.         ObjectAttributes.SecurityDescriptor = 0;
     
231.         ObjectAttributes.SecurityQualityOfService = 0;
     
232.         ZwOpenKey(&KeyHandle, 3u, &ObjectAttributes);
     
233.         if ( KeyHandle )
     
234.         {
     
235.           RtlInitUnicodeString(&ValueName, SourceString);
     
236.           if ( ZwSetValueKey(KeyHandle, &ValueName, 0, Type, Data, DataSize) >= 0 )
     
237.             v16 = 1;
     
238.         }
     
239.         ExFreePoolWithTag(v10, 0x5441524Bu);
     
240.       }
     
241.       if ( KeyHandle )
     
242.       {
     
243.         if ( v16 == 1 )
     
244.           ZwFlushKey(KeyHandle);
     
245.         ZwClose(KeyHandle);
     
246.       }
     
247.     }
     
248.   }
     
249.   return v16;
     
250. }
     
251. 
     
252. char SetDenyService()
     
253. {
     
254.   return ExecFunc('DKs', L"DenyServices", (FARPROC)CallBackShowInfo);
     
255. }
     
256. 
     
257. char setDemandServices()
     
258. {
     
259.   return ExecFunc('DemK', L"DemandServices", (FARPROC)CallbackService);
     
260. }
     
261. 
     
262. char SetDeleteFiles()
     
263. {
     
264.   return ExecFunc('DFs', L"DenyFiles", (FARPROC)CallbackDelete);
     
265. }
     
266. 
     
267. char ResetDenyServices()
     
268. {
     
269.   return ExecFunc('DKs', L"DenyServices", (FARPROC)DeleteService1);
     
270. }
     
271. 
     
272. BOOL __stdcall ReadFile(int a1, int lpBuffer)
     
273. {
     
274.   PVOID v2; // eax@4
     
275.   int FileInformation; // [sp+8h] [bp-44h]@1
     
276.   int v5; // [sp+Ch] [bp-40h]@1
     
277.   SIZE_T NumberOfBytes; // [sp+10h] [bp-3Ch]@1
     
278.   int v7; // [sp+14h] [bp-38h]@1
     
279.   int v8; // [sp+18h] [bp-34h]@1
     
280.   int v9; // [sp+1Ch] [bp-30h]@1
     
281.   OBJECT_ATTRIBUTES ObjectAttributes; // [sp+20h] [bp-2Ch]@1
     
282.   struct _IO_STATUS_BLOCK IoStatusBlock; // [sp+38h] [bp-14h]@1
     
283.   int v12; // [sp+40h] [bp-Ch]@1
     
284.   PVOID P; // [sp+44h] [bp-8h]@1
     
285.   HANDLE FileHandle; // [sp+48h] [bp-4h]@1
     
286. 
     
287.   FileInformation = 0;
     
288.   IoStatusBlock.Status = 0;
     
289.   IoStatusBlock.Information = 0;
     
290.   v5 = 0;
     
291.   NumberOfBytes = 0;
     
292.   v7 = 0;
     
293.   v8 = 0;
     
294.   v9 = 0;
     
295.   ObjectAttributes.ObjectName = (PUNICODE_STRING)a1;
     
296.   v12 = 0;
     
297.   P = 0;
     
298.   FileHandle = 0;
     
299.   *(_DWORD *)lpBuffer = 0;
     
300.   ObjectAttributes.Length = 24;
     
301.   ObjectAttributes.RootDirectory = 0;
     
302.   ObjectAttributes.Attributes = 576;
     
303.   ObjectAttributes.SecurityDescriptor = 0;
     
304.   ObjectAttributes.SecurityQualityOfService = 0;
     
305.   if ( IoCreateFile(
     
306.          &FileHandle,
     
307.          0x80100000,
     
308.          &ObjectAttributes,
     
309.          &IoStatusBlock,
     
310.          0,
     
311.          0x80u,
     
312.          1u,
     
313.          1u,
     
314.          0x60u,
     
315.          0,
     
316.          0,
     
317.          0,
     
318.          0,
     
319.          0x100u) >= 0
     
320.     && ZwQueryInformationFile(FileHandle, &IoStatusBlock, &FileInformation, 0x18u, FileStandardInformation) >= 0
     
321.     && NumberOfBytes < 0xA00000 )
     
322.   {
     
323.     v2 = ExAllocatePoolWithTag(0, NumberOfBytes, 0x21545645u);
     
324.     P = v2;
     
325.     if ( v2 )
     
326.     {
     
327.       if ( ZwReadFile(FileHandle, 0, 0, 0, &IoStatusBlock, v2, NumberOfBytes, 0, 0) >= 0 )
     
328.       {
     
329.         *(_DWORD *)lpBuffer = NumberOfBytes;
     
330.         v12 = 1;
     
331.       }
     
332.     }
     
333.   }
     
334.   if ( FileHandle )
     
335.   {
     
336.     ZwClose(FileHandle);
     
337.     FileHandle = 0;
     
338.   }
     
339.   if ( !v12 && P )
     
340.   {
     
341.     ExFreePoolWithTag(P, 0);
     
342.     P = 0;
     
343.   }
     
344.   return (BOOL)P;
     
345. }
     
346. 
     
347. void __stdcall PowerCallbackFunction(PVOID CallbackContext, PVOID Argument1, PVOID Argument2)
     
348. {
     
349.   char v3; // bl@5
     
350.   char v4; // al@5
     
351.   signed __int32 v5; // eax@7
     
352. 
     
353.   if ( PowerCallbackEnable && Argument1 == (PVOID)3 )// PO_CB_SYSTEM_STATE_LOCK
     
354.   {
     
355.     if ( Argument2 )
     
356.     {
     
357.       if ( Argument2 != (PVOID)1 )
     
358.         return;
     
359.       v5 = 0;
     
360.       goto LABEL_10;
     
361.     }
     
362.     if ( !KeGetCurrentIrql() )
     
363.     {
     
364.       v3 = InitCmFuncs((FARPROC)CmCallBackFunc, 0);
     
365.       v4 = InitServiceList();
     
366.       if ( v3 )
     
367.       {
     
368.         if ( v4 )
     
369.         {
     
370.           v5 = 1;
     
371. LABEL_10:
     
372.           _InterlockedExchange((volatile signed __int32 *)&dword_14814, v5);
     
373.           return;
     
374.         }
     
375.       }
     
376.     }
     
377.   }
     
378. }
     
379. 
     
380. int __stdcall IsSameDir(PCUNICODE_STRING String2)
     
381. {
     
382.   POBJECT_NAME_INFORMATION v1; // edi@1
     
383.   const WCHAR *v2; // eax@1
     
384.   PVOID v3; // eax@6
     
385.   PWSTR v4; // ecx@8
     
386.   unsigned __int16 v5; // ax@11
     
387.   OBJECT_ATTRIBUTES ObjectAttributes; // [sp+Ch] [bp-44h]@1
     
388.   struct _OBJECT_HANDLE_INFORMATION HandleInformation; // [sp+24h] [bp-2Ch]@1
     
389.   struct _IO_STATUS_BLOCK IoStatusBlock; // [sp+2Ch] [bp-24h]@1
     
390.   UNICODE_STRING DestinationString; // [sp+34h] [bp-1Ch]@1
     
391.   int v11; // [sp+3Ch] [bp-14h]@1
     
392.   PVOID Object; // [sp+40h] [bp-10h]@1
     
393.   int v13; // [sp+44h] [bp-Ch]@1
     
394.   PCWSTR SourceString; // [sp+48h] [bp-8h]@1
     
395.   HANDLE FileHandle; // [sp+4Ch] [bp-4h]@1
     
396. 
     
397.   DestinationString.Length = 0;
     
398.   *(_DWORD *)&DestinationString.MaximumLength = 0;
     
399.   HIWORD(DestinationString.Buffer) = 0;
     
400.   ObjectAttributes.Length = 0;
     
401.   ObjectAttributes.RootDirectory = 0;
     
402.   ObjectAttributes.ObjectName = 0;
     
403.   ObjectAttributes.Attributes = 0;
     
404.   ObjectAttributes.SecurityDescriptor = 0;
     
405.   ObjectAttributes.SecurityQualityOfService = 0;
     
406.   IoStatusBlock.Status = 0;
     
407.   IoStatusBlock.Information = 0;
     
408.   HandleInformation.HandleAttributes = 0;
     
409.   HandleInformation.GrantedAccess = 0;
     
410.   v11 = 0;
     
411.   v13 = 0;
     
412.   FileHandle = 0;
     
413.   Object = 0;
     
414.   v1 = 0;
     
415.   v2 = (const WCHAR *)ExAllocatePoolWithTag(0, 522u, 0x70617468u);
     
416.   SourceString = v2;
     
417.   if ( v2 )
     
418.   {
     
419.     memset((void *)v2, 0, 522u);
     
420.     v13 = 520;
     
421.     if ( GetRegValue(
     
422.            L"\\REGISTRY\\MACHINE\\SYSTEM\\CurrentControlSet\\Services\\TSKSP",
     
423.            L"ImagePath",
     
424.            (void *)SourceString,
     
425.            (int)&v13) >= 0 )
     
426.     {
     
427.       v13 = wcslen(SourceString);
     
428.       if ( (unsigned int)v13 < 0x104 )
     
429.       {
     
430.         RtlInitUnicodeString(&DestinationString, SourceString);
     
431.         ObjectAttributes.ObjectName = &DestinationString;
     
432.         ObjectAttributes.Length = 24;
     
433.         ObjectAttributes.RootDirectory = 0;
     
434.         ObjectAttributes.Attributes = 576;
     
435.         ObjectAttributes.SecurityDescriptor = 0;
     
436.         ObjectAttributes.SecurityQualityOfService = 0;
     
437.         if ( IoCreateFile(
     
438.                &FileHandle,
     
439.                0x100080u,
     
440.                &ObjectAttributes,
     
441.                &IoStatusBlock,
     
442.                0,
     
443.                0x80u,
     
444.                1u,
     
445.                1u,
     
446.                0x60u,
     
447.                0,
     
448.                0,
     
449.                0,
     
450.                0,
     
451.                0x100u) >= 0
     
452.           && ObReferenceObjectByHandle(FileHandle, 0, 0, 0, &Object, &HandleInformation) >= 0 )
     
453.         {
     
454.           v3 = ExAllocatePoolWithTag(0, 0x400u, 0x21545645u);
     
455.           v1 = (POBJECT_NAME_INFORMATION)v3;
     
456.           if ( v3 )
     
457.           {
     
458.             memset(v3, 0, 0x400u);
     
459.             if ( ObQueryNameString(Object, v1, 1024, &v13) >= 0 )
     
460.             {
     
461.               v4 = v1->Name.Buffer;
     
462.               if ( v4 )
     
463.               {
     
464.                 if ( v1->Name.Length > 0u )
     
465.                 {
     
466.                   do
     
467.                   {
     
468.                     if ( v4[((unsigned int)v1->Name.Length >> 1) - 1] == 92 )
     
469.                       break;
     
470.                     v5 = v1->Name.Length - 2;
     
471.                     v1->Name.Length = v5;
     
472.                   }
     
473.                   while ( v5 > 0u );
     
474.                 }
     
475.                 if ( RtlPrefixUnicodeString(&v1->Name, String2, 1u) )
     
476.                   v11 = 1;
     
477.               }
     
478.             }
     
479.           }
     
480.         }
     
481.       }
     
482.     }
     
483.   }
     
484.   if ( Object )
     
485.   {
     
486.     ObfDereferenceObject(Object);
     
487.     Object = 0;
     
488.   }
     
489.   if ( FileHandle )
     
490.   {
     
491.     ZwClose(FileHandle);
     
492.     FileHandle = 0;
     
493.   }
     
494.   if ( v1 )
     
495.     ExFreePoolWithTag(v1, 0);
     
496.   if ( SourceString )
     
497.     ExFreePoolWithTag((PVOID)SourceString, 0);
     
498.   return v11;
     
499. }
     
500. 
     
501. char __stdcall IsDirDepth1(PUNICODE_STRING CurKeyPath)
     
502. {
     
503.   WCHAR *v1; // ecx@3
     
504.   WCHAR *v2; // ecx@6
     
505.   UNICODE_STRING DestinationString; // [sp+8h] [bp-14h]@1
     
506.   UNICODE_STRING String1; // [sp+10h] [bp-Ch]@1
     
507.   char v6; // [sp+1Bh] [bp-1h]@1
     
508. 
     
509.   String1.Length = 0;
     
510.   *(_DWORD *)&String1.MaximumLength = 0;
     
511.   HIWORD(String1.Buffer) = 0;
     
512.   DestinationString.Length = 0;
     
513.   *(_DWORD *)&DestinationString.MaximumLength = 0;
     
514.   v6 = 0;
     
515.   HIWORD(DestinationString.Buffer) = 0;
     
516.   if ( CurKeyPath )
     
517.   {
     
518.     if ( (RtlInitUnicodeString(&DestinationString, L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\services"),
     
519.           CurKeyPath->Length > DestinationString.Length)
     
520.       && (*(_DWORD *)&String1.Length = *(_DWORD *)&CurKeyPath->Length,
     
521.           v1 = CurKeyPath->Buffer,
     
522.           String1.Length = DestinationString.Length,
     
523.           String1.Buffer = v1,
     
524.           RtlEqualUnicodeString(&String1, &DestinationString, 1u) == 1)
     
525.       && FindRegDirDepth_0(
     
526.            CurKeyPath,
     
527.            '\\',
     
528.            (unsigned int)DestinationString.Length >> 1,
     
529.            (unsigned int)CurKeyPath->Length >> 1) == 1
     
530.       || CurKeyPath->Length > URegServicePath.Length
     
531.       && (*(_DWORD *)&String1.Length = *(_DWORD *)&CurKeyPath->Length,
     
532.           v2 = CurKeyPath->Buffer,
     
533.           String1.Length = URegServicePath.Length,
     
534.           String1.Buffer = v2,
     
535.           RtlEqualUnicodeString(&String1, &URegServicePath, 1u) == 1)
     
536.       && FindRegDirDepth_0(
     
537.            CurKeyPath,
     
538.            '\\',
     
539.            (unsigned int)URegServicePath.Length >> 1,
     
540.            (unsigned int)CurKeyPath->Length >> 1) == 1 )
     
541.       v6 = 1;
     
542.   }
     
543.   return v6;
     
544. }
     
545. 
     
546. char __stdcall IfBeginwithSlash(PUNICODE_STRING *a1)
     
547. {
     
548.   char result; // al@1
     
549.   PUNICODE_STRING v2; // ecx@2
     
550.   PWSTR v3; // edx@3
     
551. 
     
552.   result = 0;
     
553.   if ( a1 )
     
554.   {
     
555.     v2 = *a1;
     
556.     if ( *a1 )
     
557.     {
     
558.       v3 = v2->Buffer;
     
559.       if ( v3 )
     
560.       {
     
561.         if ( v2->Length )
     
562.         {
     
563.           if ( *v3 == '\\' )
     
564.             result = 1;
     
565.         }
     
566.       }
     
567.     }
     
568.   }
     
569.   return result;
     
570. }
     
571. 
     
572. char __stdcall InitShutdown(PDEVICE_OBJECT DeviceObject)
     
573. {
     
574.   char v1; // bl@1
     
575. 
     
576.   v1 = 0;
     
577.   if ( DeviceObject )
     
578.   {
     
579.     if ( IsRegisterShutdown == 1 )
     
580.       return 1;
     
581.     if ( !IoRegisterShutdownNotification(DeviceObject) )
     
582.     {
     
583.       IsRegisterShutdown = 1;
     
584.       return 1;
     
585.     }
     
586.   }
     
587.   return v1;
     
588. }
     
589. 
     
590. char InitServiceList()
     
591. {
     
592.   char v0; // bl@1
     
593.   PVOID v1; // eax@6
     
594.   PKEY_BASIC_INFORMATION keyinfo; // ebx@6
     
595.   NTSTATUS v3; // eax@7
     
596.   PVOID v4; // eax@11
     
597.   PVOID v5; // esi@11
     
598.   PVOID v6; // eax@12
     
599.   int v7; // eax@13
     
600.   NTSTATUS v8; // eax@15
     
601.   ULONG i; // [sp-14h] [bp-4Ch]@2
     
602.   KEY_INFORMATION_CLASS v11; // [sp-10h] [bp-48h]@2
     
603.   SIZE_T *v12; // [sp-Ch] [bp-44h]@2
     
604.   ULONG v13; // [sp-8h] [bp-40h]@2
     
605.   SIZE_T *v14; // [sp-4h] [bp-3Ch]@2
     
606.   OBJECT_ATTRIBUTES ObjectAttributes; // [sp+Ch] [bp-2Ch]@1
     
607.   UNICODE_STRING DestinationString; // [sp+24h] [bp-14h]@1
     
608.   ULONG Index; // [sp+2Ch] [bp-Ch]@1
     
609.   HANDLE KeyHandle; // [sp+30h] [bp-8h]@1
     
610.   SIZE_T NumberOfBytes; // [sp+34h] [bp-4h]@2
     
611. 
     
612.   DestinationString.Length = 0;
     
613.   *(_DWORD *)&DestinationString.MaximumLength = 0;
     
614.   HIWORD(DestinationString.Buffer) = 0;
     
615.   v0 = 0;
     
616.   KeyHandle = 0;
     
617.   Index = 0;
     
618.   ClearList();
     
619.   RtlInitUnicodeString(&DestinationString, L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\services");
     
620.   ObjectAttributes.ObjectName = &DestinationString;
     
621.   ObjectAttributes.Length = 24;
     
622.   ObjectAttributes.RootDirectory = 0;
     
623.   ObjectAttributes.Attributes = 576;
     
624.   ObjectAttributes.SecurityDescriptor = 0;
     
625.   ObjectAttributes.SecurityQualityOfService = 0;
     
626.   ZwOpenKey(&KeyHandle, 0x20019u, &ObjectAttributes);
     
627.   if ( KeyHandle )
     
628.   {
     
629.     v14 = &NumberOfBytes;
     
630.     v13 = 0;
     
631.     v12 = &NumberOfBytes;
     
632.     v11 = 0;
     
633.     for ( i = 0; ; i = Index )
     
634.     {
     
635.       NumberOfBytes = 0;
     
636.       v8 = ZwEnumerateKey(KeyHandle, i, v11, v12, v13, v14);
     
637.       if ( v8 == -2147483622 || v8 != -2147483643 && v8 != -1073741789 )
     
638.         break;
     
639.       if ( !NumberOfBytes )
     
640.         break;
     
641.       v1 = ExAllocatePoolWithTag(0, NumberOfBytes, 'TARK');
     
642.       keyinfo = (PKEY_BASIC_INFORMATION)v1;
     
643.       if ( !v1 )
     
644.         break;
     
645.       memset(v1, 0, NumberOfBytes);
     
646.       v3 = ZwEnumerateKey(KeyHandle, Index, 0, keyinfo, NumberOfBytes, &NumberOfBytes);
     
647.       if ( v3 == -2147483622 || v3 < 0 )
     
648.       {
     
649.         ExFreePoolWithTag(keyinfo, 'TARK');
     
650.         break;
     
651.       }
     
652.       ++Index;
     
653.       if ( keyinfo->NameLength < 520 )
     
654.       {
     
655.         v4 = ExAllocatePoolWithTag(0, 0xCu, 'TARK');
     
656.         v5 = v4;
     
657.         if ( !v4 )
     
658.         {
     
659.           ExFreePoolWithTag(keyinfo, 'TARK');
     
660.           break;
     
661.         }
     
662.         *(_DWORD *)v4 = 0;
     
663.         *((_DWORD *)v4 + 1) = 0;
     
664.         *((_DWORD *)v4 + 2) = 0;
     
665.         v6 = ExAllocatePoolWithTag(0, keyinfo->NameLength + 2, 'TARK');
     
666.         *((_DWORD *)v5 + 2) = v6;
     
667.         if ( !v6 )
     
668.         {
     
669.           ExFreePoolWithTag(keyinfo, 'TARK');
     
670.           ExFreePoolWithTag(v5, 'TARK');
     
671.           break;
     
672.         }
     
673.         memset(v6, 0, keyinfo->NameLength + 2);
     
674.         memcpy(*((void **)v5 + 2), keyinfo->Name, keyinfo->NameLength);
     
675.         KeWaitForSingleObject(&ServiceNameListLock, 0, 0, 0, 0);
     
676.         v7 = (int)*(&ServiceList + 1);
     
677.         *(_DWORD *)v5 = &ServiceList;
     
678.         *((_DWORD *)v5 + 1) = v7;
     
679.         *(_DWORD *)v7 = v5;
     
680.         *(&ServiceList + 1) = v5;
     
681.         KeSetEvent(&ServiceNameListLock, 1, 0);
     
682.         ExFreePoolWithTag(keyinfo, 'TARK');
     
683.       }
     
684.       else
     
685.       {
     
686.         ExFreePoolWithTag(keyinfo, 'TARK');
     
687.       }
     
688.       v14 = &NumberOfBytes;
     
689.       v13 = 0;
     
690.       v12 = &NumberOfBytes;
     
691.       v11 = 0;
     
692.     }
     
693.     v0 = 1;
     
694.     if ( KeyHandle )
     
695.       ZwClose(KeyHandle);
     
696.   }
     
697.   return v0;
     
698. }
     
699. 
     
700. char __stdcall InitReg(int a1, int a2)
     
701. {
     
702.   int Data; // [sp+Ch] [bp-4h]@1
     
703. 
     
704.   Data = 0;
     
705.   ResetDenyServices();
     
706.   SetDeleteFiles();
     
707.   SetDemandServices();
     
708.   if ( !DelRegKey(L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\services\\AntiRK", L"DenyServices") )
     
709.     SetRegVal(L"AntiRK", L"DenyServices", &Data, 0, 3u);
     
710.   if ( !DelRegKey(L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\services\\AntiRK", L"DenyFiles") )
     
711.     SetRegVal(L"AntiRK", L"DenyFiles", &Data, 0, 3u);
     
712.   if ( !DelRegKey(L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\services\\AntiRK", L"DemandServices") )
     
713.     SetRegVal(L"AntiRK", L"DemandServices", &Data, 0, 3u);
     
714.   return 1;
     
715. }
     
716. 
     
717. char InitPowerCallback()
     
718. {
     
719.   OBJECT_ATTRIBUTES ObjectAttributes; // [sp+8h] [bp-20h]@1
     
720.   UNICODE_STRING DestinationString; // [sp+20h] [bp-8h]@1
     
721. 
     
722.   ObjectAttributes.Length = 0;
     
723.   ObjectAttributes.RootDirectory = 0;
     
724.   ObjectAttributes.ObjectName = 0;
     
725.   ObjectAttributes.Attributes = 0;
     
726.   ObjectAttributes.SecurityDescriptor = 0;
     
727.   ObjectAttributes.SecurityQualityOfService = 0;
     
728.   DestinationString.Length = 0;
     
729.   *(_DWORD *)&DestinationString.MaximumLength = 0;
     
730.   HIWORD(DestinationString.Buffer) = 0;
     
731.   if ( IsPowerCallbackInit != 1 )
     
732.   {
     
733.     if ( !KeGetCurrentIrql()
     
734.       && (RtlInitUnicodeString(&DestinationString, L"\\Callback\\PowerState"),
     
735.           ObjectAttributes.ObjectName = &DestinationString,
     
736.           ObjectAttributes.Length = 24,
     
737.           ObjectAttributes.RootDirectory = 0,
     
738.           ObjectAttributes.Attributes = 576,
     
739.           ObjectAttributes.SecurityDescriptor = 0,
     
740.           ObjectAttributes.SecurityQualityOfService = 0,
     
741.           ExCreateCallback(&CallbackObject, &ObjectAttributes, 0, 1u),
     
742.           CallbackObject)
     
743.       && (CallbackRegistration = ExRegisterCallback(CallbackObject, PowerCallbackFunction, 0)) != 0 )
     
744.       IsPowerCallbackInit = 1;
     
745.     else
     
746.       UnInitPowerCallback();
     
747.   }
     
748.   return 1;
     
749. }
     
750. 
     
751. char __stdcall InitInitialRoutine(PDRIVER_OBJECT DriverObject)
     
752. {
     
753.   char result; // al@1
     
754. 
     
755.   result = 0;
     
756.   if ( DriverObject )
     
757.   {
     
758.     IoRegisterBootDriverReinitialization(DriverObject, DriverReinitializationRoutine, 0);
     
759.     result = 1;
     
760.   }
     
761.   return result;
     
762. }
     
763. 
     
764. char __stdcall InitCmFuncs(FARPROC Function, PVOID Context)
     
765. {
     
766.   char v2; // bl@1
     
767. 
     
768.   v2 = 0;
     
769.   if ( Function )
     
770.   {
     
771.     if ( IsCmFuncInit == 1 )
     
772.       return 1;
     
773.     if ( CmRegisterCallback
     
774.       || (CmRegisterCallback = (int (__stdcall *)(_DWORD, _DWORD, _DWORD))GetNtProcAddress(L"CmRegisterCallback")) != 0 )
     
775.     {
     
776.       if ( CmUnRegisterCallback
     
777.         || (CmUnRegisterCallback = (int (__stdcall *)(_DWORD, _DWORD))GetNtProcAddress(L"CmUnRegisterCallback")) != 0 )
     
778.       {
     
779.         if ( KeGetCurrentIrql() <= 1u && CmRegisterCallback(Function, Context, &Cookie) >= 0 )
     
780.         {
     
781.           IsCmFuncInit = 1;
     
782.           return 1;
     
783.         }
     
784.       }
     
785.     }
     
786.   }
     
787.   return v2;
     
788. }
     
789. 
     
790. int __stdcall Init(PDRIVER_OBJECT DriverObject, PDEVICE_OBJECT DeviceObject, PUNICODE_STRING RegistryPath)
     
791. {
     
792.   char v3; // bl@1
     
793.   int result; // eax@2
     
794. 
     
795.   *(&ServiceList + 1) = &ServiceList;
     
796.   ServiceList = &ServiceList;
     
797.   KeInitializeEvent(&ServiceNameListLock, SynchronizationEvent, 1u);
     
798.   GetRegServicePath();
     
799.   v3 = InitInitialRoutine(DriverObject);
     
800.   if ( v3 && (v3 = InitShutdown(DeviceObject)) != 0 )
     
801.     v3 = 1;
     
802.   else
     
803.     UnInit(DeviceObject);
     
804.   LOBYTE(result) = v3;
     
805.   return result;
     
806. }
     
807. 
     
808. signed int GetSectionObjectAddress()
     
809. {
     
810.   signed int v0; // ebx@1
     
811.   PVOID v1; // eax@3
     
812.   PVOID v2; // esi@3
     
813.   unsigned int v3; // esi@7
     
814. 
     
815.   v0 = 0;
     
816.   if ( SectionObjectOffset )
     
817.   {
     
818.     v0 = 1;
     
819.   }
     
820.   else
     
821.   {
     
822.     v1 = MmGetSystemRoutineAddress(&stru_14754);
     
823.     v2 = v1;
     
824.     if ( v1 )
     
825.     {
     
826.       if ( MmIsAddressValid(v1) )
     
827.       {
     
828.         if ( MmIsAddressValid((char *)v2 + 14) )
     
829.         {
     
830.           if ( RtlCompareMemory(&loc_14748, v2, 0xAu) == 10 )
     
831.           {
     
832.             v3 = *(_DWORD *)((char *)v2 + 10);
     
833.             if ( v3 >= 0x114 )
     
834.             {
     
835.               SectionObjectOffset = v3 - 4;
     
836.               v0 = 1;
     
837.             }
     
838.           }
     
839.         }
     
840.       }
     
841.     }
     
842.   }
     
843.   return v0;
     
844. }
     
845. 
     
846. NTSTATUS __stdcall sub_121E5(PCWSTR a1, PCWSTR SourceString, void *a3, int a4)
     
847. {
     
848.   PVOID v4; // edi@1
     
849.   ULONG v5; // eax@3
     
850.   OBJECT_ATTRIBUTES ObjectAttributes; // [sp+Ch] [bp-30h]@1
     
851.   UNICODE_STRING v8; // [sp+24h] [bp-18h]@1
     
852.   UNICODE_STRING DestinationString; // [sp+2Ch] [bp-10h]@1
     
853.   ULONG ResultLength; // [sp+34h] [bp-8h]@1
     
854.   HANDLE KeyHandle; // [sp+38h] [bp-4h]@1
     
855.   NTSTATUS SourceStringa; // [sp+48h] [bp+Ch]@1
     
856. 
     
857.   KeyHandle = 0;
     
858.   v4 = 0;
     
859.   ResultLength = 0;
     
860.   RtlInitUnicodeString(&DestinationString, SourceString);
     
861.   RtlInitUnicodeString(&v8, a1);
     
862.   ObjectAttributes.ObjectName = &v8;
     
863.   ObjectAttributes.Length = 24;
     
864.   ObjectAttributes.RootDirectory = 0;
     
865.   ObjectAttributes.Attributes = 576;
     
866.   ObjectAttributes.SecurityDescriptor = 0;
     
867.   ObjectAttributes.SecurityQualityOfService = 0;
     
868.   SourceStringa = ZwOpenKey(&KeyHandle, 0x20019u, &ObjectAttributes);
     
869.   if ( SourceStringa >= 0 )
     
870.   {
     
871.     SourceStringa = ZwQueryValueKey(KeyHandle, &DestinationString, KeyValuePartialInformation, 0, 0, &ResultLength);
     
872.     if ( SourceStringa == -1073741789 )
     
873.     {
     
874.       v5 = ResultLength;
     
875.       if ( !a3 || *(_DWORD *)a4 < ResultLength )
     
876.         goto LABEL_8;
     
877.       v4 = ExAllocatePoolWithTag(0, ResultLength, 0x214B4954u);
     
878.       if ( v4 )
     
879.       {
     
880.         SourceStringa = ZwQueryValueKey(
     
881.                           KeyHandle,
     
882.                           &DestinationString,
     
883.                           KeyValuePartialInformation,
     
884.                           v4,
     
885.                           ResultLength,
     
886.                           &ResultLength);
     
887.         if ( SourceStringa >= 0 )
     
888.         {
     
889.           memcpy(a3, (char *)v4 + 12, *((_DWORD *)v4 + 2));
     
890.           v5 = *((_DWORD *)v4 + 2);
     
891. LABEL_8:
     
892.           *(_DWORD *)a4 = v5;
     
893.           goto LABEL_9;
     
894.         }
     
895.       }
     
896.     }
     
897.   }
     
898. LABEL_9:
     
899.   if ( KeyHandle )
     
900.   {
     
901.     ZwClose(KeyHandle);
     
902.     KeyHandle = 0;
     
903.   }
     
904.   if ( v4 )
     
905.     ExFreePoolWithTag(v4, 0);
     
906.   return SourceStringa;
     
907. }
     
908. 
     
909. char GetRegServicePath()
     
910. {
     
911.   OBJECT_ATTRIBUTES ObjectAttributes; // [sp+Ch] [bp-240h]@1
     
912.   UNICODE_STRING ValueName; // [sp+24h] [bp-228h]@1
     
913.   ULONG ResultLength; // [sp+2Ch] [bp-220h]@1
     
914.   UNICODE_STRING DestinationString; // [sp+30h] [bp-21Ch]@1
     
915.   HANDLE KeyHandle; // [sp+38h] [bp-214h]@1
     
916.   char v6; // [sp+3Fh] [bp-20Dh]@1
     
917.   KEY_VALUE_PARTIAL_INFORMATION KeyValueInformation; // [sp+40h] [bp-20Ch]@1
     
918. 
     
919.   DestinationString.Length = 0;
     
920.   *(_DWORD *)&DestinationString.MaximumLength = 0;
     
921.   HIWORD(DestinationString.Buffer) = 0;
     
922.   ValueName.Length = 0;
     
923.   *(_DWORD *)&ValueName.MaximumLength = 0;
     
924.   HIWORD(ValueName.Buffer) = 0;
     
925.   LOWORD(KeyValueInformation.TitleIndex) = 0;
     
926.   v6 = 0;
     
927.   KeyHandle = 0;
     
928.   memset((char *)&KeyValueInformation.TitleIndex + 2, 0, 518u);
     
929.   ResultLength = 0;
     
930.   RtlInitUnicodeString(&DestinationString, L"\\Registry\\Machine\\SYSTEM\\Select");
     
931.   ObjectAttributes.ObjectName = &DestinationString;
     
932.   ObjectAttributes.Length = 24;
     
933.   ObjectAttributes.RootDirectory = 0;
     
934.   ObjectAttributes.Attributes = 576;
     
935.   ObjectAttributes.SecurityDescriptor = 0;
     
936.   ObjectAttributes.SecurityQualityOfService = 0;
     
937.   ZwOpenKey(&KeyHandle, 0x20019u, &ObjectAttributes);
     
938.   if ( !KeyHandle )
     
939.     goto LABEL_12;
     
940.   RtlInitUnicodeString(&ValueName, L"Current");
     
941.   if ( ZwQueryValueKey(KeyHandle, &ValueName, KeyValuePartialInformation, &KeyValueInformation, 520u, &ResultLength) >= 0
     
942.     && KeyValueInformation.DataLength == 4 )
     
943.   {
     
944.     wsprintfW(
     
945.       (wchar_t *)RegServicePath,
     
946.       259,
     
947.       L"\\Registry\\Machine\\SYSTEM\\ControlSet%03u\\services",
     
948.       *(_DWORD *)&KeyValueInformation.Data[0]);
     
949.     RtlInitUnicodeString(&URegServicePath, RegServicePath);
     
950.     v6 = 1;
     
951.   }
     
952.   if ( KeyHandle )
     
953.   {
     
954.     ZwClose(KeyHandle);
     
955.     KeyHandle = 0;
     
956.   }
     
957.   if ( !v6 )
     
958. LABEL_12:
     
959.     RtlInitUnicodeString(&URegServicePath, L"\\Registry\\Machine\\SYSTEM\\ControlSet001\\services");
     
960.   return v6;
     
961. }
     
962. 
     
963. char __stdcall sub_11B58(int a1, void *a2, int a3)
     
964. {
     
965.   int v3; // edi@6
     
966.   int v5; // [sp+Ch] [bp-214h]@1
     
967.   char v6; // [sp+13h] [bp-20Dh]@1
     
968.   unsigned __int16 v7; // [sp+14h] [bp-20Ch]@1
     
969.   void *v8; // [sp+18h] [bp-208h]@5
     
970. 
     
971.   v6 = 0;
     
972.   LOBYTE(v7) = 0;
     
973.   memset((char *)&v7 + 1, 0, 0x207u);
     
974.   v5 = 0;
     
975.   if ( a1 )
     
976.   {
     
977.     if ( a2 )
     
978.     {
     
979.       if ( a3 )
     
980.       {
     
981.         memset(a2, 0, *(_DWORD *)a3);
     
982.         if ( ObQueryNameString(a1, &v7, 520, &v5) >= 0 )
     
983.         {
     
984.           if ( v8 )
     
985.           {
     
986.             v3 = v7;
     
987.             if ( (unsigned int)v7 < *(_DWORD *)a3 )
     
988.             {
     
989.               memcpy(a2, v8, v7);
     
990.               *(_DWORD *)a3 = v3;
     
991.               v6 = 1;
     
992.             }
     
993.           }
     
994.         }
     
995.       }
     
996.     }
     
997.   }
     
998.   return v6;
     
999. }
     
1000. 
      
1001. PVOID __stdcall GetNtProcAddress(PCWSTR SourceString)
      
1002. {
      
1003.   PVOID v1; // ecx@1
      
1004.   UNICODE_STRING DestinationString; // [sp+4h] [bp-8h]@1
      
1005. 
      
1006.   DestinationString.Length = 0;
      
1007.   *(_DWORD *)&DestinationString.MaximumLength = 0;
      
1008.   v1 = 0;
      
1009.   HIWORD(DestinationString.Buffer) = 0;
      
1010.   if ( SourceString )
      
1011.   {
      
1012.     RtlInitUnicodeString(&DestinationString, SourceString);
      
1013.     v1 = MmGetSystemRoutineAddress(&DestinationString);
      
1014.   }
      
1015.   return v1;
      
1016. }
      
1017. 
      
1018. int __stdcall GetFileObjectFromProcess(PEPROCESS Process, PVOID *pFilePointer)
      
1019. {
      
1020.   int v2; // ebx@1
      
1021.   int v3; // eax@3
      
1022.   int v4; // eax@9
      
1023.   int v5; // eax@10
      
1024.   void *v6; // esi@10
      
1025. 
      
1026.   v2 = 0xC0000001;
      
1027.   if ( pFilePointer )
      
1028.   {
      
1029.     if ( MajorVersion <= 5 )
      
1030.     {
      
1031.       if ( (MinorVersion == 1 || MinorVersion == 2) && GetSectionObjectAddress() == 1 )
      
1032.       {
      
1033.         v4 = *(_DWORD *)((char *)Process + SectionObjectOffset);
      
1034.         if ( v4 )
      
1035.         {
      
1036.           v5 = **(_DWORD **)(v4 + 20);
      
1037.           v6 = *(void **)(v5 + 36);
      
1038.           if ( v6 )
      
1039.           {
      
1040.             ObfReferenceObject(*(PVOID *)(v5 + 36));
      
1041.             *pFilePointer = v6;
      
1042.             v2 = 0;
      
1043.           }
      
1044.         }
      
1045.       }
      
1046.     }
      
1047.     else
      
1048.     {
      
1049.       v3 = PsReferenceProcessFilePointer;
      
1050.       if ( PsReferenceProcessFilePointer
      
1051.         || (v3 = (int)MmGetSystemRoutineAddress(&UPsReferenceProcessFilePointer),
      
1052.             (PsReferenceProcessFilePointer = v3) != 0) )
      
1053.         v2 = ((int (__stdcall *)(PEPROCESS, PVOID *))v3)(Process, pFilePointer);
      
1054.     }
      
1055.   }
      
1056.   return v2;
      
1057. }
      
1058. 
      
1059. POBJECT_NAME_INFORMATION __stdcall sub_13101(LPVOID Process)
      
1060. {
      
1061.   POBJECT_NAME_INFORMATION v1; // edi@1
      
1062.   struct _OBJECT_NAME_INFORMATION *v2; // eax@5
      
1063.   int v4; // [sp+8h] [bp-8h]@1
      
1064.   PVOID Object; // [sp+Ch] [bp-4h]@1
      
1065. 
      
1066.   v1 = 0;
      
1067.   v4 = 0;
      
1068.   Object = 0;
      
1069.   if ( MajorVersion != 5 || MinorVersion )
      
1070.   {
      
1071.     if ( GetFileObjectFromProcess((PEPROCESS)Process, &Object) >= 0 )
      
1072.     {
      
1073.       if ( !Object )
      
1074.         return v1;
      
1075.       v2 = (struct _OBJECT_NAME_INFORMATION *)ExAllocatePoolWithTag(0, 0x400u, '!TVE');
      
1076.       v1 = v2;
      
1077.       if ( v2 )
      
1078.       {
      
1079.         memset(v2, 0, 0x400u);
      
1080.         if ( ObQueryNameString(Object, v1, 1024, &v4) < 0 || !v1->Name.Buffer )
      
1081.         {
      
1082.           ExFreePoolWithTag(v1, 0);
      
1083.           v1 = 0;
      
1084.         }
      
1085.       }
      
1086.     }
      
1087.     if ( Object )
      
1088.       ObfDereferenceObject(Object);
      
1089.   }
      
1090.   return v1;
      
1091. }
      
1092. 
      
1093. void *__stdcall GetAntiRKRegVal(PCWSTR KeyPath, PCWSTR ValueName, PDWORD plen)
      
1094. {
      
1095.   PVOID v3; // eax@6
      
1096.   void *infobuf; // edi@6
      
1097.   OBJECT_ATTRIBUTES ObjectAttributes; // [sp+Ch] [bp-30h]@1
      
1098.   UNICODE_STRING DestinationString; // [sp+24h] [bp-18h]@1
      
1099.   UNICODE_STRING ValueNamea; // [sp+2Ch] [bp-10h]@1
      
1100.   HANDLE KeyHandle; // [sp+34h] [bp-8h]@1
      
1101.   SIZE_T infolen; // [sp+38h] [bp-4h]@1
      
1102. 
      
1103.   DestinationString.Length = 0;
      
1104.   *(_DWORD *)&DestinationString.MaximumLength = 0;
      
1105.   HIWORD(DestinationString.Buffer) = 0;
      
1106.   ValueNamea.Length = 0;
      
1107.   *(_DWORD *)&ValueNamea.MaximumLength = 0;
      
1108.   HIWORD(ValueNamea.Buffer) = 0;
      
1109.   ObjectAttributes.Length = 0;
      
1110.   ObjectAttributes.RootDirectory = 0;
      
1111.   ObjectAttributes.ObjectName = 0;
      
1112.   ObjectAttributes.Attributes = 0;
      
1113.   ObjectAttributes.SecurityDescriptor = 0;
      
1114.   KeyHandle = 0;
      
1115.   ObjectAttributes.SecurityQualityOfService = 0;
      
1116.   infolen = 0;
      
1117.   if ( !KeyPath )
      
1118.     goto LABEL_11;
      
1119.   if ( !ValueName )
      
1120.     goto LABEL_11;
      
1121.   RtlInitUnicodeString(&DestinationString, KeyPath);
      
1122.   ObjectAttributes.ObjectName = &DestinationString;
      
1123.   ObjectAttributes.Length = 24;
      
1124.   ObjectAttributes.RootDirectory = 0;
      
1125.   ObjectAttributes.Attributes = 576;
      
1126.   ObjectAttributes.SecurityDescriptor = 0;
      
1127.   ObjectAttributes.SecurityQualityOfService = 0;
      
1128.   ZwOpenKey(&KeyHandle, 1u, &ObjectAttributes);
      
1129.   if ( !KeyHandle )
      
1130.     goto LABEL_11;
      
1131.   RtlInitUnicodeString(&ValueNamea, ValueName);
      
1132.   if ( ZwQueryValueKey(KeyHandle, &ValueNamea, KeyValuePartialInformation, &infolen, 0, &infolen) != -1073741789 )
      
1133.     goto LABEL_11;
      
1134.   if ( !infolen )
      
1135.     goto LABEL_11;
      
1136.   v3 = ExAllocatePoolWithTag(0, infolen, 'TARK');
      
1137.   infobuf = v3;
      
1138.   if ( !v3 )
      
1139.     goto LABEL_11;
      
1140.   memset(v3, 0, infolen);
      
1141.   if ( ZwQueryValueKey(KeyHandle, &ValueNamea, KeyValuePartialInformation, infobuf, infolen, &infolen) < 0 )
      
1142.   {
      
1143.     freebuf(infobuf);
      
1144. LABEL_11:
      
1145.     infobuf = 0;
      
1146.     goto LABEL_12;
      
1147.   }
      
1148.   if ( plen )
      
1149.     *plen = infolen;
      
1150. LABEL_12:
      
1151.   if ( KeyHandle )
      
1152.     ZwClose(KeyHandle);
      
1153.   return infobuf;
      
1154. }
      
1155. 
      
1156. bool __stdcall sub_110EC(PCUNICODE_STRING tofind)
      
1157. {
      
1158.   PVOID v1; // esi@3
      
1159.   LSA_UNICODE_STRING DestinationString; // [sp+4h] [bp-10h]@6
      
1160.   PCWSTR SourceString; // [sp+Ch] [bp-8h]@2
      
1161.   bool v5; // [sp+12h] [bp-2h]@1
      
1162.   char v6; // [sp+13h] [bp-1h]@1
      
1163. 
      
1164.   v5 = 1;
      
1165.   v6 = 0;
      
1166.   if ( tofind )
      
1167.   {
      
1168.     SourceString = (PCWSTR)ExAllocatePoolWithTag(0, 0x410u, 0x5441524Bu);
      
1169.     if ( SourceString )
      
1170.     {
      
1171.       KeWaitForSingleObject(&ServiceNameListLock, 0, 0, 0, 0);
      
1172.       v1 = ServiceList;
      
1173.       if ( ServiceList && ServiceList != &ServiceList )
      
1174.       {
      
1175.         while ( 1 )
      
1176.         {
      
1177.           DestinationString.Length = 0;
      
1178.           *(_DWORD *)&DestinationString.MaximumLength = 0;
      
1179.           HIWORD(DestinationString.Buffer) = 0;
      
1180.           if ( *((_DWORD *)v1 + 2) )
      
1181.           {
      
1182.             memset((void *)SourceString, 0, 0x410u);
      
1183.             wsprintfW(
      
1184.               (wchar_t *)SourceString,
      
1185.               520,
      
1186.               L"%s\\%s",
      
1187.               L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\services",
      
1188.               *((_DWORD *)v1 + 2));
      
1189.             RtlInitUnicodeString(&DestinationString, SourceString);
      
1190.             if ( RtlEqualUnicodeString(&DestinationString, tofind, 1u) == 1 )
      
1191.               break;
      
1192.             memset((void *)SourceString, 0, 0x410u);
      
1193.             wsprintfW((wchar_t *)SourceString, 520, L"%s\\%s", RegServicePath, *((_DWORD *)v1 + 2));
      
1194.             RtlInitUnicodeString(&DestinationString, SourceString);
      
1195.             if ( RtlEqualUnicodeString(&DestinationString, tofind, 1u) == 1 )
      
1196.               break;
      
1197.           }
      
1198.           v1 = *(PVOID *)v1;
      
1199.           if ( v1 == &ServiceList )
      
1200.             goto LABEL_12;
      
1201.         }
      
1202.         v6 = 1;
      
1203. LABEL_12:
      
1204.         KeSetEvent(&ServiceNameListLock, 1, 0);
      
1205.         v5 = v6 == 1;
      
1206.       }
      
1207.       else
      
1208.       {
      
1209.         KeSetEvent(&ServiceNameListLock, 1, 0);
      
1210.       }
      
1211.       ExFreePoolWithTag((PVOID)SourceString, 0x5441524Bu);
      
1212.     }
      
1213.   }
      
1214.   return v5;
      
1215. }
      
1216. 
      
1217. int __stdcall sub_10AAC(PUNICODE_STRING ustr, WCHAR ch, DWORD strlen, unsigned int a4)
      
1218. {
      
1219.   int result; // eax@1
      
1220.   unsigned int v5; // edi@3
      
1221.   WCHAR *v6; // esi@6
      
1222.   DWORD v7; // ecx@6
      
1223. 
      
1224.   result = 0;
      
1225.   if ( ustr )
      
1226.   {
      
1227.     if ( ustr->Length )
      
1228.     {
      
1229.       v5 = (unsigned int)ustr->Length >> 1;
      
1230.       if ( strlen < v5 && a4 <= v5 && strlen < a4 )
      
1231.       {
      
1232.         v6 = &ustr->Buffer[strlen];
      
1233.         v7 = a4 - strlen;
      
1234.         do
      
1235.         {
      
1236.           if ( *v6 == ch )
      
1237.             ++result;
      
1238.           ++v6;
      
1239.           --v7;
      
1240.         }
      
1241.         while ( v7 );
      
1242.       }
      
1243.     }
      
1244.   }
      
1245.   return result;
      
1246. }
      
1247. 
      
1248. PDEVICE_OBJECT __stdcall CreateDeviceAndSymbol(PDRIVER_OBJECT DriverObject, PCWSTR SourceString, PCWSTR a3)
      
1249. {
      
1250.   UNICODE_STRING SymbolicLinkName; // [sp+8h] [bp-14h]@1
      
1251.   UNICODE_STRING DestinationString; // [sp+10h] [bp-Ch]@1
      
1252.   PDEVICE_OBJECT DeviceObject; // [sp+18h] [bp-4h]@1
      
1253. 
      
1254.   DestinationString.Length = 0;
      
1255.   *(_DWORD *)&DestinationString.MaximumLength = 0;
      
1256.   HIWORD(DestinationString.Buffer) = 0;
      
1257.   SymbolicLinkName.Length = 0;
      
1258.   *(_DWORD *)&SymbolicLinkName.MaximumLength = 0;
      
1259.   DeviceObject = 0;
      
1260.   HIWORD(SymbolicLinkName.Buffer) = 0;
      
1261.   if ( DriverObject )
      
1262.   {
      
1263.     if ( SourceString )
      
1264.     {
      
1265.       if ( a3 )
      
1266.       {
      
1267.         RtlInitUnicodeString(&DestinationString, SourceString);
      
1268.         RtlInitUnicodeString(&SymbolicLinkName, a3);
      
1269.         IoCreateDevice(DriverObject, 0, &DestinationString, 0x22u, 0x100u, 0, &DeviceObject);
      
1270.         if ( DeviceObject )
      
1271.         {
      
1272.           if ( IoCreateSymbolicLink(&SymbolicLinkName, &DestinationString) >= 0 )
      
1273.           {
      
1274.             if ( DeviceObject )
      
1275.               return DeviceObject;
      
1276.             IoDeleteSymbolicLink(&SymbolicLinkName);
      
1277.           }
      
1278.           if ( DeviceObject )
      
1279.           {
      
1280.             IoDeleteDevice(DeviceObject);
      
1281.             DeviceObject = 0;
      
1282.           }
      
1283.         }
      
1284.       }
      
1285.     }
      
1286.   }
      
1287.   return DeviceObject;
      
1288. }
      
1289. 
      
1290. int __stdcall CreateCloseDispatch(int a1, PIRP Irp)
      
1291. {
      
1292.   PIO_STACK_LOCATION v2; // eax@1
      
1293.   int v3; // esi@1
      
1294.   PEPROCESS Process; // eax@4
      
1295. 
      
1296.   v2 = (PIO_STACK_LOCATION)Irp->Tail.Overlay.CurrentStackLocation;
      
1297.   v3 = -1073741823;
      
1298.   if ( v2 )
      
1299.   {
      
1300.     if ( v2->MajorFunction )
      
1301.     {
      
1302.       v3 = 0;
      
1303.     }
      
1304.     else
      
1305.     {
      
1306.       KeWaitForSingleObject(&CreateDispatchLock, 0, 0, 0, 0);
      
1307.       Process = IoGetCurrentProcess();
      
1308.       v3 = CheckPrcoessValid((LPVOID)Process, 1) != 0 ? 0 : STATUS_ACCESS_DENIED;
      
1309.       KeSetEvent(&CreateDispatchLock, 1, 0);
      
1310.     }
      
1311.   }
      
1312.   CompleteRequest(Irp, v3, 0);
      
1313.   return v3;
      
1314. }
      
1315. 
      
1316. int __stdcall CompleteRequest(PIRP Irp, int a2, int a3)
      
1317. {
      
1318.   int result; // eax@2
      
1319. 
      
1320.   if ( Irp )
      
1321.   {
      
1322.     Irp->IoStatus.Status = a2;
      
1323.     Irp->IoStatus.Information = a3;
      
1324.     IofCompleteRequest(Irp, 0);
      
1325.     result = 0;
      
1326.   }
      
1327.   else
      
1328.   {
      
1329.     result = -1073741823;
      
1330.   }
      
1331.   return result;
      
1332. }
      
1333. 
      
1334. void __stdcall CmCallBackFunc(int a1, int notifytype, _REG_CREATE_KEY_INFORMATION *notifydata)
      
1335. {
      
1336.   PUNICODE_STRING v3; // eax@8
      
1337.   unsigned int v4; // ecx@11
      
1338.   PUNICODE_STRING v5; // esi@12
      
1339.   const void *v6; // ecx@13
      
1340.   bool v7; // al@18
      
1341.   bool v8; // zf@19
      
1342.   LSA_UNICODE_STRING DestinationString; // [sp+10h] [bp-43Ch]@5
      
1343.   int v10; // [sp+18h] [bp-434h]@5
      
1344.   int v11; // [sp+1Ch] [bp-430h]@1
      
1345.   WCHAR SourceString; // [sp+20h] [bp-42Ch]@5
      
1346.   char v13; // [sp+22h] [bp-42Ah]@5
      
1347.   CPPEH_RECORD ms_exc; // [sp+434h] [bp-18h]@1
      
1348. 
      
1349.   _SEH_prolog4_GS(stru_14688, 1068);
      
1350.   v11 = 0;
      
1351.   JUMPOUT(notifydata, 0, &unk_1161F);
      
1352.   JUMPOUT(dword_14814, 0, &unk_1161F);
      
1353.   ms_exc.registration.TryLevel = 0;
      
1354.   if ( notifytype != 1 )
      
1355.   {
      
1356.     if ( notifytype == 4 )                      // RegNtRenameKey
      
1357.     {
      
1358.       v8 = CheckRegKeyValid(notifydata->CompleteName, 0) == 0;
      
1359. LABEL_23:
      
1360.       if ( !v8 )
      
1361.         v11 = -1073741790;
      
1362.       goto LABEL_25;
      
1363.     }
      
1364.     if ( notifytype == 10 )                     // RegNtPreCreateKey
      
1365.     {
      
1366.       if ( !IsDirCorrect(notifydata->CompleteName) )
      
1367.         goto LABEL_25;
      
1368.       v7 = FindService(notifydata->CompleteName);
      
1369.       goto LABEL_19;
      
1370.     }
      
1371.     if ( notifytype != 26 )
      
1372.       goto LABEL_25;
      
1373.     DestinationString.Length = 0;               // RegNtPreCreateKeyEx
      
1374.     *(_DWORD *)&DestinationString.MaximumLength = 0;
      
1375.     HIWORD(DestinationString.Buffer) = 0;
      
1376.     SourceString = 0;
      
1377.     memset(&v13, 0, 0x40Eu);
      
1378.     v10 = 1040;
      
1379.     if ( IsAbsolutePath(&notifydata->CompleteName) )
      
1380.     {
      
1381.       v5 = notifydata->CompleteName;
      
1382.       if ( notifydata->CompleteName )
      
1383.       {
      
1384.         v6 = v5->Buffer;
      
1385.         if ( v6 )
      
1386.         {
      
1387.           if ( (unsigned int)v5->Length >= 0x410 )
      
1388.             goto LABEL_25;
      
1389.           memcpy(&SourceString, v6, v5->Length);
      
1390.         }
      
1391.       }
      
1392.     }
      
1393.     else
      
1394.     {
      
1395.       GetObjectName((int)notifydata->RootObject, &SourceString, (int)&v10);
      
1396.       if ( !SourceString || (unsigned int)v10 >= 0x410 )
      
1397.         goto LABEL_25;
      
1398.       v3 = notifydata->CompleteName;
      
1399.       if ( notifydata->CompleteName && v3->Buffer )
      
1400.       {
      
1401.         if ( (unsigned int)v3->Length + v10 + 4 >= 0x410 )
      
1402.           goto LABEL_25;
      
1403.         v4 = (unsigned int)v10 >> 1;
      
1404.         *(&SourceString + v4) = 92;
      
1405.         v10 = v4 + 1;
      
1406.         memcpy(&SourceString + v4 + 1, v3->Buffer, v3->Length);
      
1407.       }
      
1408.     }
      
1409.     if ( SourceString )
      
1410.     {
      
1411.       RtlInitUnicodeString(&DestinationString, &SourceString);
      
1412.       if ( IsDirCorrect(&DestinationString) )
      
1413.       {
      
1414.         v7 = FindService(&DestinationString);
      
1415. LABEL_19:
      
1416.         v8 = v7 == 1;
      
1417.         goto LABEL_23;
      
1418.       }
      
1419.     }
      
1420.   }
      
1421. LABEL_25:
      
1422.   ms_exc.registration.TryLevel = -2;
      
1423.   JUMPOUT(&unk_11621);
      
1424. }
      
1425. 
      
1426. char ClearList()
      
1427. {
      
1428.   struct _KEVENT *v0; // ebx@1
      
1429.   PVOID v1; // esi@1
      
1430.   int v2; // eax@4
      
1431.   void *v3; // eax@4
      
1432. 
      
1433.   v0 = &ServiceNameListLock;
      
1434.   KeWaitForSingleObject(&ServiceNameListLock, 0, 0, 0, 0);
      
1435.   v1 = ServiceList;
      
1436.   if ( ServiceList && *(&ServiceList + 1) )
      
1437.   {
      
1438.     if ( ServiceList != &ServiceList )
      
1439.     {
      
1440.       do
      
1441.       {
      
1442.         v2 = *(_DWORD *)v1;
      
1443.         ServiceList = (PVOID)v2;
      
1444.         *(_DWORD *)(v2 + 4) = &ServiceList;
      
1445.         v3 = (void *)*((_DWORD *)v1 + 2);
      
1446.         if ( v3 )
      
1447.         {
      
1448.           ExFreePoolWithTag(v3, 0x5441524Bu);
      
1449.           *((_DWORD *)v1 + 2) = 0;
      
1450.         }
      
1451.         ExFreePoolWithTag(v1, 0x5441524Bu);
      
1452.         v1 = ServiceList;
      
1453.       }
      
1454.       while ( ServiceList != &ServiceList );
      
1455.       v0 = &ServiceNameListLock;
      
1456.     }
      
1457.     KeSetEvent(v0, 1, 0);
      
1458.   }
      
1459.   else
      
1460.   {
      
1461.     KeSetEvent(&ServiceNameListLock, 1, 0);
      
1462.   }
      
1463.   return 1;
      
1464. }
      
1465. 
      
1466. char __stdcall sub_10FD8(HANDLE KeyObj, PCUNICODE_STRING KeyName)
      
1467. {
      
1468.   LSA_UNICODE_STRING DestinationString; // [sp+Ch] [bp-21Ch]@1
      
1469.   int v4; // [sp+14h] [bp-214h]@1
      
1470.   char v5; // [sp+1Bh] [bp-20Dh]@1
      
1471.   OBJECT_NAME_INFORMATION nameinfo; // [sp+1Ch] [bp-20Ch]@1
      
1472. 
      
1473.   v5 = 0;
      
1474.   LOBYTE(nameinfo.Name.Length) = 0;
      
1475.   memset((char *)&nameinfo.Name.Length + 1, 0, 519u);
      
1476.   v4 = 0;
      
1477.   DestinationString.Length = 0;
      
1478.   *(_DWORD *)&DestinationString.MaximumLength = 0;
      
1479.   HIWORD(DestinationString.Buffer) = 0;
      
1480.   if ( KeyObj )
      
1481.   {
      
1482.     if ( ObQueryNameString(KeyObj, &nameinfo, 520, &v4) >= 0 )
      
1483.     {
      
1484.       if ( IsDirCorrect(&nameinfo.Name) )
      
1485.       {
      
1486.         if ( !KeyName
      
1487.           || (RtlInitUnicodeString(&DestinationString, L"ImagePath"),
      
1488.               RtlEqualUnicodeString(KeyName, &DestinationString, 1u)) )
      
1489.           v5 = 1;
      
1490.       }
      
1491.     }
      
1492.   }
      
1493.   return v5;
      
1494. }
      
1495. 
      
1496. signed int __stdcall CheckPrcoessValid(LPVOID Process, int a2)
      
1497. {
      
1498.   BOOL v2; // ebx@1
      
1499.   PUNICODE_STRING v3; // eax@3
      
1500.   int v4; // edi@3
      
1501.   BOOL v5; // eax@6
      
1502.   unsigned int v6; // edi@7
      
1503.   unsigned int v7; // eax@9
      
1504.   signed int v9; // [sp+Ch] [bp-BCh]@1
      
1505.   int v10; // [sp+10h] [bp-B8h]@1
      
1506.   PVOID Process1; // [sp+14h] [bp-B4h]@1
      
1507.   unsigned int Buffer; // [sp+18h] [bp-B0h]@1
      
1508.   int v13; // [sp+1Ch] [bp-ACh]@1
      
1509.   int v14; // [sp+20h] [bp-A8h]@1
      
1510.   int Source2; // [sp+24h] [bp-A4h]@1
      
1511.   int v16; // [sp+28h] [bp-A0h]@1
      
1512.   int v17; // [sp+2Ch] [bp-9Ch]@1
      
1513.   int v18; // [sp+30h] [bp-98h]@1
      
1514.   int v19; // [sp+34h] [bp-94h]@1
      
1515.   int v20; // [sp+38h] [bp-90h]@12
      
1516.   char Source1; // [sp+B4h] [bp-14h]@1
      
1517.   int v22; // [sp+B5h] [bp-13h]@1
      
1518.   int v23; // [sp+B9h] [bp-Fh]@1
      
1519.   int v24; // [sp+BDh] [bp-Bh]@1
      
1520.   __int16 v25; // [sp+C1h] [bp-7h]@1
      
1521.   char v26; // [sp+C3h] [bp-5h]@1
      
1522. 
      
1523.   Process1 = Process;
      
1524.   v13 = 0;
      
1525.   v14 = 0;
      
1526.   Source2 = 0;
      
1527.   v16 = 0;
      
1528.   v17 = 0;
      
1529.   v18 = 0;
      
1530.   v2 = 0;
      
1531.   Source1 = 0;
      
1532.   v22 = 0;
      
1533.   v23 = 0;
      
1534.   v24 = 0;
      
1535.   v25 = 0;
      
1536.   v26 = 0;
      
1537.   v9 = 0;
      
1538.   Buffer = 0;
      
1539.   v10 = 0;
      
1540.   LOBYTE(v19) = 0;
      
1541.   memset((char *)&v19 + 1, 0, 0x7Fu);
      
1542.   if ( !MajorVersion )
      
1543.     PsGetVersion(&MajorVersion, &MinorVersion, &BuildNumber, 0);
      
1544.   v3 = (PUNICODE_STRING)GetFileNameFromProcess(Process1);
      
1545.   v4 = (int)v3;
      
1546.   Process1 = v3;
      
1547.   if ( v3 )
      
1548.   {
      
1549.     if ( !a2 || IsSameDir(v3) )
      
1550.     {
      
1551.       v5 = ReadFile(v4, (int)&Buffer);
      
1552.       v2 = v5;
      
1553.       if ( v5 )
      
1554.       {
      
1555.         v6 = Buffer;
      
1556.         if ( Buffer > 0x40 )
      
1557.         {
      
1558.           if ( CheckNtImageValid((PVOID)v5) )
      
1559.           {
      
1560.             v7 = *(_DWORD *)(v2 + 40);
      
1561.             if ( v7 )
      
1562.             {
      
1563.               if ( v7 <= v6 - 128 )
      
1564.               {
      
1565.                 v10 = 24;
      
1566.                 if ( md5_encrypt1(v2 + v7, 128, (int)&v19, (int)&v10) )
      
1567.                 {
      
1568.                   qmemcpy(&v13, &v19, 0x18u);
      
1569.                   if ( v20 )
      
1570.                   {
      
1571.                     if ( v20 <= Buffer && v19 + v20 <= Buffer )
      
1572.                     {
      
1573.                       md5_encrypt2((int)&Source1, v2 + v19, v20);
      
1574.                       if ( RtlCompareMemory(&Source1, &Source2, 0x10u) == 16 )
      
1575.                         v9 = 1;
      
1576.                     }
      
1577.                   }
      
1578.                 }
      
1579.               }
      
1580.             }
      
1581.           }
      
1582.         }
      
1583.       }
      
1584.     }
      
1585.     ExFreePoolWithTag(Process1, 0);
      
1586.     if ( v2 )
      
1587.       ExFreePoolWithTag((PVOID)v2, 0);
      
1588.   }
      
1589.   return v9;
      
1590. }
      
1591. 
      
1592. int __stdcall CheckNtImageValid(PVOID VirtualAddress)
      
1593. {
      
1594.   char *v1; // esi@5
      
1595.   signed int v3; // [sp+10h] [bp-1Ch]@1
      
1596. 
      
1597.   v3 = 0;
      
1598.   if ( VirtualAddress )
      
1599.   {
      
1600.     if ( MmIsAddressValid(VirtualAddress) )
      
1601.     {
      
1602.       if ( MmIsAddressValid((char *)VirtualAddress + 60) )
      
1603.       {
      
1604.         if ( *(_WORD *)VirtualAddress == 23117 )
      
1605.         {
      
1606.           v1 = (char *)VirtualAddress + *((_DWORD *)VirtualAddress + 15);
      
1607.           if ( v1 )
      
1608.           {
      
1609.             if ( MmIsAddressValid(v1) && *(_DWORD *)v1 == 17744 )
      
1610.               v3 = 1;
      
1611.           }
      
1612.         }
      
1613.       }
      
1614.     }
      
1615.   }
      
1616.   return v3;
      
1617. }
      
1618. 
      
1619. char __stdcall ResetRegInfo1(int Data, void *a2, size_t a3)
      
1620. {
      
1621.   size_t v3; // ebx@1
      
1622.   PVOID v4; // eax@5
      
1623.   void *v5; // edi@5
      
1624.   int v7; // [sp+8h] [bp-4h]@1
      
1625. 
      
1626.   v3 = a3 + 520;
      
1627.   v7 = 0;
      
1628.   if ( Data == 'DKs' || Data == 'DemK' )
      
1629.   {
      
1630.     if ( a2 )
      
1631.     {
      
1632.       if ( a3 )
      
1633.       {
      
1634.         Data = (Data == 'DKs') + 3;
      
1635.         v4 = ExAllocatePoolWithTag(0, a3 + 520, 0x5441524Bu);
      
1636.         v5 = v4;
      
1637.         if ( v4 )
      
1638.         {
      
1639.           memset(v4, 0, v3);
      
1640.           memcpy(v5, a2, a3);
      
1641.           SetRegVal((WCHAR *)v5, L"Start", &Data, 4u, 4u);
      
1642.           SetRegVal((WCHAR *)v5, L"ErrorControl", &v7, 4u, 4u);
      
1643.           ExFreePoolWithTag(v5, 0x5441524Bu);
      
1644.         }
      
1645.       }
      
1646.     }
      
1647.   }
      
1648.   return 1;
      
1649. }
      
1650. 
      
1651. char __stdcall regset8(PVOID P, void *a2, size_t a3)
      
1652. {
      
1653.   unsigned int v3; // ebx@1
      
1654.   PVOID v4; // eax@4
      
1655.   PVOID Pa; // [sp+10h] [bp+8h]@4
      
1656. 
      
1657.   v3 = a3 + 520;
      
1658.   if ( P == (PVOID)'DFs' )
      
1659.   {
      
1660.     if ( a2 )
      
1661.     {
      
1662.       if ( a3 )
      
1663.       {
      
1664.         v4 = ExAllocatePoolWithTag(0, a3 + 520, 'TARK');
      
1665.         Pa = v4;
      
1666.         if ( v4 )
      
1667.         {
      
1668.           memset(v4, 0, v3);
      
1669.           if ( a3 >= 8 && !memcmp(a2, L"\\??\", 8u) )
      
1670.             memcpy(Pa, a2, a3);
      
1671.           else
      
1672.             wsprintfW((wchar_t *)Pa, v3 >> 1, L"%s%s", L"\\??\", a2);
      
1673.           DoDeleteFile((PCWSTR)Pa);
      
1674.           ExFreePoolWithTag(Pa, 'TARK');
      
1675.         }
      
1676.       }
      
1677.     }
      
1678.   }
      
1679.   return 1;
      
1680. }
      
1681. 
      
1682. char __stdcall func(int a1, void *a2, size_t a3)
      
1683. {
      
1684.   PVOID v3; // edi@6
      
1685. 
      
1686.   if ( a2 && a3 && (a1 == 'DFs' || a1 == 'DKs' || a1 == 'DemK') )
      
1687.   {
      
1688.     v3 = ExAllocatePoolWithTag(0, a3 + 520, 0x5441524Bu);
      
1689.     if ( v3 )
      
1690.     {
      
1691.       memset(v3, 0, a3 + 520);
      
1692.       memcpy(v3, a2, a3);
      
1693.       switch ( a1 )
      
1694.       {
      
1695.         case 'DFs':
      
1696.           DbgPrint("[[AntiRK]][PrintDenyInfo] Deny Files Path = %ws\n", v3);
      
1697.           break;
      
1698.         case 'DKs':
      
1699.           DbgPrint("[[AntiRK]][PrintDenyInfo] Deny Keys Path = %ws\n", v3);
      
1700.           break;
      
1701.         case 'DemK':
      
1702.           DbgPrint("[[AntiRK]][PrintDenyInfo] Disable Keys Path = %ws\n", v3);
      
1703.           break;
      
1704.         default:
      
1705.           DbgPrint("[[AntiRK]][PrintDenyInfo] Type not Match,Unknow Error\n");
      
1706.           break;
      
1707.       }
      
1708.       ExFreePoolWithTag(v3, 0x5441524Bu);
      
1709.     }
      
1710.   }
      
1711.   return 1;
      
1712. }
      

复制代码