Construindo um Fluxo de Trabalho de Verificação de Vulnerabilidades

Quando Usar

Use esta habilidade quando:

• Equipes de SOC precisarem estabelecer ou aprimorar programas recorrentes de verificação de vulnerabilidades
• Resultados de verificação exigirem priorização além das pontuações CVSS brutas, usando contexto de ativos e inteligência de ameaças
• Dados de vulnerabilidade precisarem ser integrados ao SIEM para correlação com tentativas de exploração
• O rastreamento de remediação precisar ser formalizado com painéis e relatórios baseados em SLA

Não use para testes de penetração ou exploração ativa — a verificação de vulnerabilidades identifica fraquezas, testes de penetração validam a explorabilidade.

Pré-requisitos

• Scanner de vulnerabilidades (Tenable Nessus Professional, Qualys VMDR ou OpenVAS/Greenbone)
• Inventário de ativos com classificações de criticidade (crítico para negócios, padrão, desenvolvimento)
• Acesso de rede do scanner a todos os segmentos de destino (baseado em agente ou verificação de rede)
• Integração com SIEM para ingestão e correlação de resultados de verificação
• Sistema de gerenciamento de patches (WSUS, SCCM, Intune) para rastreamento de remediação

Fluxo de Trabalho

Etapa 1: Definir Escopo e Agendamento da Verificação

Crie políticas de verificação que cubram todos os tipos de ativos:

Configuração de Verificação Nessus (API):

import requests

nessus_url = "https://nessus.company.com:8834"
headers = {"X-ApiKeys": f"accessKey={access_key};secretKey={secret_key}"}

# Create scan policy
policy = {
    "uuid": "advanced",
    "settings": {
        "name": "SOC Weekly Infrastructure Scan",
        "description": "Weekly credentialed scan of all server and workstation segments",
        "scanner_id": 1,
        "policy_id": 0,
        "text_targets": "10.0.0.0/16, 172.16.0.0/12",
        "launch": "WEEKLY",
        "starttime": "20240315T020000",
        "rrules": "FREQ=WEEKLY;INTERVAL=1;BYDAY=SA",
        "enabled": True
    },
    "credentials": {
        "add": {
            "Host": {
                "Windows": [{
                    "domain": "company.local",
                    "username": "nessus_svc",
                    "password": "SCAN_SERVICE_PASSWORD",
                    "auth_method": "Password"
                }],
                "SSH": [{
                    "username": "nessus_svc",
                    "private_key": "/path/to/nessus_key",
                    "auth_method": "public key"
                }]
            }
        }
    }
}

response = requests.post(f"{nessus_url}/scans", headers=headers, json=policy,
                         verify=not os.environ.get("SKIP_TLS_VERIFY", "").lower() == "true")  # Set SKIP_TLS_VERIFY=true for self-signed certs in lab environments
scan_id = response.json()["scan"]["id"]
print(f"Scan created: ID {scan_id}")

Verificação Qualys VMDR via API:

import qualysapi

conn = qualysapi.connect(
    hostname="qualysapi.qualys.com",
    username="api_user",
    password="API_PASSWORD"
)

# Launch vulnerability scan
params = {
    "action": "launch",
    "scan_title": "Weekly_Infrastructure_Scan",
    "ip": "10.0.0.0/16",
    "option_id": "123456",  # Scan profile ID
    "iscanner_name": "Internal_Scanner_01",
    "priority": "0"
}

response = conn.request("/api/2.0/fo/scan/", params)
print(f"Scan launched: {response}")

Etapa 2: Processar e Priorizar Resultados da Verificação

Baixe os resultados e aplique priorização baseada em risco:

import requests
import csv

# Export Nessus results
response = requests.get(
    f"{nessus_url}/scans/{scan_id}/export",
    headers=headers,
    params={"format": "csv"},
    verify=not os.environ.get("SKIP_TLS_VERIFY", "").lower() == "true",  # Set SKIP_TLS_VERIFY=true for self-signed certs in lab environments
)

# Parse and prioritize
vulns = []
reader = csv.DictReader(response.text.splitlines())
for row in reader:
    cvss = float(row.get("CVSS v3.0 Base Score", 0))
    asset_criticality = get_asset_criticality(row["Host"])  # From asset inventory

    # Risk-based priority calculation
    risk_score = cvss * asset_criticality_multiplier(asset_criticality)

    # Boost score if actively exploited (check CISA KEV)
    if row.get("CVE") in cisa_kev_list:
        risk_score *= 1.5

    vulns.append({
        "host": row["Host"],
        "plugin_name": row["Name"],
        "severity": row["Risk"],
        "cvss": cvss,
        "cve": row.get("CVE", "N/A"),
        "risk_score": round(risk_score, 1),
        "asset_criticality": asset_criticality,
        "kev": row.get("CVE") in cisa_kev_list
    })

# Sort by risk score
vulns.sort(key=lambda x: x["risk_score"], reverse=True)

…