CobaltStrike Manual Traduzido

Machine Translated by Google
www.cobaltstrike.com
Índice
Índice................................................. .................................................. .............................. 2
1.Bem-vindo ao CobaltStrike............................................. .................................................. ............. 6 1.1 O que é

CobaltStrike? .................................................. .................................................. ......................... 6 1.2Instalação e
Atualizações ........................ .................................................. ............................................. 7 Requisitos do
sistema .. .................................................. .................................................. .............................................7 Execute
a'atualização' programa................................................. .................................................. .........................................7 1.3O
Servidor da Equipe...... .................................................. .................................................. ......................... 8
1.4CobaltStrikeClient ................... .................................................. .................................................. ......... 9 1.5Operações
Distribuídas e em Equipe ..................................... ......................... .........................................10 1.6
ScriptingCobaltStrike ... .................................................. .................................................. ..................11
2.Interface do usuário ............................................. .................................................. ..............................12 2.1Visão

Geral............... .................................................. .................................................. ......................... 12 2.2 Barra de
ferramentas ............... .................................................. .................................................. ..............................12 2.3Visualizações
de Sessão e Destino ............ .................................................. ..............................13 Tabela de
Alvos ........... .................................................. .................................................. .................................................. 13 Tabela de
Sessões ............................................. .................................................. .................................................. ........... 14 Gráfico
Dinâmico .......................... .................................................. .................................................. ....................................... 14
2.4Abas........ .................................................. .................................................. ......................................... 16 2.5
Consolas .................................................... .................................................. .................................................. 16 2.6
Tabelas ................................................. .................................................. .................................................. ....17
3.Gerenciamento de Dados................................................. .................................................. ......................... 18

3.1 Visão geral ........................ .................................................. .................................................. .........................18
3.2 Metas ........................ .................................................. .................................................. .........................18
3.3Serviços ................... .................................................. .................................................. ..............................19
3.4Credenciais................. .................................................. .................................................. ..........................19
3.5Manutenção..................... .................................................. .................................................. ................... 19
4.Gestão de Ouvintes e Infraestrutura................................................ ..............................20

4.1 Visão geral .............................................. .................................................. .................................................. 20
4.2Gerenciamento de Ouvintes ............................................. .................................................. ........................20
4.3CobaltStrike'sBeaconCarga Útil..................... .................................................. .........................20 4.4Estágio de Carga
Útil ............ .................................................. .................................................. .........................21
4.5HTTPBeaconeHTTPSBeacon........................... .................................................. .........................21
ManualHTTPProxyConfiguration ........................ .................................................. ............................................. 23
Redirecionadores... .................................................. .................................................. .................................................. ..........
23 4.6DNSBBeacon.............................. .................................................. . .................................................. .......24 Canais de
Dados .................................................. .................................................. .................................................. ............... 24
Configuração do Ouvinte .............................. .................................................. .................................................. ..............................
25 4.7SMBBacon ................ .................................................. .................................................. .......................26
Vinculando e Desvinculando ........................................................ .................................................. .............................................
26 4.8TCPBeacon .. .................................................. .................................................. .......................................27 Conectando e
desvinculando ........ .................................................. .................................................. ......................... 28
4.9ExternaC2................... .................................................. .................................................. .......................28 4.10Ouvintes
Estrangeiros ........................ .................................................. .................................................. .....29
2
4.11Consolidação de Infraestrutura ................................................ .................................................. ........29

4.12Recursos de segurança de carga útil........................................ .................................................. .......................30
5. Obtendo um ponto de apoio ............................................. .................................................. .......................31 5.1Profiler

de sistema do lado do cliente................... .................................................. ..............................31
5.2CobaltStrikeWebServices..... .................................................. .................................................. ........31 5.3Pacotes
de Ataque Orientado pelo Usuário..................................... .................................................. .......................31 Aplicativo
HTML.............................. .................................................. .................................................. .............................. 32
MSOfficeMacro ........................ .................................................. .................................................. ......................... 32
Gerador de Carga ............ .................................................. ..... .................................................. ......................... 32
Windows Executável ............... .................................................. .................................................. ..............................
32 Executável(s) do Windows............... .................................................. .................................................. .........................
32 5.4Arquivos de Hospedagem....................... .................................................. .................................................. .........33
5.5Web Drive-byAttacks Orientada pelo Usuário.............................. .................................................. .......................33
JavaSignedAppletAttack.............................. .................................................. .................................................. ...........
33 JavaSmartAppletAttack ..................................... .................................................. .................... ..............................
33 ScriptedWebDelivery(S)........... .................................................. .................................................. .........................
33 5.6 Exploits do lado do cliente ....................... .................................................. .................................................. ....34
5.7CloneaSite................................................ .................................................. .................................................. 34
5.8SpearPhishing................................................ .................................................. .........................................35
Metas .......... .................................................. .................................................. .................................................. ..............
35 Modelos .................................... .................................................. .................................................. .........................
35 Enviando Mensagens ............ .................................................. .................................................. ....................................... 36
6.Artefatos de carga útil e evasão de antivírus............................................. .........................38

6.1Filosofia .............. .................................................. .................................................. ..................................38 6.2O Kit
de Artefatos.................. .................................................. .................................................. ..................38 ATeoria do Kit
de Artefatos.............................. .................................................. ............................................. 38
WhereArtifactKitFails .................................................. .................................................. ......................................... 39
Como usar o Kit de Artefatos....... .................................................. .................................................. .........................
39 6.3A Estrutura de Evasão do Véu................... .................................... .................................................. .....40
6.4Ataques JavaApplet ................................................ .................................................. ....................40
6.5OResourceKit.................. .................................................. .................................................. .............. 41
7.Pós-Exploração ............................................. .................................................. .......................... 42

7.1Console Beacon................................................ .................................................. .........................42 7.2Menu do
Sinalizador ................... .................................................. .................................................. ...........42 7.3Operações
Assíncronas e Interativas.................................... .............................................43 7.4Comandos de
Execução .................................................. .................................................. ..........................43 7.5Passagem de
Sessão..................... .................................................. .................................................. ..............44 7.6Processos Pais
Alternativos................................. .................................................. .........................45
7.7SpoofProcessArguments .................. .................................................. ....................................... .......45
7.8Bloqueando DLLs em Processos Filhos ........................................ .................................................. ...........46 7.9
Carregar e Baixar Arquivos .............................. .................................................. ..............................46 7.10Navegador
de Arquivos..................... .................................................. .................................................. ...............46 7.11Comandos
do Sistema de Arquivos.............................. .................................................. .........................47 7.12Registro do
Windows ......... .................................................. .................................................. .........47 7.13 Teclas e Capturas de
Tela ........................................ .................................................. ....48 7.14Trabalhos de Pós-
Exploração ........................... .................................................. .............................. .............48 7.15O Navegador do
Processo ......................... .................................................. .........................48 7.16Controle de Área de
Trabalho......... .................................................. .................................................. ....................... 49
3
7.17 Escalonamento de Privilégios................................................. .................................................. ..............................51

Elevar com uma Exploração ....................... .................................................. .................................................. .......... 51
Elevar com credenciais conhecidas ....................... .................................................. ............................................. 52
GetSYSTEM... .................................................. .................................................. .................................................. ............
52 UACBypass .................................. .................................................. .................................................. ..................................
52 Privilégios ................... .................................................. .................................................. .......................................... ........
53 7.18Mimikatz ........................................ .................................................. .................................................. .....53
7.19Colheita de credenciais e hash ............................................. .................................................. ..53
7.20PortScanning ............................................. .................................................. .........................53
7.21NetworkandHostEnumeration ....... .................................................. .........................................54 7.22Relações de
Confiança.... .................................................. .................................................. ...................54
KerberosTickets................................ .................................................. .................................................. ........................
54 7.23Movimento Lateral................... .................................................. .................................................. .......55 7.24GUI
de Movimento Lateral........................................ .......................................... .................................... 56
8.Pivotação do navegador ............................................. .................................................. .........................57

8.1Visão Geral.............................. .................................................. .................................................. .........................57
8.2 Configuração ....................... .................................................. .................................................. .........................58
8.3Uso .............. .................................................. .................................................. ....................................... 59
8.4Como Funciona................................................ .................................................. ......................................... 59
9. Girando ............................................. .................................................. .........................................60 9.1 O que é

Pivotante ... .................................................. .................................................. ..............................60
9.2MEIASSProxy ................. .................................................. .................................................. .........................60 Cadeias
Proxy .................................. .................................................. .................................................. .......................................
60 Metasploit......... .................................................. .................................................. .................................................. .........
60 9.3ReversePortForward.............................. .................................................. .........................61
9.4PivotListeners........ .................................................. .................................................. .........................61 9.5VPN
Coberta .................. .................................................. .................................................. .......................62
10.SSSSessões................................................ .................................................. .........................64 10.1O Cliente

SSH .............. .................................................. .................................................. ..................64 10.2Comandos
de Execução ........................ .................................................. .........................................64 10.3 Carregar e
Baixar Arquivos . .................................................. .................................................. ........64 10.4Peer-to-
peerC2................................... .................................................. ........................................64
10.5SOCKSPivotingandReversePortForwards .................................................. .......................65
11.Comando e Controle Maleável ............................................. .......................................... 66
11.1 Visão geral .............................................. .................................................. .........................................66 11.2
Verificando Erros . .................................................. .................................................. .......................66
11.3PerfilIdioma........................ .................................................. .................................................. ......66
DataTransformLanguage.............................. .................................................. ......................................... 68
Cordas .... .................................................. .................................................. .................................................. .........................
69 Cabeçalhos e Parâmetros......................... .................................................. .................................................. .........
69 Opções ......................... .................................................. .................................................. .................................................. ..
70 11.4HTTPStaging ............................................. .................................................. .........................................71
11.5ABeaconHTTPTransactionWalth-through.... .................................................. .........................72 11.6Configuração
do Servidor HTTP ........................ .................................................. ..............................74 11.7Certificados SSL
autoassinados com SSLBeacon........ .................................................. ......74 11.8Certificados SSL válidos com
SSLBeacon ............................ .................................................. ..........75 11.9Variantes de
Perfil..................................... .................................................. ............................................. 76 11.10Certificação de
Assinatura de Código cat.................................................. .................................................. ............... 76
4
11.11 Qual é a mais perigosa, maleávelC2 ou uma piscina?.................................................77
12.PE maleável, injeção de processo e pós-exploração ........................................... ......78 12.1Visão

geral........................................ .................................................. .................................................. ...78 12.2PEeIndicadores
de Memória.............................. .................................................. .........78 Clonagem de Cabeçalhos de
PE.............................. .................................................. .................................................. .......... 79 Evasão e
Ofuscação na Memória ....................... .................................................. .................................... 79 12.3 Processo
de Injeção........... .................................................. .................................................. .........80 12.4Trabalhos de Pós-
Exploração................................... .................................................. ....................... ...............82
13. Relatórios e Registros ............................................. .................................................. .............84

13.1Registro .................................. .................................................. .................................................. ..............84 13.2
Relatórios ................................... .................................................. .................................................. ..............84 Relatório
de Atividade .................................... .................................................. .................................................. .........................
85 Relatório de Hosts......................... .................................................. .................................................. .......................................
85 Indicadores de Compromisso......... .................................................. .................................................. .........................
86 Relatório de Sessões......... .................................................. .................................................. .........................................
87 Engenharia Social .................................................. .................................................. ..................................................
87 Táticas, Técnicas e Procedimentos ........................................ .................................................. ......................... 87
13.3Relatórios de Logon Personalizado .............................. .................................................. .......................................88
13.4Relatórios Personalizados ....... .................................................. .................................................. ....................... 88
Apêndice A. Atalhos de Teclado ............................................. .................................................. 0,89
Última atualização: 2 de dezembro de 2019
5
1. Bem-vindo ao Cobalt Strike

1.1 O que é Cobalt Strike?
Cobalt Strike é uma plataforma para simulações de adversários e operações de equipe vermelha. O produto foi
projetado para executar ataques direcionados e emular as ações pós-exploração de agentes de ameaças avançados.
Este setor descreve o processo de ataque suportado pelo conjunto de recursos do Cobalt Strike. O restante deste
manual discute esses recursos em detalhes.
Figura 1. O conjunto de problemas de ofensa
Um ataque direcionado bem planejado começa com o reconhecimento. O criador de perfil de sistema do Cobalt
Strike é um aplicativo da Web que mapeia a superfície de ataque do lado do cliente do seu alvo. As informações
obtidas no reconhecimento ajudarão você a entender quais opções têm a melhor chance de sucesso em seu alvo.
A armação está emparelhando uma carga útil pós-exploração com um documento ou exploração que a
executará no alvo. Cobalt Strike tem opções para transformar documentos comuns em artefatos armados. O
Cobalt Strike também tem opções para exportar sua carga útil pós-exploração, Beacon, em vários formatos
para emparelhar com artefatos fora desse conjunto de ferramentas.
Use a ferramenta de spear phishing do Cobalt Strike para entregar seu documento armado para uma ou mais
pessoas na rede do seu alvo. A ferramenta de phishing do Cobalt Strike transforma e-mails salvos em phishes
perfeitos em pixels.
Controle a rede do seu alvo com o Beacon do Cobalt Strike. Essa carga útil pós-exploração usa um padrão de
comunicação assíncrono “baixo e lento” que é comum com malware de ameaças avançadas. O Beacon telefonará
para casa por DNS, HTTP ou HTTPS. O Beacon percorre configurações comuns de proxy e chama vários hosts para
resistir ao bloqueio.
6
Exercite a atribuição de ataque do seu alvo e a capacidade de análise com a linguagem Maleable Command and Control
do Beacon. Reprograme o Beacon para usar indicadores de rede que se pareçam com malware conhecido ou se misturem
com o tráfego existente.
Pivote na rede comprometida, descubra hosts e mova-se lateralmente com a automação útil do Beacon e a comunicação ponto
a ponto sobre pipes nomeados e soquetes TCP. O Cobalt Strike é otimizado para capturar relacionamentos de confiança e permitir
movimento lateral com credenciais capturadas, hashes de senha, tokens de acesso e tíquetes Kerberos.
Demonstre o risco comercial significativo com as ferramentas de exploração do usuário da Cobalt Strike. Os fluxos de
trabalho do Cobalt Strike facilitam a implantação de registradores de pressionamento de tecla e ferramentas de captura de tela em
sistemas comprometidos. Use o navegador dinâmico para obter acesso a sites nos quais seu alvo comprometido está conectado
com o Internet Explorer. Essa técnica somente Cobalt Strike funciona com a maioria dos sites e ignora a autenticação de dois
fatores.
Os recursos de relatórios do Cobalt Strike reconstroem o engajamento do seu cliente. Forneça aos administradores de
rede um cronograma de atividades para que possam encontrar indicadores de ataque em seus sensores.
A Cobalt Strike gera relatórios de alta qualidade que você pode apresentar aos seus clientes como produtos independentes ou
usar como apêndices à sua narrativa escrita.
Ao longo de cada uma das etapas acima, você precisará entender o ambiente de destino, suas defesas e raciocinar sobre
a melhor maneira de atingir seus objetivos com o que está disponível para você.
Isso é evasão. Não é o objetivo da Cobalt Strike fornecer evasão pronta para uso. Em vez disso, o produto fornece
flexibilidade, tanto em suas configurações potenciais quanto em opções para executar ações de ofensa, para permitir que você
adapte o produto às suas circunstâncias e objetivos.
1.2 Instalação e Atualizações

A Strategic Cyber LLC distribui os pacotes Cobalt Strike como arquivos nativos para Windows, Linux e MacOS X. Para instalar o
Cobalt Strike, simplesmente extraia seu arquivo em seu sistema operacional.
Requisitos de sistema
Cobalt Strike requer Oracle Java 1.8, Oracle Java 11 ou OpenJDK 11.
Se você tiver um produto antivírus em seu sistema, certifique-se de desativá-lo antes de instalar o Cobalt Strike.
Execute o programa de 'atualização'

O pacote de distribuição Cobalt Strike contém o(s) lançador(es) Cobalt Strike para esse sistema, arquivos de suporte e o
programa atualizador. Ele não contém o próprio programa Cobalt Strike.
Você deve executar o programa de atualização para baixar o produto Cobalt Strike.
7
Figura 2. O processo de atualização (boa tentativa, mas a chave da imagem não é mais válida)
Certifique-se de atualizar o software do servidor de equipe e do cliente com sua chave de licença. Cobalt Strike
é geralmente licenciado por usuário. O servidor de equipe não requer uma licença separada.
1.3 O Servidor de Equipe

Cobalt Strike é dividido em um cliente e um componente de servidor. O servidor, conhecido como servidor de
equipe, é o controlador da carga útil do Beacon e o host dos recursos de engenharia social do Cobalt Strike.
O servidor de equipe também armazena os dados coletados pelo Cobalt Strike e gerencia o registro.
O servidor de equipe Cobalt Strike deve ser executado em um sistema Linux compatível. Para iniciar um
servidor de equipe Cobalt Strike, use o script teamserver incluído no pacote Cobalt Strike Linux.
Figura 3. Iniciando o Team Server
O servidor de equipe tem dois parâmetros obrigatórios e dois parâmetros opcionais. O primeiro é o endereço
IP acessível externamente do servidor de equipe. Cobalt Strike usa esse valor como um host padrão para seus
recursos. A segunda é a senha que os membros da equipe usarão para conectar o cliente Cobalt Strike ao servidor
da equipe.
O terceiro parâmetro é opcional. Este parâmetro especifica um Perfil C2 Maleável. Os Capítulos 11 e 12 discutem
esse recurso.
O quarto parâmetro também é opcional. Este parâmetro especifica uma data de término no formato AAAA-MM-
DD. O servidor de equipe incorporará essa data de morte em cada estágio do Beacon que ele gerar. A carga
útil do Beacon se recusará a ser executada a partir dessa data. A carga útil do Beacon também será encerrada
se acordar nessa data ou após essa data.
8
Quando o servidor de equipe for iniciado, ele publicará o hash SHA256 do certificado SSL do servidor de equipe.
Distribua este hash para os membros da sua equipe. Quando os membros da sua equipe se conectarem, o cliente Cobalt
Strike perguntará se eles reconhecem esse hash antes de autenticar no servidor da equipe.
Esta é uma proteção importante contra ataques man-in-the-middle.
1.4 Cliente Cobalt Strike

O cliente Cobalt Strike se conecta ao servidor de equipe. Para iniciar o cliente Cobalt Strike, use o iniciador incluído no
pacote da sua plataforma.
Você verá uma caixa de diálogo de conexão quando o cliente Cobalt Strike for iniciado.
Figura 4. Caixa de diálogo Cobalt Strike Connect
Especifique o endereço do seu servidor de equipe no campo Host . A porta padrão para o servidor de equipe é 50050.
Raramente há um motivo para alterar isso. O campo Usuário é seu apelido no servidor de equipe. Altere isso para o seu
indicativo de chamada, identificador ou nome de fantasia de hacker inventado. A senha
campo é a senha compartilhada para o servidor de equipe.
Pressione Conectar para se conectar ao servidor da equipe Cobalt Strike.
Se esta for sua primeira conexão com este servidor de equipe, o Cobalt Strike perguntará se você reconhece o hash
SHA256 deste servidor de equipe. Se você fizer isso, pressione OK e o cliente Cobalt Strike se conectará ao servidor. O
Cobalt Strike também lembrará esse hash SHA256 para conexões futuras. Você pode gerenciar esses hashes através do
Cobalt Strike -> Preferences -> Fingerprints.
9
Figura 5. Verificando o certificado SSL do servidor
O Cobalt Strike acompanha os servidores da equipe aos quais você se conecta e lembra suas informações.
Selecione um desses perfis de servidor de equipe no lado esquerdo da caixa de diálogo de conexão para preencher a caixa
de diálogo de conexão com suas informações. Você também pode podar esta lista através do Cobalt Strike -> Preferences
-> Team Servers.
1.5 Operações Distribuídas e em Equipe

Use Cobalt Strike para coordenar um esforço distribuído da equipe vermelha. Stage Cobalt Strike em um ou mais hosts
remotos. Inicie seus servidores de equipe e faça com que sua equipe se conecte.
Figura 6. Operações Distribuídas com Cobalt Strike
Uma vez conectado a um servidor de equipe, sua equipe:
• Use as mesmas sessões
• Compartilhar hosts, dados capturados e arquivos baixados

• Comunique-se por meio de um log de eventos compartilhado.
O cliente Cobalt Strike pode se conectar a vários servidores de equipe. Vá para Cobalt Strike -> New Connection para
iniciar uma nova conexão. Quando conectado a vários servidores, uma barra de comutação aparecerá na parte inferior da
janela do Cobalt Strike.
10
Figura 7. Barra de comutação do servidor
Essa barra de comutação permite alternar entre instâncias ativas do servidor Cobalt Strike. Cada servidor tem seu
próprio botão. Clique com o botão direito do mouse em um botão e selecione Renomear para que o texto do botão
reflita a função do servidor durante seu engajamento. Este nome de botão também identificará o servidor no Cobalt
Strike Activity Report.
Quando conectado a vários servidores, o Cobalt Strike agrega ouvintes de todos os servidores aos quais está
conectado. Essa agregação permite enviar um e-mail de phishing de um servidor que faz referência a um site malicioso
hospedado em outro servidor. No final do seu envolvimento, o recurso de relatórios do Cobalt Strike consultará todos
os servidores aos quais você está conectado e mesclará os dados para contar uma história.
1.6 Script Cobalt Strike

