Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Auditoria de segurança e certificação

Aula 14 de 14 Atualizada a 28 de julho de 2026 Avancado
Nesta página
  1. Da segurança ad hoc à conformidade certificável
  2. Saiba qual o quadro aplicável
  3. Uma lista de verificação que abrange cinco domínios
  4. Auditar significa exigir evidências
  5. Automatize o que for possível
  6. O que um certificador espera
  7. Pontos-chave
  8. Teste os seus conhecimentos

Da segurança ad hoc à conformidade certificável

As lições anteriores forneceram-lhe as ferramentas técnicas para proteger um sistema de IA. Contudo, verificações de segurança pontuais não são suficientes — e a razão não é apenas burocrática. O que verifica uma vez deixa de ser verificado assim que lança a próxima versão, e nada sinaliza essa lacuna. Clientes, reguladores e parceiros exigem provas formais: evidências de que os seus controlos existem, funcionam e se mantêm ao longo do tempo. A auditoria e a certificação transformam as suas práticas num quadro verificável e contínuo.

Saiba qual o quadro aplicável

Cinco quadros intersectam-se na IA, cada um com um âmbito diferente. Distinga-os antes de se comprometer com qualquer coisa.

Norma Âmbito Relevância para IA
ISO 27001 Segurança da informação Base para qualquer sistema que processe dados
ISO 42001 Gestão de IA Específico para IA: governança, risco, ciclo de vida
AI Act (UE) Regulamentação europeia Obrigatório para sistemas de alto risco na UE
SOC 2 Type II Controlos de segurança SaaS Exigido por clientes empresariais
OWASP LLM Top 10 Melhores práticas de segurança para LLM Lista de verificação de referência para auditoria técnica

A distinção decisiva separa o que é obrigatório do que é opcional. O AI Act da UE é um regulamento: se o seu sistema se enquadrar na categoria de alto risco, não tem opção de recusar. As normas ISO e o SOC 2 são certificações voluntárias, tipicamente exigidas por clientes empresariais e não por reguladores. O OWASP LLM Top 10 não é certificável — é uma referência técnica e constitui o melhor ponto de partida para uma primeira auditoria interna, pois custa apenas tempo.

Uma lista de verificação que abrange cinco domínios

Uma auditoria séria vai além da técnica. A lista de verificação abaixo distribui os seus pontos de controlo por cinco domínios, e essa distribuição conta uma história: a governança e a conformidade pesam tanto quanto a segurança, porque uma configuração técnica impecável que ninguém assume e que não está documentada em lado nenhum falhará qualquer auditoria externa.

A criticidade separa o obrigatório do recomendado, uma distinção que mais tarde impulsiona uma decisão binária. O sandboxing aparece como recomendado e não como obrigatório, e essa classificação justifica-se: aplica-se apenas a sistemas que executam código gerado, ao passo que a filtragem de entradas e saídas diz respeito a todas as aplicações, sem exceção. Uma lista de verificação bem calibrada não pede a um chatbot de FAQ que justifique o isolamento de contentores.

from dataclasses import dataclass, field
from datetime import datetime

@dataclass
class ControlPoint:
    id: str
    category: str
    description: str
    criticality: str  # mandatory, recommended, optional
    compliant: bool | None = None
    evidence: str = ""
    comment: str = ""

def create_audit_checklist() -> list[ControlPoint]:
    """Creates a comprehensive AI security audit checklist."""
    return [
        # Governance
        ControlPoint("GOV-01", "Governance",
            "Documented and approved AI security policy", "mandatory"),
        ControlPoint("GOV-02", "Governance",
            "Designated AI security owner (CISO/DPO)", "mandatory"),
        ControlPoint("GOV-03", "Governance",
            "Up-to-date register of AI processing activities", "mandatory"),

        # Data
        ControlPoint("DAT-01", "Data",
            "Inventory of data sent to LLM APIs", "mandatory"),
        ControlPoint("DAT-02", "Data",
            "Anonymization/pseudonymization of personal data", "mandatory"),
        ControlPoint("DAT-03", "Data",
            "DPA signed with each AI API provider", "mandatory"),
        ControlPoint("DAT-04", "Data",
            "Defined conversation retention policy", "mandatory"),

        # Technical security
        ControlPoint("SEC-01", "Security",
            "Prompt injection: defense-in-depth implemented", "mandatory"),
        ControlPoint("SEC-02", "Security",
            "Content filtering (inputs and outputs)", "mandatory"),
        ControlPoint("SEC-03", "Security",
            "Rate limiting and abuse detection", "mandatory"),
        ControlPoint("SEC-04", "Security",
            "API keys stored in a vault (not hardcoded)", "mandatory"),
        ControlPoint("SEC-05", "Security",
            "Sandboxing for generated code execution", "recommended"),
        ControlPoint("SEC-06", "Security",
            "Monitoring and alerts on anomalies", "recommended"),

        # Red teaming
        ControlPoint("RED-01", "Red teaming",
            "Security tests before every production release", "mandatory"),
        ControlPoint("RED-02", "Red teaming",
            "Regular red teaming (quarterly minimum)", "recommended"),
        ControlPoint("RED-03", "Red teaming",
            "Red team report with remediation tracking", "mandatory"),

        # Compliance
        ControlPoint("CONF-01", "Compliance",
            "DPIA completed for AI processing activities", "mandatory"),
        ControlPoint("CONF-02", "Compliance",
            "Data subject rights implemented (access, erasure)", "mandatory"),
        ControlPoint("CONF-03", "Compliance",
            "Transparent user notice about AI usage", "mandatory"),
        ControlPoint("CONF-04", "Compliance",
            "Risk classification per the EU AI Act", "recommended"),
    ]

