Compliance e Frameworks de Segurança: ISO 27001, SOC 2, LGPD e GDPR Já leu

Segurança técnica sem governança é como construir uma fortaleza sem documentar as regras de acesso. Frameworks de compliance traduzem requisitos legais, regulatórios e de mercado em controles auditáveis, processos repetíveis e evidências verificáveis. Para engenheiros de software, compreender ISO 27001, SOC 2, LGPD e GDPR não é uma responsabilidade exclusiva do jurídico ou do CISO: são esses frameworks que definem o que deve ser implementado, como deve ser documentado e como a organização demonstra que cumpre suas obrigações. Este artigo explora cada framework em profundidade, com mapeamentos de controles, exemplos de políticas e implementações técnicas verificáveis.

Por Que Compliance Importa para Engenheiros

Compliance é frequentemente percebido como burocracia — formulários, auditorias e certificações que cabem ao departamento jurídico e ao time de GRC (Governance, Risk and Compliance). Essa percepção é equivocada e custosa. A implementação real dos controles exigidos por qualquer framework de segurança — criptografia em repouso e em trânsito, controle de acesso, logging de auditoria, gestão de vulnerabilidades — é feita por engenheiros. A ausência de compreensão técnica dos requisitos resulta em implementações que passam na documentação mas falham em auditorias técnicas.

Além disso, frameworks como LGPD e GDPR estabelecem obrigações legais com sanções significativas: o GDPR prevê multas de até 4% do faturamento global anual ou €20 milhões, o que for maior. A LGPD prevê sanções de até 2% do faturamento no Brasil, limitadas a R$ 50 milhões por infração. Organizações que processam dados pessoais não podem ignorar essas obrigações.

Os Quatro Frameworks Abordados

ISO 27001: Sistema de Gestão de Segurança da Informação

A ISO/IEC 27001 é a norma internacional que especifica os requisitos para estabelecer, implementar, manter e melhorar continuamente um Sistema de Gestão de Segurança da Informação (SGSI). Ela não prescreve controles específicos de tecnologia — prescreve um sistema de gestão: um conjunto de processos, políticas e evidências que demonstram que a organização identifica riscos e os trata de forma sistemática.

A Estrutura do SGSI (Cláusulas 4 a 10)

A norma é estruturada em cláusulas de requisito (4 a 10) e um Anexo A com 93 controles opcionais organizados em quatro temas. As cláusulas são:

O Anexo A: Os 93 Controles em Quatro Temas

A versão de 2022 da ISO 27001 reorganizou os controles em quatro temas principais, substituindo os 14 domínios da versão de 2013:

Avaliação e Tratamento de Riscos: o Coração da ISO 27001

O diferencial da ISO 27001 é sua abordagem baseada em risco: os controles selecionados não são obrigatórios universalmente — cada organização seleciona os controles relevantes com base em uma avaliação formal de riscos. Isso exige um processo sistemático de identificar ativos, ameaças, vulnerabilidades, calcular o risco residual e decidir como tratá-lo.

from dataclasses import dataclass, field
from typing import Literal
from enum import Enum
import uuid


class TratamentoRisco(Enum):
    MITIGAR    = "mitigar"      # Implementar controles para reduzir o risco
    ACEITAR    = "aceitar"      # Risco tolerável; documentar e monitorar
    TRANSFERIR = "transferir"   # Seguro, terceiro
    EVITAR     = "evitar"       # Eliminar a atividade que gera o risco


@dataclass
class Ativo:
    id: str = field(default_factory=lambda: str(uuid.uuid4())[:8])
    nome: str = ""
    tipo: str = ""              # "dados", "sistema", "infraestrutura"
    valor: int = 0              # 1-5: impacto se perdido/comprometido
    proprietario: str = ""