Cobalt Strike é programável por meio de sua linguagem Aggressor Script. O Aggressor Script é o sucessor
espiritual da linguagem de script Cortana de Armitage. Os dois não são compatíveis embora.
Para gerenciar scripts, vá para Cobalt Strike -> Script Manager.
Figura 8. Gerenciador de scripts
Um script padrão dentro do Cobalt Strike define todos os menus pop-up do Cobalt Strike e formata as informações
exibidas nos consoles do Cobalt Strike. Por meio do mecanismo Aggressor Script, você pode substituir esses
padrões e personalizar o Cobalt Strike de acordo com suas preferências.
Você também pode usar o Aggressor Script para adicionar novos recursos ao Beacon do Cobalt Strike e
para automatizar certas tarefas.
Para saber mais sobre o Aggressor Script, consulte sua documentação em:
• https://www.cobaltstrike.com/aggressor-script/
11
2. Interface do usuário
2.1 Visão geral

A interface de usuário do Cobalt Strike é dividida em duas partes. A parte superior da interface mostra uma
visualização de sessões ou destinos. A parte inferior da interface exibe guias para cada recurso ou sessão do
Cobalt Strike com a qual você interage. Você pode clicar na área entre essas duas partes e redimensioná-las ao seu
gosto.
Figura 9. Interface de usuário do Cobalt Strike
2.2 Barra de ferramentas
A barra de ferramentas na parte superior do Cobalt Strike oferece acesso rápido às funções comuns do Cobalt Strike.
Conhecer os botões da barra de ferramentas acelerará consideravelmente o uso do Cobalt Strike.
Conectar-se a outro servidor de equipe
Desconecte-se do servidor de equipe atual
Crie e edite os ouvintes do Cobalt Strike
Mude para a visualização “Pivot Graph”
12
Mude para a visualização “Tabela de Sessão”
Mude para a visualização “Tabela de Destino”
Ver credenciais
Ver arquivos baixados
Ver pressionamentos de tecla
Ver capturas de tela
Gere um executável ou DLL Cobalt Strike sem estágio
Configurar o ataque do miniaplicativo assinado por Java
Gerar uma macro maliciosa do Microsoft Office
Defenda um ataque de entrega da Web com script sem etapas
Hospede um arquivo no servidor web do Cobalt Strike
Gerencie arquivos e aplicativos hospedados no servidor web da Cobalt Strike
Visite a página de suporte do Cobalt Strike

Sobre Cobalt Strike
2.3 Visualizações de Sessão e Destino

O Cobalt Strike tem várias visualizações, cada uma projetada para ajudar uma parte diferente do seu engajamento.
Você pode alternar entre visualizações na barra de ferramentas ou no menu Cobalt Strike -> Visualization .
Tabela de alvos
A Tabela de Destinos mostra os destinos no modelo de dados do Cobalt Strike. A tabela de destinos exibe o endereço IP de cada
destino, seu nome NetBIOS e uma nota que você ou um dos membros de sua equipe atribuiu ao destino. O ícone à esquerda de
um destino indica seu sistema operacional. Um ícone vermelho com relâmpagos indica que o alvo tem uma sessão Cobalt Strike
Beacon associada a ele.
Figura 10. Visualização de Alvos de Ataque de Cobalto
13
Clique em qualquer um dos cabeçalhos da tabela para classificar os hosts. Realce uma linha e clique com o botão direito do mouse
para abrir um menu com opções para esse host. Pressione Ctrl e Alt e clique para selecionar e desmarcar hosts individuais.
A tabela do alvo é útil para o movimento lateral e para entender a rede do seu alvo.
Tabela de sessões
A tabela de sessões mostra quais Beacons estão chamando para esta instância Cobalt Strike. Beacon é a carga útil do Cobalt Strike
para emular agentes de ameaças avançados. Aqui, você verá o endereço IP externo de cada Beacon, o endereço IP interno, o listener
de saída para esse Beacon, quando o Beacon ligou pela última vez para casa e outras informações. Ao lado de cada linha há um
ícone que indica o sistema operacional do destino comprometido. Se o ícone estiver vermelho com relâmpagos, o Beacon está sendo
executado em um processo com privilégios de administrador. Um ícone desbotado indica que a sessão do Beacon foi solicitada a sair
e reconheceu este comando.
Figura 11. Ferramenta de gerenciamento de sinalizadores de ataque de cobalto
Se você usar um ouvinte DNS Beacon, esteja ciente de que o Cobalt Strike não saberá nada sobre um host até que ele faça o
check-in pela primeira vez. Se você vir uma entrada com um horário de última chamada e pronto, você precisará dar a esse Beacon
sua primeira tarefa para ver mais informações.
Clique com o botão direito do mouse em um ou mais Beacon's para ver suas opções de pós-exploração.
Gráfico dinâmico
Cobalt Strike tem a capacidade de ligar vários Beacons em uma cadeia. Esses Beacons vinculados recebem seus comandos e enviam
sua saída por meio do Beacon pai em sua cadeia. Esse tipo de encadeamento é útil para controlar quais sessões saem de uma rede
e para emular um ator disciplinado que restringe seus caminhos de comunicação dentro de uma rede a algo plausível. Esse
encadeamento de Beacons é um dos recursos mais poderosos do Cobalt Strike.
Os fluxos de trabalho do Cobalt Strike tornam esse encadeamento muito fácil. Não é incomum que os operadores do Cobalt Strike
encadeem Beacons com quatro ou cinco níveis de profundidade regularmente. Sem um auxílio visual é muito difícil acompanhar e
entender essas cadeias. É aqui que entra o gráfico dinâmico.
O Pivot Graph mostra suas cadeias de Beacon de maneira natural. Cada sessão do Beacon tem um ícone.
Assim como na tabela de sessões: o ícone de cada host indica seu sistema operacional. Se o ícone estiver vermelho com relâmpagos,
o Beacon está sendo executado em um processo com privilégios de administrador. Um mais escuro
ícone indica que a sessão Beacon foi solicitada a sair e reconheceu este comando.
14
O ícone do firewall representa o ponto de saída da carga útil do Beacon. Uma linha verde tracejada
indica o uso de conexões HTTP ou HTTPS de beacon para deixar a rede. Uma linha tracejada amarela
indica o uso do DNS para sair da rede.
Figura 12. Visualização do gráfico de ataque de cobalto
Uma seta conectando uma sessão de Beacon a outra representa um link entre dois Beacons.
O Beacon do Cobalt Strike usa pipes nomeados do Windows e soquetes TCP para controlar Beacons dessa
maneira ponto a ponto. Uma seta laranja é um canal de tubulação nomeado. As sessões SSH também usam
uma seta laranja. Uma seta azul é um canal de soquete TCP. Um vermelho (pipe nomeado) ou roxo (TCP)
seta indica que um link Beacon está quebrado.
Clique em um Beacon para selecioná-lo. Você pode selecionar vários Beacons clicando e arrastando uma
caixa sobre os hosts desejados. Pressione Ctrl e Shift e clique para selecionar ou desmarcar um Beacon individual.
Clique com o botão direito do mouse em um Beacon para abrir um menu com as opções de pós-exploração disponíveis.
Vários atalhos de teclado estão disponíveis no gráfico dinâmico.
• Ctrl+Mais — zoom
• Ctrl+Menos — diminuir o zoom
• Ctrl+0 — redefinir o nível de zoom
• Ctrl+A — selecione todos os hosts
• Escape — limpar a seleção
• Ctrl+C — organiza hosts em círculo
• Ctrl+S — organiza hosts em uma pilha
15
• Ctrl+H — organiza os hosts em uma hierarquia.
Clique com o botão direito do mouse no gráfico dinâmico sem beacons selecionados para configurar o layout desse gráfico.
2.4 Abas
Cobalt Strike abre cada caixa de diálogo, console e tabela em uma guia. Clique no botão X para fechar uma guia.
Use Ctrl+D para fechar a guia ativa. Ctrl+Shift+D fechará todas as guias, exceto a ativa.
Você pode clicar com o botão direito do mouse no botão X para abrir uma guia em uma janela, fazer uma captura de tela de uma guia ou
fechar todas as guias com o mesmo nome.
Os atalhos de teclado também existem para essas funções. Use Ctrl+W para abrir a guia ativa em sua própria janela. Use
Ctrl+T para salvar rapidamente uma captura de tela da guia ativa.
Ctrl+B enviará a guia atual para a parte inferior da janela Cobalt Strike. Isso é útil para guias que você precisa assistir
constantemente. Ctrl+E irá desfazer esta ação e remover a guia na parte inferior da janela Cobalt Strike.
Segure shift e clique em X para fechar todas as guias com o mesmo nome. Segure shift + control e clique em X para abrir a guia
em sua própria janela.
Use Ctrl+Esquerda e Ctrl+Direita para alternar rapidamente as guias.
Você pode arrastar e soltar as guias para alterar sua ordem.
2.5 Consolas
Cobalt Strike fornece um console para interagir com sessões Beacon, scripts e bate-papo com seus
companheiros de equipe.
Figura 13. Uma guia do console
Os consoles rastreiam seu histórico de comandos. Use a seta para cima para percorrer os comandos digitados anteriormente. A
seta para baixo volta para o último comando que você digitou.
16
Use a tecla Tab para completar comandos e parâmetros.
Use Ctrl+Plus para aumentar o tamanho da fonte do console, Ctrl+Menos para diminuir e Ctrl+0
para redefini-lo. Essa alteração é local apenas para o console atual. Visite Cobalt Strike -> Preferences para alterar
permanentemente a fonte.
Pressione Ctrl+F para mostrar um painel que permitirá pesquisar texto no console.
Use Ctrl+A para selecionar todo o texto no buffer do console.
2.6 Tabelas
O Cobalt Strike usa tabelas para exibir sessões, credenciais, destinos e outras informações de engajamento.
A maioria das tabelas no Cobalt Strike tem a opção de atribuir um realce de cor às linhas realçadas.
Esses destaques são visíveis para outros clientes Cobalt Strike. Clique com o botão direito do mouse e procure a Cor
cardápio.
Pressione Ctrl+F em uma tabela para mostrar o painel de pesquisa de tabela. Esse recurso permite filtrar a tabela atual.
Figura 14. Tabela com Painel de Pesquisa
O campo de texto é onde você digita seus critérios de filtro. O formato dos critérios depende da coluna à qual você
escolhe aplicar o filtro. Use a notação CIDR (por exemplo, 192.168.1.0/24) e intervalos de host (192.168.1-192.169.200)
para filtrar colunas que contêm endereços. Use números ou intervalos de números para colunas que contêm números.
Use caracteres curinga (*, ?) para filtrar colunas que contêm strings.
O ! botão nega os critérios atuais. Pressione enter para aplicar os critérios especificados à tabela atual. Você pode
empilhar quantos critérios quiser. O botão Redefinir removerá os filtros aplicados à tabela atual.
17
3. Gerenciamento de dados
3.1 Visão geral

O servidor de equipe da Cobalt Strike é um corretor para informações coletadas pela Cobalt Strike durante seu engajamento.
O Cobalt Strike analisa a saída de sua carga útil do Beacon para extrair destinos, serviços e credenciais.
Se você deseja exportar os dados do Cobalt Strike, você pode fazê-lo através de Reporting -> Export Data.
Cobalt Strike oferece opções para exportar seus dados como arquivos TSV e XML. O recurso de exportação de dados
do cliente Cobalt Strike mesclará dados de todos os servidores de equipe aos quais você está conectado no momento.
3.2 Metas
Você pode interagir com as informações do alvo do Cobalt Strike através de View -> Targets. Esta guia exibe as mesmas
informações que a Visualização de Destinos.
Pressione Importar para importar um arquivo com informações de destino. Cobalt Strike aceita arquivos de texto simples com
um host por linha. Ele também aceita arquivos XML gerados pelo Nmap (a opção –oX).
Pressione Adicionar para adicionar novos alvos ao modelo de dados do Cobalt Strike.
Figura 15. Adicionar um destino
Esta caixa de diálogo permite adicionar vários hosts ao banco de dados do Cobalt Strike. Especifique um intervalo de
endereços IP ou use a notação CIDR no campo Endereço para adicionar vários hosts ao mesmo tempo. Mantenha
pressionada a tecla shift ao clicar em Salvar para adicionar hosts ao modelo de dados e manter esta caixa de diálogo aberta.
Selecione um ou mais hosts e clique com o botão direito do mouse para abrir o menu de hosts. Este menu é onde você
altera a nota sobre os hosts, define suas informações de sistema operacional ou remove os hosts do modelo de dados.
18
3.3 Serviços
Em uma exibição de destino, clique com o botão direito do mouse em um host e selecione Serviços. Isso abrirá o
navegador de serviços do Cobalt Strike. Aqui você pode navegar pelos serviços, atribuir notas a diferentes serviços e
também remover entradas de serviço.
Figura 16. A caixa de diálogo de serviços
3.4 Credenciais
Vá para View -> Credentials para interagir com o modelo de credencial do Cobalt Strike. Pressione Adicionar para
adicionar uma entrada ao modelo de credencial. Novamente, você pode segurar shift e pressionar Salvar para manter a
caixa de diálogo aberta e facilitar a adição de novas credenciais ao modelo. Pressione Copiar para copiar as entradas
destacadas para a área de transferência. Use Exportar para exportar credenciais no formato PWDump.
Figura 17. O Modelo de Credencial
3.5 Manutenção
O modelo de dados do Cobalt Strike mantém todos os seus metadados de estado e estado na pasta data/ . Esta pasta
existe na pasta da qual você executou o servidor de equipe Cobalt Strike.
Para limpar o modelo de dados do Cobalt Strike: pare o servidor de equipe, exclua a pasta data/ e seu conteúdo.
O Cobalt Strike recriará a pasta data/ quando você iniciar o servidor de equipe em seguida.
Se você quiser arquivar o modelo de dados, pare o servidor de equipe e use seu programa favorito para armazenar os
dados/ pasta e seus arquivos em outro lugar. Para restaurar o modelo de dados, pare o servidor de equipe e restaure o
conteúdo antigo na pasta data/ .
Relatório -> Redefinir dados redefine o modelo de dados do Cobalt Strike sem reiniciar o servidor de equipe.
19
4. Gerenciamento de Ouvinte e Infraestrutura

4.1 Visão geral
A primeira etapa de qualquer engajamento é configurar a infraestrutura. No caso da Cobalt Strike, a infraestrutura
consiste em um ou mais servidores de equipe, redirecionadores e registros DNS que apontam para seus
servidores e redirecionadores de equipe. Depois de ter um servidor de equipe em execução, você desejará se
conectar a ele e configurá-lo para receber conexões de sistemas comprometidos. Os ouvintes são o mecanismo
do Cobalt Strike para fazer isso.
Um listener é simultaneamente informações de configuração para uma carga útil e uma diretiva para Cobalt
Strike levantar um servidor para receber conexões dessa carga útil. Um ouvinte consiste em um nome definido
pelo usuário, o tipo de carga útil e várias opções específicas de carga útil.
4.2 Gerenciamento de Ouvintes

Para gerenciar os ouvintes do Cobalt Strike, vá para Cobalt Strike -> Listeners. Isso abrirá uma guia listando
todos os seus payloads e listeners configurados.
Figura 18. Guia de Gerenciamento de Ouvinte
Pressione Adicionar para criar um novo ouvinte.
Ao criar um ouvinte, certifique-se de dar a ele um nome memorável. Esse nome é como você se referirá a esse
ouvinte por meio dos comandos e fluxos de trabalho do Cobalt Strike.
Para editar um ouvinte, realce um ouvinte e pressione Editar.
Para remover um ouvinte, realce o ouvinte e pressione Remover.
4.3 Carga do Sinalizador do Cobalt Strike

Mais comumente, você configurará ouvintes para a carga útil Beacon do Cobalt Strike. Beacon é a carga
útil do Cobalt Strike para modelar atacantes avançados. Use o Beacon para sair de uma rede por HTTP,
HTTPS ou DNS. Você também pode limitar quais hosts saem de uma rede controlando Beacons ponto a ponto
sobre pipes nomeados do Windows e soquetes TCP.
20
Beacon é flexível e suporta comunicação assíncrona e interativa. A comunicação assíncrona é baixa e lenta.
O Beacon telefonará para casa, baixará suas tarefas e dormirá.
A comunicação interativa acontece em tempo real.
Os indicadores de rede do Beacon são maleáveis. Redefina a comunicação do Beacon com a linguagem
C2 maleável do Cobalt Strike. Isso permite ocultar a atividade do Beacon para se parecer com outro
malware ou se misturar como tráfego legítimo. O Capítulo 11 discute esse recurso.
4.4 Preparação de carga útil

Um tópico que merece menção, como informação de fundo, é a preparação de carga útil. Muitas estruturas de
ataque dissociam o ataque das coisas que o ataque executa. Esse material que um ataque executa é conhecido
como carga útil. As cargas úteis geralmente são divididas em duas partes: o estágio de carga útil e o estágio de
carga útil. Um stager é um pequeno programa, geralmente assembly otimizado manualmente, que baixa um
estágio de carga útil, o injeta na memória e passa a execução para ele. Este processo é conhecido como
encenação.
O processo de encenação é necessário em algumas ações de ofensa. Muitos ataques têm limites rígidos sobre a
quantidade de dados que podem carregar na memória e executar após a exploração bem-sucedida. Isso limita
bastante suas opções de pós-exploração, a menos que você entregue sua carga de pós-exploração em etapas.
Cobalt Strike usa encenação em seus ataques dirigidos ao usuário. Estes são a maioria dos itens em
Ataques -> Pacotes e Ataques -> Web Drive-by. Os estágios usados nesses locais dependem da carga útil
emparelhada com o ataque. Por exemplo, o HTTP Beacon tem um stager HTTP. O DNS Beacon possui um estágio
de registro DNS TXT. Nem todas as cargas úteis têm opções de estágio. Cargas sem estágio não podem ser
entregues com essas opções de ataque.
Se você não precisar de teste de carga útil, poderá desativá-lo. Defina a opção host_stage em seu
perfil Malleable C2 como false. Isso impedirá que o Cobalt Strike hospede estágios de carga útil em seus
servidores web e DNS. Há um grande benefício OPSEC em fazer isso. Com o staging ativado, qualquer pessoa
pode se conectar ao seu servidor, solicitar uma carga útil e analisar seu conteúdo para encontrar informações de
sua configuração de carga útil.
No Cobalt Strike 4.0 e posterior, as ações de pós-exploração e movimento lateral evitam os estágios e optam por
fornecer uma carga útil completa sempre que possível. Se você desabilitar o teste de carga útil, não deverá notá-
lo quando estiver pronto para fazer a pós-exploração.
4.5 Sinalizador HTTP e Sinalizador HTTPS
As tarefas de download dos beacons HTTP e HTTPS com uma solicitação HTTP GET. Esses beacons enviam
dados de volta com uma solicitação HTTP POST. Este é o padrão. Você tem um controle incrível sobre o
comportamento e os indicadores nesta carga através do Maleable C2.
Para levantar um ouvinte HTTP ou HTTPS Beacon, vá para Cobalt Strike -> Listeners. Pressione Adicionar.
Escolha Beacon HTTP como sua opção de carga útil.
21
Figura 19. Opções de HTTP Beacon
Pressione [+] para adicionar um ou mais hosts para o HTTP Beacon chamar de home. Pressione [-] para remover um
ou mais hosts. Pressione [X] para limpar os hosts atuais. Se você tiver vários hosts, ainda poderá colar uma lista
separada por vírgulas de hosts de retorno de chamada nesta caixa de diálogo. Isso está ok. J
O campo HTTP Host (Stager) controla o host do HTTP Stager para o HTTP Beacon. Esse valor é usado apenas se
você emparelhar essa carga com um ataque que requer um stager explícito.
O campo Perfil é onde você seleciona uma variante de perfil Maleável C2. Uma variante é uma forma de
especificando várias variações de perfil em um arquivo. Com variantes, cada ouvinte HTTP ou HTTPS configurado
pode ter diferentes indicadores de rede.
O campo Porta HTTP (C2) define a porta para a qual seu HTTP Beacon ligará para casa. O campo HTTP Port
(Bind) especifica a porta à qual seu servidor web de carga útil HTTP Beacon será vinculado. Essas opções são úteis
se você deseja configurar redirecionadores de dobra de porta (por exemplo, um redirecionador que aceita conexões
na porta 80 ou 443, mas roteia a conexão para seu servidor de equipe em outra porta).
O valor HTTP Host Header , se especificado, é propagado para seus stagers HTTP e por meio de sua comunicação
HTTP. Esta opção facilita o aproveitamento do fronting de domínio
com Cobalt Strike.
Pressione … ao lado do campo HTTP Proxy para especificar uma configuração de proxy explícita para esta
carga.
22
Configuração manual de proxy HTTP

