feat(nexxa): NEXXA versionada en dtic-DIIAA (1.3.0): pools por individuo mente/red, API por rol y gestión desde nexxa-web
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>
This commit is contained in:
Ricardo Monla
2026-10-04 16:42:13 -03:00
co-authored by Claude Opus 5.5 GEMMA
parent 50ac0d0fdf
commit a60758875d
31 changed files with 5653 additions and 0 deletions
+117
View File
@@ -0,0 +1,117 @@
# 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