# 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