A caixa de diálogo Configurações de proxy (manuais) oferece várias opções para controlar a configuração de proxy para solicitações
HTTP e HTTPS do Beacon. O comportamento padrão do Beacon é usar a configuração de proxy do Internet Explorer para o
contexto atual do processo/usuário.
O campo Tipo configura o tipo de proxy. Os campos Host e Port informam ao Beacon onde reside o proxy. Os campos Nome
de usuário e Senha são opcionais. Esses campos especificam as credenciais que o Beacon usa para autenticar no proxy.
Figura 20. Configurações Manuais de Proxy
Verifique as configurações de proxy Ignorar; use a caixa de conexão direta para forçar o Beacon a tentar suas solicitações HTTP
e HTTPS sem passar por um proxy.
Pressione Set para atualizar a caixa de diálogo Beacon com as configurações de proxy desejadas. Pressione Redefinir para
definir a configuração do proxy de volta ao comportamento padrão.
Nota: a configuração manual do proxy afeta apenas os estágios de carga útil HTTP e HTTPS Beacon.
Ele não se propaga para os estágios de carga útil.
Redirecionadores
Um redirecionador é um sistema que fica entre a rede do seu alvo e o seu servidor de equipe. Quaisquer conexões que
chegam ao redirecionador são encaminhadas ao seu servidor de equipe para serem processadas. Um redirecionador é
uma maneira de fornecer vários hosts para suas cargas úteis do Beacon chamarem de casa. Um redirecionador também
ajuda na segurança operacional, pois dificulta o rastreamento da verdadeira localização do seu
servidor da equipe.
Os recursos de gerenciamento de ouvintes do Cobalt Strike suportam o uso de redirecionadores. Basta especificar seus hosts
redirecionadores ao configurar um listener HTTP ou HTTPS Beacon. Cobalt Strike não valida esta informação. Se o host que você
fornece não é afiliado ao host atual, o Cobalt Strike assume que é um redirecionador. Uma maneira simples de transformar um
servidor em um redirecionador é usar socat.
23
Aqui está a sintaxe socat para encaminhar todas as conexões na porta 80 para o servidor de equipe
em 192.168.12.100 na porta 80:
socat TCP4-LISTEN:80,fork TCP4:192.168.12.100:80
4.6 Sinalizador de DNS

O DNS Beacon é um recurso favorito do Cobalt Strike. Essa carga útil usa solicitações de DNS para sinalizar de volta
para você. Essas solicitações de DNS são pesquisas em domínios para os quais seu servidor de equipe Cobalt Strike
tem autoridade. A resposta do DNS diz ao Beacon para dormir ou se conectar a você para baixar tarefas. A resposta
do DNS também informará ao Beacon como baixar tarefas do seu
servidor da equipe.
Figura 21. Sinalizador de DNS em ação
No Cobalt Strike 4.0 e posterior, o DNS Beacon é uma carga útil somente DNS. Não há modo de comunicação
HTTP nesta carga. Esta é uma mudança em relação às versões anteriores do produto.
Canais de dados
Hoje, o DNS Beacon pode baixar tarefas em registros DNS TXT, registros DNS AAAA ou registros DNS A. Essa
carga útil tem a flexibilidade de alternar entre esses canais de dados enquanto está no destino. Use o comando mode
do Beacon para alterar o canal de dados do Beacon atual. modo dns
é o canal de dados de registro DNS A. o modo dns6 é o canal de registro DNS AAAA. E o modo dns-txt é o canal
de dados do registro DNS TXT. O padrão é o canal de dados do registro TXT do DNS.
Esteja ciente de que o DNS Beacon não faz check-in até que haja uma tarefa disponível. Use o check -in
comando para solicitar que o DNS Beacon faça check-in na próxima vez que ligar para casa.
24
Configuração do Ouvinte
Para criar um listener DNS Beacon: vá para Cobalt Strike -> Listeners, pressione Add e selecione Beacon
DNS como o tipo de carga útil.
Figura 22. Opções de sinalizador de DNS
Pressione [+] para adicionar um ou mais domínios para o beacon. Seu sistema de servidor de equipe Cobalt Strike
deve ser autoritário para os domínios que você especificar. Crie um registro DNS A e aponte-o para o servidor da
equipe Cobalt Strike. Use os registros DNS NS para delegar vários domínios ou subdomínios ao registro A do seu
servidor de equipe Cobalt Strike.
O campo DNS Host (Stager) configura o stager de registro TXT do DNS Beacon. Este stager é usado apenas
com recursos Cobalt Strike que exigem um stager explícito. Seu sistema de servidor de equipe Cobalt Strike
também deve ser autoritário para este domínio.
Para testar sua configuração de DNS, abra um terminal e digite nslookup jibberish.beacon domain.
Se você obtiver uma resposta de registro A de 0.0.0.0, seu DNS está configurado corretamente. Se você não
receber uma resposta, sua configuração de DNS não está correta e o DNS Beacon não se comunicará com você.
Certifique-se de que seus registros DNS façam referência ao endereço principal em sua interface de rede. O
servidor DNS da Cobalt Strike sempre enviará respostas do endereço primário da sua interface de rede.
Os resolvedores de DNS tendem a descartar respostas quando solicitam informações de um servidor, mas recebem
uma resposta de outro.
25
Se você estiver atrás de um dispositivo NAT, certifique-se de usar seu endereço IP público para o registro NS e configure
seu firewall para encaminhar tráfego UDP na porta 53 para seu sistema. Cobalt Strike inclui um servidor DNS para controlar
o Beacon.
4.7 Sinalizador SMB

O SMB Beacon usa pipes nomeados para se comunicar por meio de um Beacon pai. Essa comunicação ponto a ponto
funciona com Beacons no mesmo host. Também funciona em toda a rede.
O Windows encapsula a comunicação de pipe nomeado dentro do protocolo SMB. Daí o nome, SMB Beacon.
Para configurar uma carga útil SMB Beacon, vá para Cobalt Strike -> Listeners. Pressione Adicionar. Escolha Beacon
SMB como sua opção de carga útil.
Figura 23. Sinalizador SMB
A única opção associada ao SMB Beacon é o nome do canal. Você pode definir um nome de canal explícito ou
aceitar a opção padrão.
O SMB Beacon é compatível com a maioria das ações no Cobalt Strike que geram uma carga útil. A exceção a isso são
os ataques dirigidos pelo usuário (por exemplo, Ataques -> Pacotes, Ataques -> Web Drive by) que exigem estágios
explícitos.
As ações de pós-exploração e movimento lateral do Cobalt Strike que geram uma carga útil tentarão assumir o controle
de (link) para a carga útil SMB Beacon para você. Se você executar o SMB Beacon manualmente, precisará vinculá-lo a
partir de um Beacon pai.
Vinculando e Desvinculando
No console do Beacon, use o link [host] [pipe] para vincular o Beacon atual a um Beacon SMB que está aguardando
uma conexão. Quando o Beacon atual fizer check-in, seus pares vinculados também farão check-in.
Para se misturar com o tráfego normal, os Beacons vinculados usam pipes nomeados do Windows para se comunicar. Este
tráfego é encapsulado no protocolo SMB. Existem algumas ressalvas para essa abordagem:
1. Os hosts com um SMBBeacon devem aceitar conexões na porta 445.

2. Você só pode vincular Beacons gerenciados pela mesma instância Cobalt Strike.
26
Se você receber um erro 5 (acesso negado) depois de tentar vincular a um Beacon: roube o token de um usuário
de domínio ou use make_token DOMAIN\user password para preencher seu token atual com credenciais válidas
para o destino. Tente se conectar ao Beacon novamente.
Para destruir um link Beacon use unlink [endereço IP] [session PID] no pai ou filho. O argumento [session
PID] é o ID do processo do Beacon a ser desvinculado. Esse valor é como você especifica um Beacon específico
para desvincular quando houver vários Beacons filhos.
Quando você desvincula um SMB Beacon, ele não sai nem desaparece. Em vez disso, ele entra em um
estado em que espera uma conexão de outro Beacon. Você pode usar o comando link para retomar o controle do
SMB Beacon de outro Beacon no futuro.
4.8 Sinalizador TCP

O TCP Beacon usa um soquete TCP para se comunicar através de um Beacon pai. Essa comunicação ponto a
ponto funciona com Beacons no mesmo host e em toda a rede.
Figura 24. Sinalizador TCP
Para configurar uma carga útil TCP Beacon, vá para Cobalt Strike -> Listeners. Pressione Adicionar.
Escolha Beacon TCP como sua opção de carga útil.
O TCP Beacon configurado dessa maneira é uma carga útil de ligação. Uma carga útil de ligação é aquela que
aguarda uma conexão de seu controlador (neste caso, outra sessão de Beacon). A opção Port (C2) controla a
porta em que o TCP Beacon aguardará as conexões. Marque Bind to localhost apenas para que o TCP Beacon se
ligue a 127.0.0.1 quando escutar uma conexão. Essa é uma boa opção se você usar o TCP Beacon para ações
somente de host local.
O TCP Beacon é compatível com a maioria das ações no Cobalt Strike que geram uma carga útil. A exceção
a isso são, semelhantes ao SMB Beacon, os ataques dirigidos pelo usuário (por exemplo, Ataques ->
Pacotes, Ataques -> Web Drive-by) que requerem stagers explícitos.
As ações de pós-exploração e movimento lateral do Cobalt Strike que geram uma carga útil tentarão assumir o
controle de (conectar) à carga útil do TCP Beacon para você. Se você executar o TCP Beacon manualmente,
precisará se conectar a ele a partir de um Beacon pai.
27
Conectando e desvinculando
No console do Beacon, use connect [endereço IP] [porta] para conectar a sessão atual a um TCP
Beacon que está aguardando uma conexão. Quando a sessão atual fizer check-in, seus pares vinculados
também farão check-in.
Para destruir um link Beacon, use unlink [endereço IP] [session PID] no console de sessão pai ou filho.
Mais tarde, você pode se reconectar ao TCP Beacon do mesmo host (ou de um host diferente).
4.9 C2 Externo
C2 externo é uma especificação para permitir que programas de terceiros atuem como uma camada de
comunicação para a carga útil do Beacon do Cobalt Strike. Esses programas de terceiros se conectam ao
Cobalt Strike para ler quadros destinados e gravar quadros com saída de cargas controladas dessa maneira.
O servidor C2 externo é o que esses programas de terceiros usam para interagir com o seu Cobalt Strike
servidor da equipe.
Vá para Cobalt Strike -> Listeners, pressione Add e escolha External C2 como sua carga útil.
Figura 25. C2 externo
A interface C2 Externa tem duas opções. Port (Bind) especifica a porta em que o servidor C2 externo
aguarda conexões. Marque Bind to localhost only para tornar o servidor C2 externo somente localhost.
Os ouvintes C2 externos não são como outros ouvintes Cobalt Strike. Você não pode alvejá-los com as
ações pós-exploração do Cobalt Strike. Esta opção é apenas uma conveniência para levantar a própria
interface.
Para saber mais sobre o C2 Externo, visite a documentação em:
https://www.cobaltstrike.com/help-externalc2
28
4.10 Ouvintes Estrangeiros

Cobalt Strike apoia o conceito de ouvintes estrangeiros. Esses são aliases para manipuladores de carga
útil x86 hospedados no Metasploit Framework ou outras instâncias do Cobalt Strike. Para passar uma
sessão do Windows HTTPS Meterpreter para um amigo com msfconsole, configure uma carga de HTTPS
externa e aponte os valores de Host e Port para seu manipulador. Você pode usar ouvintes estrangeiros em
qualquer lugar em que usaria um ouvinte x86 Cobalt Strike.
4.11 Consolidação de Infraestrutura

O modelo da Cobalt Strike para operações distribuídas é criar um servidor de equipe separado para cada fase
do seu envolvimento. Por exemplo, faz sentido separar sua infraestrutura de pós-exploração e persistência. Se
uma ação pós-exploração for descoberta, você não deseja que a correção dessa infraestrutura elimine os
retornos de chamada que permitirão que você volte à rede.
Algumas fases de engajamento exigem várias opções de redirecionador e canal de comunicação. Cobalt Strike 4.0
é amigável para isso.
Figura 26. Recursos de consolidação de infraestrutura
Você pode vincular vários ouvintes HTTP, HTTPS e DNS a um único servidor de equipe Cobalt Strike.
Essas cargas também oferecem suporte à dobra de porta em sua configuração. Isso permite que você use
a porta comum para seu canal (80, 443 ou 53) nas configurações do redirecionador e C2, mas vincule esses
ouvintes a portas diferentes para evitar conflitos de porta em seu sistema de servidor de equipe.
29
Para dar variedade aos seus indicadores de rede, os perfis Maleable C2 da Cobalt Strike podem conter várias variantes.
Uma variante é uma maneira de adicionar variações do perfil atual em um arquivo de perfil. Você pode especificar uma
variante de Perfil ao definir cada ouvinte HTTP ou HTTPS Beacon.
Além disso, você pode definir vários TCP e SMB Beacons em um servidor de equipe, cada um com diferentes configurações
de pipe e porta. Qualquer Beacon de saída, do mesmo servidor de equipe, pode controlar qualquer uma dessas cargas de
TCP ou SMB Beacon assim que forem implantados no ambiente de destino.
4.12 Recursos de segurança de carga útil

O Cobalt Strike toma medidas para proteger a comunicação de Beacons e para garantir que um Beacon possa apenas receber
tarefas e enviar saída para seu servidor de equipe.
Quando você configura a carga útil do Beacon pela primeira vez, o Cobalt Strike gera um par de chaves
pública/privada exclusivo para o seu servidor de equipe. A chave pública do servidor de equipe é incorporada ao
estágio de carga útil do Beacon. O Beacon usa a chave pública do servidor de equipe para criptografar os metadados
da sessão que ele envia ao servidor de equipe.
O Beacon deve sempre enviar metadados de sessão antes que o servidor de equipe possa emitir tarefas e receber saída
da sessão do Beacon. Esses metadados contêm uma chave de sessão aleatória gerada por esse Beacon. O servidor de
equipe usa a chave de sessão de cada Beacon para criptografar tarefas e descriptografar a saída.
Cada implementação de Beacon e canal de dados usa esse mesmo esquema. Você tem a mesma segurança com
o canal de dados de registro A no HTTP Híbrido e o Sinalizador DNS que você tem com o Sinalizador HTTPS.
Esteja ciente de que o acima se aplica ao Beacon assim que for encenado. Os estágios de carga útil, devido ao seu
tamanho, não possuem recursos de segurança integrados.
30
5. Obtendo um ponto de apoio
5.1 Perfil do sistema do lado do cliente

O criador de perfil de sistema é uma ferramenta de reconhecimento para ataques do lado do cliente. Esta ferramenta inicia um
servidor web local e faz impressões digitais de qualquer pessoa que o visite. O criador de perfil do sistema fornece uma lista de
aplicativos e plug-ins que ele descobre por meio do navegador do usuário. O criador de perfil do sistema também tenta descobrir o
endereço IP interno dos usuários que estão atrás de um servidor proxy.
Para iniciar o criador de perfil do sistema, vá para Ataques -> Web Drive-by -> Criador de perfil do sistema .
Para iniciar o criador de perfil, você deve especificar um URI para vincular e uma porta para iniciar o servidor web Cobalt Strike.
Se você especificar um URL de redirecionamento, o Cobalt Strike redirecionará os visitantes para esse URL assim que seu perfil
for obtido. Clique em Iniciar para iniciar o criador de perfil do sistema.
O System Profiler usa um Java Applet não assinado para revelar o endereço IP interno do destino e determinar qual versão do
Java o destino possui. Com o recurso de segurança clique para executar do Java, isso pode levantar suspeitas. Desmarque a
caixa Use Java Applet to get information para remover o Java Applet do System Profiler.
Marque a caixa Ativar SSL para servir o System Profiler sobre SSL. Esta caixa está desativada, a menos que você especifique
um certificado SSL válido com Malleable C2. O Capítulo 11 discute isso.
Para visualizar os resultados do criador de perfil do sistema, vá para Visualizar -> Aplicativos. O Cobalt Strike listará todos os
aplicativos descobertos durante o processo de criação de perfil do sistema.
5.2 Serviços Web Cobalt Strike

Muitos recursos do Cobalt Strike são executados em seu próprio servidor web. Esses serviços incluem o criador de perfil do
sistema, HTTP Beacon e os ataques drive-by da Web do Cobalt Strike. Não há problema em hospedar vários recursos do Cobalt
Strike em um servidor web.
Para gerenciar os serviços web do Cobalt Strike, vá para View -> Web Drive-by -> Manage. Aqui, você pode copiar qualquer
URL do Cobalt Strike para a área de transferência ou interromper um serviço web do Cobalt Strike.
Use View -> Web Log para monitorar as visitas aos seus serviços web Cobalt Strike.
Se o servidor web da Cobalt Strike vir uma solicitação do navegador Lynx, Wget ou Curl; Cobalt Strike retornará automaticamente
uma página 404. Cobalt Strike faz isso como proteção leve contra a espionagem da equipe azul.
5.3 Pacotes de ataque dirigidos pelo usuário

Os melhores ataques não são exploits. Em vez disso, os melhores ataques aproveitam os recursos normais para obter a execução
do código. O Cobalt Strike facilita a configuração de vários ataques direcionados ao usuário. Esses ataques aproveitam os ouvintes
que você já configurou. Navegue até Ataques -> Pacotes e escolha uma das seguintes opções.
31
Aplicativo HTML
Um aplicativo HTML é um programa do Windows escrito em HTML e uma linguagem de script com suporte
do Internet Explorer. Este pacote gera um aplicativo HTML que executa uma carga útil Cobalt Strike. Você pode
escolher a opção Executável para obter um aplicativo HTML que descarta um executável no disco e o executa.
Escolha a opção PowerShell para obter um aplicativo HTML que usa o PowerShell para executar uma carga útil.
Use a opção VBA para gerar silenciosamente uma instância do Microsoft Excel e executar uma macro maliciosa que
injeta uma carga útil na memória.
Macro do MS Office
Este pacote gera uma macro do Microsoft Office e apresenta instruções para incorporar a macro no Microsoft Word
ou no Microsoft Excel.
Gerador de carga útil

Este pacote permite exportar os stagers do Cobalt Strike em vários formatos.
Executável do Windows
Este pacote gera um artefato executável do Windows que entrega um estágio de carga útil. Este pacote
oferece várias opções de saída.
O Windows EXE é um executável do Windows.
O Windows Service EXE é um executável do Windows que responde aos comandos do Service Control
Manager. Você pode usar este executável para criar um serviço do Windows com sc ou como um executável
personalizado com os módulos PsExec do Metasploit Framework.
A DLL do Windows (32 bits) é uma DLL do Windows x86.
A DLL do Windows (64 bits) é uma DLL do Windows x64. Essa DLL gerará um processo de 32 bits e migrará
seu ouvinte para ele. Ambas as opções de DLL exportam uma função Iniciar compatível com rundll32.exe. Use
rundll32.exe para carregar sua DLL a partir da linha de comando.
rundll32 foo.dll,Iniciar
Marque a caixa Use x64 payload para gerar artefatos x64 que emparelham com um stager x64.
Marque a caixa Assinar arquivo executável para assinar um artefato EXE ou DLL com um certificado de
assinatura de código. Você deve especificar um certificado em um perfil Maleable C2.
Executável do Windows (S)

Este pacote exporta Beacon, sem um stager, como um executável, executável de serviço, DLL de 32 bits ou DLL de
64 bits. Um artefato de carga útil que não usa um stager é chamado de artefato sem estágio. Este pacote também tem
uma opção do PowerShell para exportar o Beacon como um script do PowerShell e uma opção bruta para exportar o
Beacon como um blob de código independente de posição.
Por padrão, essa caixa de diálogo exporta estágios de carga útil x86. Marque a caixa Use x64 payload para gerar
um estágio x64 com um artefato x64.
32
Marque a caixa Assinar arquivo executável para assinar um artefato EXE ou DLL com um certificado de
assinatura de código.
5.4 Hospedando Arquivos
O servidor web do Cobalt Strike pode hospedar seus pacotes orientados pelo usuário para você. Vá para Attacks -> Web
Drive-by -> Host File para configurar isso. Escolha o arquivo para hospedar, selecione uma URL arbitrária e escolha o tipo
mime para o arquivo.
Por si só, a capacidade de hospedar um arquivo não é muito impressionante. No entanto, em um momento, você aprenderá
como incorporar URLs do Cobalt Strike em um e-mail de spear phishing. Quando você faz isso, o Cobalt Strike pode cruzar
os visitantes do seu arquivo com os e-mails enviados e incluir essas informações no relatório de engenharia social.
5.5 Ataques dirigidos pelo usuário na Web
O Cobalt Strike disponibiliza várias ferramentas para configurar ataques drive-by da Web disponíveis para você. Para iniciar
um ataque rapidamente, vá para Ataques -> Web Drive-by e escolha uma opção:
Ataque de miniaplicativo assinado em Java
Este ataque inicia um servidor web que hospeda um applet Java autoassinado. Os visitantes são solicitados a dar
permissão ao applet para ser executado. Quando um visitante concede essa permissão, você obtém acesso ao sistema dele.
O Java Signed Applet Attack usa o injetor Java do Cobalt Strike. No Windows, o injetor Java injetará o shellcode de um
ouvinte do Windows diretamente na memória para você.
Para obter o máximo de quilometragem deste ataque, você vai querer baixar o Applet Kit do arsenal Cobalt Strike e
assiná-lo com um certificado de assinatura de código.
Ataque de Applet Inteligente Java

O Smart Applet Attack da Cobalt Strike combina vários exploits para desabilitar a sandbox de segurança Java em
um único pacote. Este ataque inicia um servidor web que hospeda um applet Java. Inicialmente, esse applet é executado
na sandbox de segurança do Java e não requer aprovação do usuário para ser iniciado.
O applet analisa seu ambiente e decide qual exploração Java usar. Se a versão do Java for vulnerável, o applet desabilitará
o sandbox de segurança e executará uma carga útil usando o injetor Java do Cobalt Strike.
Entrega da Web com script (S)

