Análise de Transparência de Certificados para Phishing

Visão Geral

Transparência de Certificados (CT) é um padrão de segurança da Internet que cria um registro público, somente de adição, de todos os certificados SSL/TLS emitidos. Monitorar logs de CT permite a detecção precoce de domínios de phishing que registram certificados imitando marcas legítimas, emissão não autorizada de certificados para domínios próprios e infraestrutura de ataque baseada em certificados. Esta habilidade abrange a consulta de logs de CT via crt.sh, monitoramento em tempo real com Certstream, a construção de alertas automatizados para certificados suspeitos e a integração de descobertas em fluxos de trabalho de inteligência de ameaças.

Quando Usar

• Ao investigar incidentes de segurança que exigem a análise de transparência de certificados para phishing.
• Ao construir regras de detecção ou consultas de caça a ameaças para este domínio.
• Quando analistas de SOC precisam de procedimentos estruturados para este tipo de análise.
• Ao validar a cobertura de monitoramento de segurança para técnicas de ataque relacionadas.

Pré-requisitos

• Python 3.9+ com requests, certstream, tldextract, Levenshtein bibliotecas.
• Acesso ao crt.sh (https://crt.sh/) para consultas históricas de logs de CT.
• Certstream (https://certstream.calidog.io/) para monitoramento em tempo real.
• Lista de domínios de organizações e palavras-chave de marca para monitorar.
• Compreensão da estrutura de certificados SSL/TLS e do processo de emissão.

Conceitos Chave

Logs de Transparência de Certificados

Logs de CT são registros criptograficamente garantidos, publicamente auditáveis e somente de adição de emissão de certificados TLS. Principais CAs (Let's Encrypt, DigiCert, Sectigo, Google Trust Services) submetem todos os certificados emitidos a múltiplos logs de CT. A partir de 2025, Chrome e Safari exigirão CT para todos os certificados publicamente confiáveis.

Detecção de Phishing via CT

Atacantes registram domínios semelhantes e obtêm certificados gratuitos (muitas vezes da Let's Encrypt) para fazer com que sites de phishing pareçam legítimos com HTTPS. O monitoramento de CT detecta isso precocemente porque o certificado aparece nos logs antes que a campanha de phishing seja lançada, proporcionando uma janela para bloqueio proativo.

Banco de Dados crt.sh

crt.sh é uma interface web gratuita e um banco de dados PostgreSQL operado pela Sectigo que indexa logs de CT. Ele suporta pesquisas com curinga (%.example.com), consultas SQL diretas e respostas de API JSON. Ele rastreia a emissão, expiração e revogação de certificados em todos os principais logs de CT.

Fluxo de Trabalho

Etapa 1: Consultar crt.sh para Histórico de Certificados

import requests
import json
from datetime import datetime
import tldextract

class CTLogMonitor:
    CRT_SH_URL = "https://crt.sh"

    def __init__(self, monitored_domains, brand_keywords):
        self.monitored_domains = monitored_domains
        self.brand_keywords = [k.lower() for k in brand_keywords]

    def query_crt_sh(self, domain, include_expired=False):
        """Consulta crt.sh para certificados que correspondem a um domínio."""
        params = {
            "q": f"%.{domain}",
            "output": "json",
        }
        if not include_expired:
            params["exclude"] = "expired"

        resp = requests.get(self.CRT_SH_URL, params=params, timeout=30)
        if resp.status_code == 200:
            certs = resp.json()
            print(f"[+] crt.sh: {len(certs)} certificados para *.{domain}")
            return certs
        return []

    def find_suspicious_certs(self, domain):
        """Encontra certificados que podem ser tentativas de phishing."""
        certs = self.query_crt_sh(domain)
        suspicious = []

        for cert in certs:
            common_name = cert.get("common_name", "").lower()
            name_value = cert.get("name_value", "").lower()
            issuer = cert.get("issuer_name", "")
            not_before = cert.get("not_before", "")
            not_after = cert.get("not_after", "")

            # Verifica correspondências exatas de domínio (legítimo)
            extracted = tldextract.extract(common_name)
            cert_domain = f"{extracted.domain}.{extracted.suffix}"
            if cert_domain == domain:
                continue  # Certificado legítimo

            # Sinaliza padrões suspeitos
            flags = []
            if domain.replace(".", "") in common_name.replace(".", ""):
                flags.append("contém string de domínio alvo")
            if any(kw in common_name for kw in self.brand_keywords):
                flags.append("contém palavra-chave da marca")
            if "let's encrypt" in issuer.lower():
                flags.append("CA gratuita (Let's Encrypt)")

            if flags:
                suspicious.append({

…