@dataclass
class RiscoISO27001:
    id: str = field(default_factory=lambda: str(uuid.uuid4())[:8])
    ativo: Ativo = field(default_factory=Ativo)
    ameaca: str = ""
    vulnerabilidade: str = ""
    probabilidade: int = 0      # 1-5
    impacto: int = 0            # 1-5
    controles_existentes: list[str] = field(default_factory=list)
    controles_adicionais: list[str] = field(default_factory=list)
    tratamento: TratamentoRisco = TratamentoRisco.MITIGAR
    responsavel: str = ""
    prazo_dias: int = 90

    @property
    def nivel_risco_inerente(self) -> int:
        return self.probabilidade * self.impacto * self.ativo.valor

    @property
    def nivel_risco_residual(self) -> int:
        reducao = min(0.9, len(self.controles_existentes) * 0.15)
        return int(self.nivel_risco_inerente * (1 - reducao))

    @property
    def classificacao(self) -> str:
        r = self.nivel_risco_residual
        if r >= 50: return "CRÍTICO"
        if r >= 30: return "ALTO"
        if r >= 15: return "MÉDIO"
        return "BAIXO"


class RegistroRiscos:
    """Representa o documento central de gestão de riscos da ISO 27001."""

    def __init__(self, organizacao: str):
        self.organizacao = organizacao
        self.riscos: list[RiscoISO27001] = []

    def adicionar(self, risco: RiscoISO27001):
        self.riscos.append(risco)

    def relatorio_executivo(self):
        print(f"\n{'='*60}")
        print(f"REGISTRO DE RISCOS ISO 27001 — {self.organizacao}")
        print(f"Total de riscos: {len(self.riscos)}")
        print(f"{'='*60}\n")

        for risco in sorted(self.riscos, key=lambda r: r.nivel_risco_residual, reverse=True):
            print(f"[{risco.classificacao:8s}] {risco.ameaca}")
            print(f"  Ativo         : {risco.ativo.nome} (valor={risco.ativo.valor})")
            print(f"  Risco inerente: {risco.nivel_risco_inerente}")
            print(f"  Risco residual: {risco.nivel_risco_residual}")
            print(f"  Tratamento    : {risco.tratamento.value}")
            print(f"  Responsável   : {risco.responsavel} | Prazo: {risco.prazo_dias}d")
            if risco.controles_adicionais:
                print(f"  Controles (+) : {', '.join(risco.controles_adicionais)}")
            print()


# ── Exemplo ──────────────────────────────────────────────────────────────────

bd_producao = Ativo(nome="Banco de Dados de Clientes", tipo="dados", valor=5,
                    proprietario="time_dados")
api_publica  = Ativo(nome="API Pública de Pagamentos", tipo="sistema", valor=5,
                     proprietario="time_backend")
backup_nuvem = Ativo(nome="Backups Nuvem", tipo="infraestrutura", valor=4,
                     proprietario="time_infra")

registro = RegistroRiscos("Empresa Exemplo S.A.")

registro.adicionar(RiscoISO27001(
    ativo=bd_producao,
    ameaca="Exfiltração de dados de clientes por credencial comprometida",
    vulnerabilidade="Usuários privilegiados sem MFA",
    probabilidade=4, impacto=5,
    controles_existentes=["Firewall de banco", "Logs de acesso"],
    controles_adicionais=["MFA obrigatório", "PAM com sessões gravadas", "Alertas UEBA"],
    tratamento=TratamentoRisco.MITIGAR,
    responsavel="CISO", prazo_dias=30
))

registro.adicionar(RiscoISO27001(
    ativo=api_publica,
    ameaca="Injeção SQL via parâmetros da API de pagamentos",
    vulnerabilidade="Ausência de validação de entrada e WAF",
    probabilidade=3, impacto=5,
    controles_existentes=["Code review", "Testes unitários"],
    controles_adicionais=["WAF", "SAST no pipeline CI", "Pentest semestral"],
    tratamento=TratamentoRisco.MITIGAR,
    responsavel="Tech Lead", prazo_dias=45
))

registro.adicionar(RiscoISO27001(
    ativo=backup_nuvem,
    ameaca="Ransomware criptografando backups acessíveis via credencial única",
    vulnerabilidade="Backups acessíveis com a mesma credencial de produção",
    probabilidade=2, impacto=4,
    controles_existentes=["Backups diários"],
    controles_adicionais=["Backups imutáveis (Object Lock)", "Credenciais separadas", "Teste de restauração mensal"],
    tratamento=TratamentoRisco.MITIGAR,
    responsavel="SRE Lead", prazo_dias=60
))

registro.relatorio_executivo()

Declaração de Aplicabilidade (SoA)