Esse recurso gera um artefato de carga útil Beacon sem estágio, hospeda-o no servidor web do Cobalt Strike e apresenta
um one-liner para baixar e executar o artefato. As opções são: bitsadmin, powershell e python.
A opção bitsadmin hospeda um executável e usa bitsadmin para baixá-lo. O método bitsadmin executa o executável
via cmd.exe. A opção powershell hospeda um script do PowerShell e usa powershell.exe para baixar o script e avaliá-lo.
A opção python hospeda um script Python e usa python.exe para baixar o script e executá-lo. Cada uma dessas opções
é uma maneira diferente de executar um ouvinte Cobalt Strike.
33
5.6 Explorações do lado do cliente
Você pode usar um exploit do Metasploit Framework para entregar um Cobalt Strike Beacon. O Beacon do Cobalt
Strike é compatível com o protocolo de teste do Metasploit Framework. Para entregar um Beacon com um exploit do
Metasploit Framework:
• Use windows/ meterpreter/ reverse_http[s] como seu PAYLOAD e defina LHOST e LPORT para apontar
para seu ouvinte CobaltStrikelister. Você não está realmente entregando o Meterpreter aqui, você está
dizendo ao Metasploit Framework para gerar o HTTP[s]
stager que baixa uma carga útil do LHOST/LPORT especificado.
• Defina DisablePayloadHandler como True. Isso informará ao Metasploit Framework para evitar ficar em cima
de um manipulador dentro do Metaploit Framework para atender sua conexão de carga útil.
• Defina PrependMigrate como True. Esta opção informa ao Metasploit Framework para anexar o código shell
que executa o estágio de carga útil em outro processo.
Aqui está uma captura de tela do msfconsole usada para suportar um Flash Exploit para entregar o Cobalt Strike
HTTP Beacon hospedado em 192.168.1.5 na porta 80:
Figura 27. Usando ataques do lado do cliente do Metasploit
5.7 Clonar um site
Antes de enviar um exploit para um alvo, é útil prepará-lo. A ferramenta de clonagem de sites da Cobalt Strike pode
ajudar com isso. A ferramenta de clonagem de sites faz uma cópia local de um site com algum código adicionado para
corrigir links e imagens para que funcionem conforme o esperado.
Para clonar um site, vá para Ataques -> Web Drive-by -> Clonar Site.
34
É possível incorporar um ataque em um site clonado. Escreva o URL do seu ataque no campo Incorporar e o Cobalt
Strike irá adicioná-lo ao site clonado com um IFRAME. Clique no botão ... para selecionar uma das explorações do
lado do cliente em execução.
Figura 28. Ferramenta de clone de site
Sites clonados também podem capturar pressionamentos de tecla. Marque a caixa Registrar pressionamentos de tecla
no site clonado . Isso inserirá um keylogger JavaScript no site clonado.
Para ver os pressionamentos de tecla registrados ou ver os visitantes do seu site clonado, vá para Exibir -> Log da Web.
5.8 Spear Phishing
Alvos
Agora que você entende os ataques do lado do cliente, vamos falar sobre como levar o ataque ao usuário. A maneira
mais comum de entrar na rede de uma organização é por meio de spear phishing.
Antes de enviar uma mensagem de phishing, você deve montar uma lista de alvos. Cobalt Strike espera alvos em um
arquivo de texto. Cada linha do arquivo contém um destino. O destino pode ser um endereço de e-mail.
Você também pode usar um endereço de e-mail, uma guia e um nome. Se fornecido, um nome ajuda o Cobalt Strike a
personalizar cada phishing.
Modelos
Em seguida, você precisa de um modelo de phishing. O bom dos modelos é que você pode reutilizá-los entre os
compromissos. Cobalt Strike usa mensagens de e-mail salvas como seus modelos. O Cobalt Strike removerá anexos,
lidará com problemas de codificação e reescreverá cada modelo para cada ataque de phishing.
Se você quiser criar um modelo personalizado, escreva uma mensagem e envie para você mesmo. A maioria dos clientes
de e-mail tem uma maneira de obter a fonte original da mensagem. No Gmail, clique na seta para baixo ao lado de
Responder e selecione Mostrar original. Salve esta mensagem em um arquivo e parabenize-se—
você criou seu primeiro modelo de phishing Cobalt Strike.
35
Você pode personalizar seu modelo com os tokens do Cobalt Strike. Cobalt Strike substitui os seguintes tokens em seus
modelos:
Símbolo Descrição
%Para% O endereço de e-mail da pessoa para a qual a mensagem é enviada
%Nomear% O nome da pessoa para quem a mensagem é enviada.
%URL% O conteúdo do campo Incorporar URL na caixa de diálogo de spear phishing.
Enviando mensagens
Agora que você tem seus alvos e um modelo, está pronto para usar o phishing. Para iniciar a ferramenta de spear
phishing, vá para Attacks -> Spear Phish.
Figura 29. Ferramenta Spear Phishing
Para enviar uma mensagem de phishing, você deve primeiro importar seus alvos. Clique na pasta ao lado do
campo Destinos para importar seu arquivo de destino.
Em seguida, escolha seu arquivo de modelo. Clique na pasta ao lado do campo Modelo para escolher um.
Agora, você tem a opção de anexar um arquivo, se desejar. Este é um ótimo momento para usar um dos pacotes
de engenharia social discutidos anteriormente. O Cobalt Strike adicionará seu anexo à mensagem de phishing de
saída.
Você também pode pedir à Cobalt Strike para reescrever todos os URLs no modelo com um URL de sua
escolha. Cole a URL ou pressione ... para escolher uma das ferramentas hospedadas pelo Cobalt Strike. As ferramentas
do Cobalt Strike incluem sites clonados, o servidor de exploração automática e o criador de perfil do sistema.
Quando você incorpora um URL, o Cobalt Strike anexará ?id=%TOKEN% a ele. Cada mensagem enviada receberá seu
próprio token. O Cobalt Strike usa esse token para mapear os visitantes do site para e-mails enviados. Se você se
preocupa com relatórios, certifique-se de manter esse valor em vigor.
36
Defina o Mail Server para uma retransmissão aberta ou o registro de troca de e-mail para seu destino. Se necessário, você
também pode se autenticar em um servidor de e-mail para enviar suas mensagens de phishing.
Pressione … ao lado do campo Mail Server para configurar opções de servidor adicionais. Você pode especificar um nome de
usuário e senha para autenticar. A opção Random Delay diz ao Cobalt Strike para atrasar aleatoriamente cada mensagem por
um tempo aleatório, até o número de segundos que você especificar. Se esta opção não estiver definida, Cobalt Strike não
atrasará suas mensagens.
Figura 30. Configurar Servidor de Correio
Defina Bounce To para um endereço de e-mail para onde as mensagens devolvidas devem ir. Esse valor não afetará a mensagem
que seus alvos veem. Pressione Visualizar para ver uma mensagem montada para um de seus destinatários. Se a visualização
estiver boa, pressione Enviar para entregar seu ataque.
Cobalt Strike envia mensagens de phishing através do servidor da equipe.
37
6. Artefatos de carga útil e evasão antivírus

6.1 Filosofia
A Strategic Cyber LLC regularmente responde a perguntas sobre evasão. O Cobalt Strike ignora os produtos
antivírus? Quais produtos antivírus ele ignora? Com que frequência isso é verificado?
Os artefatos padrão do Cobalt Strike provavelmente são capturados pela maioria das soluções de segurança de endpoint.
A evasão não é um objetivo do produto Cobalt Strike padrão. O Cobalt Strike oferece flexibilidade.
Você, o operador, pode alterar os executáveis, DLLs, applets e modelos de script que o Cobalt Strike usa em seus
fluxos de trabalho. Você também pode exportar a carga útil Beacon do Cobalt Strike em uma variedade de formatos
que funcionam com ferramentas de terceiros projetadas para ajudar na evasão.
Este capítulo destacará os recursos do Cobalt Strike que fornecem essa flexibilidade.
6.2 O Kit de Artefatos

Cobalt Strike usa o Artifact Kit para gerar seus executáveis e DLLs. O Artifact Kit é uma estrutura de código-
fonte para criar executáveis e DLLs que evitam alguns produtos antivírus.
A teoria do kit de artefatos

Os produtos antivírus tradicionais usam assinaturas para identificar problemas conhecidos. Se incorporarmos nosso
shellcode ruim conhecido em um executável, um produto antivírus reconhecerá o shellcode e sinalizará o executável
como malicioso.
Para anular essa detecção, é comum que um invasor ofusque o shellcode de alguma forma e o coloque no binário.
Esse processo de ofuscação anula os produtos antivírus que usam uma pesquisa de string simples para identificar
códigos maliciosos.
Muitos produtos antivírus vão um passo além. Esses produtos antivírus simulam a execução de um executável
em um sandbox virtual. A cada etapa de execução emulada, o produto antivírus verifica se há problemas
conhecidos no espaço do processo emulado. Se um defeito conhecido aparecer, o produto antivírus sinalizará o
executável ou a DLL como mal-intencionado. Essa técnica derrota muitos codificadores e empacotadores que
tentam ocultar problemas conhecidos de produtos antivírus baseados em assinatura.
O contador de Cobalt Strike para isso é simples. A sandbox antivírus tem limitações. Não é uma máquina
virtual completa. Existem comportamentos do sistema que o sandbox antivírus não emula.
O Artifact Kit é uma coleção de modelos executáveis e DLL que dependem de algum comportamento que os
produtos antivírus não emulam para recuperar o shellcode localizado dentro do binário.
Uma das técnicas [veja: src-common/bypass-pipe.c no Artifact Kit] gera executáveis e DLLs que servem shellcode
para eles mesmos através de um pipe nomeado. Se um sandbox antivírus não emular pipes nomeados, ele não
encontrará o shellcode inválido conhecido.
38
Onde o kit de artefatos falha

É claro que é possível que produtos antivírus anulem implementações específicas do Kit de Artefatos. Se um
fornecedor de antivírus gravar assinaturas para a técnica do Artifact Kit que você usa, os executáveis e as DLLs
que ele cria serão capturados. Isso começou a acontecer, com o tempo, com a técnica de desvio padrão no Cobalt
Strike 2.5 e abaixo. Se você deseja obter o máximo do Artifact Kit, você usará uma de suas técnicas como base
para construir sua própria implementação do Artifact Kit.
Mesmo que não é suficiente embora. Alguns produtos antivírus têm como lar os servidores do fornecedor do
antivírus. Lá, o fornecedor determina se o executável ou DLL é conhecido como bom ou desconhecido, nunca
antes visto, executável ou DLL. Alguns desses produtos enviam automaticamente executáveis e DLLs
desconhecidos ao fornecedor para análise posterior e avisam os usuários. Outros tratam executáveis e DLLs
desconhecidos como maliciosos. Depende do produto e suas configurações.
O ponto: nenhuma quantidade de “ofuscação” vai ajudá-lo nessa situação. Você está enfrentando um tipo diferente
de defesa e precisará contorná-lo de acordo. Trate essas situações da mesma forma que você trataria a lista de
permissões de aplicativos. Tente encontrar um bom programa conhecido (por exemplo, powershell) que coloque
seu estágio de carga útil na memória.
Como usar o kit de artefatos

Vá para Ajuda -> Arsenal de um Cobalt Strike licenciado para baixar o Artifact Kit. Você também pode acessar o
Arsenal diretamente em:
https://www.cobaltstrike.com/scripts
A Strategic Cyber LLC distribui o Kit de Artefatos como um arquivo .tgz. Use o comando tar para extraí-lo.
O Artifact Kit inclui um script build.sh. Execute este script no Kali Linux, sem argumentos, para construir as técnicas
padrão do Artifact Kit com o Minimal GNU for Windows Cross Compiler.
Figura 31. O processo de criação do kit de artefatos
O script de construção do Artifact Kit cria uma pasta com artefatos de modelo para cada técnica do Artifact
Kit. Para usar uma técnica com Cobalt Strike, vá para Cobalt Strike -> Script Manager e carregue o script
artifact.cna da pasta dessa técnica.
Você é encorajado a modificar o Kit de Artefatos e suas técnicas para que ele atenda às suas necessidades.
Embora programadores C habilidosos possam fazer mais com o Kit de Artefatos, é bastante viável para um
39
aventureiro não-programador para trabalhar com o Artifact Kit também. Por exemplo, um grande produto
antivírus gosta de escrever assinaturas para os executáveis no teste do Cobalt Strike cada vez que há um
lançamento. Até o Cobalt Strike 2.5, as versões de teste e licenciadas do Cobalt Strike usavam a técnica de
pipe nomeado em seus executáveis e DLLs. Esse fornecedor escreveria uma assinatura para a string de
pipe nomeada que o executável usou. Derrotar suas assinaturas, lançamento após lançamento, era tão
simples quanto mudar o nome do pipe no código-fonte da técnica do pipe.
6.3 A Estrutura de Evasão do Véu
Veil é uma estrutura popular para gerar executáveis que passam por alguns produtos antivírus. Você pode
usar o Veil para gerar executáveis para as cargas úteis do Cobalt Strike. Vá para Ataques -> Pacotes -
> Gerador de carga útil. Escolha o ouvinte para o qual deseja gerar um executável. Selecione Véu como o
tipo de saída. Pressione Gerar e salve o arquivo.
Inicie o Veil Evasion Framework e escolha a técnica que deseja usar. Veil eventualmente perguntará
sobre shellcode. Selecione a opção do Veil para fornecer shellcode personalizado. Cole o conteúdo do
arquivo que o gerador de carga útil do Cobalt Strike criou. Pressione enter e você terá um novo executável
feito pelo Veil.
Figura 32. Usando o Veil para gerar um executável
6.4 Ataques de miniaplicativos Java
A Strategic Cyber LLC distribui o código-fonte para os Applet Attacks da Cobalt Strike como o Applet Kit. Isso
também está disponível no arsenal Cobalt Strike. Vá em Ajuda -> Arsenal e baixe o Applet Kit.
Use o script build.sh incluído para construir o Applet Kit no Kali Linux. Muitos clientes da Cobalt Strike
usam essa flexibilidade para assinar os ataques Java Applet da Cobalt Strike com um certificado de
assinatura de código que eles compraram. Isso é altamente recomendado.
Para fazer com que o Cobalt Strike use seu Applet Kit sobre o interno, carregue o script applet.cna
incluído com o Applet Kit.
40
Na página Cobalt Strike Arsenal você também notará o Power Applet. Esta é uma implementação
alternativa dos ataques Java Applet do Cobalt Strike que usa o PowerShell para obter uma carga útil na
memória. O Power Applet demonstra a flexibilidade que você tem para recriar os ataques padrão do Cobalt
Strike de uma maneira completamente diferente e ainda usá-los com os fluxos de trabalho do Cobalt Strike.
Para fazer com que o Cobalt Strike use seu Applet Kit sobre o interno, carregue o script applet.cna
incluído com o Applet Kit.
6.5 O Kit de Recursos

O Resource Kit é o meio do Cobalt Strike para alterar os modelos de script HTA, PowerShell, Python,
VBA e VBS que o Cobalt Strike usa em seus fluxos de trabalho. Novamente, o Resource Kit está disponível
para usuários licenciados no arsenal Cobalt Strike. Vá para Ajuda -> Arsenal para baixar o Kit de Recursos.
O arquivo README.txt com o Resource Kit documenta os scripts incluídos e quais recursos os utilizam.
Para evitar um produto, considere alterar strings ou comportamentos nesses scripts.
Para fazer com que o Cobalt Strike use seus modelos de script sobre os modelos de script internos,
carregue o script resources.cna incluído no Resource Kit.
41
7. Pós-Exploração
7.1 O Console do Sinalizador
Clique com o botão direito do mouse em uma sessão do Beacon e selecione interagir para abrir o console
desse Beacon. O console é a principal interface do usuário para sua sessão Beacon. O console do Beacon
permite ver quais tarefas foram emitidas para um Beacon e ver quando ele as baixa. O console Beacon
também é onde a saída do comando e outras informações aparecerão.
Figura 33. Console do Beacon Cobalt Strike
Entre a entrada e a saída do console Beacon há uma barra de status. Esta barra de status contém
informações sobre a sessão atual. Em sua configuração padrão, a barra de status mostra o nome
NetBIOS do destino, o nome de usuário e o PID da sessão atual e o último horário de check-in do
Beacon.
Cada comando que é emitido para um Beacon, seja por meio da GUI ou do console, aparecerá nesta janela.
Se um companheiro de equipe emitir um comando, Cobalt Strike irá pré-fixar o comando com seu identificador.
Você provavelmente passará a maior parte do tempo com Cobalt Strike no console Beacon. Vale a pena
o seu tempo para se familiarizar com seus comandos. Digite help no console do Beacon para ver os
comandos disponíveis. Digite help seguido de um nome de comando para obter ajuda detalhada.
7.2 O Menu Sinalizador

Clique com o botão direito do mouse em um Beacon ou dentro do console de um Beacon para acessar o
menu Beacon. Este é o mesmo menu usado para abrir o console Beacon. O menu Acesso contém opções
para manipular material confiável e elevar seu acesso. O menu Explorar consiste em opções para extrair
informações e interagir com o sistema do alvo. O menu Pivoting é onde você pode configurar ferramentas
para encapsular o tráfego através de um Beacon. O menu Session é onde você gerencia a sessão atual do
Beacon.
42
Figura 34. Menu do Sinalizador de Ataque de Cobalto
Algumas das visualizações do Cobalt Strike (o gráfico dinâmico e a tabela de sessões) permitem selecionar vários Beacons
ao mesmo tempo. A maioria das ações que acontecem por meio deste menu serão aplicadas a todas as sessões de Beacon
selecionadas.
7.3 Operações Assíncronas e Interativas

Esteja ciente de que o Beacon é uma carga assíncrona. Os comandos não são executados imediatamente. Cada comando
vai para uma fila. Quando o Beacon fizer check-in (conectar a você), ele fará o download desses comandos e os executará
um por um. Neste momento, o Beacon também relatará qualquer saída que tiver para você. Se você cometer um erro, use o
comando clear para limpar a fila de comandos do Beacon atual .
Por padrão, os Beacons fazem check-in a cada sessenta segundos. Você pode mudar isso com o sono do Beacon
comando. Use sleep seguido por um tempo em segundos para especificar com que frequência o Beacon deve fazer check-in.
Você também pode especificar um segundo número entre 0 e 99. Esse número é um fator de jitter. O Beacon variará cada
um de seus tempos de check-in pela porcentagem aleatória que você especificar como um fator de jitter. Por exemplo, sleep
300 20, forçará o Beacon a dormir por 300 segundos com uma porcentagem de jitter de 20%.
Isso significa que o Beacon irá dormir por um valor aleatório entre 240s e 300s após cada check-in.
Para fazer um check-in de Beacon várias vezes a cada segundo, tente dormir 0. Este é o modo interativo. Neste modo, os
comandos serão executados imediatamente. Você deve tornar seu Beacon interativo antes de encapsular o tráfego através
dele. Alguns comandos do Beacon (por exemplo, browserpivot, desktop, etc.) colocarão automaticamente o Beacon no modo
interativo no próximo check-in.
7.4 Comandos de Execução

O comando shell do Beacon encarregará um Beacon de executar um comando via cmd.exe no host
comprometido. Quando o comando for concluído, o Beacon apresentará a saída para você.
Use o comando run para executar um comando sem cmd.exe. O comando run enviará a saída para você. O comando
execute executa um programa em segundo plano e não captura a saída.
43
Use o comando powershell para executar um comando com o PowerShell no host comprometido.
Use o comando powerpick para executar cmdlets do PowerShell sem powershell.exe. Este comando baseia-se na
técnica Unmanaged PowerShell desenvolvida por Lee Christensen. Os comandos powershell e powerpick usarão seu token
atual.
O comando psinject injetará o PowerShell não gerenciado em um processo específico e executará seu cmdlet a partir desse
local.
O comando powershell-import importará um script do PowerShell para o Beacon. Usos futuros dos comandos powershell,
powerpick e psinject terão cmdlets do script importado disponíveis para eles. O Beacon conterá apenas um script do PowerShell
por vez. Importe um arquivo vazio para limpar o script importado do Beacon.
O comando execute-assembly executará um executável .NET local como um trabalho de pós-exploração do Beacon. Você pode
passar argumentos para este assembly como se ele fosse executado a partir de uma interface de linha de comando do Windows.
Este comando também herdará seu token atual.
Se você quiser que o Beacon execute comandos de um diretório específico, use o comando cd no console do Beacon para
alternar o diretório de trabalho do processo do Beacon. O comando pwd lhe dirá de qual diretório você está trabalhando no
momento.
O comando setenv definirá uma variável de ambiente.
7.5 Passagem de Sessão

O Beacon da Cobalt Strike começou como uma tábua de salvação estável para manter o acesso a um host comprometido.
Desde o primeiro dia, o objetivo principal do Beacon era passar acessos a outros ouvintes do Cobalt Strike.
Use o comando spawn para gerar uma sessão para um ouvinte. O comando spawn aceita uma arquitetura (por exemplo,
x86, x64) e um ouvinte como seus argumentos.
Por padrão, o comando spawn gerará uma sessão em rundll32.exe. Um administrador de alerta pode achar estranho que o
rundll32.exe esteja periodicamente fazendo conexões com a Internet. Encontre um programa melhor (por exemplo, Internet
Explorer) e use o comando spawnto para indicar qual programa Beacon deve gerar para suas sessões.
O comando spawnto requer que você especifique uma arquitetura (x86 ou x64) e um caminho completo para um programa a
ser gerado, conforme necessário. Digite spawnto sozinho e pressione enter para instruir o Beacon a ir
de volta ao seu comportamento padrão.
Digite inject seguido por um ID de processo e um nome de ouvinte para injetar uma sessão em um processo específico.
Use ps para obter uma lista de processos no sistema atual. Use inject [pid] x64 para injetar um Beacon de 64 bits em um
processo x64.
Os comandos spawn e inject injetam um estágio de carga útil na memória. Se o estágio de carga útil for um HTTP, HTTPS ou
DNS Beacon e não puder alcançá-lo, você não verá uma sessão. Se o estágio de carga útil for um TCP ou SMB Beacon de
ligação, esses comandos tentarão automaticamente se conectar e assumir o controle dessas cargas.
44
Use dllinject [pid] para injetar uma DLL reflexiva em um processo.
Use o comando shinject [pid] [architecture] [/path/to/file.bin] para injetar shellcode, de um arquivo local, em um
processo no destino. Use shspawn [architecture] [/path/to/file.bin] para gerar o processo “spawn to” e injetar o arquivo
shellcode especificado nesse processo.
Use dllload [pid] [c:\path\to\file.dll] para carregar uma DLL em disco em outro processo.
7.6 Processos Pais Alternativos

