Tests ADN / test (push) Canceled after 0s
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-Authored-By: GEMMA <noreply@gemma.dtic>
121 lines
4.7 KiB
Ruby
121 lines
4.7 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
# lib_tokens.rb — Autenticación por-individuo (D045 §10, P201/Fase2)
|
|
# ==============================================================================
|
|
# Cada individuo F1 tiene su propio token — generado y guardado en el storage
|
|
# de NEXXA, sin dependencia de candados. Se guarda el HASH del token (SHA256),
|
|
# nunca el token en sí — mismo principio que un password: no hace falta el
|
|
# valor real para VERIFICAR posesión, solo para la emisión inicial (que se
|
|
# muestra una única vez al generarlo, nunca se vuelve a mostrar después).
|
|
# ==============================================================================
|
|
|
|
require 'json'
|
|
require 'securerandom'
|
|
require 'digest'
|
|
require 'time'
|
|
require 'openssl'
|
|
require_relative 'lib_estado'
|
|
|
|
module Nexxa
|
|
module Tokens
|
|
STATE_FILE = Estado.ruta('tokens')
|
|
|
|
# Estado vía Nexxa::Estado (P335/Fase 17)
|
|
def self.leer
|
|
Estado.leer('tokens', STATE_FILE, { 'tokens' => [] })
|
|
end
|
|
|
|
def self.guardar(state)
|
|
Estado.guardar('tokens', STATE_FILE, state)
|
|
end
|
|
|
|
def self.mutar(&)
|
|
Estado.mutar('tokens', STATE_FILE, { 'tokens' => [] }, &)
|
|
end
|
|
|
|
# Genera un token nuevo para un individuo — devuelve el token EN CLARO,
|
|
# una única vez (el caller es responsable de entregárselo al individuo y
|
|
# nunca volver a mostrarlo). Si el individuo ya tenía token, lo reemplaza
|
|
# (rotación simple).
|
|
def self.generar(individuo)
|
|
token = SecureRandom.hex(32)
|
|
mutar do |state|
|
|
state['tokens'].reject! { |t| t['individuo'] == individuo }
|
|
state['tokens'] << {
|
|
'individuo' => individuo,
|
|
'token_hash' => Digest::SHA256.hexdigest(token),
|
|
'creado' => Time.now.iso8601
|
|
}
|
|
state
|
|
end
|
|
token
|
|
end
|
|
|
|
# Verifica un token recibido (ej. header Authorization) — devuelve el
|
|
# nombre del individuo si es válido, nil si no. Comparación de tiempo
|
|
# constante (security-review, P201/Fase2/2.6): comparar hashes con == a
|
|
# secas es vulnerable en teoría a timing attacks — OpenSSL.fixed_length_secure_compare
|
|
# evita que el tiempo de respuesta filtre en qué byte difiere.
|
|
def self.verificar(token)
|
|
return nil if token.to_s.strip.empty?
|
|
|
|
hash = Digest::SHA256.hexdigest(token)
|
|
entrada = leer['tokens'].find do |t|
|
|
t['token_hash'].bytesize == hash.bytesize &&
|
|
OpenSSL.fixed_length_secure_compare(t['token_hash'], hash)
|
|
end
|
|
entrada && entrada['individuo']
|
|
end
|
|
|
|
# Todos los individuos con token registrado — solo metadata (individuo +
|
|
# fecha de creación), NUNCA el hash ni el token (P201/Fase3, mismo criterio
|
|
# que Registro.todas con valor_cifrado).
|
|
def self.listar
|
|
leer['tokens'].map { |t| { 'individuo' => t['individuo'], 'creado' => t['creado'] } }
|
|
end
|
|
|
|
# Revoca el acceso de un individuo — borra su entrada, sin deshacer. El
|
|
# individuo necesita un token nuevo (generar) para volver a consultar NEXXA.
|
|
def self.revocar(individuo)
|
|
existia = nil
|
|
mutar do |state|
|
|
existia = state['tokens'].reject! { |t| t['individuo'] == individuo }
|
|
state
|
|
end
|
|
!existia.nil?
|
|
end
|
|
|
|
# Cifrado de punta a punta (P204, "Aplica Pilares" — reemplaza la
|
|
# decisión previa de diferirlo): cada individuo registra SU PROPIA clave
|
|
# pública RSA — la privada nunca sale del individuo, nunca la ve NEXXA ni
|
|
# GEMMA. Self-service: solo el individuo autenticado con SU token puede
|
|
# tocar SU propia clave (server.rb lo gatea) — ni siquiera un admin la
|
|
# puede setear por otro, porque eso rompería la propiedad de punta a
|
|
# punta (si un tercero pudiera registrar la clave pública "en nombre de"
|
|
# otro, podría sustituirla por una propia y interceptar).
|
|
def self.registrar_clave_publica(individuo:, clave_publica_pem:)
|
|
# Validar que es una clave pública RSA válida antes de guardar — falla
|
|
# rápido con un error claro en vez de guardar basura silenciosamente.
|
|
OpenSSL::PKey::RSA.new(clave_publica_pem)
|
|
|
|
mutar do |state|
|
|
entrada = state['tokens'].find { |t| t['individuo'] == individuo }
|
|
raise "Individuo sin token: #{individuo}" unless entrada
|
|
|
|
entrada['clave_publica_pem'] = clave_publica_pem
|
|
state
|
|
end
|
|
true
|
|
rescue OpenSSL::PKey::RSAError
|
|
raise 'Clave pública inválida — se espera PEM RSA (ej. openssl rsa -pubout)'
|
|
end
|
|
|
|
# nil si el individuo no registró clave — server.rb cae a texto plano en
|
|
# ese caso (compatibilidad, no rompe consumidores que todavía no migraron).
|
|
def self.clave_publica(individuo)
|
|
entrada = leer['tokens'].find { |t| t['individuo'] == individuo }
|
|
entrada && entrada['clave_publica_pem']
|
|
end
|
|
end
|
|
end
|