macrecon

CI License: MIT Bash 3.2+ macOS Version

Auditoria de credenciais e chaves para macOS — feita para profissionais de segurança.

demo

O GIF roda macrecon --demo — todos os dados são fictícios (IPs em TEST-NET-1, tokens fake). Rode macrecon --demo no seu terminal para ver o mesmo relatório sem escanear o sistema.

O macrecon é uma ferramenta de linha de comando (CLI) que roda no terminal do Mac. Ele faz um raio-X completo do seu sistema procurando por chaves SSH, certificados, credenciais de nuvem (AWS, GCP, Azure), tokens de API, chaves GPG, e segredos vazados no histórico do Git.

A diferença é que ele não só encontra os arquivos — ele também audita se estão seguros, gera relatórios profissionais, e pode até comparar snapshots para detectar se alguém adicionou uma chave nova no sistema.

• Pentesters que precisam avaliar rapidamente a superfície de ataque de um Mac
• Profissionais de Incident Response que precisam detectar backdoors e persistência
• Administradores de sistema que querem garantir que as chaves SSH estão seguras
• Desenvolvedores que querem fazer backup das próprias chaves
• Auditors de compliance que precisam de relatórios em SARIF

# Clonar
git clone https://github.com/berodcdev/macrecon.git
cd macrecon
# Rodar direto do repo (sem instalar)
./macrecon --demo # preview com dados fictícios
./macrecon # auditoria completa do seu sistema
# Ou instalar como symlink user-local (sem sudo, recomendado)
make install-local
macrecon --version # agora roda de qualquer diretório
# Alternativa: instalação global (precisa de sudo)
sudo make install

Não precisa instalar nada extra — o macrecon usa apenas ferramentas que já vêm no macOS (ssh-keygen, mdfind, security, lsof, stat).

# Preview com dados fictícios (não toca no sistema)
macrecon --demo
# Auditoria completa (tudo ligado)
macrecon
# Scan rápido (só busca, sem auditoria profunda)
macrecon --profile quick
# Só listar os caminhos dos arquivos (para usar em scripts)
macrecon --quiet

# Tudo ligado: scan + auditoria + config + keychain + sistema + git history
./macrecon --profile full --git
# Relatório SARIF para integrar com GitHub Code Scanning
./macrecon --git --sarif relatorio.sarif
# Relatório HTML interativo para mostrar ao cliente
./macrecon --html relatorio.html
# Salvar um snapshot do estado atual antes do teste
./macrecon --baseline antes_do_teste.json
# Após o teste, comparar o que mudou
./macrecon --diff antes_do_teste.json

# Snapshot completo com hashes para cadeia de custódia
./macrecon --profile forensic --sarif evidencia.sarif
# Detectar persistência SSH em LaunchAgents
./macrecon --system
# Ver conexões SSH ativas (possível exfiltração)
./macrecon --system | grep "Outbound"
# Corrigir permissões inseguras automaticamente
./macrecon --fix-perms --yes

# Copiar todas as chaves para um diretório de backup
./macrecon --export ~/backup_chaves
# O backup inclui:
# ssh_keys/public/ — chaves públicas (chmod 644)
# ssh_keys/private/ — chaves privadas (chmod 600)
# ssh_keys/host/ — chaves de host
# credentials/ — credenciais cloud
# manifest.json — inventário completo

• Chaves públicas e privadas (ed25519, RSA, ECDSA, DSA)
• Chaves de host em /etc/ssh/
• Chaves PuTTY (.ppk)
• Chaves PKCS12 (.p12, .pfx)
• Chaves renomeadas (detecta pelo conteúdo, não só pelo nome)

• AWS: ~/.aws/credentials, ~/.aws/config
• GCP: ~/.config/gcloud/ (credentials, application_default)
• Azure: ~/.azure/ (accessTokens, servicePrincipal)
• Kubernetes: ~/.kube/config
• Docker: ~/.docker/config.json
• npm: ~/.npmrc (auth tokens)
• Git: ~/.git-credentials