Auditar significa exigir evidências

O campo que muda tudo na execução da auditoria é evidence. Assinalar «conforme» sem uma referência documental não significa nada para um auditor externo, que perguntará sistematicamente o que sustenta a afirmação. O exemplo de utilização mostra isto claramente: a conformidade do ponto GOV-01 assenta num documento nomeado e datado, não numa declaração de intenções.

A terceira chamada ilustra o caso mais instrutivo — uma não conformidade associada ao seu plano de correção. Uma chave de API num ficheiro de ambiente não é um escândalo; é uma prática comum. Ainda assim, falha no ponto de controlo, e o comentário delineia o caminho para a conformidade. Uma auditoria que não revele nenhuma não conformidade deve levantar suspeitas: geralmente sinaliza uma lista de verificação permissiva, não um sistema perfeito.

A decisão final é binária e não ponderada: uma única não conformidade obrigatória inverte o veredito. A taxa de conformidade, calculada em paralelo, mede o progresso entre auditorias — nunca negocia o veredito em si.

class AISecurityAudit:
    """Executes and documents an AI security audit."""

    def __init__(self, system_name: str, auditor: str):
        self.system_name = system_name
        self.auditor = auditor
        self.date = datetime.now().strftime("%Y-%m-%d")
        self.checklist = create_audit_checklist()

    def evaluate(self, point_id: str, compliant: bool, evidence: str, comment: str = ""):
        """Evaluates a control point."""
        for point in self.checklist:
            if point.id == point_id:
                point.compliant = compliant
                point.evidence = evidence
                point.comment = comment
                return
        raise ValueError(f"Unknown control point: {point_id}")

    def report(self) -> dict:
        """Generates the audit report."""
        evaluated = [p for p in self.checklist if p.compliant is not None]
        compliant = [p for p in evaluated if p.compliant]
        non_compliant = [p for p in evaluated if not p.compliant]
        not_evaluated = [p for p in self.checklist if p.compliant is None]

        # Mandatory non-compliances are blockers
        blockers = [
            p for p in non_compliant if p.criticality == "mandatory"
        ]

        return {
            "system": self.system_name,
            "auditor": self.auditor,
            "date": self.date,
            "total_controls": len(self.checklist),
            "evaluated": len(evaluated),
            "compliant": len(compliant),
            "non_compliant": len(non_compliant),
            "not_evaluated": len(not_evaluated),
            "blockers": len(blockers),
            "compliance_rate": f"{len(compliant) / max(len(evaluated), 1) * 100:.0f}%",
            "decision": "NON-COMPLIANT" if blockers else "COMPLIANT",
            "blocking_non_compliances": [
                {"id": p.id, "description": p.description, "comment": p.comment}
                for p in blockers
            ],
        }

# Usage example
audit = AISecurityAudit("Customer Support Chatbot v2.3", "security_analyst")
audit.evaluate("GOV-01", True, "Document POL-SEC-AI-2026 approved on 2026-01-15")
audit.evaluate("SEC-01", True, "Multi-layer guardrails implemented (see architecture)")
audit.evaluate("SEC-04", False, "OpenAI API key in .env environment variable",
              "Migrate to a vault (HashiCorp Vault or AWS Secrets Manager)")

result = audit.report()
print(f"Decision: {result['decision']}")
print(f"Compliance rate: {result['compliance_rate']}")

Um último contador — o número de pontos não avaliados — desempenha um papel silencioso mas decisivo. Impede que confunda «conforme» com «não verificado», uma confusão que se instala quando uma auditoria se estende por semanas e ninguém se lembra onde parou.

Automatize o que for possível

Uma auditoria anual capta um instantâneo. Entre instantâneos, uma chave de API pode ficar incorporada no código, um limite de taxa pode ser desativado para desbloquear um cliente apressado, ou a moderação pode ser contornada para um teste rápido. As verificações automatizadas preenchem essa lacuna, executando-se em cada ciclo de integração contínua.

Nem tudo se presta à automação, e deve dizê-lo claramente. A procura de chaves incorporadas no código é mecanizável porque inspeciona o código. As outras duas verificações no exemplo devolvem valores fixos, o que só faz sentido como ponto de partida: em produção, devem realmente exercitar o serviço — chamar a API vinte e uma vezes para confirmar que surge um 429, ou submeter conteúdo de teste à moderação para confirmar que esta responde. Uma verificação que devolve sempre «verdadeiro» é pior do que nenhuma verificação, porque fabrica confiança sem medir nada.