Use ppid [pid] para atribuir um processo pai alternativo para programas executados por sua sessão Beacon.
Este é um meio de fazer com que sua atividade se misture com ações normais no alvo. A sessão atual do Beacon
deve ter direitos para o pai alternativo e é melhor se o processo pai alternativo existir na mesma sessão da área de
trabalho do seu Beacon. Digite ppid, sem argumentos, para ter processos de inicialização do Beacon sem pai
falsificado.
O comando runu executará um comando com outro processo como pai. Este comando será executado com os direitos e
a sessão da área de trabalho de seu processo pai alternativo. A sessão Beacon atual deve ter direitos totais para o pai
alternativo. O comando spawnu gerará um processo temporário, como filho de um processo especificado, e injetará um
estágio de carga útil Beacon nele.
O valor spawnto controla qual programa é usado como um processo temporário.
7.7 Argumentos do processo de falsificação

Cada Beacon tem uma lista interna de comandos para os quais deve falsificar argumentos. Quando o Beacon executa um
comando que corresponde a uma lista, o Beacon:
1. Inicia o processo correspondente em um estado suspenso (com os argumentos falsos)

2. Atualiza a memória do processo com os argumentos reais
3. Retoma o processo
O efeito é que a instrumentação do host que registra um lançamento de processo verá os argumentos falsos.
Isso ajuda a mascarar sua atividade real.
Use argument [comando] [argumentos falsos] para adicionar um comando a esta lista interna. A parte [comando] pode
conter uma variável de ambiente. Use argument [comando] para remover um comando desta lista interna. argument, por
si só, lista os comandos nesta lista interna.
A lógica de correspondência do processo é exata. Se o Beacon tentar iniciar “net.exe”, ele não corresponderá a
net, NET.EXE ou c:\windows\system32\net.exe de sua lista interna. Ele corresponderá apenas ao net.exe.
O x86 Beacon só pode falsificar argumentos em processos filho x86. Da mesma forma, o x64 Beacon só pode falsificar
argumentos em processos filho x64.
Os argumentos reais são gravados no espaço de memória que contém os argumentos falsos. Se os argumentos reais
forem mais longos que os argumentos falsos, a inicialização do comando falhará.
45
7.8 Bloqueando DLLs em Processos Filhos

Use blockdlls para solicitar ao Beacon que inicie processos filho com uma política de assinatura binária que bloqueia
DLLs que não são da Microsoft do espaço do processo. Use blockdlls parar para desabilitar esse comportamento.
Esse recurso requer o Windows 10.
7.9 Carregar e Baixar Arquivos

O comando download fará o download do arquivo solicitado. Você não precisa fornecer aspas em torno de um
nome de arquivo com espaços nele. Beacon é construído para baixa e lenta exfiltração de dados. Durante cada check-
in, o Beacon baixará uma parte fixa de cada arquivo que está encarregado de obter. O tamanho desse pedaço
depende do canal de dados atual do Beacon. Os canais HTTP e HTTPS extraem dados em blocos de 512 KB.
Digite downloads para ver uma lista de downloads de arquivos em andamento para o Beacon atual. Use o
comando cancelar , seguido de um nome de arquivo, para cancelar um download em andamento. Você pode usar
curingas com seu comando de cancelamento para cancelar vários downloads de arquivos de uma só vez.
Vá para Visualizar -> Downloads no Cobalt Strike para ver os arquivos que sua equipe baixou até agora.
Somente os downloads concluídos serão exibidos nesta guia. Os arquivos baixados são armazenados no servidor
de equipe. Para trazer os arquivos de volta ao seu sistema, destaque-os aqui e pressione Sincronizar Arquivos.
O Cobalt Strike fará o download dos arquivos selecionados para uma pasta de sua escolha em seu sistema.
O comando upload fará upload de um arquivo para o host.
Ao fazer upload de um arquivo, às vezes você desejará atualizar seus carimbos de data e hora para que ele se
misture com outros arquivos na mesma pasta. Use o comando timestomp para fazer isso. O comando timestomp
corresponderá aos horários Modificado, Acessado e Criado de um arquivo para outro arquivo.
7.10 Navegador de arquivos
O File Browser do Beacon é uma oportunidade de explorar os arquivos em um sistema comprometido. Vá para
[Beacon] -> Explore -> File Browser para abri-lo.
O navegador de arquivos solicitará uma listagem do diretório de trabalho atual do Beacon. Quando esse resultado
chegar, o navegador de arquivos será preenchido.
O lado esquerdo do navegador de arquivos é uma árvore que organiza as unidades e pastas conhecidas em uma
visualização. O lado direito do navegador de arquivos mostra o conteúdo da pasta atual.
46
Figura 35. Navegador de arquivos
Cada navegador de arquivos armazena em cache as listagens de pastas que recebe. Uma pasta colorida indica que o conteúdo
da pasta está no cache deste navegador de arquivos. Você pode navegar para pastas em cache sem gerar uma nova solicitação de
listagem de arquivos. Pressione Atualizar para solicitar ao Beacon que atualize o conteúdo da pasta atual.
Uma pasta cinza-escuro significa que o conteúdo da pasta não está no cache deste navegador de arquivos. Clique em uma pasta
na árvore para que o Beacon gere uma tarefa para listar o conteúdo dessa pasta (e atualizar seu cache). Clique duas vezes em uma
pasta cinza escuro na visualização da pasta atual do lado direito para fazer o
mesmo.
Para subir uma pasta, pressione o botão de pasta ao lado do caminho do arquivo acima da visualização de detalhes da pasta do
lado direito. Se a pasta pai estiver no cache deste navegador de arquivos, você verá os resultados imediatamente. Se a pasta pai
não estiver no cache do navegador de arquivos, o navegador gerará uma tarefa para listar o conteúdo da pasta pai.
Clique com o botão direito do mouse em um arquivo para baixá-lo ou excluí-lo.
Para ver quais unidades estão disponíveis, pressione Listar unidades.
7.11 Comandos do Sistema de Arquivos

Você pode preferir navegar e manipular o sistema de arquivos no console do Beacon. Você também pode fazer isso. Use o comando
ls para listar os arquivos no diretório atual. Use mkdir para criar um diretório.
rm irá remover um arquivo ou pasta. cp copia um arquivo para um destino. mv move um arquivo.
7.12 O Registro do Windows

Use reg_query [x86|x64] [HIVE\path\to\key] para consultar uma chave específica no registro. Este comando imprimirá os
valores dessa chave e uma lista de todas as subchaves. A opção x86/x64 é necessária e força o Beacon a usar o WOW64 (x86) ou
a exibição nativa do registro. reg_query [x86|x64] [HIVE\path\to\key] [value] consultará um valor específico em uma chave do
Registro.
47
7.13 Teclas e capturas de tela

As ferramentas do Beacon para registrar pressionamentos de tecla e fazer capturas de tela são projetadas para injetar em outro processo
e relatar seus resultados ao seu Beacon.
Para iniciar o keylogger, use o keylogger pid para injetar em um processo x86. Usar keylogger pid
x64 para injetar em um processo x64. Explorer.exe é um bom candidato para esta ferramenta. Usar keylogger
por si só para injetar o keystroke logger em um processo temporário. O keystroke logger monitorará os pressionamentos de
tecla do processo injetado e os reportará ao Beacon até que o processo termine ou você elimine o trabalho de pós-exploração
do keystroke logger.
Esteja ciente de que vários registradores de pressionamento de tecla podem entrar em conflito entre si. Use apenas um keystroke
logger por sessão de desktop.
Para fazer uma captura de tela, use o pid de captura de tela para injetar a ferramenta de captura de tela em um processo x86. Use
a captura de tela pid x64 para injetar em um processo x64. Novamente, explorer.exe é um bom candidato para esta ferramenta. Esta
variante do comando screenshot fará uma captura de tela e sairá. A captura de tela, por si só, injetará a ferramenta de captura de tela
em um processo temporário. Use a arquitetura pid de captura de tela
é hora de solicitar que a ferramenta de captura de tela seja executada por alguns segundos e relatar uma captura de tela sempre que
o Beacon fizer check-in. Essa é uma maneira prática de observar a área de trabalho de um usuário.
Quando o Beacon receber novas capturas de tela ou pressionamentos de tecla, ele postará uma mensagem no console do
Beacon. As informações de captura de tela e pressionamento de tecla não estão disponíveis no console do Beacon. Vá para View ->
Keystrokes para ver os pressionamentos de tecla registrados em todas as suas sessões de Beacon.
Vá para Exibir -> Capturas de tela para navegar pelas capturas de tela de todas as suas sessões do Beacon.
Ambas as caixas de diálogo são atualizadas à medida que novas informações chegam. Essas caixas de diálogo facilitam para um
operador monitorar pressionamentos de tecla e capturas de tela em todas as suas sessões de Beacon.
7.14 Trabalhos Pós-Exploração

Vários recursos do Beacon são executados como tarefas em outro processo (por exemplo, o keystroke logger e a ferramenta de captura
de tela). Esses trabalhos são executados em segundo plano e relatam sua saída quando disponível. Use os empregos
comando para ver quais trabalhos estão sendo executados em seu Beacon. Use jobkill [número do trabalho] para eliminar um trabalho.
7.15 O Navegador de Processos

O Process Browser faz o óbvio; ele encarrega um Beacon de mostrar uma lista de processos e mostra essas informações para você.
O lado esquerdo mostra os processos organizados em uma árvore. O processo atual do seu Beacon é destacado em amarelo.
O lado direito mostra os detalhes do processo. O Process Browser também é um local conveniente para representar um token de outro
processo, implantar a ferramenta de captura de tela ou implantar o keystroke logger. Realce um ou mais processos e pressione o botão
apropriado na parte inferior da guia.
48
Figura 36. Navegador de processos
Se você destacar vários Beacons e encarregá-los de mostrar processos, o Cobalt Strike mostrará um Process
Browser que também informa de qual host o processo vem. Essa variante do Process Browser é uma maneira
conveniente de implantar as ferramentas de pós-exploração do Beacon em vários sistemas de uma só vez. Basta
classificar por nome de processo, destacar os processos interessantes em seus sistemas de destino e pressionar o
botão Captura de tela ou Log de pressionamentos de tecla para implantar essas ferramentas em todos os sistemas
destacados.
7.16 Controle de Área de Trabalho

Para interagir com um desktop em um host de destino, vá para [beacon] -> Explore -> Desktop (VNC). Isso colocará
um servidor VNC na memória do processo atual e fará um túnel da conexão por meio do Beacon.
Quando o servidor VNC estiver pronto, o Cobalt Strike abrirá uma guia chamada Desktop HOST@PID.
Você também pode usar o comando desktop do Beacon para injetar um servidor VNC em um processo específico.
Use a arquitetura pid de desktop low|high. O último parâmetro permite especificar uma qualidade para a sessão
VNC.
49
Figura 37. Visualizador de desktop Cobalt Strike
A parte inferior da guia da área de trabalho tem vários botões. Estes são:
Atualizar a tela
Somente visualização
Diminuir Zoom
Aumentar Zoom
Zoom para 100%
Ajustar o zoom para ajustar a guia
Enviar Ctrl+Escape
Bloqueie a tecla Ctrl
Bloqueie a tecla Alt
Se você não puder digitar em uma guia da área de trabalho, verifique o estado dos botões Ctrl e Alt . Quando um
dos botões é pressionado, todas as teclas pressionadas são enviadas com o modificador Ctrl ou Alt. Pressione o botão
Ctrl ou Alt para desativar esse comportamento. Certifique -se de que View only também não esteja pressionado. Para
evitar que você mova o mouse acidentalmente, apenas Exibir é pressionado por padrão.
50
7.17 Escalonamento de Privilégios

Alguns comandos de pós-exploração requerem direitos em nível de administrador do sistema. O Beacon inclui
várias opções para ajudá-lo a elevar seu acesso.
Elevar com um Exploit

Digite elevate para listar explorações de escalonamento de privilégios registradas no Cobalt Strike. Execute
elevate [exploit] [listener] para tentar elevar com um exploit específico. Você também pode lançar um desses exploits
através de [beacon] -> Access -> Elevate.
Use runasadmin, por si só, para listar as explorações do elevador de comando registradas no Cobalt Strike. Execute
runasadmin [exploit] [command + args] para tentar executar o comando especificado em um ambiente elevado
contexto.
Cobalt Strike separa explorações de elevador de comando e explorações de rendimento de sessão porque alguns
ataques são uma oportunidade natural para gerar uma sessão. Outros ataques geram um “executar este comando”
primitivo. Gerar uma sessão a partir de uma primitiva “executar este comando” coloca muitas decisões de armamento
(nem sempre favoráveis) nas mãos de seu desenvolvedor de ferramentas. Com runasadmin, é sua escolha soltar um
executável no disco e executá-lo, executar um one-liner do PowerShell ou enfraquecer o destino de alguma forma.
Se você quiser usar um one-liner do PowerShell para gerar uma sessão, vá para [session] -> Access -> One liner.
Essa caixa de diálogo configurará um servidor da Web somente localhost em sua sessão do Beacon para hospedar
um estágio de carga útil e retornar um comando do PowerShell para baixar e executar esse estágio de carga útil.
Este servidor web é de uso único. Uma vez conectado a uma vez, ele se limpará e deixará de servir sua carga útil.
Se você executar um TCP ou SMB Beacon com esta ferramenta, precisará usar conectar ou link para assumir o
controle da carga manualmente. Além disso, esteja ciente de que, se você tentar usar uma carga x64, isso falhará
se o x86 PowerShell estiver em seu $PATH.
Figura 38. PowerShell One-liner
O Cobalt Strike não possui muitas opções de elevação integradas. O desenvolvimento de exploits não é o foco do
trabalho da Strategic Cyber LLC. No entanto, é fácil integrar explorações de escalonamento de privilégios por meio
da linguagem de programação Aggressor Script da Cobalt Strike. Para ver como é, baixe o Elevate Kit. O Elevate Kit
é um Script Agressor que integra várias explorações de escalonamento de privilégios de código aberto no Cobalt
Strike. https://github.com/rsmudge/ElevateKit
51
Elevar com credenciais conhecidas

Use runas [DOMAIN\user] [password] [command] para executar um comando como outro usuário usando suas
credenciais. O comando runas não retornará nenhuma saída. Você pode usar runas de um contexto não privilegiado.
Use spawnas [DOMÍNIO\usuário] [senha] [ouvinte] para gerar uma sessão como outro usuário usando suas credenciais.
Este comando gera um processo temporário e injeta seu estágio de carga útil nele. Você também pode ir para [beacon] ->
Access -> Spawn As para executar este comando também.
Com esses dois comandos, esteja ciente de que as credenciais para uma conta não SID 500 gerarão uma carga útil em um
contexto de integridade média. Você precisará usar o Bypass UAC para elevar a um nível alto
contexto de integridade. Além disso, esteja ciente de que você deve executar esses comandos de uma pasta de trabalho
que a conta especificada possa ler.
Obter SISTEMA
Use getsystem para representar um token para a conta SYSTEM. Esse nível de acesso pode permitir que você execute
ações privilegiadas que não são possíveis como usuário Administrador.
Outra maneira de obter SYSTEM é criar um serviço que execute uma carga útil. O comando elevar svc-exe [ouvinte]
faz isso. Ele descartará um executável que executa uma carga útil, criará um serviço para executá-lo, assumirá o controle
da carga útil e limpará o serviço e o executável.
Bypass UAC
A Microsoft introduziu o Controle de Conta de Usuário (UAC) no Windows Vista e o refinou no Windows 7. O UAC funciona
muito como o sudo no UNIX. No dia-a-dia um usuário trabalha com privilégios normais. Quando o usuário precisa realizar uma
ação privilegiada, o sistema pergunta se ele gostaria de elevar seus direitos.
Cobalt Strike vem com alguns ataques de desvio do UAC. Esses ataques não funcionarão se o usuário atual não for um
administrador. Para verificar se o usuário atual está no grupo Administradores, use run
whoami /grupos.
elevar uac-token-duplication [ouvinte] gerará um processo temporário com direitos elevados e injetará um estágio de
carga útil nele. Esse ataque usa uma brecha do UAC que permite que um processo não elevado inicie um processo
arbitrário com um token roubado de um processo elevado. Essa brecha exige que o ataque remova vários direitos
atribuídos ao token elevado. As habilidades de sua nova sessão refletirão esses direitos restritos. Se Always Notify estiver
em sua configuração mais alta, esse ataque exigirá que um processo elevado já esteja em execução na sessão atual da área
de trabalho (como o mesmo usuário). Este ataque funciona no Windows 7 e no Windows 10 antes da atualização de novembro
de 2018.
runasadmin uac-token-duplication [command] é o mesmo ataque descrito acima, mas esta variante executa um
comando de sua escolha em um contexto elevado.
runasadmin uac-cmstplua [comando] tentará ignorar o UAC e executar um comando em um contexto elevado. Esse
ataque se baseia em um objeto COM que eleva automaticamente de determinados contextos de processo (assinado pela
Microsoft, reside em c:\windows\*).
52
Privilégios
Digite getprivs para habilitar os privilégios atribuídos ao seu token de acesso atual.
7.18 Mimicatz
Beacon integra mimikatz. Use o comando mimikatz para passar qualquer comando para o despachante de
comandos do mimikatz. Por exemplo, mimikatz standard::coffee lhe dará uma xícara de café.
O Beacon se encarregará de injetar uma instância mimikatz que corresponda à arquitetura nativa do seu destino.
Alguns comandos mimikatz devem ser executados como SYSTEM para funcionar. Prefixe um comando com um !
para forçar o mimikatz a elevar para SYSTEM antes de executar seu comando. Por exemplo, mimikatz !lsa::cache
recuperará hashes de senha salgada armazenados em cache pelo sistema.
De vez em quando, você pode precisar executar um comando mimikatz com o token de acesso atual do Beacon.
Prefixe um comando com um @ para forçar o mimikatz a representar o token de acesso atual do Beacon. Por
exemplo, mimikatz @lsadump::dcsync executará o comando dcsync em mimikatz com o token de acesso atual do
Beacon.
7.19 Coleta de credenciais e hash

Para despejar hashes, vá para [beacon] -> Access -> Dump Hashes. Você também pode usar o hashdump
comando do console Beacon. Esses comandos gerarão um trabalho que injeta no LSASS e despeja os hashes de
senha para usuários locais no sistema atual.
O comando logonpasswords usará mimikatz para recuperar senhas de texto simples e hashes para usuários
conectados ao sistema atual. O comando logonpasswords é o mesmo que [beacon] -> Access -> Run Mimikatz.
Use dcsync [DOMAIN.FQDN] para obter hashes de senha para todas as contas de um controlador de
domínio. Essa técnica usa APIs do Windows criadas para sincronizar informações entre controladores de
domínio. Requer uma relação de confiança de administrador de domínio. Beacon usa mimikatz para executar
esta técnica. Use dcsync [DOMAIN.FQDN] [DOMAIN\user], se desejar um hash de senha específico.
As credenciais despejadas com esses comandos são coletadas pelo Cobalt Strike e armazenadas no modelo
de dados de credenciais. Vá para Exibir -> Credenciais para obter as credenciais da equipe atual
servidor.
7.20 Varredura de Porta

Beacon tem um scanner de porta embutido. Use o portscan [targets] [ports] [discovery method] para iniciar o
trabalho do scanner de porta. Você pode especificar uma lista de intervalos de destino separados por vírgulas. O
mesmo vale para as portas também. Por exemplo, as portascan 172.16.48.0/24 1-1024,8080 verificarão os hosts
172.16.48.0 a 172.16.48.255 nas portas 1 a 1024 e 8080.
Existem três opções de descoberta de destino. O método arp usa uma solicitação ARP para descobrir se um host
está ativo ou não. O método icmp envia uma solicitação de eco ICMP para verificar se um alvo está ativo.
A opção none diz à ferramenta portscan para assumir que todos os hosts estão ativos.
53
O scanner de porta será executado, entre os check-ins do Beacon. Quando tiver resultados para relatar, ele os enviará
para o console do Beacon. O Cobalt Strike processará essas informações e atualizará o modelo de destino com os hosts
descobertos.
7.21 Enumeração de Rede e Host

O módulo net do Beacon fornece ferramentas para interrogar e descobrir alvos em uma rede de diretório ativo do
Windows. Use o comando net dclist para localizar o controlador de domínio para o domínio ao qual o destino ingressou.
Use o comando net view para localizar destinos no domínio ao qual o destino ingressou. Ambos os comandos também
preenchem o modelo de destino. O comando net computadores
encontra destinos consultando grupos de contas de computador em um controlador de domínio.
Os comandos no módulo net do Beacon são construídos sobre as APIs de Enumeração de Rede do Windows. A maioria
desses comandos são substituições diretas de muitos dos comandos net internos do Windows. Há também alguns recursos
exclusivos aqui também. Por exemplo, use net localgroup \\TARGET para listar os grupos em outro sistema. Use net
localgroup \\TARGET group name para listar os membros de um grupo em outro sistema. Esses comandos são ótimos
durante o movimento lateral quando você precisa descobrir quem é um administrador local em outro sistema.
Use help net para obter uma lista de todos os comandos no módulo net do Beacon. Use o comando help net para
obter ajuda para cada comando individual.
7.22 Relações de Confiança

