Biblioteca Arcane

Arcane.Chaves

Ciclo de vida de chave criptográfica: propósito cobrado, prazo, rotação que mantém as antigas decifrando o passado, identificador no dado cifrado, cifragem em envelope (DEK/KEK), recifragem, derivação por contexto (HKDF) e exportação do cofre cifrada pela senha mestra.

Arcane.Crypto gera bytes aleatórios e cifra com eles. O que ele não tem é o ciclo de vida: de onde a chave veio, até quando vale, para que serve, e o que fazer com o dado cifrado pela versão anterior.

Sem isso, o que acontece na prática é sempre o mesmo: uma chave nasce numa variável de ambiente, é usada para tudo, e nunca é trocada — porque trocá-la tornaria ilegível tudo que já foi cifrado.

propósito e prazo

adopt Arcane.Chaves as Ch

cofre := Ch.cofre()
k := cofre.gerar("sessao", proposito := "assinar", prazo := 86400.0)

assert len(Ch.usar(k, "assinar")) is 32

// O proposito e COBRADO: uma chave por finalidade impede que um
// comprometimento vire todos os comprometimentos.
monitor:
    Ch.usar(k, "cifrar")
handle CryptoKeyError as e:
    out "recusado: esta chave e de 'assinar'"

// E o material nao aparece em texto — o vazamento mais comum e
// alguem imprimir o objeto para depurar.
out k          // <chave SvJsJypGwyqR (assinar)>

Rotação: a antiga continua lendo#

Esta é a decisão que torna a rotação possível na prática. Se trocar a chave tornasse ilegível o que já foi cifrado, ninguém trocaria — e é exatamente o que acontece na maioria dos sistemas.

rotacionar

adopt Arcane.Chaves as Ch

cofre := Ch.cofre()
cofre.gerar("mestra", proposito := "cifrar")

envelope := cofre.envelopar("um terabyte de dados", "mestra")

// Rotaciona: a nova passa a ser a ativa, e a antiga fica aposentada.
nova := cofre.rotacionar("mestra", "cifrar")

// O dado antigo continua legivel — o envelope carrega o 'kid'.
out Ch.e_chave(nova)
assert cofre.desenvelopar(envelope) isnt void

// E recifrar troca a chave sem tocar nos dados.
novo := cofre.recifrar(envelope, "mestra")
assert novo["kid"] is nova.kid

O momento único de atualizar#

avisar antes

adopt Arcane.Chaves as Ch

cofre := Ch.cofre()
cofre.gerar("curta", proposito := "cifrar", prazo := 3600.0)
cofre.gerar("longa", proposito := "cifrar", prazo := 99999999.0)

// Uma chave que vence sem ninguem saber derruba o sistema numa
// madrugada. O aviso e o que transforma isso em tarefa.
perto := cofre.precisa_rotacionar(aviso := 7200.0)
cycle c in perto:
    out $"   rotacionar '{c['rotulo']}' ({c['kid']})"

O que ele NÃO é#

Não é	Porque
um HSM ou KMS	o material vive na memória deste processo, e quem lê a memória lê a chave. Um HSM existe justamente para que a chave nunca saia dele — e isso é hardware, não biblioteca
persistente sozinho	`exportar()` devolve o cofre cifrado pela senha mestra, e gravar é decisão de quem chama. Um cofre que escolhesse onde gravar escolheria errado em metade dos casos
assimétrico	RSA e curva elíptica em Python puro são lentas e são exatamente onde um erro de implementação vira falha silenciosa. Para assinatura com prova perante terceiro, um serviço

As primitivas: Arcane.Crypto. Guia: Autenticação.

Constantes#

Nome	Valor
`ESTADOS`	`["ativa", "aposentada", "revogada"]`
`PROPOSITOS`	`["assinar", "cifrar", "derivar", "autenticar"]`

Funções (4)#

Assinatura
`cofre(opcoes=None)`
`derivar_de(chave, contexto, tamanho=32)`
`e_chave(v)`
`usar(chave, proposito)`