A Declaração de Aplicabilidade (Statement of Applicability) é o documento central que lista todos os 93 controles do Anexo A, indica quais são aplicáveis à organização, por que foram selecionados (ou excluídos), e qual é o status de implementação. É o documento principal examinado por auditores de certificação.

Processo de Certificação ISO 27001: A certificação exige dois estágios de auditoria: no Estágio 1, o auditor revisa a documentação (SGSI, políticas, SoA, registro de riscos). No Estágio 2, o auditor verifica a implementação real dos controles in loco e por evidências (logs, relatórios, registros de treinamento). A certificação é válida por três anos, com auditorias de manutenção anuais.

SOC 2: Controles para Provedores de Serviços em Nuvem

Service Organization Control 2 (SOC 2) é um framework de auditoria desenvolvido pelo AICPA (American Institute of CPAs) que avalia se um provedor de serviços implementa controles adequados para proteger dados de clientes. Ao contrário da ISO 27001, SOC 2 não resulta em uma certificação — resulta em um relatório emitido por um auditor independente que descreve os controles existentes e se eles operaram efetivamente durante o período de auditoria.

Os Cinco Trust Service Criteria

SOC 2 avalia organizações com base em cinco critérios de serviço confiável. Segurança é o único critério obrigatório; os demais são selecionados conforme o modelo de negócios:

SOC 2 Tipo I vs Tipo II

Existem dois tipos de relatório SOC 2 com finalidades distintas. O Tipo I avalia se os controles estão adequadamente desenhados em um ponto específico no tempo — é uma fotografia. O Tipo II avalia se os controles desenhados operaram efetivamente ao longo de um período (tipicamente 6 a 12 meses) — é um filme. Clientes corporativos geralmente exigem SOC 2 Tipo II, pois demonstra operação real e não apenas intenção.

Controles Técnicos Exigidos pelo Critério de Segurança (CC)

Implementação de Logging para SOC 2

Um dos controles mais verificados em auditorias SOC 2 é o logging de segurança (CC7.1, CC7.2). O sistema deve registrar eventos de segurança relevantes, imutáveis, com retenção adequada e alertas em tempo real:

import json
import logging
import hashlib
import time
from datetime import datetime, timezone
from typing import Optional
from enum import Enum
import uuid


class EventoSeguranca(Enum):
    AUTENTICACAO_SUCESSO        = "auth.success"
    AUTENTICACAO_FALHA          = "auth.failure"
    AUTORIZACAO_NEGADA          = "authz.denied"
    DADOS_ACESSADOS             = "data.accessed"
    DADOS_MODIFICADOS           = "data.modified"
    DADOS_EXPORTADOS            = "data.exported"
    CONFIGURACAO_ALTERADA       = "config.changed"
    PRIVILEGIO_ESCALADO         = "privilege.escalated"
    ALERTA_ANOMALIA             = "anomaly.detected"
    ACESSO_ADMIN                = "admin.access"