• TLS: .crt, .cer, .cert, .csr
• Certificate Authorities: .ca-bundle, .ca
• GPG: .gpg, .asc, secring.gpg

• OpenVPN: .ovpn
• WireGuard: wg*.conf

O macrecon escaneia o conteúdo dos arquivos (não só o nome) procurando por:

• Cloud: AWS (AKIA...), GCP (AIza...), Tencent (AKID...), Alibaba (LTAI...)
• SaaS: GitHub (ghp_, gho_, ghs_), GitLab (glpat-), Stripe (sk_live_), Slack (xox..., webhooks), OpenAI (sk-...), Anthropic (sk-ant-), HuggingFace, DigitalOcean, Linode, Vultr, Twilio, SendGrid
• Infrastructure: Vault (hvs.), Heroku, Cloudflare, Telegram
• Tokens: JWT (eyJ...), bearer tokens, OAuth
• Database: Connection strings (postgres://user:pass@, mysql://, mongodb://, redis://, amqp://)
• Generic: api_key=, secret_key=, password=, session_id=

• git log --all procurando por chaves privadas e tokens
• Arquivos deletados que continham secrets
• Objetos "dangling" (nunca commitados mas presentes no .git)
• URLs com credenciais embedded em .git/config
• Git hooks (persistência)

• .bash_history, .zsh_history, .python_history, .psql_history, .mysql_history
• Detecta: API keys em export VAR=SECRET, senhas em CLI (mysql -p, psql)

• .netrc (machine + login + password)
• .pgpass (host:port:db:user:password)
• .my.cnf (MySQL credentials)
• .vault-token (HashiCorp Vault)
• .config/gh/hosts.yml (GitHub CLI tokens)

• Parse do ~/.ssh/config: quais Hosts usam quais IdentityFile
• Chaves em uso vs órfãs (não referenciadas em nenhum Host)
• Estado do agente SSH (ssh-add -l)

• 15+ diretivas de hardening: PermitRootLogin, PasswordAuthentication, MaxAuthTries, etc.
• Usa sshd -T (effective config) se root, fallback para parse manual
• Estado do Remote Login (via launchctl)

• Entradas SSH com passphrase armazenada (service name, caminho da chave)
• Credenciais de Git no keychain (github.com, gitlab.com, bitbucket.org)
• Identidades SSH (certificados)
• Estado do login keychain (trancado/destrancado)
• Lista de keychains de terceiros (openvpn, parallels, etc.)

• SIP: System Integrity Protection (csrutil status)
• Gatekeeper: spctl --status
• FileVault: fdesetup status
• TCC: Apps com Full Disk Access, Accessibility (requer FDA no terminal)
• LaunchAgents: Persistência SSH (reverse tunnels, backdoors via autossh, ngrok, cloudflared)
• Network listeners: Portas abertas (lsof -iTCP -sTCP:LISTEN)
• Outbound SSH: Conexões SSH ativas (possível exfiltração)
• OS version: Para matching de CVEs

Saída colorida no terminal com tabelas, seções de auditoria, config, keychain, sistema e git.

{"files": [...], "secrets": [...], "git_findings": [...]}

Padrão OASIS para integração com GitHub Code Scanning, Azure DevOps e SIEMs. 12 regras:

Relatório interativo com CSS dark, tabelas filtráveis, cards de resumo.

Relatório com resumo executivo, inventário, auditoria e recomendações.

Apenas os caminhos dos arquivos, um por linha (para pipe).

Saida:
 --json Saida JSON
 --quiet Apenas caminhos
 --no-color Sem cores
 -h, --help Ajuda
 -v, --version Versao
Busca:
 --dir <path> Adiciona diretorio
 --depth <n> Profundidade (padrao: 5)
 --spotlight Usa mdfind (padrao)
 --no-spotlight Usa find
Modulos:
 --audit/--no-audit Auditoria (padrao: on)
 --config/--no-config SSH config (padrao: on)
 --cloud/--no-cloud Cloud creds (padrao: on)
 --keychain/--no-keychain Keychain (padrao: on)
 --system/--no-system Sistema (padrao: on)
 --git Git history scan (padrao: off)
 --secret-scan/--no-secret-scan Content scan (padrao: on)
 --show-secrets Exibir secrets sem redacao (cuidado!)
Relatorios:
 --markdown <file> Relatorio Markdown (- para stdout)
 --html <file> Relatorio HTML (- para stdout)
 --sarif <file> Relatorio SARIF v2.1.0 (- para stdout)
Baseline & IR:
 --baseline <file> Salvar snapshot
 --diff <file> Comparar com snapshot
Remediacao:
 --fix-perms Corrigir permissoes inseguras
 --harden-sshd Endurecer sshd_config
 --cleanup-orphans Remover .pub orfaos
 --yes Nao pedir confirmacao
Perfis:
 --profile <name> quick | full | forensic | compliance | ir
Export:
 --export <dir> Backup de chaves

macrecon/
├── macrecon # CLI principal (dispatch + flags + pipeline)
├── lib/
│ ├── common.sh # Utils, OS detect, cores, temp, TSV registry
│ ├── classify.sh # Classificação tripla (conteúdo + path + nome)
│ ├── scan.sh # Engine de busca (Spotlight/find) + cloud creds
│ ├── secret_scan.sh # Content-based secret scanning (50+ patterns + entropia)
│ ├── audit.sh # Perms, passphrase, força, SHA256, btime, xattr, ACLs
│ ├── config.sh # SSH config + sshd_config + ssh-agent analysis
│ ├── keychain.sh # macOS Keychain audit (security CLI)
│ ├── system.sh # SIP/Gatekeeper/FileVault/TCC/LaunchAgents/listeners
│ ├── git_scan.sh # Git history: pickaxe, blob grep, deleted, dangling
│ ├── baseline.sh # Snapshot JSON + diff para IR
│ ├── remediate.sh # Fix perms, harden sshd, cleanup orphans
│ └── report.sh # Output: table/JSON/quiet/Markdown/HTML/SARIF
├── profiles/ # quick, full, forensic, compliance, ir
├── completions/ # Bash completion
├── man/ # Man page
├── tests/ # Smoke tests
├── .github/ # CI (GitHub Actions) + issue/PR templates
├── assets/ # demo.gif + demo.tape (VHS)
├── Makefile # install / install-local / test / test-smoke / lint / clean
├── CHANGELOG.md # Histórico de versões
├── CONTRIBUTING.md # Como contribuir
├── SECURITY.md # Política de disclosure de vulnerabilidades
└── CODE_OF_CONDUCT.md # Código de conduta

• macOS: Compatível com bash 3.2 nativo (sem dependências externas)
• Linux: Preparação para Linux (detecção de OS, stat format adaptável)
• Sem arrays associativos: TSV + sort -u para deduplicação
• Sem ${var,,}: tr '[:upper:]' '[:lower:]' para lowercase
• Sem alternativas vazias em regex: .* no lugar de (OPENSSH|RSA|)

O macrecon é a única ferramenta open-source que une:

1. Auditoria de config SSH local (sshd_config, ssh_config, authorized_keys, known_hosts)
2. Stores de credenciais macOS (Keychain, ssh-agent, TCC)
3. Controles CIS/STIG (SIP, Gatekeeper, FileVault, LaunchAgents)
4. Secret scanning de conteúdo (50+ patterns + entropia de Shannon)
5. SARIF reporting (primeira ferramenta de host audit macOS com SARIF)
6. Baseline & diff para resposta a incidentes
7. Git history scanning (pickaxe, blob grep, deleted, dangling)

Nenhuma outra ferramenta combina tudo isso num único CLI.

Contribuições são bem-vindas! Veja CONTRIBUTING.md para detalhes sobre estilo de código (bash 3.2 compatível), como rodar os testes (make test e make test-smoke), e o fluxo de pull requests.

Encontrou uma vulnerabilidade no macrecon? Por favor, não abra uma issue pública. Veja SECURITY.md para reportar de forma privada e coordenada.

Veja CHANGELOG.md para o histórico completo de versões.

MIT — compatível com uso comercial e open-source.