API tools faq
paste
Advertisement
Broihon

Shellcodes

Broihon
Feb 3rd, 2019
1,844
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ (WinAPI) 10.47 KB | None | 0 0
raw download clone embed print report
  1. /////////////////////////////////////////
  2. //PART 2:
  3. /////////////////////////////////////////
  4. //NTCREATETHREADEX X64:
  5. BYTE Shellcode[] =
  6.     {
  7.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     // - 0x10   -> argument / returned value
  8.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     // - 0x08   -> pRoutine
  9.  
  10.         0x48, 0x8B, 0xC1,                                   // + 0x00   -> mov rax, rcx
  11.         0x48, 0x8B, 0x08,                                   // + 0x03   -> mov rcx, [rax]
  12.  
  13.         0x48, 0x83, 0xEC, 0x28,                             // + 0x06   -> sub rsp, 0x28
  14.         0xFF, 0x50, 0x08,                                   // + 0x0A   -> call qword ptr [rax + 0x08]
  15.         0x48, 0x83, 0xC4, 0x28,                             // + 0x0D   -> add rsp, 0x28
  16.  
  17.         0x48, 0x8D, 0x0D, 0xD8, 0xFF, 0xFF, 0xFF,           // + 0x11   -> lea rcx, [pCodecave]
  18.         0x48, 0x89, 0x01,                                   // + 0x18   -> mov [rcx], rax
  19.         0x48, 0x31, 0xC0,                                   // + 0x1B   -> xor rax, rax
  20.  
  21.         0xC3                                                // + 0x1E   -> ret
  22.     }; // SIZE = 0x1F (+ 0x10)
  23.  
  24. /////////////////////////////////////////
  25. //PART 3:
  26. /////////////////////////////////////////
  27. //THREADHIJACKING X64:
  28. BYTE Shellcode[] =
  29.     {
  30.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,                         // - 0x08           -> returned value
  31.                
  32.         0x48, 0x83, 0xEC, 0x08,                                                 // + 0x00           -> sub rsp, 0x08
  33.  
  34.         0xC7, 0x04, 0x24, 0x00, 0x00, 0x00, 0x00,                               // + 0x04 (+ 0x07)  -> mov [rsp], RipLowPart
  35.         0xC7, 0x44, 0x24, 0x04, 0x00, 0x00, 0x00, 0x00,                         // + 0x0B (+ 0x0F)  -> mov [rsp + 0x04], RipHighPart
  36.  
  37.         0x50, 0x51, 0x52, 0x41, 0x50, 0x41, 0x51, 0x41, 0x52, 0x41, 0x53,       // + 0x13           -> push r(a/c/d)x / r(8 - 11)
  38.         0x9C,                                                                   // + 0x1E           -> pushfq
  39.  
  40.         0x48, 0xB8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,             // + 0x1F (+ 0x21)  -> mov rax, pRoutine
  41.         0x48, 0xB9, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,             // + 0x29 (+ 0x2B)  -> mov rcx, pArg
  42.  
  43.         0x48, 0x83, 0xEC, 0x20,                                                 // + 0x33           -> sub rsp, 0x20
  44.         0xFF, 0xD0,                                                             // + 0x37           -> call rax
  45.         0x48, 0x83, 0xC4, 0x20,                                                 // + 0x39           -> add rsp, 0x20
  46.  
  47.         0x48, 0x8D, 0x0D, 0xB4, 0xFF, 0xFF, 0xFF,                               // + 0x3D           -> lea rcx, [pCodecave]
  48.         0x48, 0x89, 0x01,                                                       // + 0x44           -> mov [rcx], rax
  49.  
  50.         0x9D,                                                                   // + 0x47           -> popfq
  51.         0x41, 0x5B, 0x41, 0x5A, 0x41, 0x59, 0x41, 0x58, 0x5A, 0x59, 0x58,       // + 0x48           -> pop r(11-8) / r(d/c/a)x
  52.        
  53.         0xC6, 0x05, 0xA9, 0xFF, 0xFF, 0xFF, 0x00,                               // + 0x53           -> mov byte ptr[$ - 0x57], 0
  54.  
  55.         0xC3                                                                    // + 0x5A           -> ret
  56.     }; // SIZE = 0x5B (+ 0x08)
  57.  
  58. /////////////////////////////////////////
  59. //THREADHIJACKING X86:
  60. BYTE Shellcode[] =
  61.     {
  62.         0x00, 0x00, 0x00, 0x00,                     // - 0x04 (pCodecave)   -> returned value                           ;buffer to store returned value (eax)
  63.  
  64.         0x83, 0xEC, 0x04,                           // + 0x00               -> sub esp, 0x04                            ;prepare stack for ret
  65.         0xC7, 0x04, 0x24, 0x00, 0x00, 0x00, 0x00,   // + 0x03 (+ 0x06)      -> mov [esp], OldEip                        ;store old eip as return address
  66.  
  67.         0x50, 0x51, 0x52,                           // + 0x0A               -> psuh e(a/c/d)                            ;save e(a/c/d)x
  68.         0x9C,                                       // + 0x0D               -> pushfd                                   ;save flags register
  69.  
  70.         0xB9, 0x00, 0x00, 0x00, 0x00,               // + 0x0E (+ 0x0F)      -> mov ecx, pArg                            ;load pArg into ecx
  71.         0xB8, 0x00, 0x00, 0x00, 0x00,               // + 0x13 (+ 0x14)      -> mov eax, pRoutine
  72.  
  73.         0x51,                                       // + 0x18               -> push ecx                                 ;push pArg
  74.         0xFF, 0xD0,                                 // + 0x19               -> call eax                                 ;call target function
  75.  
  76.         0xA3, 0x00, 0x00, 0x00, 0x00,               // + 0x1B (+ 0x1C)      -> mov dword ptr[pCodecave], eax            ;store returned value
  77.        
  78.         0x9D,                                       // + 0x20               -> popfd                                    ;restore flags register
  79.         0x5A, 0x59, 0x58,                           // + 0x21               -> pop e(d/c/a)                             ;restore e(d/c/a)x
  80.        
  81.         0xC6, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00,   // + 0x24 (+ 0x26)      -> mov byte ptr[pCodecave + 0x06], 0x00     ;set checkbyte to 0
  82.  
  83.         0xC3                                        // + 0x2B               -> ret                                      ;return to OldEip
  84.     }; // SIZE = 0x2C (+ 0x04)
  85.  
  86. /////////////////////////////////////////
  87. //PART 4:
  88. /////////////////////////////////////////
  89. //SETWINDOWSHOOKEX X64:
  90. BYTE Shellcode[] =
  91.     {
  92.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // - 0x18   -> pArg / returned value / rax  ;buffer
  93.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // - 0x10   -> pRoutine                     ;pointer to target function
  94.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // - 0x08   -> CallNextHookEx               ;pointer to CallNextHookEx
  95.  
  96.         0x55,                                           // + 0x00   -> push rbp                     ;save important registers
  97.         0x54,                                           // + 0x01   -> push rsp
  98.         0x53,                                           // + 0x02   -> push rbx
  99.  
  100.         0x48, 0x8D, 0x1D, 0xDE, 0xFF, 0xFF, 0xFF,       // + 0x03   -> lea rbx, [pArg]              ;load pointer into rbx
  101.  
  102.         0x48, 0x83, 0xEC, 0x20,                         // + 0x0A   -> sub rsp, 0x20                ;reserve stack
  103.         0x4D, 0x8B, 0xC8,                               // + 0x0E   -> mov r9,r8                    ;set up arguments for CallNextHookEx
  104.         0x4C, 0x8B, 0xC2,                               // + 0x11   -> mov r8, rdx
  105.         0x48, 0x8B, 0xD1,                               // + 0x14   -> mov rdx,rcx
  106.         0xFF, 0x53, 0x10,                               // + 0x17   -> call [rbx + 0x10]            ;call CallNextHookEx
  107.         0x48, 0x83, 0xC4, 0x20,                         // + 0x1A   -> add rsp, 0x20                ;update stack
  108.  
  109.         0x48, 0x8B, 0xC8,                               // + 0x1E   -> mov rcx, rax                 ;copy retval into rcx
  110.  
  111.         0xEB, 0x00,                                     // + 0x21   -> jmp $ + 0x02                 ;jmp to next instruction
  112.         0xC6, 0x05, 0xF8, 0xFF, 0xFF, 0xFF, 0x18,       // + 0x23   -> mov byte ptr[$ - 0x01], 0x1A ;hotpatch jmp above to skip shellcode
  113.  
  114.         0x48, 0x87, 0x0B,                               // + 0x2A   -> xchg [rbx], rcx              ;store CallNextHookEx retval, load pArg
  115.         0x48, 0x83, 0xEC, 0x20,                         // + 0x2D   -> sub rsp, 0x20                ;reserve stack
  116.         0xFF, 0x53, 0x08,                               // + 0x31   -> call [rbx + 0x08]            ;call pRoutine
  117.         0x48, 0x83, 0xC4, 0x20,                         // + 0x34   -> add rsp, 0x20                ;update stack
  118.  
  119.         0x48, 0x87, 0x03,                               // + 0x38   -> xchg [rbx], rax              ;store pRoutine retval, restore CallNextHookEx retval
  120.  
  121.         0x5B,                                           // + 0x3B   -> pop rbx                      ;restore important registers
  122.         0x5C,                                           // + 0x3C   -> pop rsp
  123.         0x5D,                                           // + 0x3D   -> pop rbp
  124.  
  125.         0xC3                                            // + 0x3E   -> ret                          ;return
  126.     }; // SIZE = 0x3F (+ 0x18)
  127.  
  128. /////////////////////////////////////////
  129. //SETWINDOWSHOOKEX X86:
  130. BYTE Shellcode[] =
  131.     {
  132.         0x00, 0x00, 0x00, 0x00,         // - 0x08               -> pArg                     ;pointer to argument
  133.         0x00, 0x00, 0x00, 0x00,         // - 0x04               -> pRoutine                 ;pointer to target function
  134.  
  135.         0x55,                           // + 0x00               -> push ebp                 ;x86 stack frame creation
  136.         0x8B, 0xEC,                     // + 0x01               -> mov ebp, esp
  137.  
  138.         0xFF, 0x75, 0x10,               // + 0x03               -> push [ebp + 0x10]        ;push CallNextHookEx arguments
  139.         0xFF, 0x75, 0x0C,               // + 0x06               -> push [ebp + 0x0C]
  140.         0xFF, 0x75, 0x08,               // + 0x09               -> push [ebp + 0x08]
  141.         0x6A, 0x00,                     // + 0x0C               -> push 0x00
  142.         0xE8, 0x00, 0x00, 0x00, 0x00,   // + 0x0E (+ 0x0F)      -> call CallNextHookEx      ;call CallNextHookEx
  143.  
  144.         0xEB, 0x00,                     // + 0x13               -> jmp $ + 0x02             ;jmp to next instruction
  145.  
  146.         0x50,                           // + 0x15               -> push eax                 ;save eax (CallNextHookEx retval)
  147.         0x53,                           // + 0x16               -> push ebx                 ;save ebx (non volatile)
  148.  
  149.         0xBB, 0x00, 0x00, 0x00, 0x00,   // + 0x17 (+ 0x18)      -> mov ebx, pArg            ;move pArg (pCodecave) into ebx
  150.         0xC6, 0x43, 0x1C, 0x14,         // + 0x1C               -> mov [ebx + 0x1C], 0x17   ;hotpatch jmp above to skip shellcode
  151.  
  152.         0xFF, 0x33,                     // + 0x20               -> push [ebx]               ;push pArg (__stdcall)
  153.  
  154.         0xFF, 0x53, 0x04,               // + 0x22               -> call [ebx + 0x04]        ;call target function
  155.  
  156.         0x89, 0x03,                     // + 0x25               -> mov [ebx], eax           ;store returned value
  157.  
  158.         0x5B,                           // + 0x27               -> pop ebx                  ;restore old ebx
  159.         0x58,                           // + 0x28               -> pop eax                  ;restore eax (CallNextHookEx retval)
  160.  
  161.         0x5D,                           // + 0x29               -> pop ebp                  ;restore ebp
  162.         0xC2, 0x0C, 0x00                // + 0x2A               -> ret 0x000C               ;return
  163.     }; // SIZE = 0x3D (+ 0x08)
  164.  
  165. /////////////////////////////////////////
  166. //PART 5:
  167. /////////////////////////////////////////
  168. //QUEUEUSERAPC X64:
  169. BYTE Shellcode[] =
  170.     {
  171.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     // - 0x18   -> returned value                           ;buffer to store returned value
  172.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     // - 0x10   -> pArg                                     ;buffer to store argument
  173.         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,     // - 0x08   -> pRoutine                                 ;pointer to the rouinte to call
  174.  
  175.         0xEB, 0x00,                                         // + 0x00   -> jmp $+0x02                               ;jump to the next instruction
  176.                
  177.         0x48, 0x8B, 0x41, 0x10,                             // + 0x02   -> mov rax, [rcx + 0x10]                    ;move pRoutine into rax
  178.         0x48, 0x8B, 0x49, 0x08,                             // + 0x06   -> mov rcx, [rcx + 0x08]                    ;move pArg into rcx
  179.  
  180.         0x48, 0x83, 0xEC, 0x28,                             // + 0x0A   -> sub rsp, 0x28                            ;reserve stack
  181.         0xFF, 0xD0,                                         // + 0x0E   -> call rax                                 ;call pRoutine
  182.         0x48, 0x83, 0xC4, 0x28,                             // + 0x10   -> add rsp, 0x28                            ;update stack
  183.  
  184.         0x48, 0x85, 0xC0,                                   // + 0x14   -> test rax, rax                            ;check if rax indicates success/failure
  185.         0x74, 0x11,                                         // + 0x17   -> je pCodecave + 0x2A                      ;jmp to ret if routine failed
  186.        
  187.         0x48, 0x8D, 0x0D, 0xC8, 0xFF, 0xFF, 0xFF,           // + 0x19   -> lea rcx, [pCodecave]                     ;load pointer to codecave into rcx
  188.         0x48, 0x89, 0x01,                                   // + 0x20   -> mov [rcx], rax                           ;store returned value
  189.  
  190.         0xC6, 0x05, 0xD7, 0xFF, 0xFF, 0xFF, 0x28,           // + 0x23   -> mov byte ptr[pCodecave + 0x18], 0x28     ;hot patch jump to skip shellcode
  191.        
  192.         0xC3                                                // + 0x2A   -> ret                                      ;return
  193.     }; // SIZE = 0x2B (+ 0x10)
  194.  
  195. /////////////////////////////////////////
  196. //QUEUEUSERAPC X86:
  197. BYTE Shellcode[] =
  198.     {
  199.         0x00, 0x00, 0x00, 0x00, // - 0x0C   -> returned value                   ;buffer to store returned value
  200.         0x00, 0x00, 0x00, 0x00, // - 0x08   -> pArg                             ;buffer to store argument
  201.         0x00, 0x00, 0x00, 0x00, // - 0x04   -> pRoutine                         ;pointer to the routine to call
  202.  
  203.         0x55,                   // + 0x00   -> push ebp                         ;x86 stack frame creation
  204.         0x8B, 0xEC,             // + 0x01   -> mov ebp, esp
  205.        
  206.         0xEB, 0x00,             // + 0x03   -> jmp pCodecave + 0x05 (+ 0x0C)    ;jump to next instruction
  207.        
  208.         0x53,                   // + 0x05   -> push ebx                         ;save ebx
  209.         0x8B, 0x5D, 0x08,       // + 0x06   -> mov ebx, [ebp + 0x08]            ;move pCodecave into ebx (non volatile)
  210.        
  211.         0xFF, 0x73, 0x04,       // + 0x09   -> push [ebx + 0x04]                ;push pArg on stack
  212.         0xFF, 0x53, 0x08,       // + 0x0C   -> call dword ptr[ebx + 0x08]       ;call pRoutine
  213.        
  214.         0x85, 0xC0,             // + 0x0F   -> test eax, eax                    ;check if eax indicates success/failure
  215.         0x74, 0x06,             // + 0x11   -> je pCodecave + 0x19 (+ 0x0C)     ;jmp to cleanup if routine failed
  216.        
  217.         0x89, 0x03,             // + 0x13   -> mov [ebx], eax                   ;store returned value
  218.         0xC6, 0x43, 0x10, 0x15, // + 0x15   -> mov byte ptr [ebx + 0x10], 0x15  ;hot patch jump to skip shellcode
  219.  
  220.         0x5B,                   // + 0x19   -> pop ebx                          ;restore old ebx
  221.  
  222.         0x5D,                   // + 0x1A   -> pop ebp                          ;restore ebp
  223.         0xC2, 0x04, 0x00        // + 0x1B   -> ret 0x0004                       ;return
  224.     }; // SIZE = 0x1E (+ 0x0C)
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!