class AuditLogger:
    """
    Logger de auditoria estruturado para compliance SOC 2 / ISO 27001.
    Gera eventos imutáveis com hash de integridade encadeado (chain of custody).
    """

    def __init__(self, servico: str, ambiente: str = "producao"):
        self.servico = servico
        self.ambiente = ambiente
        self._ultimo_hash = "GENESIS"

        self._logger = logging.getLogger(f"audit.{servico}")
        handler = logging.StreamHandler()
        handler.setFormatter(logging.Formatter('%(message)s'))
        self._logger.addHandler(handler)
        self._logger.setLevel(logging.INFO)

    def _calcular_hash(self, evento: dict) -> str:
        conteudo = json.dumps(evento, sort_keys=True, default=str) + self._ultimo_hash
        return hashlib.sha256(conteudo.encode()).hexdigest()

    def registrar(
        self,
        tipo: EventoSeguranca,
        usuario_id: str,
        recurso: str,
        resultado: str,
        detalhes: Optional[dict] = None,
        ip_origem: Optional[str] = None
    ) -> str:
        evento_id = str(uuid.uuid4())
        ts = datetime.now(timezone.utc).isoformat()

        evento = {
            "evento_id": evento_id,
            "timestamp": ts,
            "servico": self.servico,
            "ambiente": self.ambiente,
            "tipo": tipo.value,
            "usuario_id": usuario_id,
            "recurso": recurso,
            "resultado": resultado,
            "ip_origem": ip_origem,
            "detalhes": detalhes or {},
            "hash_anterior": self._ultimo_hash
        }

        hash_atual = self._calcular_hash(evento)
        evento["hash_integridade"] = hash_atual
        self._ultimo_hash = hash_atual

        self._logger.info(json.dumps(evento, ensure_ascii=False))
        return evento_id

    def autenticacao_sucesso(self, usuario_id: str, ip: str, metodo_mfa: str = "TOTP"):
        return self.registrar(
            EventoSeguranca.AUTENTICACAO_SUCESSO,
            usuario_id=usuario_id, recurso="sistema/login",
            resultado="SUCESSO", ip_origem=ip,
            detalhes={"mfa_utilizado": True, "metodo_mfa": metodo_mfa}
        )

    def autenticacao_falha(self, usuario_id: str, ip: str, motivo: str):
        return self.registrar(
            EventoSeguranca.AUTENTICACAO_FALHA,
            usuario_id=usuario_id, recurso="sistema/login",
            resultado="FALHA", ip_origem=ip,
            detalhes={"motivo": motivo}
        )

    def acesso_negado(self, usuario_id: str, recurso: str, acao: str, ip: str):
        return self.registrar(
            EventoSeguranca.AUTORIZACAO_NEGADA,
            usuario_id=usuario_id, recurso=recurso,
            resultado="NEGADO", ip_origem=ip,
            detalhes={"acao_tentada": acao}
        )

    def exportacao_dados(self, usuario_id: str, tabela: str, registros: int, ip: str):
        return self.registrar(
            EventoSeguranca.DADOS_EXPORTADOS,
            usuario_id=usuario_id, recurso=f"dados/{tabela}",
            resultado="EXECUTADO", ip_origem=ip,
            detalhes={"registros_exportados": registros, "formato": "CSV"}
        )


# ── Demonstração ──────────────────────────────────────────────────────────────

audit = AuditLogger(servico="api-pagamentos", ambiente="producao")

audit.autenticacao_sucesso("alice@empresa.com", "177.72.100.1")
audit.autenticacao_falha("hacker@example.com", "45.33.32.156", "Senha incorreta")
audit.acesso_negado("bob@empresa.com", "admin/configuracoes", "write", "10.0.0.5")
audit.exportacao_dados("carol@empresa.com", "clientes", 15000, "10.0.0.8")

A saída é um JSON estruturado com hash encadeado, compatível com ferramentas de SIEM (Splunk, Elastic SIEM, Datadog). A cadeia de hashes permite detectar adulteração retroativa de logs — qualquer modificação em um evento quebra todos os hashes subsequentes.

LGPD: Lei Geral de Proteção de Dados Pessoais

A Lei 13.709/2018 (LGPD) é o principal instrumento legal brasileiro de proteção de dados pessoais, em vigor desde setembro de 2020. Ela se aplica a qualquer operação de tratamento de dados pessoais de pessoas naturais localizadas no Brasil, independentemente de onde a organização está sediada — portanto, empresas norte-americanas, europeias e de qualquer outra jurisdição que coletam dados de brasileiros estão sujeitas à LGPD.

Conceitos Fundamentais da LGPD

As Bases Legais para Tratamento de Dados

A LGPD exige que cada operação de tratamento de dados seja fundamentada em uma das dez bases legais previstas no art. 7°. O consentimento é apenas uma delas — e geralmente não a mais adequada para relações contratuais:

Direitos dos Titulares: o que a Aplicação Deve Suportar

A LGPD garante aos titulares direitos que a organização é obrigada a atender dentro de prazo razoável. Do ponto de vista de engenharia, o sistema deve ter capacidade técnica de responder a cada um desses direitos:

from dataclasses import dataclass, field
from datetime import datetime, timedelta
from typing import Optional
from enum import Enum
import uuid


