# 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' module Nexxa module Tokens STATE_FILE = File.expand_path('tokens.json', __dir__).freeze def self.leer if File.exist?(STATE_FILE) JSON.parse(File.read(STATE_FILE)) else { 'tokens' => [] } end rescue JSON::ParserError { 'tokens' => [] } end def self.guardar(state) File.write(STATE_FILE, JSON.pretty_generate(state) + "\n") File.chmod(0o600, STATE_FILE) 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) state = leer state['tokens'].reject! { |t| t['individuo'] == individuo } state['tokens'] << { 'individuo' => individuo, 'token_hash' => Digest::SHA256.hexdigest(token), 'creado' => Time.now.iso8601 } guardar(state) 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) state = leer existia = state['tokens'].reject! { |t| t['individuo'] == individuo } guardar(state) if existia !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) state = leer entrada = state['tokens'].find { |t| t['individuo'] == individuo } raise "Individuo sin token: #{individuo}" unless entrada entrada['clave_publica_pem'] = clave_publica_pem guardar(state) 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