Implementando autorização num sistema legado: os desafios de quem executa

O cenário: entregar dentro de limites

Desafios e soluções encontradas

1. Duas fontes da verdade

2. Onde a regra mora

• No código: a regra é revisada, versionada e testada junto com a aplicação, mas qualquer mudança exige um deploy.

• Num arquivo de configuração, como um JSON: muda sem mexer no código, mas continua precisando de deploy e perde a checagem do compilador.

• No banco, por rota: muda sem deploy e vira uma fonte única, mas passa a exigir uma validação forte, porque uma regra errada no banco é uma falha de segurança em produção.

3. O custo de cada pedido e o cache

PRAZO_DO_CACHE = 300  # segundos: só uma rede de segurança


def concessoes_do_usuario(usuario_id, cache, banco):
    concessoes = cache.get(usuario_id)
    if concessoes is None:
        concessoes = banco.concessoes_de(usuario_id)
        cache.set(usuario_id, concessoes, PRAZO_DO_CACHE)
    return concessoes


def revogar(concessao_id, cache, banco):
    usuario_id = banco.revogar(concessao_id)
    # a revogação apaga o cache da pessoa na hora, sem esperar o prazo
    cache.delete(usuario_id)

• Leitura barata → a segunda consulta da mesma pessoa já sai do cache.

• Revogação imediata → quem perde um acesso perde na hora, e não daqui a cinco minutos.

• Prazo como rede de segurança → se uma invalidação falhar, o estrago dura no máximo o prazo do cache.

Os riscos de um motor genérico

#Case 1: o campo ausente que autoriza

def igual_ingenuo(exigido, concedido):
    return exigido == concedido


def igual(exigido, concedido):
    return exigido is not None and exigido == concedido


# o pedido chegou sem organização, e a concessão também não tem uma
igual_ingenuo(None, None)  # True: autorizou sem saber sobre o quê
igual(None, None)  # False

#Case 2: os nomes que viram iguais

def normalizar(nome):
    return nome.strip().lower().replace("-", "_").replace(" ", "_")


normalizar("relatorio-mensal") == normalizar("relatorio_mensal")  # True

import re

NOME_VALIDO = re.compile(r"[a-z][a-z0-9_]*")


def validar_nome(nome):
    # o nome é conferido quando é gravado, e não ajeitado na hora de decidir
    if not NOME_VALIDO.fullmatch(nome):
        raise ValueError(f"nome fora do padrão: {nome!r}")
    return nome

#Case 3: “alguma” no lugar de “todas”

def alguma(exigido, concedido):
    return any(alvo in concedido for alvo in exigido)


def todas(exigido, concedido):
    return bool(exigido) and all(alvo in concedido for alvo in exigido)


# o pedido mexe em duas organizações; a concessão só cobre uma
pedido = ["org-a", "org-b"]
concedido = ["org-a"]

alguma(pedido, concedido)  # True: o pedido passaria pela metade
todas(pedido, concedido)  # False

#Case 4: o erro de configuração que só aparece no pedido

#Case 5: o teste que não distingue “negou” de “quebrou”

Influenciar sem decidir

• Leia a restrição como requisito: em vez de brigar com o limite, use-o para desenhar a solução. Foi a restrição que me levou a separar o dado da decisão.

• Entregue bem o que é seu: uma solução boa dentro do escopo convence mais do que uma proposta grande fora dele.

• Deixe o próximo passo onde a próxima pessoa vai encontrá-lo: o que ficou para depois — o cache e a validação na subida — ficou registrado no próprio código, ao lado de onde precisaria entrar.

• Mostre o custo antes de propor a mudança: uma arquitetura dificilmente muda por causa de uma opinião, mas costuma mudar por causa de um risco bem explicado.

Roadmap e próximos passos

• Ausência nunca autoriza, com os campos de isolamento sempre obrigatórios.

• Nomes conferidos na gravação e comparados exatamente na decisão, sem apelidos de curinga.

• Esquema e regras validados na subida, antes do primeiro pedido.

• Um comparador de cobertura para os pedidos com vários alvos.

• Um registro de cada decisão, com o campo que negou, para investigar uma recusa sem precisar adivinhar.

• Testes de propriedade, que geram milhares de casos automaticamente para conferir regras que nunca podem quebrar, como “uma concessão de uma organização nunca alcança outra”.

Conclusão