class DireitoLGPD(Enum):
    CONFIRMACAO_EXISTENCIA      = "confirmacao_existencia"   # Art. 18, I
    ACESSO                      = "acesso"                   # Art. 18, II
    CORRECAO                    = "correcao"                 # Art. 18, III
    ANONIMIZACAO_BLOQUEIO       = "anonimizacao_bloqueio"    # Art. 18, IV
    PORTABILIDADE               = "portabilidade"            # Art. 18, V
    ELIMINACAO_CONSENTIMENTO    = "eliminacao_consentimento" # Art. 18, VI
    INFORMACAO_COMPARTILHAMENTO = "info_compartilhamento"    # Art. 18, VII
    REVOGACAO_CONSENTIMENTO     = "revogacao_consentimento"  # Art. 18, IX


class StatusSolicitacao(Enum):
    RECEBIDA   = "recebida"
    EM_ANALISE = "em_analise"
    CONCLUIDA  = "concluida"
    RECUSADA   = "recusada"


@dataclass
class SolicitacaoTitular:
    id: str = field(default_factory=lambda: str(uuid.uuid4()))
    titular_cpf: str = ""
    titular_email: str = ""
    direito: DireitoLGPD = DireitoLGPD.ACESSO
    descricao: str = ""
    recebida_em: datetime = field(default_factory=datetime.utcnow)
    status: StatusSolicitacao = StatusSolicitacao.RECEBIDA
    respondida_em: Optional[datetime] = None
    resposta: str = ""
    prazo: datetime = field(init=False)

    def __post_init__(self):
        self.prazo = self.recebida_em + timedelta(days=15)

    @property
    def dias_restantes(self) -> int:
        return max(0, (self.prazo - datetime.utcnow()).days)

    @property
    def atrasada(self) -> bool:
        return datetime.utcnow() > self.prazo and self.status not in (
            StatusSolicitacao.CONCLUIDA, StatusSolicitacao.RECUSADA
        )


class CentralPrivacidade:
    """Central de gestão de solicitações de titulares para conformidade com LGPD."""

    def __init__(self):
        self._solicitacoes: dict[str, SolicitacaoTitular] = {}

    def registrar(self, solicitacao: SolicitacaoTitular) -> str:
        self._solicitacoes[solicitacao.id] = solicitacao
        print(f"[LGPD] Solicitacao registrada: {solicitacao.id[:8]} | "
              f"{solicitacao.direito.value} | prazo: {solicitacao.prazo.date()}")
        return solicitacao.id

    def responder(self, solicitacao_id: str, resposta: str, status: StatusSolicitacao):
        sol = self._solicitacoes.get(solicitacao_id)
        if not sol:
            print(f"Solicitacao {solicitacao_id} nao encontrada.")
            return
        sol.status        = status
        sol.resposta      = resposta
        sol.respondida_em = datetime.utcnow()
        print(f"[LGPD] Respondida: {sol.id[:8]} | {status.value}")

    def relatorio_conformidade(self):
        total     = len(self._solicitacoes)
        atrasadas = sum(1 for s in self._solicitacoes.values() if s.atrasada)
        concluidas = sum(1 for s in self._solicitacoes.values()
                         if s.status == StatusSolicitacao.CONCLUIDA)
        print(f"\n=== Relatorio LGPD — Solicitacoes de Titulares ===")
        print(f"  Total recebidas : {total}")
        print(f"  Concluidas      : {concluidas}")
        print(f"  Atrasadas       : {atrasadas}")
        print(f"  Conformidade    : {'OK' if atrasadas == 0 else 'RISCO — VERIFICAR'}")


# ── Demonstração ──────────────────────────────────────────────────────────────

central = CentralPrivacidade()

s1 = SolicitacaoTitular(
    titular_cpf="123.456.789-00", titular_email="joao@example.com",
    direito=DireitoLGPD.ACESSO,
    descricao="Quero saber quais dados meus voces possuem."
)
s2 = SolicitacaoTitular(
    titular_cpf="987.654.321-00", titular_email="maria@example.com",
    direito=DireitoLGPD.ELIMINACAO_CONSENTIMENTO,
    descricao="Solicito a exclusao de todos os meus dados cadastrais."
)

central.registrar(s1)
central.registrar(s2)
central.responder(s1.id, "Dados enviados por e-mail seguro: nome, CPF, endereco.", StatusSolicitacao.CONCLUIDA)
central.relatorio_conformidade()