class ContinuousAudit:
    """Automatically verifies security controls on an ongoing basis."""

    def __init__(self):
        self.checks = {}

    def add_check(self, name: str, check_function):
        """Adds an automated check."""
        self.checks[name] = check_function

    def run(self) -> dict:
        """Runs all checks."""
        results = {}
        for name, check in self.checks.items():
            try:
                ok, detail = check()
                results[name] = {"status": "PASS" if ok else "FAIL", "detail": detail}
            except Exception as e:
                results[name] = {"status": "ERROR", "detail": str(e)}
        return results

# Automated checks
continuous_audit = ContinuousAudit()

def check_api_keys():
    """Verifies that no API keys are hardcoded in the codebase."""
    import subprocess
    result = subprocess.run(
        ["grep", "-r", "sk-", "src/", "--include=*.py", "-l"],
        capture_output=True, text=True,
    )
    files = result.stdout.strip().split("\n") if result.stdout.strip() else []
    return len(files) == 0, f"{len(files)} file(s) with hardcoded key"

def check_rate_limiting():
    """Verifies that rate limiting is active."""
    return True, "Rate limiting active (429 after 20 req/min)"

def check_moderation():
    """Verifies that moderation is active on the pipeline."""
    return True, "Moderation API called on inputs and outputs"

continuous_audit.add_check("api_keys_secured", check_api_keys)
continuous_audit.add_check("rate_limiting_active", check_rate_limiting)
continuous_audit.add_check("moderation_active", check_moderation)

O que um certificador espera

Apontar para uma certificação como a ISO 42001 ou o SOC 2 altera o esforço, e deve saber isso antes de se comprometer. A documentação vem em primeiro lugar: políticas, procedimentos e registos atualizados — o trabalho que as equipas de engenharia mais facilmente adiam. Segue-se a evidência — registos, relatórios de testes, capturas de ecrã — e é muito mais fácil de recolher se a arquivar à medida que avança, em vez de três semanas antes da auditoria. O histórico é o requisito mais difícil de recuperar: um SOC 2 Type II examina como os controlos operaram ao longo de vários meses, algo que nenhum esforço de última hora pode fabricar. A formação vem a seguir, e deve provar que ocorreu, o que significa listas de presenças datadas e materiais. Por fim, a melhoria contínua exige demonstrar que as constatações são corrigidas e retestadas — exatamente o ciclo de revalidação do capítulo anterior, cujo valor compreende agora: produz a evidência que o certificador exigirá.

O ciclo de auditar, corrigir, retestar e certificar não tem fim. Cada nova funcionalidade reabre pontos de controlo, e esse é exatamente o significado de «contínuo» em «melhoria contínua».

Pontos-chave

  • A auditoria transforma as melhores práticas de segurança em evidências verificáveis
  • A lista de verificação abrange governança, dados, segurança técnica, red teaming e conformidade
  • As não conformidades obrigatórias são bloqueantes — devem ser corrigidas antes da implementação
  • A auditoria contínua automatiza verificações repetitivas (chaves de API, limites de taxa, moderação)
  • A certificação (ISO 42001, SOC 2) exige documentação, evidências e histórico: o ciclo de auditar, corrigir e retestar é contínuo, nunca pontual

Teste os seus conhecimentos

Segurança ofensiva e defensiva: o controlo final antes da auditoria.

1. O que é um ataque de injeção de *prompt*?

Resposta: Instruções maliciosas inseridas nos dados que o modelo processa (página web, documento, mensagem) para sequestrar o seu comportamento — defesa: isolar instruções dos dados, validar saídas, limitar capacidades expostas.

2. *Jailbreaking* vs. injeção de *prompt*: qual é a diferença?

Resposta: O jailbreaking tenta fazer com que o modelo contorne as suas regras através de conversa direta; a injeção funciona através de conteúdo de terceiros que o modelo processa. Ambos são testados — e contrariados — de forma diferente.

3. Porquê a filtragem em várias camadas?

Resposta: Porque nenhuma camada é perfeita: a moderação de entrada, as barreiras de proteção da aplicação, os controlos de saída e a limitação de taxa complementam-se — defesa em profundidade aplicada à IA.

4. O que envolve uma campanha de *red teaming* de IA?

Resposta: Atacar metodicamente o seu próprio sistema (cenários de injeção, jailbreaks, exfiltração) com uma taxonomia de riscos, documentar violações, priorizar a correção — e depois retestar.

5. O que abrange a vertente do RGPD numa implementação da OpenAI?

Resposta: A base legal para o processamento, a minimização de dados para os dados enviados, os direitos dos titulares dos dados e as salvaguardas contratuais — a conformidade é desenhada com a arquitetura, não depois.

Um sistema de IA seguro está provado: taxonomia, testes ofensivos, defesas em camadas, auditoria — o ciclo que este curso o levou a praticar.