Files
dtic-DIIAA/servicios/nexxa/organismo/lib_tokens.rb
T

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