Registro de Operações de Tratamento (ROPA)

Tanto a LGPD quanto o GDPR exigem que as organizações mantenham um Registro das Operações de Tratamento de Dados (Record of Processing Activities — ROPA). Este é um documento vivo que mapeia cada tipo de dado coletado, a finalidade, a base legal, os destinatários, o prazo de retenção e as medidas de segurança aplicadas:

from dataclasses import dataclass, field
from typing import Optional


@dataclass
class OperacaoTratamento:
    """Representa uma entrada no Registro de Operacoes de Tratamento (ROPA)."""
    id: str
    nome_processo: str
    controlador: str
    finalidade: str
    base_legal: str
    categorias_dados: list[str]
    dados_sensiveis: bool
    destinatarios: list[str]
    paises_transferencia: list[str]
    prazo_retencao: str
    medidas_seguranca: list[str]
    dpo_contato: str
    ultima_revisao: Optional[str] = None


ropa: list[OperacaoTratamento] = [
    OperacaoTratamento(
        id="OP-001",
        nome_processo="Cadastro de Clientes Pessoa Fisica",
        controlador="Empresa Exemplo S.A. (CNPJ: 00.000.000/0001-00)",
        finalidade="Viabilizar a prestacao dos servicos contratados e emissao de notas fiscais",
        base_legal="Execucao de contrato — Art. 7, V, LGPD",
        categorias_dados=["nome completo", "CPF", "e-mail", "telefone", "endereco", "IP"],
        dados_sensiveis=False,
        destinatarios=["Receita Federal (NF)", "Processadora de Pagamentos"],
        paises_transferencia=[],
        prazo_retencao="5 anos apos encerramento do contrato (obrigacao fiscal)",
        medidas_seguranca=["Criptografia AES-256 em repouso", "TLS 1.3 em transito",
                           "Acesso por RBAC com MFA", "Logs de auditoria com retencao 5 anos"],
        dpo_contato="privacidade@empresa.com.br",
        ultima_revisao="2025-01-15"
    ),
    OperacaoTratamento(
        id="OP-002",
        nome_processo="Analytics de Uso da Plataforma",
        controlador="Empresa Exemplo S.A. (CNPJ: 00.000.000/0001-00)",
        finalidade="Analise de comportamento para melhoria de produto",
        base_legal="Interesse legitimo — Art. 7, IX, LGPD",
        categorias_dados=["user_id anonimizado", "eventos de clique", "paginas visitadas", "IP truncado"],
        dados_sensiveis=False,
        destinatarios=["Plataforma de Analytics interna"],
        paises_transferencia=[],
        prazo_retencao="2 anos",
        medidas_seguranca=["Pseudoanonimizacao de user_id", "IP truncado (/24)",
                           "Acesso restrito ao time de produto"],
        dpo_contato="privacidade@empresa.com.br",
        ultima_revisao="2025-01-15"
    )
]

print("=== Registro de Operacoes de Tratamento (ROPA) ===\n")
for op in ropa:
    print(f"[{op.id}] {op.nome_processo}")
    print(f"  Base legal      : {op.base_legal}")
    print(f"  Dados sensiveis : {'SIM' if op.dados_sensiveis else 'Nao'}")
    print(f"  Categorias      : {', '.join(op.categorias_dados)}")
    print(f"  Retencao        : {op.prazo_retencao}")
    print(f"  Transferencia   : {op.paises_transferencia or ['Apenas Brasil']}")
    print()

GDPR: Regulamento Geral de Proteção de Dados da Europa

O General Data Protection Regulation (GDPR), Regulamento (UE) 2016/679, é o principal instrumento de proteção de dados pessoais da União Europeia, em vigor desde maio de 2018. Considerado o mais abrangente e influente regulamento de privacidade do mundo, o GDPR foi a principal inspiração para a LGPD brasileira — as estruturas são similares, mas o GDPR possui requisitos adicionais e mecanismos de enforcement mais consolidados.

GDPR vs LGPD: Principais Diferenças

Privacy by Design: Implementação Técnica

O GDPR (Art. 25) exige Privacy by Design e Privacy by Default: a proteção de dados deve ser considerada desde a concepção do sistema, não adicionada como camada posterior. Na prática, isso se traduz em decisões técnicas concretas:

import hashlib
import hmac
import re
from typing import Optional


class PrivacyByDesign:
    """
    Utilitarios de Privacy by Design para implementacao pratica de
    requisitos GDPR/LGPD em sistemas Python.
    """

    def __init__(self, chave_pseudonimizacao: str):
        # Chave separada dos dados — deve ser armazenada em cofre (Vault)
        self._chave = chave_pseudonimizacao.encode()

    # ── Pseudoanonimizacao ───────────────────────────────────────────────────
    def pseudonimizar(self, identificador: str) -> str:
        """
        Transforma um identificador em pseudonimo consistente via HMAC-SHA256.
        O mesmo identificador sempre produz o mesmo pseudonimo (necessario para
        joins analiticos), mas e irreversivel sem a chave.
        """
        return hmac.new(self._chave, identificador.encode(), hashlib.sha256).hexdigest()[:16]

    # ── Anonimizacao ─────────────────────────────────────────────────────────
    @staticmethod
    def anonimizar_email(email: str) -> str:
        """Mascara e-mail: joao.silva@empresa.com → j***a@empresa.com"""
        local, domain = email.rsplit("@", 1)
        if len(local) <= 2:
            return f"***@{domain}"
        return f"{local[0]}{'*' * (len(local) - 2)}{local[-1]}@{domain}"

    @staticmethod
    def truncar_ip(ip: str) -> str:
        """Trunca o ultimo octeto do IPv4 para anonimizacao parcial."""
        partes = ip.split(".")
        if len(partes) == 4:
            return f"{partes[0]}.{partes[1]}.{partes[2]}.0"
        return ip

    @staticmethod
    def mascarar_cpf(cpf: str) -> str:
        """Mascara CPF mantendo apenas sufixo: 123.456.789-00 → ***.***.789-00"""
        digits = re.sub(r'\D', '', cpf)
        if len(digits) == 11:
            return f"***.***.{digits[6:9]}-{digits[9:]}"
        return "***"

    # ── Minimizacao de dados ─────────────────────────────────────────────────
    @staticmethod
    def minimizar(dados: dict, campos_necessarios: list[str]) -> dict:
        """Filtra apenas os campos necessarios para a finalidade especifica."""
        return {k: v for k, v in dados.items() if k in campos_necessarios}

    # ── Verificacao de consentimento ─────────────────────────────────────────
    @staticmethod
    def consentimento_valido(consentimento: dict, finalidade: str) -> bool:
        """
        Verifica se o consentimento e valido para a finalidade solicitada.
        GDPR Art. 7: consentimento deve ser especifico, informado, inequivoco.
        """
        if not consentimento.get("ativo", False):
            return False
        if finalidade not in consentimento.get("finalidades", []):
            return False
        if not consentimento.get("data_consentimento"):
            return False
        return True


# ── Demonstração ──────────────────────────────────────────────────────────────

pbyd = PrivacyByDesign(chave_pseudonimizacao="chave-secreta-do-vault-nao-hardcode")

dados_usuario = {
    "nome": "Joao Silva",
    "cpf": "123.456.789-00",
    "email": "joao.silva@empresa.com",
    "telefone": "(41) 99999-0000",
    "ip": "177.72.100.50",
    "data_nascimento": "1990-05-15",
    "saldo": 1500.00
}

user_id_analitico = pbyd.pseudonimizar(dados_usuario["cpf"])
print(f"Pseudonimo analitico (CPF): {user_id_analitico}")
print(f"E-mail no log             : {pbyd.anonimizar_email(dados_usuario['email'])}")
print(f"IP no log                 : {pbyd.truncar_ip(dados_usuario['ip'])}")
print(f"CPF no log                : {pbyd.mascarar_cpf(dados_usuario['cpf'])}")

dados_analytics = pbyd.minimizar(dados_usuario, campos_necessarios=["ip", "data_nascimento"])
dados_analytics["ip"] = pbyd.truncar_ip(dados_analytics["ip"])
print(f"\nDados enviados ao analytics: {dados_analytics}")

