Compliance: LGPD e GDPR para desenvolvedores

1. Fundamentos das Leis de Proteção de Dados para Devs

LGPD (Lei Geral de Proteção de Dados, Brasil) e GDPR (General Data Protection Regulation, União Europeia) são marcos regulatórios que impactam diretamente o desenvolvimento de software. Enquanto a LGPD prevê multas de até 2% do faturamento (limitado a R$ 50 milhões por infração), o GDPR pode aplicar sanções de até €20 milhões ou 4% do faturamento global.

Princípios-chave que afetam o código:
- Minimização de dados: Coletar apenas o necessário para a funcionalidade
- Consentimento: Obter autorização explícita para processar dados
- Transparência: Informar claramente como os dados serão usados

Diferença prática entre LGPD e GDPR:
O GDPR exige consentimento explícito para qualquer processamento de dados sensíveis, enquanto a LGPD permite algumas bases legais adicionais, como "legítimo interesse". No código, isso significa que sistemas brasileiros podem ter mais flexibilidade no tratamento de dados sem consentimento explícito em alguns cenários.

2. Mapeamento de Dados e Bases Legais no Desenvolvimento

Identifique todos os pontos onde dados pessoais são coletados, processados ou armazenados:

// Exemplo de mapeamento de dados no sistema
// Dados pessoais: nome, email, CPF, endereço IP
// Dados sensíveis: biometria, dados de saúde, orientação sexual
// Fluxo: Cadastro -> Validação -> Armazenamento -> Processamento -> Exclusão

Bases legais comuns para devs:
- Execução de contrato: processar dados do usuário para entregar o serviço contratado
- Legítimo interesse: análises internas que não prejudiquem o titular
- Consentimento: marketing, compartilhamento com terceiros

Documente com Data Flow Diagrams (DFDs) para cada operação:

[Usuário] -> [Formulário de Cadastro] -> [API de Validação] -> [Banco de Dados]
   |                                                                 |
   +-> [Log de Consentimento]                                        |
   +-> [Serviço de Email] -------------------------------------------+

3. Consentimento e Coleta de Dados no Frontend e Backend

Implemente formulários de consentimento granulares:

// Frontend - Exemplo de opt-in granular
function renderConsentForm() {
    return {
        marketing: { checked: false, label: "Receber ofertas por email" },
        analytics: { checked: true, label: "Dados anônimos de uso" },
        sharing: { checked: false, label: "Compartilhar com parceiros" }
    };
}

Validação e armazenamento seguro do consentimento:

// Backend - Registro de consentimento com timestamp
function storeConsent(userId, consents) {
    const record = {
        userId: userId,
        consents: JSON.stringify(consents),
        timestamp: Date.now(),
        ipAddress: hash(request.ip), // pseudonimizado
        userAgent: request.headers['user-agent']
    };
    database.insert('consent_logs', record);
}

Tratamento de dados de menores:
Implemente verificação de idade antes de coletar dados:

function validateUserAge(birthDate) {
    const age = calculateAge(birthDate);
    if (age < 13) {
        throw new Error("Usuário menor de 13 anos requer consentimento dos pais");
    }
    if (age < 18) {
        return { requiresParentalConsent: true, age: age };
    }
    return { requiresParentalConsent: false, age: age };
}

4. Direitos dos Titulares: Como Implementar no Código

API para direito de acesso e exclusão:

// Rota para solicitação de exclusão de dados
app.post('/api/v1/data/deletion-request', async (req, res) => {
    const userId = req.user.id;

    // 1. Validar identidade do titular
    const user = await database.findUser(userId);

    // 2. Iniciar processo de exclusão
    const deletionJob = {
        userId: userId,
        status: 'pending',
        createdAt: Date.now(),
        deadline: Date.now() + (15 * 24 * 60 * 60 * 1000) // 15 dias LGPD
    };

    await database.insert('deletion_requests', deletionJob);

    // 3. Notificar o titular
    await emailService.sendConfirmation(user.email, deletionJob.id);

    res.json({ message: "Solicitação registrada", requestId: deletionJob.id });
});

Anonimização vs Pseudonimização:

// Pseudonimização - reversível com chave
function pseudonymizeData(data) {
    const key = crypto.randomBytes(32);
    const cipher = crypto.createCipher('aes-256-gcm', key);
    return { encrypted: cipher.update(data, 'utf8', 'hex'), key: key };
}

// Anonimização - irreversível
function anonymizeData(data) {
    return crypto.createHash('sha256').update(data + salt).digest('hex');
}

5. Segurança Técnica e Proteção de Dados desde a Concepção

Criptografia em repouso (AES-256) e em trânsito (TLS 1.3):

// Configuração de TLS 1.3 no servidor
const https = require('https');
const options = {
    secureProtocol: 'TLSv1_3_method',
    ciphers: 'TLS_AES_256_GCM_SHA384',
    honorCipherOrder: true
};