O coração do logon único do Windows é o token de acesso. Quando um usuário faz logon em um host Windows, um token
de acesso é gerado. Este token contém informações sobre o usuário e seus direitos. O token de acesso também contém
informações necessárias para autenticar o usuário atual em outro sistema na rede. Personifique ou gere um token e o
Windows usará suas informações para se autenticar em um recurso de rede para você.
Use steal_token [id do processo] para representar um token de um processo existente. Se você quiser ver quais
processos estão sendo executados, use ps. O comando getuid imprimirá seu token atual. Use rev2self para voltar ao
seu token original.
Se você conhece as credenciais de um usuário; use make_token [DOMAIN\user] [password] para gerar um token que
passe essas credenciais. Este token é uma cópia do seu token atual com informações de logon único modificadas. Ele
mostrará seu nome de usuário atual. Este é o comportamento esperado.
Use mimikatz para passar o hash com Beacon. O comando Beacon pth [DOMAIN\user] [ntlm hash] criará e personificará
um token de acesso para passar o hash especificado.
A caixa de diálogo Make Token do Beacon ([beacon] -> Access -> Make Token) é um front-end para esses
comandos. Ele apresentará o conteúdo do modelo de credencial e usará o comando certo para transformar a entrada de
credencial selecionada em um token de acesso.
Ingressos Kerberos
Use kerberos_ticket_use [/path/to/ticket] para injetar um tíquete Kerberos na sessão atual.
Isso permitirá que o Beacon interaja com sistemas remotos usando os direitos deste ticket. Tente isso com um Golden
Ticket gerado pelo mimikatz 2.0.
54
Use kerberos_ticket_purge para limpar todos os tickets kerberos associados à sua sessão.
7.23 Movimento Lateral

Depois de ter um token para um administrador de domínio ou um usuário de domínio que é um administrador local em
um destino, você pode abusar dessa relação de confiança para obter o controle do destino. O Beacon da Cobalt Strike
possui várias opções integradas para movimento lateral.
Digite jump para listar as opções de movimento lateral registradas com Cobalt Strike. Execute jump [module] [target]
[listener] para tentar executar uma carga útil em um destino remoto.
Módulo de salto Arco Descrição

psexec x86 Use um serviço para executar um artefato Service EXE
psexec64 x64 Use um serviço para executar um artefato Service EXE
psexec_psh x86 Use um serviço para executar um one-liner do PowerShell

winrm winrm64 x86 Execute um script do PowerShell via WinRM
x64 Execute um script do PowerShell via WinRM
Execute remote-exec, por si só, para listar os módulos de execução remota registrados no Cobalt Strike. Use remote-
exec [module] [target] [command + args] para tentar executar o comando especificado em um destino remoto.
Módulo de execução remota Descrição

psexec Execução remota via Service Control Manager
winrm Execução remota via WinRM (PowerShell)
wmi Execução remota via WMI (PowerShell)
O movimento lateral é uma área, semelhante à escalada de privilégios, onde alguns ataques apresentam um conjunto
natural de primitivos para gerar uma sessão em um alvo remoto. Alguns ataques fornecem apenas uma execução primitiva.
A divisão entre salto e execução remota oferece flexibilidade para decidir como armar um primitivo somente de execução.
O Aggressor Script possui uma API para adicionar novos módulos para jump e remote-exec. Consulte a documentação
do Aggressor Script (o capítulo Beacon, especificamente) para obter mais informações.
55
7.24 GUI de movimento lateral

O Cobalt Strike também fornece uma GUI para facilitar o movimento lateral. Mudar para os alvos
Visualização ou vá para Exibir -> Destinos. Navegue até [alvo] -> Saltar e escolha a opção de movimento lateral
desejada.
A seguinte caixa de diálogo será aberta:
Figura 39. Diálogo de Movimento Lateral
Para usar esta caixa de diálogo:
Primeiro, decida qual confiança você deseja usar para o movimento lateral. Se você quiser usar o token em um de
seus Beacons, marque a caixa Usar token de acesso atual da sessão . Se você quiser usar credenciais ou hashes
para movimento lateral, tudo bem também. Selecione as credenciais do armazenamento de credenciais ou preencha os
campos Usuário, Senha e Domínio. O Beacon usará essas informações para gerar um token de acesso para você. Lembre-
se de que você precisa operar a partir de um contexto de alta integridade [administrador] para que isso funcione.
Em seguida, escolha o ouvinte a ser usado para o movimento lateral. O SMB Beacon geralmente é um bom
candidato aqui.
Por último, selecione de qual sessão você deseja realizar o ataque de movimento lateral. O modelo assíncrono de ataque
do Cobalt Strike exige que cada ataque seja executado a partir de um sistema comprometido.
Não há opção para realizar este ataque sem uma sessão de Beacon para atacar. Se você estiver em um compromisso
interno, considere conectar um sistema Windows que você controla e use-o como ponto de partida para atacar outros
sistemas com credenciais ou hashes.
Pressione Iniciar. Cobalt Strike ativará a guia para o Beacon selecionado e emitirá comandos para ele. O feedback do
ataque aparecerá no console do Beacon.
56
8. Navegador Pivotante
8.1 Visão geral

Malwares como o Zeus e suas variantes se injetam no navegador do usuário para roubar informações bancárias.
Este é um ataque man-in-the-browser. Assim chamado, porque o invasor está injetando malware no navegador do
alvo.
O malware Man-in-the-browser usa duas abordagens para roubar informações bancárias. Eles capturam dados de
formulário à medida que são enviados para um servidor. Por exemplo, malware pode prender PR_Write no Firefox para
interceptar dados HTTP POST enviados pelo Firefox. Ou injetam JavaScript em determinadas páginas da Web para
fazer o usuário pensar que o site está solicitando informações de que o invasor precisa.
Cobalt Strike oferece uma terceira abordagem para ataques man-in-the-browser. Ele permite que o invasor sequestre
sessões da Web autenticadas — todas elas. Depois que um usuário faz login em um site, um invasor pode solicitar
que o navegador do usuário faça solicitações em seu nome. Como o navegador do usuário está fazendo a solicitação,
ele se autenticará novamente automaticamente em qualquer site no qual o usuário já esteja conectado. Eu chamo isso
de pivô do navegador - porque o invasor está girando seu navegador por meio do navegador do usuário comprometido.
Figura 40. Navegador pivotante em ação
A implementação da Cobalt Strike de dinamização do navegador para o Internet Explorer injeta um servidor proxy HTTP
no navegador do usuário comprometido. Não confunda isso com a alteração das configurações de proxy do usuário.
Este servidor proxy não afeta como o usuário chega a um site. Em vez disso, esse servidor proxy está disponível para
o invasor. Todas as solicitações que chegam por ele são atendidas pelo navegador do usuário.
57
8.2 Configuração
Para configurar o pivô do navegador, vá para [beacon] -> Explore -> Browser Pivot. Escolha a instância do Internet
Explorer na qual você deseja injetar. Você também pode decidir a qual porta vincular o servidor proxy dinâmico do
navegador.
Figura 41. Iniciar um pivô do navegador
Esteja ciente de que o processo em que você injeta é muito importante. Injete no Internet Explorer para herdar as
sessões da Web autenticadas de um usuário. As versões modernas do Internet Explorer geram cada guia em seu próprio
processo. Se seu destino usa uma versão moderna do Internet Explorer, você deve injetar um processo associado a uma
guia aberta para herdar o estado da sessão. Qual processo de guia não importa (as guias filhas compartilham o estado da
sessão). Identifique os processos da guia do Internet Explorer examinando o valor PPID na caixa de diálogo de configuração
do Browser Pivoting. Se o PPID referenciar explorer.exe, o processo não está associado a uma guia. Se o PPID fizer
referência a iexplore.exe, o processo será associado a uma guia. O Cobalt Strike mostrará uma marca de seleção ao lado
dos processos nos quais acha que você deve injetar.
Depois que o Browser Pivot estiver configurado, configure seu navegador da Web para usar o servidor Browser Pivot Proxy.
Lembre-se, o servidor Browser Pivot da Cobalt Strike é um servidor proxy HTTP.
Figura 42. Definir as configurações do navegador
58
8.3 Uso
Você pode navegar na web como seu usuário de destino assim que a rotação do navegador for iniciada. Esteja ciente de
que o servidor proxy dinâmico do navegador apresentará seu certificado SSL para sites habilitados para SSL que você visitar.
Isso é necessário para que a tecnologia funcione.
O servidor proxy dinâmico do navegador solicitará que você adicione um host ao armazenamento confiável do navegador quando
detectar um erro de SSL. Adicione esses hosts ao armazenamento confiável e pressione atualizar para que os sites protegidos por SSL
sejam carregados corretamente.
Se o seu navegador fixar o certificado de um site de destino, você pode achar impossível fazer com que seu
navegador aceite o certificado SSL do servidor proxy dinâmico do navegador. Isso é uma dor. Uma opção é usar um
navegador diferente. O navegador Chromium de código aberto tem uma opção de linha de comando para ignorar todos os
erros de certificado. Isso é ideal para uso de pivotagem do navegador:
chromium --ignore-certificate-errors --proxy-server=[host]:[port]
Para parar o servidor proxy Browser Pivot, digite browserpivot stop em seu console Beacon.
Você precisará reinjetar o servidor proxy dinâmico do navegador se o usuário fechar a guia na qual você está trabalhando. A
guia Browser Pivot irá avisá-lo quando não puder se conectar ao servidor proxy pivot do navegador no navegador.
8.4 Como funciona

O Internet Explorer delega toda a sua comunicação a uma biblioteca chamada WinINet. Esta biblioteca, que qualquer
programa pode usar, gerencia cookies, sessões SSL e autenticação de servidor para seus consumidores. O Browser
Pivoting da Cobalt Strike aproveita o fato de que o WinINet gerencia de forma transparente a autenticação e a
reautenticação por processo. Ao injetar a tecnologia Browser Pivoting da Cobalt Strike na instância do Internet Explorer
de um usuário, você obtém essa reautenticação transparente gratuitamente.
59
9. Girando
9.1 O que é Pivoting
Pivotar, para fins deste manual, é transformar um sistema comprometido em um ponto de salto para outros ataques e
ferramentas. O Beacon da Cobalt Strike oferece várias opções de pivotamento. Para cada uma dessas opções, você
deve certificar-se de que seu Beacon esteja no modo interativo. O modo interativo é quando um Beacon faz check-in
várias vezes a cada segundo. Use o comando sleep 0 para colocar seu Beacon no modo interativo.
9.2 Procuração SOCKS

Vá para [beacon] -> Pivoting -> SOCKS Server para configurar um servidor proxy SOCKS4a em seu servidor de
equipe. Ou use o socks 8080 para configurar um servidor proxy SOCKS4a na porta 8080 (ou qualquer outra porta que
você escolher).
Todas as conexões que passam por esses servidores SOCKS se transformam em tarefas de conexão, leitura, gravação
e fechamento para que o Beacon associado seja executado. Você pode tunelar via SOCKS através de qualquer tipo
de Beacon (mesmo um SMB Beacon).
O canal de dados HTTP do Beacon é o mais responsivo para fins de pivotagem. Se você quiser dinamizar o tráfego pelo
DNS, use o modo de comunicação de registro DNS TXT.
Para ver os servidores SOCKS que estão atualmente configurados, vá para View -> Proxy Pivots.
Use a parada de meias para desabilitar o servidor proxy SOCKS.
Cadeias de proxy
A ferramenta proxychains forçará um programa externo a usar um servidor proxy SOCKS que você designar. Você
pode usar proxychains para forçar ferramentas de terceiros através do servidor SOCKS da Cobalt Strike. Para saber
mais sobre proxychains, visite:
• http://proxychains.sourceforge.net/
Metasploit
Você também pode encapsular exploits e módulos do Metasploit Framework por meio do Beacon. Crie um servidor
proxy Beacon SOCKS [conforme descrito acima] e cole o seguinte no console do Metasploit Framework:
setg Proxies socks4: IP do servidor de equipe : porta proxy

setg ReverseAllowProxy true
Esses comandos instruirão o Metasploit Framework a aplicar sua opção Proxies a todos os módulos executados
deste ponto em diante. Assim que você terminar de dinamizar o Beacon dessa maneira, use unsetg Proxies para
interromper esse comportamento.
60
Se você achar difícil lembrar o que foi dito acima, vá para View -> Proxy Pivots. Realce o pivô de proxy que você
configurou e pressione Túnel. Este botão fornecerá a sintaxe setg Proxies necessária para encapsular o Metasploit
Framework através do seu Beacon.
9.3 Encaminhar Porta Reversa

Use o comando rportfwd para configurar um pivô reverso por meio do Beacon. O comando rportfwd vinculará
uma porta no destino comprometido. Qualquer conexão com esta porta fará com que seu servidor Cobalt Strike
inicie uma conexão com outro host e porta e retransmita o tráfego entre essas duas conexões. Cobalt Strike túneis
este tráfego através de Beacon. A sintaxe para rportfwd é: rportfwd [bind port] [forward host] [forward port].
Use rportfwd stop [bind port] para desabilitar o encaminhamento de porta reversa.
9.4 Ouvintes Pivot

É uma boa estratégia limitar o número de conexões diretas da rede do seu alvo para sua infraestrutura de comando
e controle. Um listener dinâmico permite que você crie um listener vinculado a uma sessão Beacon ou SSH. Dessa
forma, você pode criar novas sessões reversas sem conexões mais diretas com sua infraestrutura de comando e
controle.
Para configurar um listener dinâmico, vá para [beacon] -> Pivoting -> Listener…. Isso abrirá uma caixa de
diálogo onde você pode definir um novo ouvinte de pivô.
Figura 43. Configure um Pivot Listener
Um ouvinte dinâmico será vinculado à porta de escuta na sessão especificada. O valor Listen Host
configura o endereço que sua carga TCP reversa usará para se conectar a este listener.
No momento, a única opção de carga útil é windows/beacon_reverse_tcp.
Os Pivot Listeners não alteram a configuração de firewall do host dinâmico. Se um host dinâmico tiver um firewall
baseado em host, isso poderá interferir no seu ouvinte. Você, o operador, é responsável por antecipar esta
situação e tomar as medidas corretas para isso.
Para remover um listener de pivô, vá para Cobalt Strike -> Listeners e remova o listener de lá.
O Cobalt Strike enviará uma tarefa para derrubar o soquete de escuta, se a sessão ainda estiver acessível.
61
9.5 VPN secreta

O pivô de VPN é uma maneira flexível de encapsular o tráfego sem as limitações de um pivô de proxy. Cobalt Strike oferece
VPN pivotante por meio de seu recurso Covert VPN. Covert VPN cria uma interface de rede no sistema Cobalt Strike e
conecta essa interface à rede do alvo.
Figura 44. Implantar VPN Encoberta
Para ativar o Covert VPN, clique com o botão direito do mouse em um host comprometido, vá para [beacon] -> Pivoting ->
Deploy VPN. Selecione a interface remota à qual você deseja que o Covert VPN se vincule. Se nenhuma interface local estiver
presente, pressione Adicionar para criar uma.
Verifique o endereço MAC do host Clone para fazer com que sua interface local tenha o mesmo endereço MAC que a interface
remota. É mais seguro deixar esta opção marcada.
Pressione Deploy para iniciar o cliente Covert VPN no destino. Covert VPN requer acesso de administrador para implantação.
Assim que uma interface Covert VPN estiver ativa, você poderá usá-la como qualquer interface física em seu sistema.
Use ifconfig para configurar seu endereço IP. Se a sua rede de destino tiver um servidor DHCP, você poderá solicitar um
endereço IP dele usando as ferramentas integradas do seu sistema operacional.
Para gerenciar suas interfaces Covert VPN, vá para Cobalt Strike -> Interfaces. Aqui, o Cobalt Strike mostrará as interfaces
Covert VPN, como elas estão configuradas e quantos bytes foram transmitidos e recebidos através de cada interface.
Realce uma interface e pressione Remover para destruir a interface e fechar o cliente remoto Covert VPN. O Covert VPN
removerá seus arquivos temporários na reinicialização e desfará automaticamente todas as alterações do sistema
imediatamente.
Pressione Adicionar para configurar uma nova interface Covert VPN.
62
Figura 45. Configurar uma interface VPN secreta
As interfaces secretas de VPN consistem em um tap de rede e um canal para comunicar 63 quadros de
rede. Para configurar a interface, escolha um nome de interface (isto é o que você manipulará através do
ifconfig posteriormente) e um endereço MAC.
Você também deve configurar o canal de comunicação Covert VPN para sua interface. Covert VPN
pode comunicar quadros Ethernet através de uma conexão UDP, conexão TCP, ICMP ou usando o
protocolo HTTP. O canal TCP (Reverse) tem o destino conectado à sua instância Cobalt Strike. O canal
TCP (Bind) tem o túnel Cobalt Strike da VPN através do Beacon.
Cobalt Strike irá configurar e gerenciar a comunicação com o cliente Covert VPN com base na porta
local e no canal que você selecionar.
O canal HTTP Covert VPN faz uso do servidor web Cobalt Strike. Você pode hospedar outros aplicativos
da web Cobalt Strike e vários canais HTTP Covert VPN na mesma porta.
Para melhor desempenho, use o canal UDP. O canal UDP tem a menor quantidade de sobrecarga em
comparação com os canais TCP e HTTP. Use os canais ICMP, HTTP ou TCP (Bind) se precisar passar por
um firewall restritivo.
Embora o Covert VPN tenha uma vantagem de flexibilidade, o uso de um pivô VPN sobre um pivô proxy
dependerá da situação. Covert VPN requer acesso de administrador. Um pivô de proxy não.
Covert VPN cria um novo canal de comunicação. Um pivô de proxy não. Você deve usar um pivô de
proxy inicialmente e mudar para um pivô de VPN quando for necessário.
63
10. Sessões SSH

10.1 O Cliente SSH
O Cobalt Strike controla os destinos UNIX com um cliente SSH integrado. Esse cliente SSH recebe tarefas e roteia
sua saída por meio de um Beacon pai.
Use ssh [target] [user] [password] para iniciar uma sessão SSH de um Beacon. Você também pode usar ssh-key
[target] [user] [/path/to/key.pem] para autenticar com uma chave.
Esses comandos executam o cliente SSH do Cobalt Strike. O cliente relatará quaisquer problemas de
conexão ou autenticação ao Beacon pai. Se a conexão for bem-sucedida, você verá uma nova sessão na tela do
Cobalt Strike. Esta é uma sessão SSH. Clique com o botão direito do mouse nesta sessão e pressione Interagir
para abrir o console SSH.
Digite help para ver uma lista de comandos suportados pela sessão SSH. Digite help seguido por um nome
de comando para obter detalhes sobre esse comando.
10.2 Comandos de Execução

O comando shell executará o comando e os argumentos que você fornecer. Os comandos em execução
bloqueiam a sessão SSH por até 20 segundos antes que o Cobalt Strike coloque o comando em segundo plano.
O Cobalt Strike relatará a saída desses comandos de longa duração assim que estiver disponível.
Use sudo [senha] [comando + argumentos] para tentar executar um comando via sudo. Esse alias requer que
o sudo do destino aceite o sinalizador –S.
O comando cd mudará o diretório de trabalho atual para a sessão SSH. A pwd

comando relata o diretório de trabalho atual.
10.3 Carregar e Baixar Arquivos

O comando upload fará upload de um arquivo para o diretório de trabalho atual. O download
comando irá baixar um arquivo. Os arquivos baixados com o comando download estão disponíveis em Exibir ->
Downloads. Você também pode digitar downloads para ver os downloads de arquivos em andamento.
O comando cancelar cancelará um download em andamento.
10.4 Ponto a ponto C2

As sessões SSH podem controlar TCP Beacons. Use o comando connect para assumir o controle de um TCP
Beacon aguardando uma conexão. Use unlink para desconectar uma sessão TCP Beacon.
Vá para [sessão] -> Ouvintes -> Ouvinte Pivot… para configurar um ouvinte dinâmico vinculado a esta
sessão SSH. Isso permitirá que esse destino UNIX comprometido receba sessões reversas de TCP Beacon.
Essa opção requer que a opção GatewayPorts do daemon SSH seja definida como yes ou
ClientSpecified.
64
10.5 SOCKS pivotantes e reversos da porta para a frente

Use o comando socks para criar um servidor SOCKS em seu servidor de equipe que encaminhe o
tráfego por meio da sessão SSH. O comando rportfwd também criará um redirecionamento de porta
reverso que roteará o tráfego pela sessão SSH e sua cadeia Beacon.
Há uma ressalva para o rportfwd: o comando rportfwd solicita que o daemon SSH se vincule a todas as
interfaces. É bem provável que o daemon SSH substitua isso e force a porta a se vincular ao localhost.
Você precisa alterar a opção GatewayPorts do daemon SSH para yes ou clientspecified.
65
11. Comando e Controle Maleável

11.1 Visão geral
Muitos indicadores Beacon são controlados por um perfil Maleable C2. Um perfil Maleable C2 consiste em
configurações e transformações de dados. Uma transformação de dados é um programa simples que especifica
como transformar dados e armazená-los em uma transação. O mesmo programa que transforma e armazena
dados, interpretados de trás para frente, também extrai e recupera dados de uma transação.
Para usar um perfil personalizado, você deve iniciar um servidor de equipe Cobalt Strike e especificar seu perfil
naquele momento.
./teamserver [IP externo] [senha] [/path/to/my.profile]
Você só pode carregar um perfil por instância do Cobalt Strike.
11.2 Verificando Erros

