Tests ADN / test (push) Canceled after 0s
- Base: código de producción de srvv-nexxa (1.2.1), importado y verificado por hash (P335/F3) - Pools por individuo (lib_pools): mente y red, mezclan proveedores, keys compartidas o exclusivas - API: /disponible/mente|red y /estado por rol, pool_vacio explícito, /pools (CRUD admin), liberar admin - Revertir el agotada propio + motivo y quién la agotó (de P334/F4) - nexxa-web: sección Pools, motivo y botón Liberar, provider libre con sugerencias, escape de texto externo - Convención REG002: lib_*, cli_*, tool_humo_pool; contratos externos con su nombre - Suite local sobre copia aislada: humo HTTP, pools, revertir; servidor_prueba para mirar la web Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-Authored-By: GEMMA <noreply@gemma.dtic>
118 lines
4.7 KiB
Ruby
118 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'
|
|
|
|
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
|