consentimento = {
    "ativo": True,
    "finalidades": ["prestacao_servico", "comunicacoes_transacionais"],
    "data_consentimento": "2024-03-01"
}
print(f"\nConsentimento para marketing : {pbyd.consentimento_valido(consentimento, 'marketing')}")
print(f"Consentimento para servico   : {pbyd.consentimento_valido(consentimento, 'prestacao_servico')}")

Notificação de Incidentes: Obrigações em 72 Horas

O GDPR estabelece que incidentes de segurança envolvendo dados pessoais devem ser notificados à autoridade de proteção de dados em até 72 horas após a descoberta. Se o incidente representar alto risco aos titulares, eles também devem ser notificados sem demora. Isso exige que a organização possua um processo documentado e testado de resposta a incidentes de privacidade, com papéis claros, templates de notificação e critérios objetivos de classificação de risco.

Sanções Reais GDPR: Meta: €1,2 bilhão (maio/2023) por transferência ilegal de dados para os EUA. Amazon: €746 milhões (2021) por violações de consentimento em cookies. Google (França): €150 milhões (2022) por dificuldades no mecanismo de recusa de cookies. Estas multas demonstram que as autoridades europeias são ativas na aplicação do regulamento.

Mapeamento de Controles: ISO 27001 × SOC 2 × LGPD × GDPR

Na prática, organizações sujeitas a múltiplos frameworks procuram implementar controles unificados que atendam a todos simultaneamente — evitando redundância de esforço:

Cultura de Segurança: o Elemento Humano

Todos os controles técnicos e frameworks de compliance são ineficazes se a cultura organizacional não os sustenta. Estudos recorrentes da indústria demonstram que entre 80% e 95% dos incidentes de segurança envolvem algum elemento humano — phishing, senha reutilizada, configuração incorreta intencional ou por desconhecimento, acesso não revogado.

Uma cultura de segurança sólida se manifesta em práticas cotidianas: developers que consideram implicações de segurança durante o design de features; gestores que não pressionam por atalhos que comprometem controles; times de operações que reportam anomalias sem medo de punição; todos que completam treinamentos de conscientização e reconhecem tentativas de phishing.

Para engenheiros, a responsabilidade prática se traduz em: integrar segurança no pipeline de CI/CD (SAST, SCA, secrets scanning); revisar código com olhar de segurança; reportar dependências vulneráveis; nunca armazenar credenciais em repositórios; e entender que compliance não é um checkbox — é a operacionalização de um compromisso com clientes e titulares de dados.

Checklist de Conformidade para Engenheiros: Nenhuma credencial em repositório git (use Vault ou secrets manager) · Criptografia habilitada em repouso em todos os datastores · TLS 1.2+ em todos os endpoints; preferir TLS 1.3 · Logs de auditoria para todas as operações com dados pessoais · ROPA atualizado com cada novo tipo de dado coletado · Base legal documentada para cada operação de tratamento · Mecanismo técnico de atendimento a solicitações de titulares · Processo documentado de resposta a incidentes de privacidade · Privacy by Design: minimizar dados coletados e pseudoanonimizar onde possível · Treinamento anual de segurança e phishing para toda a equipe

Referências

1. ISO/IEC 27001:2022 — Information security, cybersecurity and privacy protection
   https://www.iso.org/standard/82875.html

2. AICPA — SOC 2 Trust Services Criteria
   https://www.aicpa-cima.com/resources/landing/system-and-organization-controls-soc-suite-of-services

3. Lei Geral de Proteção de Dados Pessoais — Lei 13.709/2018
   https://www.planalto.gov.br/ccivil_03/_ato2015-2018/2018/lei/l13709.htm

4. ANPD — Autoridade Nacional de Proteção de Dados
   https://www.gov.br/anpd/pt-br

5. Regulamento (UE) 2016/679 — GDPR (texto completo)
   https://eur-lex.europa.eu/legal-content/PT/TXT/?uri=CELEX%3A32016R0679

6. EDPB — European Data Protection Board — Guidelines
   https://edpb.europa.eu/our-work-tools/our-documents/guidelines_en

7. NIST Cybersecurity Framework 2.0
   https://www.nist.gov/cyberframework

8. OWASP — Privacy by Design Cheat Sheet
   https://cheatsheetseries.owasp.org/cheatsheets/Privacy_by_Design_Cheat_Sheet.html