// Criptografia de dados sensíveis no banco
function encryptSensitiveData(data) {
    const key = process.env.ENCRYPTION_KEY; // Armazenado em vault seguro
    const iv = crypto.randomBytes(16);
    const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
    return iv + cipher.update(data, 'utf8', 'hex') + cipher.final('hex');
}

Minimização de logs - evitar dados pessoais:

// INCORRETO - Evite isso:
console.log(`Usuário ${user.email} fez login em ${Date.now()}`);

// CORRETO - Use apenas identificadores anônimos:
console.log(`Usuário ${hash(user.id)} fez login em ${Date.now()}`);

Controle de acesso RBAC:

// Middleware de autorização baseado em função
function requireRole(role) {
    return (req, res, next) => {
        if (req.user.role !== role) {
            return res.status(403).json({ error: "Acesso negado" });
        }
        next();
    };
}

// Rotas protegidas
app.get('/api/admin/users', requireRole('admin'), getUsers);
app.get('/api/user/profile', requireRole('user'), getProfile);

6. Gerenciamento de Incidentes e Notificação Obrigatória

Detecção de vazamento no código:

// Monitoramento de padrões suspeitos
function detectDataLeak(logEntry) {
    const patterns = {
        email: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/,
        cpf: /\d{3}\.\d{3}\.\d{3}-\d{2}/,
        creditCard: /\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}/
    };

    for (const [type, pattern] of Object.entries(patterns)) {
        if (pattern.test(logEntry)) {
            alertSecurityTeam(`Possível vazamento de ${type} detectado`);
        }
    }
}

Procedimento de notificação (72h no GDPR):

async function notifyDataBreach(affectedUsers, breachDetails) {
    // 1. Notificar autoridade (ANPD ou DPA)
    await sendToAuthority({
        nature: breachDetails.type,
        affectedCount: affectedUsers.length,
        measures: ["Revogação de tokens", "Reset de senhas"],
        timeline: Date.now()
    });

    // 2. Notificar titulares afetados
    for (const user of affectedUsers) {
        await emailService.sendBreachNotification(user.email, {
            description: "Seus dados foram expostos em...",
            recommendations: ["Altere sua senha", "Monitore atividades suspeitas"]
        });
    }
}

7. Ciclo de Vida dos Dados e Retenção no Backend

Políticas de retenção com TTL e cron jobs:

// MongoDB TTL Index - exclusão automática após 90 dias
db.userSessions.createIndex(
    { createdAt: 1 },
    { expireAfterSeconds: 90 * 24 * 60 * 60 }
);

// Cron job para exclusão de dados de usuários inativos
const cron = require('node-cron');
cron.schedule('0 3 * * 0', async () => { // Todo domingo às 3h
    const cutoffDate = new Date();
    cutoffDate.setFullYear(cutoffDate.getFullYear() - 2); // 2 anos inativo

    const inactiveUsers = await database.findUsers({
        lastLogin: { $lt: cutoffDate },
        status: 'inactive'
    });

    for (const user of inactiveUsers) {
        await anonymizeUserData(user.id);
        await database.updateUser(user.id, { status: 'deleted' });
    }
});

Backup seguro e descarte irreversível:

// Descarte seguro de dados
function secureDelete(data) {
    // Sobrescrever com zeros antes de deletar
    const buffer = Buffer.from(data);
    buffer.fill(0);

    // Deletar do banco
    database.delete(data.id);

    // Registrar exclusão
    auditLog.info(`Dados do usuário ${data.id} deletados com segurança`);
}

8. Compliance Contínuo: Auditoria e Atualização de Código

Checklist de compliance para code review:

Checklist de Revisão de Código - LGPD/GDPR
[ ] Dados pessoais estão sendo minimizados?
[ ] Consentimento foi registrado antes do processamento?
[ ] Logs contêm dados pessoais desnecessários?
[ ] Criptografia está ativa em repouso e trânsito?
[ ] Políticas de retenção estão implementadas?
[ ] APIs de direitos do titular estão disponíveis?
[ ] Notificação de incidentes está configurada?

Ferramentas de varredura de dados pessoais:

// Script para detectar dados pessoais em bancos
async function scanDatabaseForPersonalData() {
    const tables = await database.listTables();
    const personalDataPatterns = {
        'email': /^[a-zA-Z0-9._%+-]+@/,
        'cpf': /^\d{11}$/,
        'phone': /^\d{10,11}$/
    };

    for (const table of tables) {
        const columns = await database.getColumns(table);
        for (const column of columns) {
            for (const [type, pattern] of Object.entries(personalDataPatterns)) {
                if (pattern.test(column.name) || pattern.test(column.sampleData)) {
                    reportPersonalData(table, column, type);
                }
            }
        }
    }
}

Atualização contínua conforme jurisprudência:
Mantenha-se atualizado com as decisões da ANPD e do EDPB (European Data Protection Board). Crie um processo de revisão trimestral das políticas de compliance e atualize o código conforme novas interpretações legais.

Referências