O pacote Linux do Cobalt Strike inclui um programa c2lint . Este programa verificará a sintaxe de um perfil de
comunicação, aplicará algumas verificações extras e até testará seu perfil com dados aleatórios. É altamente
recomendável que você verifique seus perfis com esta ferramenta antes de carregá-los no Cobalt Strike.
./c2lint [/path/to/my.profile]
11.3 Idioma do Perfil

A melhor maneira de criar um perfil é modificar um existente. Vários perfis de exemplo estão
disponíveis no Github:
• https://github.com/rsmudge/Malleable-C2-Profiles
Quando você abre um perfil, aqui está o que você verá:
# isso é um comentário
definir global_option "valor";
protocolo-transação {
definir local_option "valor";
cliente {
# personalize os indicadores do cliente
}
servidor {
# personaliza os indicadores do servidor
}
}
66
Os comentários começam com um # e vão até o final da linha. A instrução set é uma maneira de atribuir um valor a
uma opção. Os perfis usam { chaves } para agrupar instruções e informações.
As instruções sempre terminam com um ponto e vírgula.
Para ajudar tudo isso a fazer sentido, aqui está um perfil parcial:
http-get {
set uri "/foobar";
cliente {
metadados {
base64;
prefixe "usuário=";
cabeçalho "Cookie";
}
}
Este perfil parcial define indicadores para uma transação HTTP GET. A primeira instrução, set uri, atribui o URI que
o cliente e o servidor farão referência durante essa transação. Essa instrução set ocorre fora dos blocos de código
do cliente e do servidor porque se aplica a ambos.
O bloco cliente define indicadores para o cliente que executa um HTTP GET. O cliente, neste caso, é a carga útil
Beacon da Cobalt Strike.
Quando o Beacon do Cobalt Strike “telefona para casa”, ele envia metadados sobre si mesmo para o Cobalt Strike.
Neste perfil, temos que definir como esses metadados são codificados e enviados com nossa solicitação HTTP
GET.
A palavra-chave metadata seguida por um grupo de instruções especifica como transformar e incorporar metadados
em nossa solicitação HTTP GET. O grupo de instruções, seguindo a palavra-chave de metadados, é chamado de
transformação de dados.
Etapa Açao Dados

0. Iniciar metadados
1. base64 2. Codificação Base64 bWV0YWRhdGE =
prefixe "usuário=" 3. String precedente usuário=bWV0YWRhdGE=
cabeçalho "Cookie" Armazenar na transação
A primeira instrução em nossa transformação de dados afirma que codificaremos nossos metadados em base64 [1].
A segunda instrução, prepend, pega nossos metadados codificados e anexa a string user= a ele [2].
Agora nossos metadados transformados são “user=" . base64(metadados). A terceira declaração afirma que
armazenaremos nossos metadados transformados em um cabeçalho HTTP do cliente chamado Cookie [3]. É isso.
Tanto o Beacon quanto seu servidor consomem perfis. Aqui, lemos o perfil da perspectiva do cliente Beacon. O
servidor Beacon irá pegar esta mesma informação e interpretá-la
67
para trás. Digamos que nosso servidor web Cobalt Strike receba uma solicitação GET para o URI /foobar.
Agora, ele quer extrair metadados da transação.
Etapa Açao Dados

0. Iniciar
1. cabeçalho "Cookie" 2. Recuperar da transação usuário=bWV0YWRhdGE=
prefixar "user=" Remover os primeiros 5 caracteres bWV0YWRhdGE=

3. metadados base64 Decodificação Base64
A instrução de cabeçalho informará ao nosso servidor onde recuperar nossos metadados transformados de [1].
O servidor HTTP se encarrega de analisar os cabeçalhos do cliente HTTP para nós. Em seguida, precisamos lidar com a
instrução prepend. Para recuperar os dados transformados, interpretamos o prefixo como remover os primeiros X caracteres
[2], onde X é o comprimento da string original que anexamos. Agora, tudo isso
esquerda é interpretar a última instrução, base64. Usamos uma função de codificação base64 para transformar os metadados
antes. Agora, usamos uma decodificação base64 para recuperar os metadados [3].
Teremos os metadados originais assim que o interpretador de perfis terminar de executar cada uma dessas instruções
inversas.
Linguagem de transformação de dados

Uma transformação de dados é uma sequência de instruções que transformam e transmitem dados. A transformação de dados
declarações são:
Declaração Açao Inverso
anexar "string" Acrescentar "string" Remova os últimos caracteres LEN(“string”)

base64 base64url Codificação Base64 Decodificação Base64
Codificação Base64 segura para URL Decodificação Base64 segura para URL
mascarar Máscara XOR com chave aleatória Máscara XOR com a mesma chave aleatória
netbios Codificação NetBIOS 'a' Decodificação NetBIOS 'a'
netbiosu Codificação NetBIOS 'A' Decodificação NetBIOS 'A'
prefixar "string" Anexar "string" Remova os primeiros caracteres LEN(“string”)
Uma transformação de dados é uma combinação de qualquer número dessas instruções, em qualquer ordem. Por exemplo,
você pode optar por codificar em netbios os dados a serem transmitidos, acrescentar algumas informações e, em seguida,
codificar em base64 todo o pacote.
Uma transformação de dados sempre termina com uma instrução de término. Você só pode usar uma instrução de término
em uma transformação. Essa instrução informa ao Beacon e seu servidor onde na transação devem ser armazenados os
dados transformados.
68
Há quatro declarações de rescisão.
Declaração O que
header parâmetro Armazenar dados em um cabeçalho HTTP
“header” “key” print Armazenar dados em um parâmetro de URI
uri-append Enviar dados como corpo da transação

Anexar ao URI
A instrução de terminação de cabeçalho armazena dados transformados em um cabeçalho HTTP. A instrução de

terminação de parâmetro armazena dados transformados em um parâmetro HTTP. Este parâmetro é sempre enviado como
parte do URI. A instrução print envia dados transformados no corpo da transação.
A instrução print é a instrução de terminação esperada para os blocos http-get.server.output, http post.server.output e
http-stager.server.output. Você pode usar as instruções de terminação header, parameter, print e uri-append para os
outros blocos.
Se você usar um cabeçalho, parâmetro ou instrução de terminação uri-append em http-post.client.output, o Beacon dividirá
suas respostas em um tamanho razoável para caber nessa parte da transação.
Esses blocos e os dados que eles enviam são descritos em uma seção posterior.
Cordas
O Profile Language do Beacon permite que você use “strings” em vários lugares. Em geral, as strings são interpretadas
como estão. No entanto, existem alguns valores especiais que você pode usar em uma string:
Valor Valor especial

“\n” “\r” Caractere de nova linha
Devolução de carro
“\t” Caractere de tabulação
"\ VOCÊ ####" Um caractere unicode

“\x##” “\ Um byte (por exemplo, \x41 = 'A')
\” \
Cabeçalhos e Parâmetros
As transformações de dados são uma parte importante do processo de customização do indicador. Eles permitem que você
personalize os dados que o Beacon deve enviar ou receber com cada transação. Você também pode adicionar indicadores
estranhos a cada transação.
Em uma solicitação HTTP GET ou POST, esses indicadores estranhos vêm na forma de cabeçalhos ou parâmetros. Use a
instrução de parâmetro dentro do bloco do cliente para adicionar um parâmetro arbitrário a uma transação HTTP GET ou
POST.
69
Este código forçará o Beacon a adicionar ?bar=blah ao URI /foobar quando fizer uma solicitação.
http-get {
cliente {
parâmetro "bar" "blah";
Use a instrução de cabeçalho dentro dos blocos de cliente ou servidor para adicionar um cabeçalho HTTP arbitrário à
solicitação do cliente ou à resposta do servidor. Essa declaração de cabeçalho adiciona um indicador para deixar as equipes
de monitoramento de segurança de rede à vontade.
http-get {
servidor {
header "X-Not-Malware" "Prometo!";
O Profile Interpreter interpretará suas instruções de cabeçalho e parâmetro em ordem. Dito isto, a biblioteca
WinINet (cliente) e o servidor web Cobalt Strike têm a palavra final sobre onde na transação esses indicadores
aparecerão.
Opções
Você pode configurar os padrões do Beacon através do arquivo de perfil. Existem dois tipos de opções: opções
globais e locais. As opções globais alteram uma configuração global de Beacon. As opções locais são específicas
da transação. Você deve definir as opções locais no contexto correto. Use a instrução set para definir
uma opção.
definir "tempo de sono" "1000";
Aqui estão algumas opções:
Opção Valor padrão de contexto Mudanças

dns_idle 0.0.0.0 Endereço IP usado para indicar que
nenhuma tarefa está disponível para o
DNS Beacon; Máscara para outros
valores DNS C2
dns_max_txt 252 Comprimento máximo de

respostas DNS TXT para tarefas
dns_sleep 0 Forçar uma suspensão antes de
cada solicitação de DNS individual.
(em milissegundos)
dns_stager_prepend Anexar texto ao estágio de carga útil
entregue ao estágio de registro TXT
do DNS
dns_stager_subhost .stage.123456. Subdomínio usado pelo stager
de registro TXT do DNS.
dns_ttl 1 TTL para respostas DNS
host_stage verdadeiro
Carga útil do host para preparação
por HTTP, HTTPS ou DNS.
70
Requerido por stagers.

Jitter Fator de jitter padrão (0-99%)
maxdns 0 255 Comprimento máximo de
nome do host ao fazer upload de
dados pelo DNS (0-255)
nome do canal msagente_## Nome padrão do pipe a ser usado
para comunicação ponto a ponto
do SMB Beacon. ## é substituído
por um número exclusivo para seu
servidor de equipe.
pipename_stager status_## Nome do pipe a ser usado para o
stager de pipe nomeado do SMB Beacon.
## é substituído por um número.
sample_name Meu perfil O nome deste perfil (usado no
relatório de Indicadores de
Comprometimento)
hora de dormir 60.000 Tempo de suspensão padrão
(em milissegundos)
spawnto_x86 %windir%\syswow64\rundll32.exe Programa x86 padrão para abrir e
injetar shellcode em
spawnto_x64 %windir%\sysnative\rundll32.exe Programa x64 padrão para abrir e
injetar shellcode em
tcp_port 4444 Escuta de TCP Beacon padrão
porta
odiar http-get, [opção obrigatória] transação de URI
http-post
uri_x86 http-stager URI do estágio de carga útil x86
uri_x64 http-stager URI do estágio de carga útil x64
useragent Agente de usuário padrão do Internet Explorer (Aleatório) para
Comunicações HTTP.
verbo http-get, RECEBER, POSTAR Verbo HTTP a ser usado

http-post para transação
Com a opção uri, você pode especificar vários URIs como uma string separada por espaço. O servidor web do Cobalt Strike
vinculará todos esses URIs e atribuirá um desses URIs a cada host Beacon quando o estágio Beacon for construído.
Mesmo que a opção useragent exista; você pode usar a instrução de cabeçalho para substituir esta opção.
11.4 Teste HTTP

Beacon é uma carga útil em estágios. Isso significa que a carga útil é baixada por um stager e injetada na memória. Seus
indicadores http-get e http-post não terão efeito até que o Beacon esteja na memória do seu destino. O bloco http-stager do
Maleable C2 personaliza o processo de teste HTTP.
71
http-estágio {
set uri_x86 "/get32.gif";
set uri_x64 "/get64.gif";
A opção uri_x86 define o URI para baixar o estágio de carga útil x86. A opção uri_x64 define o URI para baixar
o estágio de carga útil x64.
cliente {
parâmetro "id" "1234";
cabeçalho "Cookie" "SomeValue";
}
A palavra-chave client no contexto de http-stager define o lado do cliente da transação HTTP.

Use a palavra-chave de parâmetro para adicionar um parâmetro ao URI. Use a palavra-chave header para
adicionar um cabeçalho à solicitação HTTP GET do stager.
servidor {
cabeçalho "Tipo de conteúdo" "imagem/gif";
saída {
prefixe "GIF89a";
imprimir;
}
}
}
A palavra-chave server no contexto de http-stager define o lado do servidor da transação HTTP. A

palavra-chave header adiciona um cabeçalho de servidor à resposta do servidor. A saída
palavra-chave no contexto do servidor de http-stager é uma transformação de dados para alterar o estágio de carga útil.
Essa transformação só pode preceder e anexar strings ao palco. Use a instrução de terminação de
impressão para fechar este bloco de saída.
11.5 Passo a passo de uma transação HTTP Beacon

Para juntar tudo isso, ajuda saber como é uma transação Beacon e quais dados são enviados com cada
solicitação.
Uma transação começa quando um Beacon faz uma solicitação HTTP GET para o servidor web da Cobalt Strike.
Neste momento, o Beacon deve enviar metadados que contenham informações sobre o sistema
comprometido.
Dica: os metadados da sessão são um bloco de dados criptografado. Sem codificação, não é adequado para
transporte em um cabeçalho ou parâmetro de URI. Sempre aplique uma base 64, uma URL de base 64 ou uma
declaração de bios de rede para codificar seus metadados.
O servidor web do Cobalt Strike responde a este HTTP GET com tarefas que o Beacon deve executar.
Essas tarefas são, inicialmente, enviadas como um blob binário criptografado. Você pode transformar essas
informações com a palavra-chave de saída no contexto do servidor http-get.
72
À medida que o Beacon executa suas tarefas, ele acumula saída. Após a conclusão de todas as tarefas, o Beacon verifica se há
saída para enviar. Se não houver saída, o Beacon vai dormir. Se houver saída, o Beacon inicia uma transação HTTP POST.
A solicitação HTTP POST deve conter um ID de sessão em um parâmetro ou cabeçalho de URI. O Cobalt Strike usa essas
informações para associar a saída à sessão correta. O conteúdo postado é, inicialmente, um blob binário criptografado. Você
pode transformar essas informações com a palavra-chave de saída no contexto do cliente de http-post.
O servidor web do Cobalt Strike pode responder a um HTTP POST com o que quiser. O Beacon não consome nem usa essas
informações. Você pode especificar a saída de HTTP POST com o bloco de saída no contexto do servidor de http-post.
Nota: enquanto http-getusesGETbydefaultehttp-postusesPOSTbydefault,você não está preso a essas opções.Usea

opçãoverboparaalteraressespadrões.Há muita flexibilidade aqui.
Esta tabela resume essas palavras-chave e os dados que elas enviam:
Solicitar Metadados do cliente do Dados
http-get bloco de componentes Metadados da sessão
http-get servidor saída id Tarefas do Beacon
http-post cliente saída Identificação de sessão
http-post cliente saída Respostas do Beacon

http-post servidor saída Vazio
http-stager servidor Estágio de carga útil codificado
73
11.6 Configuração do Servidor HTTP

O bloco http-config tem influência sobre todas as respostas HTTP servidas pelo servidor web da Cobalt Strike.
Aqui, você pode especificar cabeçalhos HTTP adicionais e a ordem do cabeçalho HTTP.
http-config{
defina os cabeçalhos "Data, Servidor, Comprimento do Conteúdo, Keep-Alive,
Conexão, Tipo de Conteúdo";
cabeçalho "Servidor" "Apache";
cabeçalho "Keep-Alive" "timeout=5, max=100";
cabeçalho "Conexão" "Keep-Alive";
definir trust_x_forwarded_for "true";

}
A palavra-chave header adiciona um valor de cabeçalho a cada uma das respostas HTTP do Cobalt Strike. Se
o valor do cabeçalho já estiver definido em uma resposta, esse valor será ignorado.
A opção set headers especifica a ordem em que esses cabeçalhos HTTP são entregues em uma resposta HTTP.
Quaisquer cabeçalhos que não estejam nesta lista são adicionados ao final.
A opção set trust_x_forwarded_for decide se Cobalt Strike usa o cabeçalho HTTP X-Forwarded-For para
determinar o endereço remoto de uma solicitação. Use esta opção se o seu servidor Cobalt Strike estiver atrás de um
redirecionador HTTP.
11.7 Certificados SSL autoassinados com SSL Beacon

O HTTPS Beacon utiliza os indicadores do HTTP Beacon em sua comunicação. Os perfis C2 maleáveis também
podem especificar parâmetros para o certificado SSL autoassinado do servidor Beacon C2. Isso é útil se você deseja
replicar um ator com indicadores exclusivos em seu certificado SSL:
https-certificado {
set CN "bobsmalware.com";
conjunto O "Bob's Malware";
}
Os parâmetros do certificado sob o controle do seu perfil são:
Opção Exemplo Descrição

C US País
CN beacon.cobaltstrike.com Nome comum; Seu domínio de retorno de chamada
eu Washington Localidade
O Estratégica Cyber LLC Nome da organização
ONDE Departamento de Certificação Nome da Unidade Organizacional
ST DC Estado ou Província
validade 365 Número de dias que o certificado é válido para
74
11.8 Certificados SSL válidos com SSL Beacon

Você tem a opção de usar um certificado SSL válido com Beacon. Use um perfil Malleable C2 para especificar
um arquivo Java Keystore e uma senha para o keystore. Esse keystore deve conter a chave privada do seu
certificado, o certificado raiz, quaisquer certificados intermediários e o certificado de domínio fornecido pelo
fornecedor do certificado SSL. Cobalt Strike espera encontrar o arquivo Java Keystore na mesma pasta que
seu perfil Malleable C2.
https-certificado {
defina keystore "domain.store";
defina a senha "minhasenha";
}
Os parâmetros para usar um certificado SSL válido são:
Opção de Exemplo Descrição

senha do domain.store Arquivo Java Keystore com informações de certificado
armazenamento de chaves mypassword A senha para o seu Java Keystore
Aqui estão as etapas para criar um certificado SSL válido para uso com o Beacon da Cobalt Strike:
1. Use o programa keytool para criar um arquivo Java Keystore. Este programa perguntará "Qual é o seu nome
e sobrenome?" Certifique-se de responder com o nome de domínio totalmente qualificado para o seu servidor
Beacon. Além disso, certifique-se de anotar a senha do keystore. Você precisará disso mais tarde.
$ keytool -genkey -keyalg RSA -keysize 2048 -keystore domain.store
2. Use keytool para gerar uma solicitação de assinatura de certificado (CSR). Você enviará este arquivo ao seu
fornecedor de certificado SSL. Eles irão verificar se você é quem você é e emitir um certificado. Alguns
fornecedores são mais fáceis e mais baratos de lidar do que outros.
$ keytool -certreq -keyalg RSA -file domain.csr -keystore domain.store
3. Importe a Raiz e quaisquer Certificados Intermediários fornecidos pelo seu fornecedor de SSL.
$ keytool -import -trustcacerts -alias FILE -file FILE.crt -keystore

domínio.loja
4. Finalmente, você deve instalar seu Certificado de Domínio.
$ keytool -import -trustcacerts -alias mykey -file domain.crt -keystore domain.store
E é isso. Agora você tem um arquivo Java Keystore que está pronto para usar com o Beacon do Cobalt
Strike.
75
11.9 Variantes de Perfil
Os arquivos de perfil C2 maleáveis, por padrão, contêm um perfil. É possível empacotar variações do perfil
atual especificando blocos de variantes para certificado http-get, http-post, http-stager e https.
Um bloco variante é especificado como [nome do bloco] “nome da variante” { … }. Aqui está um bloco http-
get variante chamado “My Variant”:
http-get "Minha Variante" {

cliente {
parâmetro "bar" "blah";
Um bloco variante cria uma cópia do perfil atual com os blocos variantes especificados substituindo os
blocos padrão no próprio perfil. Cada nome de variante exclusivo cria um novo perfil de variante.
Você pode preencher um perfil com quantos nomes de variantes desejar.
As variantes são selecionáveis ao configurar um listener HTTP ou HTTPS Beacon. As variantes permitem
que cada listener HTTP ou HTTPS Beacon vinculado a um único servidor de equipe tenha IOCs de rede
diferentes uns dos outros.
11.10 Certificado de assinatura de código

Ataques -> Pacotes -> Windows Executable e Windows Executable (S) oferecem a opção de assinar
um arquivo executável ou DLL. Para usar essa opção, você deve especificar um arquivo Java Keystore
com seu certificado de assinatura de código e chave privada. Cobalt Strike espera encontrar o arquivo Java
Keystore na mesma pasta que seu perfil Malleable C2.
sinal de código {
defina keystore "keystore.jks";
definir senha "senha";
definir alias "servidor";
}
As configurações do certificado de assinatura de código são:
Descrição da opção Exemplo

alias O alias do keystore
servidor
para este certificado
digest_algorithm SHA256 O algoritmo digest
keystore keystore.jks Arquivo Java Keystore com informações de certificado
password mypassword A senha para o seu Java Keystore
timestamp false Carimbo de data e hora no arquivo usando um serviço de terceiros timestamp_url http://
timestamp.digicert.com URL do serviço de timestamp
76
11.11 O que é mais perigoso, maleável C2 ou piscina?

A resposta? Ambos. O Maleable C2 oferece um novo nível de controle sobre sua rede e indicadores de host. Com
este poder vem também a responsabilidade. O C2 maleável é uma oportunidade de cometer muitos erros também.
Aqui estão algumas coisas para se pensar ao personalizar seus perfis:
1. Cada instância do Cobalt Strike usa um perfil por vez. Se você alterar um perfil ou carregar um novo perfil, os
Beacons implantados anteriormente não poderão se comunicar com você.
2. Esteja sempre ciente do estado de seus dados e do que um protocolo permitirá ao desenvolver uma transformação
de dados. Por exemplo, se você codifica metadados em base64 e os armazena em um parâmetro URI—
não vai funcionar. Por quê? Alguns caracteres base64 (+, = e /) têm significado especial em uma URL. A ferramenta
c2lint e o compilador de perfil não detectarão esses tipos de problemas.
3. Sempre teste seus perfis, mesmo após pequenas alterações. Se o Beacon não conseguir se comunicar com você,
provavelmente é um problema com seu perfil. Edite-o e tente novamente.
4. Confie na ferramenta c2lint. Esta ferramenta vai além do compilador de perfis. As verificações são fundamentadas
em como essa tecnologia é implementada. Se uma verificação do c2lint falhar, significa que há um problema real com
seu perfil.
77
12. PE maleável, injeção de processo e pós-exploração

12.1 Visão geral
Perfis C2 maleáveis são mais do que indicadores de comunicação. Os perfis C2 maleáveis também
controlam as características na memória do Beacon, determinam como o Beacon processa a injeção e
também influenciam os trabalhos pós-exploração do Cobalt Strike. Este capítulo documenta essas
extensões para a linguagem Maleable C2.
12.2 PE e Indicadores de Memória

O bloco de estágio em perfis Malleable C2 controla como o Beacon é carregado na memória e
edita o conteúdo da DLL do Beacon.
etapa {
definir userwx "falso";
set compile_time "14 de julho de 2009 8:14:00";
definir image_size_x86 "512000";
definir image_size_x64 "512000";
definir ofuscar "verdadeiro";
transform-x86 {
prefixe "\x90\x90";
strrep "ReflectiveLoader" "DoLegitStuff";
}
transform-x64 {
# transforma o estágio x64 rDLL
}
stringw "Eu não sou Beacon";

}
Os blocos transform-x86 e transform-x64 preenchem e transformam o estágio Reflective DLL

do Beacon. Esses blocos suportam três comandos: prepend, append e strrep.
O comando prepend insere uma string antes da DLL reflexiva do Beacon. O comando append adiciona
uma string após a DLL Beacon Reflective. Certifique-se de que os dados anexados sejam um código válido
para a arquitetura do palco (x86, x64). O programa c2lint não tem uma verificação para isso. O estreptococo
O comando substitui uma string dentro da DLL reflexiva do Beacon.
O bloco stage aceita comandos que adicionam strings à seção .rdata da DLL Beacon. O comando
string adiciona uma string terminada em zero. O comando stringw adiciona uma string ampla
(codificado em UTF-16LE). O comando data adiciona sua string como está.
78
O bloco stage aceita várias opções que controlam o conteúdo da DLL do Beacon e fornecem dicas para alterar o
comportamento do Reflective Loader do Beacon:
Soma de Exemplo 0 Descrição

verificação da opção O valor CheckSum no cabeçalho PE do Beacon
Limpar falso Peça ao Beacon para tentar liberar memória
associada ao pacote Reflective DLL que o inicializou.
compile_time 14 de julho de 2009 O tempo de construção no cabeçalho PE do Beacon
entry_point 8:14:00 92145 O valor EntryPoint no cabeçalho PE do Beacon

image_size_x64 512000 Valor SizeOfImage no cabeçalho PE do Beacon x64 Valor
image_size_x86 512000 SizeOfImage no cabeçalho PE do Beacon x86
module_x86 xpsservices.dll Peça ao x86 ReflectiveLoader para carregar a
biblioteca especificada e substituir seu espaço em vez de
alocar memória com VirtualAlloc.
módulo_x64 xpsservices.dll O mesmo que module_x86; afeta o carregador x64
nome beacon.x64.dll false O nome exportado da DLL Beacon
ofuscar Ofusque a tabela de importação da DLL reflexiva,
sobrescreva o conteúdo do cabeçalho não utilizado e peça
ao ReflectiveLoader para copiar o Beacon para a nova
memória sem seus cabeçalhos DLL.
rich_header Meta-informações inseridas pelo compilador
sleep_mask falso Ofuscate Beacon, na memória, antes de dormir
stomppe verdadeiro
Peça ao ReflectiveLoader para pisar nos valores MZ, PE
e e_lfanew depois de carregar a carga útil do Beacon
userwx falso Peça ao ReflectiveLoader para usar ou evitar permissões
RWX para Beacon DLL na memória
Clonagem de cabeçalhos PE
O pacote Linux do Cobalt Strike inclui uma ferramenta, peclone, para extrair cabeçalhos de uma DLL e apresentá-
los como um bloco de estágio pronto para uso:
./peclone [/path/to/sample.dll]
Evasão e ofuscação na memória

Use o comando prepend do bloco de estágio para anular a análise que verifica os primeiros bytes de um segmento de
memória para procurar sinais de uma DLL injetada. Se strings específicas da ferramenta forem usadas para detectar seus
agentes, altere-as com o comando strrep .
Se strrep não for suficiente, defina sleep_mask como true. Isso direciona o Beacon para ofuscar-se na memória antes de
dormir. Depois de dormir, o Beacon se desobstruirá para solicitar e processar tarefas. Os beacons SMB e TCP se ofuscam
enquanto aguardam uma nova conexão ou aguardam dados de sua sessão pai.
Decida o quanto você quer se parecer com uma DLL na memória. Se você quiser permitir uma detecção fácil, defina
stomppe como false. Se você quiser ofuscar levemente sua DLL Beacon na memória, defina
79
stomppe para verdade. Se você quiser enfrentar o desafio, defina ofuscação como verdadeira. Essa
opção levará muitas etapas para ofuscar seu estágio Beacon e o estado final da DLL na memória.
Defina userwx como false para pedir ao carregador do Beacon para evitar permissões RWX. Segmentos de
memória com essas permissões atrairão atenção extra de analistas e produtos de segurança.
Por padrão, o carregador do Beacon aloca memória com VirtualAlloc. O módulo de pisotear é uma
alternativa para isso. Defina module_x86 como uma DLL que seja cerca de duas vezes maior que a própria
carga útil do Beacon. O carregador x86 do Beacon carregará a DLL especificada, encontrará sua localização
na memória e a substituirá. Esta é uma maneira de situar o Beacon na memória que o Windows associa a
um arquivo no disco. É importante que a DLL escolhida não seja necessária para os aplicativos nos quais
você pretende residir. A opção module_x64 é a mesma história, mas afeta o x64 Beacon.
Se você está preocupado com o estágio Beacon que inicializa a DLL Beacon na memória, defina cleanup
para verdade. Esta opção liberará a memória associada ao estágio Beacon quando não for mais
necessária.
12.3 Injeção de Processo

O bloco de injeção de processo em perfis C2 maleáveis molda o conteúdo injetado e controla o comportamento
de injeção de processo para a carga útil do Beacon.
processo-injetar {
# define como a memória é alocada em um processo remoto
defina o alocador "VirtualAllocEx";
# molda as características e o conteúdo da memória

definir min_alloc "16384";
defina startrwx "true";
definir userwx "falso";
transform-x86 {
prefixe "\x90\x90";
}
transform-x64 {
# transforma o conteúdo injetado x64
}
# determina como executar o código injetado

executar {
CreateThread "ntdll.dll!RtlUserThreadStart";
SetThreadContext;
RtlCreateUserThread;
}
}
80
O bloco de injeção de processo aceita várias opções que controlam o processo de injeção de processo em
Baliza:
Alocador Descrição do exemplo

de opções VirtualAllocEx O método preferencial para alocar memória no processo remoto.
Especifique VirtualAllocEx ou NtMapViewOfSection. A opção
NtMapViewOfSection é apenas para injeção de mesma arquitetura.
VirtualAllocEx é sempre usado para alocações de memória entre arcos.
min_alloc 4096 false Quantidade mínima de memória para solicitar conteúdo injetado
startrwx Use RWX como permissões iniciais para conteúdo injetado. Alternativa é RW.
userwx falso Use RWX como permissões finais para conteúdo injetado.
Alternativa é RX.
Os blocos transform-x86 e transform-x64 bloqueiam o conteúdo injetado pelo Beacon. Esses blocos suportam
dois comandos: prepend e append. O comando prepend insere uma string antes do conteúdo injetado. O
comando append adiciona uma string após o conteúdo injetado. Certifique-se de que os dados anexados sejam
um código válido para a arquitetura do conteúdo injetado (x86, x64). O programa c2lint não tem uma verificação
para isso.
O bloco execute controla os métodos que o Beacon usará quando precisar injetar código em um processo.
Beacon examina cada opção no bloco de execução, determina se a opção é utilizável para o contexto atual, tenta o
método quando é utilizável e passa para a próxima opção se a execução do código não ocorreu. As opções de
execução incluem:
Opção x86 -> x64 x64 -> x86 Notas

CreateThread Apenas processo atual
CreateRemoteThread sim Sem sessão cruzada
NtQueueApcThread
NtQueueApcThread-s Esta é a técnica de injeção “Early Bird”.
Processos suspensos (por exemplo,
empregos pós-ex) apenas.
RtlCreateUserThread Sim sim Arriscado em alvos da era XP; usa
shellcode RWX para injeção x86 -> x64.
SetThreadContext sim Processos suspensos (por exemplo, empregos pós-ex)
apenas.
As opções CreateThread e CreateRemoteThread possuem variantes que geram um thread suspenso com o
endereço de outra função, atualizam o thread suspenso para executar o injetado
código e retomar esse segmento. Use a [função] “module!function+0x##” para especificar o endereço inicial a ser
falsificado. Para processos remotos, ntdll e kernel32 são os únicos módulos recomendados para extrair. A parte
opcional 0x## é um deslocamento adicionado ao endereço inicial. Essas variantes funcionam apenas x86 -> x86 e
x64 -> x64.
81
As opções de execução que você escolher devem cobrir uma variedade de casos de canto. Esses casos de canto incluem
autoinjeção, injeção em processos temporários suspensos, injeção de processo remoto entre sessões, injeção x86 -> x64,
injeção x64 -> x86 e injeção com ou sem passar um argumento. A ferramenta c2lint irá avisá-lo sobre contextos que seu bloco
de execução não cobre.
12.4 Trabalhos de Pós-Exploração

Recursos maiores de pós-exploração do Cobalt Strike (por exemplo, captura de tela, keylogger, hashdump, etc.) são
implementados como DLLs do Windows. Para executar esses recursos, o Cobalt Strike gera um processo temporário e injeta
o recurso nele. O bloco de injeção de processo controla a etapa de injeção de processo. O bloco pós-ex controla o conteúdo
e os comportamentos específicos dos recursos de pós-exploração do Cobalt Strike.
pós-ex {
# controlar o processo temporário que geramos para
set spawnto_x86 "%windir%\\syswow64\\rundll32.exe";
set spawnto_x64 "%windir%\\sysnative\\rundll32.exe";
# altere as permissões e o conteúdo de nossas DLLs pós-ex

definir ofuscar "verdadeiro";
# passa ponteiros de função chave do Beacon para seus trabalhos filhos

defina smartinject "true";
# desabilita o AMSI no powerpick, execute-assembly e psinject

definir amsi_disable "true";
}
As opções spawnto_x86 e spawnto_x64 controlam o processo temporário padrão que o Beacon irá gerar para seus recursos
de pós-exploração. Aqui estão algumas dicas para esses valores:
1. Sempre especifique o caminho completo para o programa que você deseja que o Beacon gere
2. As variáveis de ambiente (por exemplo, %windir%) estão corretas nesses caminhos.
3. Não especifique %windir%\system32 ou c:\windows\system32 diretamente. Sempre use syswow64 (x86) e

sysnative (x64). O Beacon ajustará esses valores para system32 onde for necessário.
4. Para um valor x86 spawnto, você deve especificar um programa x86. Para um valor x64 spawnto, você deve
especificar um programa x64.
5. Os caminhos que você especificar (menos o ajuste automático syswow64/sysnative) devem existir em uma
visualização x64 (nativa) e x86 (wow64) do sistema de arquivos.
A opção de ofuscação embaralha o conteúdo das DLLs pós-ex e instala o recurso pós-ex na memória de uma
maneira mais segura para OPSEC. É muito semelhante às opções ofuscate e userwx disponíveis para Beacon por meio do
bloco stage.
82
A opção smartinject direciona o Beacon para incorporar ponteiros de função chave, como GetProcAddress
e LoadLibrary, em suas DLLs pós-ex da mesma arquitetura. Isso permite que as DLLs pós-ex se iniciem
em um novo processo sem comportamento semelhante ao shellcode que é detectado e mitigado
observando os acessos de memória ao PEB e ao kernel32.dll.
A opção amsi_disable direciona powerpick, execute-assembly e psinject para corrigir a função

AmsiScanBuffer antes de carregar o código .NET ou PowerShell. Isso limita a visibilidade da Interface de
verificação antimalware nesses recursos.
83
13. Relatórios e Registros

13.1 Registro
Cobalt Strike registra todas as suas atividades no servidor da equipe. Esses logs estão localizados na pasta logs/ no mesmo
diretório em que você iniciou seu servidor de equipe. Todas as atividades do Beacon são registradas aqui com uma data e
hora.
13.2 Relatórios
O Cobalt Strike tem várias opções de relatório para ajudar a entender seus dados e transmitir uma história para seus
clientes. Você pode configurar o título, a descrição e os hosts exibidos na maioria dos relatórios.
Figura 46. Caixa de diálogo Exportar relatório
Vá para o menu Relatórios e escolha um dos relatórios para gerar. Cobalt Strike exportará seu relatório como um
documento MS Word ou PDF.
84
Relatório de atividade
O relatório de atividades fornece uma linha do tempo das atividades da equipe vermelha. Cada uma de suas atividades pós-
exploração está documentada aqui.
Figura 47. O Relatório de Atividades
Relatório de hosts
O relatório de hosts resume as informações coletadas pelo Cobalt Strike host por host.
Serviços, credenciais e sessões também estão listados aqui.
85
Indicadores de comprometimento
Este relatório se assemelha a um apêndice Indicadores de comprometimento de um relatório de inteligência de ameaças.
O conteúdo inclui uma análise gerada do seu perfil Malleable C2, qual domínio você usou e hashes MD5 para arquivos que
você carregou.
Figura 48. Indicadores do Relatório de Compromisso
86
Relatório de sessões
Este relatório documenta os indicadores e a atividade sessão a sessão. Este relatório inclui: o caminho de comunicação
que cada sessão usou para chegar até você, hashes MD5 de arquivos colocados no disco durante essa sessão, indicadores
diversos (por exemplo, nomes de serviço) e uma linha do tempo da atividade pós-exploração. Este relatório é uma
ferramenta fantástica para ajudar uma equipe de defesa de rede a entender toda a atividade do vermelho e combinar seus
sensores com sua atividade.
Figura 49. O Relatório de Sessões
Engenharia social
O relatório de engenharia social documenta cada rodada de e-mails de spear phishing, quem clicou e o que foi coletado
de cada usuário que clicou. Este relatório também mostra os aplicativos descobertos
pelo criador de perfil do sistema.
Táticas, Técnicas e Procedimentos

Este relatório mapeia suas ações Cobalt Strike para táticas dentro da Matriz ATT&CK do MITRE. A matriz ATT&CK
descreve cada tática com estratégias de detecção e mitigação. Você pode aprender mais sobre o ATT&CK do MITRE
em: https://attack.mitre.org/
87
13.3 Logotipo personalizado em relatórios

Os relatórios Cobalt Strike exibem um logotipo Cobalt Strike na parte superior da primeira página. Você pode substituir
isso por uma imagem de sua escolha. Vá para Cobalt Strike -> Preferences -> Reporting para definir isso
Sua imagem personalizada deve ter 1192x257px definida como 300dpi. A configuração de 300 dpi é necessária para
que o mecanismo de relatório renderize sua imagem no tamanho certo.
Você também pode definir uma cor de destaque. Essa cor de destaque é a cor da linha grossa abaixo de sua
imagem na primeira página do relatório. Os links dentro dos relatórios também usam a cor de destaque.
Figura 50. Um Relatório Personalizado
13.4 Relatórios personalizados

O Cobalt Strike 3.0 suporta relatórios personalizados. Esses scripts são definidos em um subconjunto da linguagem
Aggressor Script. Consultando a documentação do Aggressor Script para saber mais sobre esse recurso:
• https://www.cobaltstrike.com/aggressor-script
88
Apêndice A. Atalhos de Teclado

Os seguintes atalhos de teclado estão disponíveis.
Atalho Onde Açao

Ctrl+A console selecionar todo o texto
Ctrl+F console abra a ferramenta de busca para pesquisar no console
Ctrl+K console limpar o console
Ctrl+Menos console diminuir o tamanho da fonte
Ctrl+Mais console Aumentar o tamanho da fonte
Ctrl+0 console redefinir o tamanho da fonte
Abaixo console mostre o próximo comando no histórico de comandos
Escapar console limpar caixa de edição
Página para baixo console rolar para baixo metade da tela
Subir página console rolar para cima meia tela

Aba console complete o comando atual (em alguns tipos de console)
Acima console mostre o comando anterior no histórico de comandos

Ctrl+B em todos os enviar a guia atual para a parte inferior da janela Cobalt Strike
Ctrl+D lugares em feche a aba atual
Ctrl+Shift+D todos os lugares feche todas as guias, exceto a guia atual

Ctrl+E em todos os esvaziar a parte inferior da janela Cobalt Strike (desfazer Ctrl+B)
Ctrl+I lugares em escolha uma sessão para interagir
Ctrl+Esquerda todos os lugares mudar para a aba anterior

Ctrl+O em todos os preferências abertas
Ctrl+R lugares em Renomeie a guia atual
Ctrl+Direita todos os lugares mudar para a próxima guia
Ctrl+T em todos os tirar screenshot da guia atual (o resultado é enviado para o servidor da equipe)
Ctrl+Shift+T lugares gráfico tirar screenshot de Cobalt Strike (o resultado é enviado para o servidor da equipe)
Ctrl+W gráfico gráfico abrir a guia atual em sua própria janela
Ctrl+C gráfico gráfico organizar sessões em círculo
Ctrl+H tabelas de organizar sessões em uma hierarquia
Ctrl+Menos gráficos Reduzir o zoom
Ctrl+P salvar uma imagem da exibição do gráfico

Ctrl+Mais mais Zoom
Ctrl+S organizar sessões em uma pilha

Ctrl+0 redefinir para o nível de zoom padrão
Ctrl+F abra a ferramenta de busca para filtrar o conteúdo da tabela
Ctrl+A alvos selecionar todos os hosts
Escapar alvos limpar hosts selecionados
89

CobaltStrike Manual Traduzido

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

CobaltStrike Manual Traduzido

Enviado por

Direitos autorais:

Formatos disponíveis

Machine Translated by Google

Machine Translated by Google

1.Bem-vindo ao CobaltStrike............................................. .................................................. ............. 6 1.1 O que é

2.Interface do usuário ............................................. .................................................. ..............................12 2.1Visão

3.Gerenciamento de Dados................................................. .................................................. ......................... 18

4.Gestão de Ouvintes e Infraestrutura................................................ ..............................20

4.11Consolidação de Infraestrutura ................................................ .................................................. ........29

5. Obtendo um ponto de apoio ............................................. .................................................. .......................31 5.1Profiler

6.Artefatos de carga útil e evasão de antivírus............................................. .........................38

7.Pós-Exploração ............................................. .................................................. .......................... 42

7.17 Escalonamento de Privilégios................................................. .................................................. ..............................51

8.Pivotação do navegador ............................................. .................................................. .........................57

9. Girando ............................................. .................................................. .........................................60 9.1 O que é

10.SSSSessões................................................ .................................................. .........................64 10.1O Cliente

11.11 Qual é a mais perigosa, maleávelC2 ou uma piscina?.................................................77

12.PE maleável, injeção de processo e pós-exploração ........................................... ......78 12.1Visão

13. Relatórios e Registros ............................................. .................................................. .............84

Apêndice A. Atalhos de Teclado ............................................. .................................................. 0,89

Última atualização: 2 de dezembro de 2019

1. Bem-vindo ao Cobalt Strike

Figura 1. O conjunto de problemas de ofensa

1.2 Instalação e Atualizações

Execute o programa de 'atualização'

1.3 O Servidor de Equipe

Figura 3. Iniciando o Team Server

1.4 Cliente Cobalt Strike

Figura 4. Caixa de diálogo Cobalt Strike Connect

Pressione Conectar para se conectar ao servidor da equipe Cobalt Strike.

Figura 5. Verificando o certificado SSL do servidor

1.5 Operações Distribuídas e em Equipe

Figura 6. Operações Distribuídas com Cobalt Strike

Uma vez conectado a um servidor de equipe, sua equipe:

• Use as mesmas sessões

• Compartilhar hosts, dados capturados e arquivos baixados

Figura 7. Barra de comutação do servidor

1.6 Script Cobalt Strike

Figura 8. Gerenciador de scripts

2.1 Visão geral

Figura 9. Interface de usuário do Cobalt Strike

2.2 Barra de ferramentas

Conectar-se a outro servidor de equipe

Desconecte-se do servidor de equipe atual

Crie e edite os ouvintes do Cobalt Strike

Mude para a visualização “Pivot Graph”

Mude para a visualização “Tabela de Sessão”

Mude para a visualização “Tabela de Destino”

Ver arquivos baixados

Ver pressionamentos de tecla

Ver capturas de tela

Gere um executável ou DLL Cobalt Strike sem estágio

Configurar o ataque do miniaplicativo assinado por Java

Gerar uma macro maliciosa do Microsoft Office

Defenda um ataque de entrega da Web com script sem etapas

Hospede um arquivo no servidor web do Cobalt Strike

Gerencie arquivos e aplicativos hospedados no servidor web da Cobalt Strike

Visite a página de suporte do Cobalt Strike

2.3 Visualizações de Sessão e Destino

Figura 10. Visualização de Alvos de Ataque de Cobalto

Figura 11. Ferramenta de gerenciamento de sinalizadores de ataque de cobalto

Figura 12. Visualização do gráfico de ataque de cobalto

Vários atalhos de teclado estão disponíveis no gráfico dinâmico.

• Ctrl+H — organiza os hosts em uma hierarquia.

em sua própria janela.