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
+1
View File
@@ -0,0 +1 @@
1.3.0
+11
View File
@@ -0,0 +1,11 @@
#!/usr/bin/env ruby
# frozen_string_literal: true
# chat.rb — Entry point invocado por 'gemma apids chat' (chasis F1 nativo)
# Contrato: recibe el mensaje completo como ARGV[0], imprime texto plano
# (sin LLM, sin JSON — D045 §1/§4, cero semántica en runtime)
require_relative 'router'
texto = ARGV[0].to_s
puts Nexxa::Router.procesar(texto)
+47
View File
@@ -0,0 +1,47 @@
#!/usr/bin/env ruby
# frozen_string_literal: true
# cli_admin.rb — Bootstrap del primer usuario admin del panel web (P201/Fase4)
# Uso: ruby cli_admin.rb --usuario rmonla (crea, perfil admin)
# ruby cli_admin.rb --usuario rmonla --perfil operador
# ruby cli_admin.rb --usuario rmonla --rotar (rota su password)
# ruby cli_admin.rb --listar (metadata, sin hashes)
#
# Corre SIEMPRE en la terminal del Operador (SSH directo al nodo), nunca a
# través de GEMMA/candados ni de un agente — la password se imprime UNA vez
# acá y en ningún otro lugar (Regla 15). Una vez que existe al menos un admin,
# el alta de usuarios nuevos se hace normalmente desde el panel (sección
# Usuarios, gateada a perfil admin) — este script es solo para el bootstrap
# inicial o para recuperar acceso si quedan todos los admins bloqueados.
require_relative 'lib_auth'
args = ARGV.each_slice(2).to_h { |k, v| [k.sub(/^--/, ''), v] }
if ARGV.include?('--listar')
usuarios = Nexxa::Auth.listar
if usuarios.empty?
puts 'Sin usuarios todavía.'
else
usuarios.each { |u| puts "#{u['usuario']} (#{u['perfil']}) — #{u['activo'] == false ? 'inactivo' : 'activo'}" }
end
exit
end
usuario = args['usuario']
abort 'Uso: ruby cli_admin.rb --usuario <nombre> [--perfil admin|operador] [--rotar] | --listar' unless usuario
password = SecureRandom.urlsafe_base64(18)
if ARGV.include?('--rotar')
Nexxa::Auth.actualizar(usuario: usuario, password_nueva: password)
puts "Password rotada para '#{usuario}'. Nueva password (guardarla ahora, no se vuelve a mostrar):"
puts password
elsif Nexxa::Auth.existe?(usuario)
abort "Usuario '#{usuario}' ya existe — usar --rotar para cambiarle la password."
else
perfil = args['perfil'] || 'admin'
Nexxa::Auth.crear_usuario(usuario: usuario, password: password, perfil: perfil)
puts "Usuario '#{usuario}' creado (perfil #{perfil}). Password (guardarla ahora, no se vuelve a mostrar):"
puts password
end
@@ -0,0 +1,37 @@
#!/usr/bin/env ruby
# frozen_string_literal: true
# cli_consumidor.rb — Alta/rotación de token de consumidor sin pasar por el panel (P204)
# Uso: ruby cli_consumidor.rb --individuo gemma (genera/rota token)
# ruby cli_consumidor.rb --listar (metadata, sin hashes)
# ruby cli_consumidor.rb --revocar --individuo gemma (revoca el acceso)
#
# Corre SIEMPRE en la terminal del Operador (SSH directo al nodo), nunca a
# través de GEMMA/candados ni de un agente — el token se imprime UNA vez acá
# y en ningún otro lugar (Regla 15).
require_relative 'lib_tokens'
args = ARGV.each_slice(2).to_h { |k, v| [k.sub(/^--/, ''), v] }
if ARGV.include?('--listar')
consumidores = Nexxa::Tokens.listar
if consumidores.empty?
puts 'Sin consumidores todavía.'
else
consumidores.each { |c| puts "#{c['individuo']} — creado #{c['creado']}" }
end
exit
end
individuo = args['individuo']
abort 'Uso: ruby cli_consumidor.rb --individuo <nombre> [--revocar] | --listar' unless individuo
if ARGV.include?('--revocar')
ok = Nexxa::Tokens.revocar(individuo)
puts(ok ? "Acceso revocado para '#{individuo}'." : "'#{individuo}' no tenía token activo.")
else
token = Nexxa::Tokens.generar(individuo)
puts "Token generado para '#{individuo}' (guardarlo ahora, no se vuelve a mostrar):"
puts token
end
@@ -0,0 +1,37 @@
#!/usr/bin/env ruby
# frozen_string_literal: true
# cli_registrar.rb — Alta de una key con su valor real (D045 §10/§11, P201/Fase2-3)
# Uso: ruby cli_registrar.rb <provider> <identificador> <cuenta_origen> <reset_segundos>
# (el valor real se lee por STDIN, nunca por argv — ME-293/296)
#
# echo -n "$VALOR" | ruby cli_registrar.rb gemini gemini-01 abby 86400
#
# cuenta_origen: cuenta ante el proveedor que generó esta key — PERMANENTE,
# informativo, no filtro de acceso (D045 §11 — distinto de "quién la tiene
# asignada ahora", eso es ultimo_individuo/marcar_uso, efímero).
#
# NEXXA aloja ella misma el valor real, cifrado en su storage propio (D045 §10
# — reemplaza a candados como lugar de guarda de API keys de terceros). El
# valor nunca pasa por argv/log — solo por STDIN, mismo patrón ya usado por
# GEMMA para credenciales (ME-116).
require_relative 'lib_registro'
provider, identificador, cuenta_origen, reset_segundos = ARGV
unless provider && identificador && cuenta_origen && reset_segundos
abort 'Uso: echo -n "$VALOR" | cli_registrar.rb <provider> <identificador> <cuenta_origen> <reset_segundos>'
end
valor = $stdin.read.strip
abort 'Valor vacío por STDIN' if valor.empty?
Nexxa::Registro.registrar(
provider: provider,
identificador: identificador,
cuenta_origen: cuenta_origen,
reset_segundos: reset_segundos.to_i,
valor: valor
)
puts "Registrado: #{provider} → #{identificador} (cuenta: #{cuenta_origen})"
+20
View File
@@ -0,0 +1,20 @@
#!/usr/bin/env ruby
# frozen_string_literal: true
# latido.rb — Heartbeat mínimo, mantiene vivo el proceso del servicio
# ==============================================================================
# NEXXA-F1 (P200) responde a consultas puntuales vía apids chat (SSH bajo
# demanda, sin loop de decisión propio — D045 §1/§4). Este latido NO procesa
# estímulos ni carrera de era (a diferencia de RUBBY/PEGGY) — su único rol es
# marcar 'el organismo está vivo' para el criterio de vida (revive tras
# reinicio de la LXC) y dejar un heartbeat auditable en log, cadencia 300s
# (ME-435: latido ≠ conversar, nunca comparte proceso con el canal directo).
# ==============================================================================
LOG_FILE = File.expand_path('latido.log', __dir__)
CADENCIA_SEGUNDOS = 300
loop do
File.open(LOG_FILE, 'a') { |f| f.puts("#{Time.now.strftime('%Y-%m-%d %H:%M:%S')} — vivo") }
sleep CADENCIA_SEGUNDOS
end
+202
View File
@@ -0,0 +1,202 @@
# frozen_string_literal: true
# lib_auth.rb — Usuarios y sesiones del panel web de NEXXA (P201/Fase4)
# ==============================================================================
# Reemplaza el diseño original (nginx Basic Auth + credencial en candados de
# GEMMA) por corrección explícita del Operador: NEXXA resuelve su propia auth,
# sin dependencia de GEMMA — mismo espíritu de independencia que ya tienen
# lib_tokens.rb (individuos F1) y lib_cripto.rb (master key propia).
#
# Multi-usuario con perfil (corrección 2026-08-03 — el diseño original de un
# solo Operador binario no alcanzaba, el Operador pidió CRUD de usuarios real,
# gateado por perfil): dos perfiles, sin inventar granularidad no pedida —
# - 'admin' → todo, incluida la gestión de usuarios (crear/editar/borrar)
# - 'operador' → todo lo demás (keys, consumidores), sin gestión de usuarios
#
# No reinventa primitivas de seguridad (pedido explícito del Operador): usa
# exactamente el mismo algoritmo ya probado en producción en
# gemma/tools/candados/core/lib_cripto.rb (Armonía Integral) — PBKDF2-HMAC-SHA256,
# 100k iteraciones, salt random — en vez de SHA256 plano (adecuado para el
# token aleatorio de lib_tokens.rb, pero no para una password humana).
#
# Sesión: token aleatorio de alta entropía (mismo patrón que Tokens.generar),
# guardado server-side con expiración, entregado como cookie. HttpOnly/Secure/
# SameSite se arman a mano en el header Set-Cookie (server.rb) porque el
# WEBrick::Cookie de esta versión de Ruby no expone esos atributos — ver
# comentario en server.rb.
# ==============================================================================
require 'json'
require 'securerandom'
require 'openssl'
require 'base64'
require 'time'
module Nexxa
module Auth
USERS_FILE = File.expand_path('.usuarios.json', __dir__).freeze
SESSIONS_FILE = File.expand_path('.sessions.json', __dir__).freeze
PBKDF2_ITER = 100_000
SESSION_TTL = 8 * 3600 # 8 horas — re-login diario razonable
PERFILES_VALIDOS = %w[admin operador].freeze
# ---------- Usuarios ----------
def self.leer_usuarios
return [] unless File.exist?(USERS_FILE)
JSON.parse(File.read(USERS_FILE))
rescue JSON::ParserError
[]
end
def self.guardar_usuarios(lista)
File.write(USERS_FILE, JSON.pretty_generate(lista) + "\n")
File.chmod(0o600, USERS_FILE)
end
def self.derivar(password, salt)
OpenSSL::PKCS5.pbkdf2_hmac(password, salt, PBKDF2_ITER, 32, 'SHA256')
end
# Crea un usuario nuevo — devuelve la password EN CLARO solo si el
# caller la generó (bootstrap por cli_admin.rb), o la recibe ya elegida
# (alta vía panel por un admin). Nunca se persiste ni se loguea en claro.
# raise si el usuario ya existe o el perfil no es válido.
def self.crear_usuario(usuario:, password:, perfil:)
usuario = usuario.to_s.strip
raise 'Usuario vacío' if usuario.empty?
raise "Perfil inválido: #{perfil} (válidos: #{PERFILES_VALIDOS.join(', ')})" unless PERFILES_VALIDOS.include?(perfil)
lista = leer_usuarios
raise "Usuario '#{usuario}' ya existe" if lista.any? { |u| u['usuario'] == usuario }
salt = SecureRandom.random_bytes(16)
hash = derivar(password, salt)
lista << {
'usuario' => usuario,
'perfil' => perfil,
'salt' => Base64.strict_encode64(salt),
'hash' => Base64.strict_encode64(hash),
'activo' => true,
'creado' => Time.now.iso8601
}
guardar_usuarios(lista)
usuario
end
# Verifica usuario+password — devuelve el registro (sin salt/hash) si es
# válido y está activo, nil si no. Comparación de tiempo constante.
def self.autenticar(usuario:, password:)
entrada = leer_usuarios.find { |u| u['usuario'] == usuario.to_s.strip && u['activo'] != false }
return nil unless entrada
salt = Base64.strict_decode64(entrada['salt'])
hash_guardado = Base64.strict_decode64(entrada['hash'])
hash_calculado = derivar(password.to_s, salt)
return nil unless hash_guardado.bytesize == hash_calculado.bytesize &&
OpenSSL.fixed_length_secure_compare(hash_guardado, hash_calculado)
entrada.reject { |k, _| %w[salt hash].include?(k) }
end
# Todos los usuarios, solo metadata — NUNCA salt/hash (Regla 15).
def self.listar
leer_usuarios.map { |u| u.reject { |k, _| %w[salt hash].include?(k) } }
end
def self.existe?(usuario)
leer_usuarios.any? { |u| u['usuario'] == usuario.to_s.strip }
end
# Edita perfil/activo de un usuario existente. password_nueva opcional
# (rotación). raise si no existe o el perfil no es válido.
def self.actualizar(usuario:, perfil: nil, activo: nil, password_nueva: nil)
lista = leer_usuarios
entrada = lista.find { |u| u['usuario'] == usuario.to_s.strip }
raise "Usuario '#{usuario}' no encontrado" unless entrada
if perfil
raise "Perfil inválido: #{perfil} (válidos: #{PERFILES_VALIDOS.join(', ')})" unless PERFILES_VALIDOS.include?(perfil)
entrada['perfil'] = perfil
end
entrada['activo'] = activo unless activo.nil?
if password_nueva && !password_nueva.to_s.strip.empty?
salt = SecureRandom.random_bytes(16)
entrada['salt'] = Base64.strict_encode64(salt)
entrada['hash'] = Base64.strict_encode64(derivar(password_nueva, salt))
end
guardar_usuarios(lista)
entrada.reject { |k, _| %w[salt hash].include?(k) }
end
# Elimina un usuario — destructivo. El caller (server.rb) es responsable
# de impedir que el último admin se borre a sí mismo (guardia de negocio,
# no de esta capa de datos).
def self.eliminar(usuario)
lista = leer_usuarios
existia = lista.reject! { |u| u['usuario'] == usuario.to_s.strip }
guardar_usuarios(lista) if existia
!existia.nil?
end
def self.admins_activos
leer_usuarios.count { |u| u['perfil'] == 'admin' && u['activo'] != false }
end
# ---------- Sesiones ----------
def self.leer_sesiones
return {} unless File.exist?(SESSIONS_FILE)
JSON.parse(File.read(SESSIONS_FILE))
rescue JSON::ParserError
{}
end
def self.guardar_sesiones(sesiones)
File.write(SESSIONS_FILE, JSON.pretty_generate(sesiones) + "\n")
File.chmod(0o600, SESSIONS_FILE)
end
def self.crear_sesion(usuario, perfil)
token = SecureRandom.hex(32)
sesiones = leer_sesiones
sesiones[token] = {
'usuario' => usuario,
'perfil' => perfil,
'expira' => (Time.now + SESSION_TTL).iso8601
}
guardar_sesiones(sesiones)
token
end
# Devuelve {usuario, perfil} de la sesión si es válida, nil si no.
def self.sesion(token)
return nil if token.to_s.strip.empty?
sesiones = leer_sesiones
entrada = sesiones[token]
return nil unless entrada
if Time.parse(entrada['expira']) < Time.now
sesiones.delete(token)
guardar_sesiones(sesiones)
return nil
end
{ 'usuario' => entrada['usuario'], 'perfil' => entrada['perfil'] }
end
def self.sesion_valida?(token)
!sesion(token).nil?
end
def self.cerrar_sesion(token)
sesiones = leer_sesiones
existia = sesiones.delete(token)
guardar_sesiones(sesiones) if existia
!existia.nil?
end
end
end
+54
View File
@@ -0,0 +1,54 @@
# frozen_string_literal: true
# lib_checkins.rb — Reporte proactivo de estado de individuos F1 (P216)
# ==============================================================================
# Complementa lib_tokens.rb (identidad) con un registro simple de "qué contó cada
# individuo de sí mismo la última vez" — mismo espíritu que Registro.disponible
# para keys: NEXXA solo guarda lo que le reportan, nunca sale a diagnosticar
# nada por su cuenta. Quien consulta (GEMMA, vía bandeja.rb) decide qué hacer
# con la antigüedad del último reporte.
# ==============================================================================
require 'json'
require 'time'
module Nexxa
module Checkins
STATE_FILE = File.expand_path('checkins.json', __dir__).freeze
def self.leer
return {} unless File.exist?(STATE_FILE)
JSON.parse(File.read(STATE_FILE))
rescue JSON::ParserError
{}
end
def self.guardar(state)
File.write(STATE_FILE, JSON.pretty_generate(state) + "\n")
File.chmod(0o600, STATE_FILE)
end
# El individuo llega autenticado (individuo_autenticado(req) en server.rb,
# vía Nexxa::Tokens.verificar) — nunca confiar en un id que venga en el
# body, el token YA identifica quién reporta.
def self.registrar(individuo, estado:, detalle: nil)
state = leer
state[individuo] = {
'estado' => estado.to_s,
'detalle' => detalle,
'ultimo_reporte' => Time.now.utc.iso8601
}
guardar(state)
state[individuo]
end
def self.estado(individuo)
leer[individuo]
end
def self.listar
leer
end
end
end
+74
View File
@@ -0,0 +1,74 @@
# frozen_string_literal: true
# lib_cripto.rb — Motor criptográfico AES-256-GCM, adaptado de gemma/tools/candados/core/lib_cripto.rb
# ==============================================================================
# NEXXA-F1 (P201/Fase2) — mismo algoritmo que la bóveda de candados de GEMMA
# (Armonía Integral, no reinventar), pero SIN derivación por frase humana: NEXXA
# cifra/descifra 24/7 sin intervención (D045 §10, storage propio de la key real).
# La master key vive en un archivo local (MasterKey.cargar!), nunca en argv/log.
# ==============================================================================
require 'openssl'
require 'base64'
require 'json'
require 'securerandom'
module Nexxa
class Cripto
ALGORITHM = 'aes-256-gcm'
def initialize(key_bytes)
raise 'Master key debe tener 32 bytes (256 bits)' unless key_bytes.bytesize == 32
@key = key_bytes
end
def encrypt(plaintext)
cipher = OpenSSL::Cipher.new(ALGORITHM)
cipher.encrypt
cipher.key = @key
iv = cipher.random_iv
ciphertext = cipher.update(plaintext.to_s) + cipher.final
payload = { iv: b64(iv), tag: b64(cipher.auth_tag), data: b64(ciphertext) }
Base64.strict_encode64(payload.to_json)
end
def decrypt(token)
p = JSON.parse(Base64.strict_decode64(token), symbolize_names: true)
cipher = OpenSSL::Cipher.new(ALGORITHM)
cipher.decrypt
cipher.key = @key
cipher.iv = db64(p[:iv])
cipher.auth_tag = db64(p[:tag])
cipher.update(db64(p[:data])) + cipher.final
rescue StandardError => e
raise "Error al descifrar: #{e.message}"
end
private
def b64(d) = Base64.strict_encode64(d)
def db64(d) = Base64.strict_decode64(d)
end
module MasterKey
RUTA = File.expand_path('.master_key', __dir__)
# Genera la master key UNA VEZ (idempotente — si ya existe, no la toca).
# Devuelve los bytes en ambos casos. El caller decide si hace backup (candados).
def self.generar_si_falta!
return File.binread(RUTA) if File.exist?(RUTA)
bytes = SecureRandom.random_bytes(32)
File.binwrite(RUTA, bytes)
File.chmod(0o600, RUTA)
bytes
end
def self.cargar!
raise "Master key no existe en #{RUTA} — correr MasterKey.generar_si_falta! primero" unless File.exist?(RUTA)
File.binread(RUTA)
end
end
end
+38
View File
@@ -0,0 +1,38 @@
# frozen_string_literal: true
# lib_envelope.rb — Cifrado de punta a punta hacia el consumidor (P204, "Aplica
# Pilares" sobre la decisión previa de diferirlo)
# ==============================================================================
# Distinto de lib_cripto.rb (AES simétrico, master key propia de NEXXA, cifra EN
# REPOSO — lo que NEXXA guarda). Esto es asimétrico (RSA-OAEP), cifra PARA EL
# CONSUMIDOR — ni NEXXA ni nadie que capture el cuerpo de la respuesta HTTP
# puede leer el valor sin la clave PRIVADA del individuo, que NUNCA sale de
# ese individuo (NEXXA solo guarda la pública, ver lib_tokens.rb).
#
# RSA-OAEP directo (sin AES intermedio): las API keys son strings cortos
# (~30-60 bytes) — un RSA de 2048 bits con padding OAEP-SHA256 cifra hasta
# ~190 bytes de una, de sobra. No hace falta el patrón "envelope" clásico
# (RSA cifra una clave AES efímera, AES cifra el payload grande) porque acá
# el payload YA es chico — agregar esa capa sería complejidad sin beneficio
# real (Menos es Más).
# ==============================================================================
require 'openssl'
require 'base64'
module Nexxa
module Envelope
# Cifra `valor` con la clave pública PEM del consumidor — devuelve base64,
# listo para meter en un campo JSON de la respuesta HTTP. Nunca falla en
# silencio: una clave pública inválida hace que esto reviente (server.rb
# decide qué hacer, no lo traga acá).
def self.cifrar_para(clave_publica_pem, valor)
rsa = OpenSSL::PKey::RSA.new(clave_publica_pem)
Base64.strict_encode64(rsa.public_encrypt(valor.to_s, OpenSSL::PKey::RSA::PKCS1_OAEP_PADDING))
end
# Deliberadamente NO hay Envelope.descifrar acá — descifrar es trabajo
# del CONSUMIDOR con su propia clave privada, nunca de NEXXA. Si NEXXA
# pudiera descifrar esto, no sería de punta a punta.
end
end
+132
View File
@@ -0,0 +1,132 @@
# frozen_string_literal: true
# lib_pools.rb — Pools de keys POR INDIVIDUO: mente y red de seguridad (P335/Fase 4, Operador 2026-10-04)
#
# Cada individuo tiene dos pools: MENTE (las keys con las que piensa y opera) y RED (solo para el aviso de batería
# baja). Un pool MEZCLA proveedores y una key puede estar en varios pools (exclusiva o compartida). Es el TERCER eje de
# una key (ME-609): `cuenta_origen` dice quién la aportó (permanente, informativo), `reservado_por` quién la tiene AHORA
# (efímero) y la asignación a pools es CONFIGURACIÓN permanente que decide un admin desde nexxa-web.
#
# Persistencia: pools.json junto a registro.json (0600). NEXXA guarda todo su estado en JSON en su hábitat y no tiene
# Postgres (REG002 R15 lo pide justificar: un individuo sin BD propia; migrarlo a BD es otra decisión). Separado de
# registro.json a propósito: lo que se edita a mano desde la web (config) no se mezcla con el estado vivo de cada key.
#
# Referencia de una key en un pool: "provider/identificador" (las dos partes juntas la identifican en registro.json).
require 'json'
module Nexxa
module Pools
STATE_FILE = File.expand_path('pools.json', __dir__).freeze
ROLES = %w[mente red].freeze
module_function
def leer
return { 'individuos' => {} } unless File.exist?(STATE_FILE)
d = JSON.parse(File.read(STATE_FILE))
d['individuos'] ||= {}
d
rescue JSON::ParserError
{ 'individuos' => {} }
end
def guardar(state)
tmp = "#{STATE_FILE}.tmp-#{Process.pid}"
File.open(tmp, File::WRONLY | File::CREAT | File::TRUNC, 0o600) { |f| f.write(JSON.pretty_generate(state) + "\n") }
File.rename(tmp, STATE_FILE)
end
def ref(provider, identificador)
"#{provider}/#{identificador}"
end
# Refs del pool de un individuo para un rol. => ["gemini/abby", "deepseek/deepseek-01", ...]
def refs(individuo, rol)
Array(leer.dig('individuos', individuo.to_s, rol.to_s))
end
# Asigna una key al pool. Idempotente. Valida rol y que la key exista en el registro (inyectable para tests).
def asignar(individuo:, rol:, provider:, identificador:, existe: nil)
validar!(individuo, rol)
existe ||= ->(p, i) { Nexxa::Registro.todas.any? { |k| k['provider'] == p && k['identificador'] == i } }
raise "Key no encontrada: #{ref(provider, identificador)}" unless existe.call(provider, identificador)
state = leer
pool = (state['individuos'][individuo] ||= {})[rol] ||= []
r = ref(provider, identificador)
pool << r unless pool.include?(r)
guardar(state)
pool
end
# Quita una key de un pool. => true si estaba.
def quitar(individuo:, rol:, provider:, identificador:)
validar!(individuo, rol)
state = leer
pool = state.dig('individuos', individuo, rol)
return false unless pool&.delete(ref(provider, identificador))
state['individuos'][individuo].delete(rol) if pool.empty?
state['individuos'].delete(individuo) if state['individuos'][individuo].empty?
guardar(state)
true
end
# Al eliminar una key del registro, se saca de todos los pools (sin referencias colgadas).
def olvidar_key(provider:, identificador:)
state = leer
r = ref(provider, identificador)
cambio = false
state['individuos'].each_value { |roles| roles.each_value { |pool| cambio = true if pool.delete(r) } }
state['individuos'].each_value { |roles| roles.delete_if { |_, pool| pool.empty? } }
state['individuos'].delete_if { |_, roles| roles.empty? }
guardar(state) if cambio
cambio
end
# Pools en los que está una key. => [{ 'individuo' =>, 'rol' => }]
def de_key(provider, identificador, state = leer)
r = ref(provider, identificador)
state['individuos'].flat_map do |ind, roles|
roles.select { |_, pool| pool.include?(r) }.map { |rol, _| { 'individuo' => ind, 'rol' => rol } }
end
end
# --- Selección por NOMBRE (P335/Fase 5): el único lugar que decide si /disponible/<nombre> es un rol o un provider.
# Rol (mente|red) → el pool del individuo; si está vacío NO cae al provider (respuesta explícita 'pool_vacio').
# Otro nombre → un provider, como antes (compatibilidad con los consumidores actuales).
def rol?(nombre)
ROLES.include?(nombre.to_s)
end
def pool_vacio?(individuo, nombre)
rol?(nombre) && refs(individuo, nombre).empty?
end
def disponible(individuo, nombre)
rol?(nombre) ? Nexxa::Registro.disponible_en(refs(individuo, nombre)) : Nexxa::Registro.disponible(nombre)
end
def proxima(individuo, nombre)
rol?(nombre) ? Nexxa::Registro.proxima_en(refs(individuo, nombre)) : Nexxa::Registro.proxima(nombre)
end
def estado(individuo, nombre)
rol?(nombre) ? Nexxa::Registro.estado_en(refs(individuo, nombre)) : Nexxa::Registro.estado_pool(nombre)
end
# Pools completos con el estado de cada key, para nexxa-web. Nunca valores.
def con_estado
leer['individuos'].transform_values do |roles|
roles.to_h { |rol, pool| [rol, Nexxa::Registro.estado_en(pool)] }
end
end
def validar!(individuo, rol)
raise 'Falta el individuo' if individuo.to_s.strip.empty?
raise "rol inválido: #{rol} (esperado: #{ROLES.join('|')})" unless ROLES.include?(rol.to_s)
end
end
end
+330
View File
@@ -0,0 +1,330 @@
# frozen_string_literal: true
# lib_registro.rb — Fuente de verdad de cuotas Y del valor real de cada key
# ==============================================================================
# NEXXA-F1 (P200, evolucionado en P201/Fase2-3 — D045 §10/§11) — registro propio,
# inspirado en apirot.rb (P121, dtic-GEMMA) pero con delta de dominio: campo
# 'provider'/'cuenta_origen' (D045 §2.3/§11) y, desde P201/Fase2, el VALOR REAL
# cifrado de cada key (D045 §10: NEXXA es la fuente de verdad, ya no candados,
# para API keys de terceros). 'identificador' es una ETIQUETA legible (ej.
# 'gemini-01'), no el secreto — el secreto vive solo en 'valor_cifrado', nunca
# en texto plano en disco ni en ningún log (ME-293/296).
#
# Dos ejes distintos, no confundir (corrección P201/Fase3, D045 §11):
# - cuenta_origen: PERMANENTE — qué cuenta ante el proveedor generó esta key.
# Informativo, nunca filtro de acceso (pool compartido, D045 §8).
# - ultimo_individuo / reservar / reportar / lib_usos.rb: EFÍMERO — qué individuo
# del ecosistema APIDs la tiene asignada ahora (o la tuvo la última vez). Una
# key se reclama y se libera — no tiene "dueño" en ese sentido.
# ==============================================================================
# NO hace: no llama a los providers externos, no valida las keys en sí — solo
# lleva el registro declarado (alta vía mini-app o cli_registrar.rb)
# ==============================================================================
# Salud real de keys (P204/Fase3, D045 §8) — el CONSUMIDOR es el árbitro del
# agotamiento, no NEXXA: solo él le pegó al proveedor real. reservar() aplica
# una reserva corta de contención al dispensar (evita doble-asignación
# concurrente, sin asumir agotamiento); reportar() recibe la señal real
# ('sana' renueva, 'liberada' suelta, 'agotada' recién ahí bloquea con
# disponible_desde). Ver registro.json: campos reservado_por/reservado_hasta.
# ==============================================================================
require 'json'
require 'time'
require_relative 'lib_cripto'
require_relative 'lib_usos'
module Nexxa
module Registro
STATE_FILE = File.expand_path('registro.json', __dir__).freeze
# Reserva corta de contención (P204/Fase3, D045 §8) — no asume agotamiento,
# solo evita que 2 consumidores reciban la misma key mientras uno la está
# probando. Vence sola (evaluada en self.disponible, sin proceso de limpieza
# aparte) si nadie reporta nada; self.reportar la renueva o la libera.
RESERVA_TTL_SEGUNDOS = 600
def self.leer
if File.exist?(STATE_FILE)
JSON.parse(File.read(STATE_FILE))
else
{ 'keys' => [] }
end
rescue JSON::ParserError
{ 'keys' => [] }
end
def self.guardar(state)
File.write(STATE_FILE, JSON.pretty_generate(state) + "\n")
end
# provider: "gemini"/"groq"/... ; identificador: ETIQUETA legible (ej. "gemini-01"),
# nunca el secreto ; cuenta_origen: cuenta ante el proveedor que generó la key —
# PERMANENTE, informativo, no filtro de acceso (D045 §8/§11) ; reset_segundos:
# ciclo de cuota del proveedor, se persiste para que marcar_uso pueda recalcular
# disponible_desde sin que el caller tenga que volver a pasarlo ; valor: el
# secreto en texto plano — se cifra acá mismo, nunca se persiste sin cifrar
# (nil = alta solo de metadata, compatibilidad con registros viejos aún no
# migrados, D045 §9→§10). ultimo_uso: nil (default) = key nueva/sin agotar,
# disponible YA — nunca se asume 'se usó ahora' (bug real encontrado en
# P200/Fase4: registrar una key recién creada la dejaba "agotada" 24h por
# error, ME-603). Pasar ultimo_uso explícito solo cuando se sabe que la key
# SÍ se agotó en ese momento.
def self.registrar(provider:, identificador:, cuenta_origen:, reset_segundos:, valor: nil, ultimo_uso: nil)
state = leer
ahora = Time.now
disponible_desde = ultimo_uso ? (Time.parse(ultimo_uso) + reset_segundos).iso8601(3) : ahora.iso8601(3)
ultimo_uso ||= ahora.iso8601(3)
valor_cifrado = valor ? cifrar(valor) : nil
existente = state['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador }
if existente
existente.merge!(
'ultimo_uso' => ultimo_uso,
'disponible_desde' => disponible_desde,
'cuenta_origen' => cuenta_origen,
'reset_segundos' => reset_segundos
)
existente['valor_cifrado'] = valor_cifrado if valor_cifrado
else
state['keys'] << {
'provider' => provider,
'identificador' => identificador,
'cuenta_origen' => cuenta_origen,
'reset_segundos' => reset_segundos,
'ultimo_uso' => ultimo_uso,
'ultimo_individuo' => nil,
'disponible_desde' => disponible_desde,
'valor_cifrado' => valor_cifrado,
'activo' => true,
'reservado_por' => nil,
'reservado_hasta' => nil
}
end
guardar(state)
state
end
# Edita metadata de una key existente (P201/Fase3) — NUNCA el valor (eso no
# se re-muestra, se reemplaza vía 'registrar' con un valor nuevo si hace
# falta rotarlo). Cada parámetro es opcional: solo se actualiza lo pasado.
def self.actualizar(provider:, identificador:, cuenta_origen: nil, reset_segundos: nil, activo: nil)
state = leer
entrada = state['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador }
raise "Key no encontrada: #{provider}/#{identificador}" unless entrada
entrada['cuenta_origen'] = cuenta_origen unless cuenta_origen.nil?
entrada['reset_segundos'] = reset_segundos unless reset_segundos.nil?
entrada['activo'] = activo unless activo.nil?
guardar(state)
entrada
end
# Elimina una key del registro — destructivo, sin deshacer (P201/Fase3).
# No borra su historial en lib_usos.rb (log append-only, queda como evidencia).
def self.eliminar(provider:, identificador:)
state = leer
existia = state['keys'].reject! { |k| k['provider'] == provider && k['identificador'] == identificador }
guardar(state) if existia
!existia.nil?
end
# Todas las keys, solo metadata — para la vista de consulta de la mini-app
# (P201/Fase3). Nunca incluye valor_cifrado, bajo ningún caso (Regla 15).
def self.todas
leer['keys'].map { |k| k.reject { |campo, _| campo == 'valor_cifrado' } }
end
# Descifra y devuelve el valor real de una key — SOLO para el endpoint HTTP
# autenticado (Fase 2/2.4). El router de apids chat (router.rb) nunca llama
# a esto — sigue devolviendo solo metadata, texto plano sin el secreto.
def self.revelar(provider:, identificador:)
entrada = leer['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador }
return nil unless entrada && entrada['valor_cifrado']
descifrar(entrada['valor_cifrado'])
end
# Reserva corta de contención al dispensar (P204/Fase3, D045 §8) — reemplaza
# el bloqueo ciego de la vieja marcar_uso: NO asume agotamiento, solo evita
# que 2 consumidores reciban la misma key mientras uno la está probando.
# disponible_desde queda intacto — el agotamiento real solo lo aplica
# self.reportar(estado: 'agotada'), con la señal del consumidor. Se llama
# automático al dispensar (server.rb, GET /disponible).
def self.reservar(provider:, identificador:, individuo:)
state = leer
entrada = state['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador }
raise "Key no encontrada: #{provider}/#{identificador}" unless entrada
ahora = Time.now
entrada['ultimo_uso'] = ahora.iso8601(3)
entrada['ultimo_individuo'] = individuo
entrada['reservado_por'] = individuo
entrada['reservado_hasta'] = (ahora + RESERVA_TTL_SEGUNDOS).iso8601(3)
guardar(state)
Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: individuo, en: ahora, evento: 'dispensada')
entrada
end
# Reporte real del consumidor sobre una key que tiene reservada (P204/Fase3,
# D045 §8) — el consumidor es el árbitro de salud, no NEXXA (solo él le pegó
# al proveedor real). Exige reservado_por == individuo — nadie reporta el
# estado de una key que no tiene reservada.
# 'sana' → renueva la reserva (sigue activo, evita que le venza en uso)
# 'liberada' → libera la reserva ya, sin tocar disponible_desde (buen
# ciudadano que terminó antes de tiempo)
# 'agotada' → recién acá se aplica el bloqueo real: disponible_desde =
# ahora + (liberar_en_segundos si el proveedor dio una pista
# real, si no el reset_segundos registrado como fallback)
#
# P334/Fase 4 (GEMMA, 2026-10-04): quien marcó una key 'agotada' puede DESHACER su propio reporte con
# 'liberada' aunque ya no la tenga reservada (agotada_por == individuo y el bloqueo sigue vigente). Caso real
# 2026-10-01 19:46: un 429 por minuto reportado como agotada bloqueó el pool compartido y el consumidor no podía
# revertirlo (409). Solo el autor del reporte: nadie libera lo que bloqueó otro.
def self.reportar(provider:, identificador:, individuo:, estado:, liberar_en_segundos: nil, motivo: nil)
state = leer
entrada = state['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador }
raise "Key no encontrada: #{provider}/#{identificador}" unless entrada
ahora = Time.now
if estado == 'liberada' && entrada['reservado_por'] != individuo && revertible_por?(entrada, individuo, ahora)
entrada['disponible_desde'] = ahora.iso8601(3)
entrada['agotada_por'] = nil
guardar(state)
Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: individuo, en: ahora, evento: 'revertida')
return entrada
end
raise "Key #{provider}/#{identificador} no está reservada por #{individuo}" unless entrada['reservado_por'] == individuo
case estado
when 'sana'
entrada['reservado_hasta'] = (ahora + RESERVA_TTL_SEGUNDOS).iso8601(3)
when 'liberada'
entrada['reservado_por'] = nil
entrada['reservado_hasta'] = nil
when 'agotada'
reset_segundos = entrada['reset_segundos']
raise "Key #{provider}/#{identificador} sin reset_segundos persistido — no se puede reportar agotada" unless reset_segundos
entrada['disponible_desde'] = (ahora + (liberar_en_segundos || reset_segundos)).iso8601(3)
entrada['agotada_por'] = individuo
entrada['motivo_agotada'] = motivo.to_s[0, 200] unless motivo.to_s.empty?
entrada['reservado_por'] = nil
entrada['reservado_hasta'] = nil
Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: individuo, en: ahora, evento: 'agotada')
else
raise "estado inválido: #{estado} (esperado: sana|liberada|agotada)"
end
guardar(state)
entrada
end
# Liberación por un ADMIN desde nexxa-web (P335/Fase 7): la key queda disponible ya, sin reserva ni marca de
# agotada, sea quien sea que la bloqueó. El rastro queda en usos ('liberada-admin', con el usuario de la web).
def self.liberar_admin(provider:, identificador:, usuario:)
state = leer
entrada = state['keys'].find { |k| k['provider'] == provider && k['identificador'] == identificador }
raise "Key no encontrada: #{provider}/#{identificador}" unless entrada
ahora = Time.now
entrada['disponible_desde'] = ahora.iso8601(3) if Time.parse(entrada['disponible_desde']) > ahora
entrada['reservado_por'] = nil
entrada['reservado_hasta'] = nil
entrada['agotada_por'] = nil
entrada['motivo_agotada'] = nil
guardar(state)
Nexxa::Usos.registrar(provider: provider, identificador: identificador, individuo: "web:#{usuario}", en: ahora,
evento: 'liberada-admin')
entrada
end
# ¿individuo puede deshacer el 'agotada' de esta key? Solo si lo reportó él y el bloqueo sigue vigente.
def self.revertible_por?(entrada, individuo, ahora = Time.now)
entrada['agotada_por'] == individuo && Time.parse(entrada['disponible_desde']) > ahora
end
# Estado del pool de un provider, por key, SIN el valor (P334/Fase 4): para diagnosticar desde un consumidor sin
# entrar a la mini-app. estado: inactiva | agotada | reservada | disponible.
def self.estado_pool(provider, ahora = Time.now)
estado_de(leer['keys'].select { |k| k['provider'] == provider }, ahora)
end
# Estado de las keys de un pool (P335/Fase 5): mezcla proveedores, por eso cada fila trae su provider.
def self.estado_en(refs, ahora = Time.now)
estado_de(de_refs(refs), ahora)
end
def self.estado_de(keys, ahora = Time.now)
keys.map do |k|
estado = if k['activo'] == false then 'inactiva'
elsif Time.parse(k['disponible_desde']) > ahora then 'agotada'
elsif k['reservado_hasta'] && Time.parse(k['reservado_hasta']) > ahora then 'reservada'
else 'disponible'
end
{ 'provider' => k['provider'], 'identificador' => k['identificador'], 'estado' => estado,
'libera_en' => (estado == 'agotada' ? k['disponible_desde'] : nil),
'reservado_por' => (estado == 'reservada' ? k['reservado_por'] : nil),
'agotada_por' => (estado == 'agotada' ? k['agotada_por'] : nil),
'motivo' => (estado == 'agotada' ? k['motivo_agotada'] : nil),
'ultimo_uso' => k['ultimo_uso'], 'ultimo_individuo' => k['ultimo_individuo'] }
end
end
def self.cifrar(valor)
Nexxa::Cripto.new(Nexxa::MasterKey.cargar!).encrypt(valor)
end
def self.descifrar(valor_cifrado)
Nexxa::Cripto.new(Nexxa::MasterKey.cargar!).decrypt(valor_cifrado)
end
# Devuelve la key elegible MENOS USADA RECIENTEMENTE del provider (rotación
# del pool, P204/Fase4, propuesta del Operador) — nil si ninguna es elegible.
# Antes usaba el primer match del array: si la primera key nunca se agotaba,
# las demás no se usaban jamás y quedaban en riesgo de que el proveedor las
# diera de baja por inactividad. min_by sobre ultimo_uso rota el pool solo,
# sin estado adicional (nil = nunca usada, va primero). Elegible = 'activo'
# ausente/true (compat keys viejas), disponible_desde vencido, y
# reservado_hasta ausente/nil/vencido (compat keys pre-P204/Fase3 — la
# reserva vence sola acá, evaluada al consultar, sin limpieza aparte).
def self.disponible(provider)
elegir_libre(leer['keys'].select { |k| k['provider'] == provider })
end
# Igual que disponible, pero dentro de un POOL (P335/Fase 4): refs "provider/identificador" que pueden mezclar
# proveedores. La menos usada recientemente entre las libres, sin importar el proveedor.
def self.disponible_en(refs)
elegir_libre(de_refs(refs))
end
def self.proxima_en(refs)
de_refs(refs).select { |k| k['activo'] != false }.min_by { |k| Time.parse(k['disponible_desde']) }
end
def self.de_refs(refs)
refs = Array(refs)
leer['keys'].select { |k| refs.include?("#{k['provider']}/#{k['identificador']}") }
end
# Criterio ÚNICO de "libre ahora" (activa, no agotada, sin reserva vigente) y de cuál dar (la menos usada).
def self.elegir_libre(keys)
ahora = Time.now
keys
.select do |k|
k['activo'] != false &&
Time.parse(k['disponible_desde']) <= ahora &&
(k['reservado_hasta'].nil? || Time.parse(k['reservado_hasta']) <= ahora)
end
.min_by { |k| k['ultimo_uso'] ? Time.parse(k['ultimo_uso']) : Time.at(0) }
end
# Próxima key de un provider a liberarse (para responder explícito, nunca
# silencioso) — también excluye desactivadas, nunca las ofrece como "próxima".
def self.proxima(provider)
leer['keys']
.select { |k| k['provider'] == provider && k['activo'] != false }
.min_by { |k| Time.parse(k['disponible_desde']) }
end
end
end
+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
+46
View File
@@ -0,0 +1,46 @@
# frozen_string_literal: true
# lib_usos.rb — Registro de uso por individuo (P201/Fase3, D045 §11, ME-605 punto 5)
# ==============================================================================
# Trazabilidad de quién recibió qué key y cuándo — separado del dato de origen
# (cuenta_origen, en lib_registro.rb) y separado de registro.json (estado actual)
# para no mezclar "foto del ahora" con "historial acumulado". Append-only,
# JSONL — mismo espíritu que un log de bitácora: se escribe, no se reescribe.
# ==============================================================================
require 'json'
require 'time'
module Nexxa
module Usos
LOG_FILE = File.expand_path('usos.log', __dir__).freeze
# evento (P204/Fase3): 'dispensada' (reserva al entregar la key) o 'agotada'
# (el consumidor reportó agotamiento real) — default compat con llamadas
# previas a Fase3 (todas eran dispensas).
def self.registrar(provider:, identificador:, individuo:, en: Time.now, evento: 'dispensada')
linea = {
'provider' => provider,
'identificador' => identificador,
'individuo' => individuo,
'evento' => evento,
'en' => en.iso8601
}
File.open(LOG_FILE, 'a') { |f| f.puts(linea.to_json) }
end
# Historial más reciente primero, opcionalmente filtrado por key
def self.historial(provider: nil, identificador: nil, limit: 50)
return [] unless File.exist?(LOG_FILE)
lineas = File.readlines(LOG_FILE).filter_map do |l|
JSON.parse(l)
rescue JSON::ParserError
nil
end
lineas.select! { |l| l['provider'] == provider } if provider
lineas.select! { |l| l['identificador'] == identificador } if identificador
lineas.last(limit).reverse
end
end
end
+15
View File
@@ -0,0 +1,15 @@
#!/usr/bin/env ruby
# frozen_string_literal: true
# nexxa.rb — Entry point del router (uso CLI y, a futuro, canal apids chat)
# Uso: ruby nexxa.rb "disponible gemini"
require_relative 'router'
estimulo = ARGV.join(' ')
if estimulo.empty?
puts "Uso: ruby nexxa.rb \"disponible <provider>\""
exit 1
end
puts Nexxa::Router.procesar(estimulo)
+44
View File
@@ -0,0 +1,44 @@
# frozen_string_literal: true
# router.rb — Matching exacto estímulo → estado, cero semántica en runtime
# ==============================================================================
# NEXXA-F1 (P200) — sin LLM en ningún punto (D045 §1/§4). Responde consultas de
# pares vía apids chat con formato fijo, nunca silencioso ante agotamiento.
# ==============================================================================
require_relative 'lib_registro'
module Nexxa
module Router
# estimulo esperado: "disponible <provider>" (ej. "disponible gemini")
def self.procesar(estimulo)
partes = estimulo.to_s.strip.split(/\s+/)
return "ERROR: estímulo no reconocido — formato esperado: 'disponible <provider>'" unless partes[0] == 'disponible' && partes[1]
provider = partes[1]
key = Nexxa::Registro.disponible(provider)
if key
"#{provider.upcase}: viva (#{key['identificador']}, cuenta: #{key['cuenta_origen']})"
else
proxima = Nexxa::Registro.proxima(provider)
if proxima
restante = Time.parse(proxima['disponible_desde']) - Time.now
"#{provider.upcase}: agotado, próxima en #{formatear_tiempo(restante)}"
else
"#{provider.upcase}: sin keys registradas"
end
end
end
def self.formatear_tiempo(segundos)
segundos = [segundos, 0].max
horas = (segundos / 3600).to_i
mins = ((segundos % 3600) / 60).to_i
partes = []
partes << "#{horas}h" if horas > 0
partes << "#{mins}m" if mins > 0
partes.empty? ? '< 1m' : partes.join(' ')
end
end
end
+915
View File
@@ -0,0 +1,915 @@
#!/usr/bin/env ruby
# frozen_string_literal: true
# server.rb — Servicio HTTP/API de NEXXA (P201/Fase2-4)
# ==============================================================================
# A diferencia de gemma/tools/docs_web/server.rb y gemma/tools/sala/hub.rb
# (que corren en el MISMO host que nginx, loopback alcanza), NEXXA vive en su
# propio LXC (10.0.10.163) — srvv-proxy (10.0.10.117) le hace proxy_pass
# cross-host, así que necesita escuchar en la interfaz real, no en loopback
# (corregido P201/Fase4 tras el primer 502 real contra nexxa.frlr.utn.edu.ar).
# Sigue sin exposición directa a internet: la LAN 10.0.10.0/24 no es
# ruteable desde afuera, nginx sigue siendo el único gateway público.
#
# Dos superficies de auth, ambas resueltas por NEXXA mismo — sin nginx
# Basic Auth ni credenciales de GEMMA (corrección del Operador, P201/Fase4):
# - GET /disponible/<provider|mente|red> → individuo F1, token Bearer (lib_tokens.rb); mente|red = SU pool (P335)
# - GET /, GET /keys, GET /consumidores, GET /pools → cualquier usuario logueado (solo lectura)
# - PATCH/DELETE /keys, POST /keys/<p>/<id>/liberar, POST/DELETE /consumidores, POST/DELETE /pools,
# POST /alta, todo /usuarios → solo perfil 'admin' — 'operador' es
# read-only (corrección 2026-08-03: el diseño original dejaba mutar keys/
# consumidores a cualquier logueado, error — solo /usuarios estaba bien)
# ==============================================================================
require 'webrick'
require 'json'
require_relative 'lib_registro'
require_relative 'lib_pools'
require_relative 'lib_tokens'
require_relative 'lib_checkins'
require_relative 'lib_auth'
require_relative 'lib_envelope'
PORT = 4568
WEB_DIR = File.expand_path('../web', __dir__).freeze
SESSION_COOKIE = 'nexxa_session'
# Versión semántica real (P204/Fase4, pedido del Operador: "tipo v1.0.1", el
# build stamp por timestamp no se entendía como versión) — vive en el archivo
# VERSION junto a este script, se bumpea a mano en cada deploy con cambios
# reales (mismo criterio que cualquier changelog: subir la versión es una
# decisión de quien publica). Sirve para confirmar en la mini-app que un
# deploy realmente llegó.
#
# Se lee del disco EN CADA REQUEST (self.version, no una constante cacheada
# al arrancar) — a propósito, corrección real (Operador, "hiciste cambios sin
# versionar la app"): un deploy de solo estáticos (HTML/CSS/JS) no reinicia
# el proceso, así que una constante cacheada nunca hubiera reflejado ese
# bump sin reiniciar igual — justo el caso más común. Costo despreciable
# (un archivo de una línea) frente a que el número mienta.
VERSION_FILE = File.expand_path('VERSION', __dir__).freeze
def version_actual
File.read(VERSION_FILE).strip
end
# Cifrado de punta a punta (P204) — arma el fragmento de respuesta con el
# valor real, cifrado para EL INDIVIDUO SI tiene clave pública registrada, en
# texto plano si no (compatibilidad — un consumidor que todavía no migró a
# su propia clave sigue funcionando, protegido solo por TLS como antes).
# Un solo lugar decide esto — reusado por la dispensa normal y por
# "siguiente" en /reportar, para no repetir el criterio.
def empaquetar_valor(individuo, valor)
clave_publica = Nexxa::Tokens.clave_publica(individuo)
if clave_publica
{ valor_cifrado: Nexxa::Envelope.cifrar_para(clave_publica, valor), cifrado: true }
else
{ valor: valor, cifrado: false }
end
end
# Todo reinicio del servicio invalida las sesiones activas (P204/Fase4, pedido
# del Operador) — hace el reinicio visible: quien estaba conectado tiene que
# volver a loguearse, en vez de seguir viendo el panel sin saber si el deploy
# surtió efecto. Sesiones son de por sí efímeras (SESSION_TTL=8h, lib_auth.rb) —
# perderlas en un restart no es una pérdida real, es la señal que se pidió.
Nexxa::Auth.guardar_sesiones({})
server = WEBrick::HTTPServer.new(
Port: PORT,
BindAddress: '0.0.0.0',
Logger: WEBrick::Log.new($stdout, WEBrick::Log::INFO),
AccessLog: [[$stdout, WEBrick::AccessLog::COMMON_LOG_FORMAT]]
)
def individuo_autenticado(req)
auth = req['Authorization'].to_s
return nil unless auth.start_with?('Bearer ')
Nexxa::Tokens.verificar(auth.sub('Bearer ', '').strip)
end
# Sesión del Operador (P201/Fase4) — cookie de sesión propia de NEXXA, no
# Basic Auth de nginx. req.cookies ya viene parseado por WEBrick (stdlib).
def token_de_sesion(req)
cookie = req.cookies.find { |c| c.name == SESSION_COOKIE }
cookie&.value
end
def sesion_actual(req)
Nexxa::Auth.sesion(token_de_sesion(req))
end
def operador_autenticado?(req)
!sesion_actual(req).nil?
end
def admin_autenticado?(req)
sesion_actual(req)&.dig('perfil') == 'admin'
end
# WEBrick::Cookie (gem webrick 1.8.1) no expone HttpOnly/SameSite — se arma
# el header Set-Cookie a mano para tener las 3 flags recomendadas (OWASP):
# HttpOnly (JS no puede leerla), Secure (solo por HTTPS — nginx termina TLS
# por delante), SameSite=Strict (mitiga CSRF). Leer sigue vía req.cookies
# (eso sí soportado), esto solo afecta cómo se escribe.
def set_cookie_sesion(res, token)
res['Set-Cookie'] = "#{SESSION_COOKIE}=#{token}; Path=/; Max-Age=#{Nexxa::Auth::SESSION_TTL}; HttpOnly; Secure; SameSite=Strict"
end
def borrar_cookie_sesion(res)
res['Set-Cookie'] = "#{SESSION_COOKIE}=; Path=/; Max-Age=0; HttpOnly; Secure; SameSite=Strict"
end
def rechazar_no_autenticado(res)
res.status = 401
res.content_type = 'application/json'
res.body = { error: 'No autenticado' }.to_json
end
def rechazar_no_admin(res)
res.status = 403
res.content_type = 'application/json'
res.body = { error: 'Requiere perfil admin' }.to_json
end
NEXXA_APP_FILE = File.expand_path('index.html', WEB_DIR).freeze
LOGIN_FILE = File.expand_path('login.html', WEB_DIR).freeze
# GET / — sirve login.html o index.html según la sesión (P201/Fase4). Se lee
# del disco en cada request (mismo criterio que docs_web/server.rb, P164).
server.mount_proc '/' do |req, res|
res.status = 200
res.content_type = 'text/html; charset=utf-8'
res.body = File.read(operador_autenticado?(req) ? NEXXA_APP_FILE : LOGIN_FILE)
end
# Estáticos (css/js) — públicos a propósito: login.html los necesita antes de
# autenticar. WEBrick::HTTPServlet::FileHandler es la clase estándar de la
# stdlib para esto (no reinventar servido de estáticos).
server.mount('/css', WEBrick::HTTPServlet::FileHandler, File.join(WEB_DIR, 'css'))
server.mount('/js', WEBrick::HTTPServlet::FileHandler, File.join(WEB_DIR, 'js'))
# POST /login — body {usuario, password}. Si matchea, crea sesión y devuelve la cookie.
server.mount_proc '/login' do |req, res|
res.content_type = 'application/json'
if req.request_method != 'POST'
res.status = 405
res.body = { error: 'Método no permitido — usar POST' }.to_json
next
end
begin
body = JSON.parse(req.body)
rescue JSON::ParserError
res.status = 400
res.body = { error: 'JSON inválido' }.to_json
next
end
entrada = Nexxa::Auth.autenticar(usuario: body['usuario'], password: body['password'])
if entrada
token = Nexxa::Auth.crear_sesion(entrada['usuario'], entrada['perfil'])
set_cookie_sesion(res, token)
res.status = 200
res.body = { ok: true, usuario: entrada['usuario'], perfil: entrada['perfil'] }.to_json
else
res.status = 401
res.body = { error: 'Usuario o password incorrectos' }.to_json
end
end
# POST /logout — cierra la sesión actual, si había una.
server.mount_proc '/logout' do |req, res|
res.content_type = 'application/json'
Nexxa::Auth.cerrar_sesion(token_de_sesion(req))
borrar_cookie_sesion(res)
res.status = 200
res.body = { ok: true }.to_json
end
# GET /session — quién está logueado ahora (para que el frontend sepa qué
# mostrar, ej. la sección Usuarios solo si perfil admin).
# GET /version — build stamp público (P204/Fase4) — sin auth a propósito,
# mismo criterio que css/js: login.html también necesita mostrarlo, antes de
# autenticar.
server.mount_proc '/version' do |req, res|
res.status = 200
res.content_type = 'application/json'
res.body = { version: version_actual }.to_json
end
server.mount_proc '/session' do |req, res|
res.content_type = 'application/json'
sesion = sesion_actual(req)
if sesion
res.status = 200
res.body = sesion.to_json
else
rechazar_no_autenticado(res)
end
end
# GET /keys — metadata de todas las keys, NUNCA el valor
# PATCH /keys/<provider>/<id> — editar cuenta_origen/reset_segundos/activo
# DELETE /keys/<provider>/<id> — eliminar del registro (destructivo)
# (P201/Fase3-4, D045 §8/§11). Requiere sesión de Operador (lib_auth.rb).
#
# Clase de servlet, no mount_proc: WEBrick::HTTPServlet::ProcHandler (lo que
# usa mount_proc) solo define do_GET/do_POST/do_PUT (ver prochandler.rb) —
# nunca do_DELETE ni do_PATCH, así que un mount_proc con 'case request_method'
# nunca llega a ejecutarse para esos verbos (WEBrick responde 405 antes).
class KeysServlet < WEBrick::HTTPServlet::AbstractServlet
def partes_de(req)
req.path.sub(%r{\A/keys/?}, '').split('/')
end
def do_GET(req, res)
return rechazar_no_autenticado(res) unless operador_autenticado?(req)
res.content_type = 'application/json'
res.status = 200
res.body = Nexxa::Registro.todas.to_json
end
# POST /keys/<provider>/<identificador>/liberar — admin libera una key agotada o reservada (P335/Fase 7)
def do_POST(req, res)
return rechazar_no_autenticado(res) unless operador_autenticado?(req)
return rechazar_no_admin(res) unless admin_autenticado?(req)
res.content_type = 'application/json'
partes = partes_de(req)
unless partes.size == 3 && partes[2] == 'liberar'
res.status = 400
res.body = { error: 'Uso: POST /keys/<provider>/<identificador>/liberar' }.to_json
return
end
Nexxa::Registro.liberar_admin(provider: partes[0], identificador: partes[1], usuario: sesion_actual(req)['usuario'])
res.status = 200
res.body = { ok: true, provider: partes[0], identificador: partes[1] }.to_json
rescue RuntimeError => e
res.status = 404
res.body = { error: e.message }.to_json
end
def do_PATCH(req, res)
return rechazar_no_autenticado(res) unless operador_autenticado?(req)
return rechazar_no_admin(res) unless admin_autenticado?(req)
res.content_type = 'application/json'
partes = partes_de(req)
if partes.size != 2
res.status = 400
res.body = { error: 'Uso: PATCH /keys/<provider>/<identificador>' }.to_json
return
end
provider, identificador = partes
begin
body = JSON.parse(req.body)
rescue JSON::ParserError
res.status = 400
res.body = { error: 'JSON inválido' }.to_json
return
end
begin
entrada = Nexxa::Registro.actualizar(
provider: provider,
identificador: identificador,
cuenta_origen: body['cuenta_origen'],
reset_segundos: body['reset_segundos']&.to_i,
activo: body.key?('activo') ? body['activo'] : nil
)
res.status = 200
res.body = entrada.reject { |k, _| k == 'valor_cifrado' }.to_json
rescue RuntimeError => e
res.status = 404
res.body = { error: e.message }.to_json
end
end
def do_DELETE(req, res)
return rechazar_no_autenticado(res) unless operador_autenticado?(req)
return rechazar_no_admin(res) unless admin_autenticado?(req)
res.content_type = 'application/json'
partes = partes_de(req)
if partes.size != 2
res.status = 400
res.body = { error: 'Uso: DELETE /keys/<provider>/<identificador>' }.to_json
return
end
provider, identificador = partes
borrado = Nexxa::Registro.eliminar(provider: provider, identificador: identificador)
Nexxa::Pools.olvidar_key(provider: provider, identificador: identificador) if borrado # sin refs colgadas (P335)
if borrado
res.status = 200
res.body = { ok: true }.to_json
else
res.status = 404
res.body = { error: 'Key no encontrada' }.to_json
end
end
end
server.mount '/keys', KeysServlet
# /pools — pools por individuo (P335/Fase 5): GET para cualquier operador (estado de cada key, nunca valores);
# asignar/quitar solo admin (ME-682/ME-683, gate explícito en cada escritura).
# GET /pools
# POST /pools/<individuo>/<rol> body {provider, identificador}
# DELETE /pools/<individuo>/<rol>/<provider>/<identificador>
class PoolsServlet < WEBrick::HTTPServlet::AbstractServlet
def partes_de(req)
req.path.sub(%r{\A/pools/?}, '').split('/')
end
def responder(res, status, cuerpo)
res.status = status
res.content_type = 'application/json'
res.body = cuerpo.to_json
end
def do_GET(req, res)
return rechazar_no_autenticado(res) unless operador_autenticado?(req)
responder(res, 200, { roles: Nexxa::Pools::ROLES, individuos: Nexxa::Pools.con_estado })
end
def do_POST(req, res)
return rechazar_no_autenticado(res) unless operador_autenticado?(req)
return rechazar_no_admin(res) unless admin_autenticado?(req)
partes = partes_de(req)
return responder(res, 400, { error: 'Uso: POST /pools/<individuo>/<mente|red> {provider, identificador}' }) if partes.size != 2
body = begin
JSON.parse(req.body.to_s)
rescue JSON::ParserError
return responder(res, 400, { error: 'JSON inválido' })
end
pool = Nexxa::Pools.asignar(individuo: partes[0], rol: partes[1],
provider: body['provider'].to_s, identificador: body['identificador'].to_s)
responder(res, 200, { individuo: partes[0], rol: partes[1], pool: pool })
rescue RuntimeError => e
responder(res, 400, { error: e.message })
end
def do_DELETE(req, res)
return rechazar_no_autenticado(res) unless operador_autenticado?(req)
return rechazar_no_admin(res) unless admin_autenticado?(req)
partes = partes_de(req)
return responder(res, 400, { error: 'Uso: DELETE /pools/<individuo>/<mente|red>/<provider>/<identificador>' }) if partes.size != 4
quitada = Nexxa::Pools.quitar(individuo: partes[0], rol: partes[1], provider: partes[2], identificador: partes[3])
quitada ? responder(res, 200, { ok: true }) : responder(res, 404, { error: 'La key no está en ese pool' })
rescue RuntimeError => e
responder(res, 400, { error: e.message })
end
end
server.mount '/pools', PoolsServlet
# GET /usos — historial de eventos (dispensada/agotada) para la mini-app (P204/Fase4).
# Read-only, mismo criterio de auth que GET /keys (cualquier operador logueado).
# Usos.historial ya existía (P201/Fase3) — nunca se había montado por HTTP.
server.mount_proc '/usos' do |req, res|
next rechazar_no_autenticado(res) unless operador_autenticado?(req)
res.status = 200
res.content_type = 'application/json'
res.body = Nexxa::Usos.historial(limit: 100).to_json
end
# GET /consumidores — individuos con token registrado (metadata)
# POST /consumidores — genera/rota token para un individuo, body
# {individuo} — el token en claro se entrega
# UNA VEZ en la respuesta (mismo criterio que
# el alta de una key: se muestra al crear,
# nunca más — el Operador lo guarda en
# candados o se lo entrega al individuo)
# DELETE /consumidores/<individuo> — revoca el acceso (destructivo)
# (P201/Fase3-4). Requiere sesión de Operador (lib_auth.rb).
class ConsumidoresServlet < WEBrick::HTTPServlet::AbstractServlet
def individuo_de(req)
req.path.sub(%r{\A/consumidores/?}, '')
end
def do_GET(req, res)
return rechazar_no_autenticado(res) unless operador_autenticado?(req)
res.content_type = 'application/json'
res.status = 200
res.body = Nexxa::Tokens.listar.to_json
end
def do_POST(req, res)
return rechazar_no_autenticado(res) unless operador_autenticado?(req)
return rechazar_no_admin(res) unless admin_autenticado?(req)
res.content_type = 'application/json'
begin
body = JSON.parse(req.body)
rescue JSON::ParserError
res.status = 400
res.body = { error: 'JSON inválido' }.to_json
return
end
individuo = body['individuo'].to_s.strip
if individuo.empty?
res.status = 400
res.body = { error: 'Falta "individuo"' }.to_json
return
end
token = Nexxa::Tokens.generar(individuo)
res.status = 201
res.body = { individuo: individuo, token: token }.to_json
end
def do_DELETE(req, res)
return rechazar_no_autenticado(res) unless operador_autenticado?(req)
return rechazar_no_admin(res) unless admin_autenticado?(req)
res.content_type = 'application/json'
individuo = individuo_de(req)
if individuo.empty?
res.status = 400
res.body = { error: 'Uso: DELETE /consumidores/<individuo>' }.to_json
return
end
revocado = Nexxa::Tokens.revocar(individuo)
if revocado
res.status = 200
res.body = { ok: true }.to_json
else
res.status = 404
res.body = { error: 'Individuo no encontrado' }.to_json
end
end
end
server.mount '/consumidores', ConsumidoresServlet
# GET /usuarios — metadata de todos los usuarios del panel
# POST /usuarios — alta, body {usuario, password, perfil}
# PATCH /usuarios/<usuario> — editar perfil/activo/password, body {perfil, activo, password}
# DELETE /usuarios/<usuario> — eliminar (destructivo)
# (P201/Fase4, corrección del Operador) — gateado a perfil 'admin', no alcanza
# con estar logueado. Guardia de negocio: nunca desactivar/degradar/borrar al
# último admin activo — dejaría el panel sin nadie que pueda gestionar usuarios.
class UsuariosServlet < WEBrick::HTTPServlet::AbstractServlet
def usuario_de(req)
req.path.sub(%r{\A/usuarios/?}, '')
end
def do_GET(req, res)
return rechazar_no_autenticado(res) unless operador_autenticado?(req)
return rechazar_no_admin(res) unless admin_autenticado?(req)
res.content_type = 'application/json'
res.status = 200
res.body = Nexxa::Auth.listar.to_json
end
def do_POST(req, res)
return rechazar_no_autenticado(res) unless operador_autenticado?(req)
return rechazar_no_admin(res) unless admin_autenticado?(req)
res.content_type = 'application/json'
begin
body = JSON.parse(req.body)
rescue JSON::ParserError
res.status = 400
res.body = { error: 'JSON inválido' }.to_json
return
end
faltantes = %w[usuario password perfil].reject { |k| body[k].to_s.strip != '' }
if faltantes.any?
res.status = 400
res.body = { error: "Faltan campos: #{faltantes.join(', ')}" }.to_json
return
end
begin
Nexxa::Auth.crear_usuario(usuario: body['usuario'], password: body['password'], perfil: body['perfil'])
res.status = 201
res.body = { ok: true, usuario: body['usuario'], perfil: body['perfil'] }.to_json
rescue RuntimeError => e
res.status = 409
res.body = { error: e.message }.to_json
end
end
def do_PATCH(req, res)
return rechazar_no_autenticado(res) unless operador_autenticado?(req)
return rechazar_no_admin(res) unless admin_autenticado?(req)
res.content_type = 'application/json'
usuario = usuario_de(req)
if usuario.empty?
res.status = 400
res.body = { error: 'Uso: PATCH /usuarios/<usuario>' }.to_json
return
end
begin
body = JSON.parse(req.body)
rescue JSON::ParserError
res.status = 400
res.body = { error: 'JSON inválido' }.to_json
return
end
# Guardia: no degradar/desactivar al último admin activo.
degradando = (body.key?('perfil') && body['perfil'] != 'admin') || body['activo'] == false
if degradando
actual = Nexxa::Auth.listar.find { |u| u['usuario'] == usuario }
if actual && actual['perfil'] == 'admin' && actual['activo'] != false && Nexxa::Auth.admins_activos <= 1
res.status = 409
res.body = { error: 'No se puede desactivar/degradar al último admin activo' }.to_json
return
end
end
begin
entrada = Nexxa::Auth.actualizar(
usuario: usuario,
perfil: body['perfil'],
activo: body.key?('activo') ? body['activo'] : nil,
password_nueva: body['password']
)
res.status = 200
res.body = entrada.to_json
rescue RuntimeError => e
res.status = 404
res.body = { error: e.message }.to_json
end
end
def do_DELETE(req, res)
return rechazar_no_autenticado(res) unless operador_autenticado?(req)
return rechazar_no_admin(res) unless admin_autenticado?(req)
res.content_type = 'application/json'
usuario = usuario_de(req)
if usuario.empty?
res.status = 400
res.body = { error: 'Uso: DELETE /usuarios/<usuario>' }.to_json
return
end
actual = Nexxa::Auth.listar.find { |u| u['usuario'] == usuario }
if actual && actual['perfil'] == 'admin' && actual['activo'] != false && Nexxa::Auth.admins_activos <= 1
res.status = 409
res.body = { error: 'No se puede eliminar al último admin activo' }.to_json
return
end
borrado = Nexxa::Auth.eliminar(usuario)
if borrado
res.status = 200
res.body = { ok: true }.to_json
else
res.status = 404
res.body = { error: 'Usuario no encontrado' }.to_json
end
end
end
server.mount '/usuarios', UsuariosServlet
# GET /disponible/<provider> — entrega el valor real al individuo autenticado
# (Regla 15: sistema-a-sistema, no exposición a un humano — D045 §8/§10).
# Cifrado de punta a punta (P204, ver empaquetar_valor/lib_envelope.rb): si el
# individuo registró clave pública (POST /consumidor/clave-publica), el
# valor va cifrado con SU clave — ni TLS ni NEXXA ven el texto plano en el
# cuerpo de la respuesta, solo el individuo con su privada. Sin clave
# registrada, cae a texto plano protegido solo por TLS (compatibilidad).
# POST /disponible/<provider>/reportar — salud real de keys (P204/Fase3, D045
# §8): el consumidor, no NEXXA, reporta si la key sigue sana, si la libera
# antes de tiempo, o si se agotó de verdad contra el proveedor real.
# P335/Fase 5: <nombre> puede ser un ROL (mente|red) → el pool de ESE individuo, que mezcla proveedores; si no, es un
# provider como siempre. La decisión vive en Nexxa::Pools (disponible/proxima/estado), no acá.
server.mount_proc '/disponible' do |req, res|
individuo = individuo_autenticado(req)
if individuo.nil?
res.status = 401
res.content_type = 'application/json'
res.body = { error: 'Token inválido o ausente (header Authorization: Bearer <token>)' }.to_json
next
end
resto = req.path.sub(%r{\A/disponible/?}, '')
if req.request_method == 'POST' && resto.end_with?('/reportar')
nombre = resto.sub(%r{/reportar\z}, '')
if nombre.empty?
res.status = 400
res.content_type = 'application/json'
res.body = { error: 'Uso: POST /disponible/<provider|mente|red>/reportar' }.to_json
next
end
body = begin
JSON.parse(req.body.to_s)
rescue JSON::ParserError
{}
end
identificador = body['identificador']
estado = body['estado']
liberar_en_segundos = body['liberar_en_segundos']
# En un rol el pool mezcla proveedores: la key se identifica con provider + identificador (la que se recibió).
provider = Nexxa::Pools.rol?(nombre) ? body['provider'].to_s : nombre
unless identificador && !provider.empty? && %w[sana liberada agotada].include?(estado)
res.status = 400
res.content_type = 'application/json'
res.body = { error: 'Body esperado: {identificador, estado: sana|liberada|agotada, liberar_en_segundos?, motivo?} ' \
'(+ provider si se reporta por rol mente|red)' }.to_json
next
end
begin
Nexxa::Registro.reportar(
provider: provider, identificador: identificador, individuo: individuo,
estado: estado, liberar_en_segundos: liberar_en_segundos, motivo: body['motivo']
)
rescue StandardError => e
res.status = 409
res.content_type = 'application/json'
res.body = { error: e.message }.to_json
next
end
resp = { provider: provider, identificador: identificador, estado: estado }
if estado == 'agotada'
siguiente = Nexxa::Pools.disponible(individuo, nombre) # del mismo pool (rol) o del mismo provider
if siguiente
sp = siguiente['provider']
valor_siguiente = Nexxa::Registro.revelar(provider: sp, identificador: siguiente['identificador'])
if valor_siguiente
Nexxa::Registro.reservar(provider: sp, identificador: siguiente['identificador'], individuo: individuo)
resp[:siguiente] = { provider: sp, identificador: siguiente['identificador'] }.merge(empaquetar_valor(individuo, valor_siguiente))
end
end
end
res.status = 200
res.content_type = 'application/json'
res.body = resp.to_json
next
end
# GET /disponible/<provider>/estado (P334/Fase 4): estado del pool por key, nunca el valor. Mismo gate que el
# resto de /disponible (token de individuo, ME-683): solo metadata para diagnosticar.
if req.request_method == 'GET' && resto.end_with?('/estado')
nombre = resto.sub(%r{/estado\z}, '')
res.status = nombre.empty? ? 400 : 200
res.content_type = 'application/json'
res.body = if nombre.empty?
{ error: 'Uso: GET /disponible/<provider|mente|red>/estado' }.to_json
elsif Nexxa::Pools.rol?(nombre)
{ individuo: individuo, rol: nombre, keys: Nexxa::Pools.estado(individuo, nombre) }.to_json
else
{ provider: nombre, keys: Nexxa::Pools.estado(individuo, nombre) }.to_json
end
next
end
nombre = resto
if nombre.empty?
res.status = 400
res.content_type = 'application/json'
res.body = { error: 'Uso: GET /disponible/<provider|mente|red>' }.to_json
next
end
# Pool vacío: explícito, nunca cae al provider (el admin todavía no le asignó keys a ese individuo en ese rol)
if Nexxa::Pools.pool_vacio?(individuo, nombre)
res.status = 404
res.content_type = 'application/json'
res.body = { error: 'pool_vacio', individuo: individuo, rol: nombre }.to_json
next
end
donde = Nexxa::Pools.rol?(nombre) ? { rol: nombre } : { provider: nombre }
key = Nexxa::Pools.disponible(individuo, nombre)
if key.nil?
proxima = Nexxa::Pools.proxima(individuo, nombre)
res.status = 404
res.content_type = 'application/json'
res.body = if proxima
{ error: 'agotado', proxima_disponible: proxima['disponible_desde'] }.merge(donde).to_json
else
{ error: 'sin_keys_registradas' }.merge(donde).to_json
end
next
end
provider = key['provider']
# dry_run (P204, prp08 §"verificar sin consumir"): confirmar disponibilidad sin
# dispensar el valor ni marcar uso — nunca incluye 'valor' en la respuesta,
# pensado para health-check/verificación (evita que probar el mecanismo
# requiera recibir el secreto — ver incidente de sesión, ME-631).
if req.query['dry_run']
res.status = 200
res.content_type = 'application/json'
res.body = { provider: provider, identificador: key['identificador'], disponible: true }.to_json
next
end
valor = Nexxa::Registro.revelar(provider: provider, identificador: key['identificador'])
if valor.nil?
# Key registrada solo como metadata (no migrada todavía, D045 §9→§10) —
# respuesta explícita, nunca silenciosa (mismo criterio que router.rb)
res.status = 409
res.content_type = 'application/json'
res.body = { error: 'sin_valor_migrado', provider: provider, identificador: key['identificador'] }.to_json
next
end
# Reserva corta de contención (P204/Fase3, D045 §8) — ya no asume agotamiento
# completo al dispensar (eso lo decide el consumidor vía POST .../reportar);
# solo evita que 2 consumidores reciban la misma key mientras uno la prueba.
Nexxa::Registro.reservar(provider: provider, identificador: key['identificador'], individuo: individuo)
res.status = 200
res.content_type = 'application/json'
res.body = { provider: provider, identificador: key['identificador'] }.merge(empaquetar_valor(individuo, valor)).to_json
end
# POST /consumidor/clave-publica — cifrado de punta a punta (P204): el
# individuo registra SU PROPIA clave pública RSA (PEM), self-service — solo
# puede tocar la suya (individuo_autenticado la resuelve por su propio
# token, no hay parámetro "para quién" que alguien pueda falsear). La
# privada nunca llega a NEXXA, ni siquiera de paso — el individuo la genera
# y se la guarda él mismo, acá solo entra la mitad pública.
server.mount_proc '/consumidor/clave-publica' do |req, res|
individuo = individuo_autenticado(req)
if individuo.nil?
res.status = 401
res.content_type = 'application/json'
res.body = { error: 'Token inválido o ausente (header Authorization: Bearer <token>)' }.to_json
next
end
if req.request_method != 'POST'
res.status = 405
res.content_type = 'application/json'
res.body = { error: 'Uso: POST /consumidor/clave-publica {clave_publica: "-----BEGIN PUBLIC KEY-----..."}' }.to_json
next
end
body = begin
JSON.parse(req.body.to_s)
rescue JSON::ParserError
{}
end
begin
Nexxa::Tokens.registrar_clave_publica(individuo: individuo, clave_publica_pem: body['clave_publica'].to_s)
rescue StandardError => e
res.status = 400
res.content_type = 'application/json'
res.body = { error: e.message }.to_json
next
end
res.status = 200
res.content_type = 'application/json'
res.body = { ok: true, individuo: individuo }.to_json
end
# POST /alta — alta de una key nueva, JSON {provider, identificador, cuenta_origen,
# reset_segundos, valor}. Requiere perfil admin (operador es solo-lectura).
server.mount_proc '/alta' do |req, res|
if req.request_method != 'POST'
res.status = 405
res.content_type = 'application/json'
res.body = { error: 'Método no permitido — usar POST' }.to_json
next
end
unless operador_autenticado?(req)
rechazar_no_autenticado(res)
next
end
unless admin_autenticado?(req)
rechazar_no_admin(res)
next
end
begin
body = JSON.parse(req.body)
rescue JSON::ParserError
res.status = 400
res.content_type = 'application/json'
res.body = { error: 'JSON inválido' }.to_json
next
end
faltantes = %w[provider identificador cuenta_origen reset_segundos valor].reject { |k| body[k] }
if faltantes.any?
res.status = 400
res.content_type = 'application/json'
res.body = { error: "Faltan campos: #{faltantes.join(', ')}" }.to_json
next
end
Nexxa::Registro.registrar(
provider: body['provider'],
identificador: body['identificador'],
cuenta_origen: body['cuenta_origen'],
reset_segundos: body['reset_segundos'].to_i,
valor: body['valor']
)
res.status = 201
res.content_type = 'application/json'
res.body = { ok: true, provider: body['provider'], identificador: body['identificador'] }.to_json
end
# /checkin — reporte proactivo de estado de individuos F1 (P216). Mismo
# patrón de auth que /disponible: individuo_autenticado(req) — el token YA
# identifica quién reporta, nunca se confía en un id del body/path para
# escribir. Consultar (GET) exige token válido igual (cualquier consumidor
# logueado por Bearer, no solo el propio individuo) — es diagnóstico
# compartido entre el equipo F1, no un dato privado de cada uno.
server.mount_proc '/checkin' do |req, res|
individuo = individuo_autenticado(req)
if individuo.nil?
res.status = 401
res.content_type = 'application/json'
res.body = { error: 'Token inválido o ausente (header Authorization: Bearer <token>)' }.to_json
next
end
resto = req.path.sub(%r{\A/checkin/?}, '')
if req.request_method == 'POST' && resto.empty?
body = begin
JSON.parse(req.body.to_s)
rescue JSON::ParserError
{}
end
estado = body['estado']
if estado.to_s.strip.empty?
res.status = 400
res.content_type = 'application/json'
res.body = { error: "Uso: POST /checkin {estado: '...', detalle: '...' (opcional)}" }.to_json
next
end
registro = Nexxa::Checkins.registrar(individuo, estado: estado, detalle: body['detalle'])
res.status = 201
res.content_type = 'application/json'
res.body = { ok: true, individuo: individuo }.merge(registro).to_json
next
end
if req.request_method == 'GET' && !resto.empty?
registro = Nexxa::Checkins.estado(resto)
if registro.nil?
res.status = 404
res.content_type = 'application/json'
res.body = { error: "Sin check-in registrado para '#{resto}'" }.to_json
next
end
res.content_type = 'application/json'
res.body = { individuo: resto }.merge(registro).to_json
next
end
res.status = 404
res.content_type = 'application/json'
res.body = { error: 'Uso: POST /checkin (reportar propio estado) | GET /checkin/<individuo> (consultar)' }.to_json
end
# /checkins (bulk) — P216/Fase4: todos los check-in en una sola respuesta,
# consumida por el FRONTEND del panel (cookie de sesión del Operador, mismo
# mecanismo que /consumidores — operador_autenticado?, NO individuo_autenticado
# que exige Bearer token de individuo F1). Bug real corregido en el camino: la
# primera versión exigía Bearer, el JS nunca lo manda, devolvía 401 en loop
# con el interceptor global de fetch que recarga la página en cualquier 401.
server.mount_proc '/checkins' do |req, res|
unless operador_autenticado?(req)
res.status = 401
res.content_type = 'application/json'
res.body = { error: 'Sesión inválida o expirada' }.to_json
next
end
res.content_type = 'application/json'
res.body = Nexxa::Checkins.listar.to_json
end
trap('INT') { server.shutdown }
trap('TERM') { server.shutdown }
server.start
+245
View File
@@ -0,0 +1,245 @@
#!/usr/bin/env ruby
# frozen_string_literal: true
# tool_humo_pool.rb — Pool de tests de humo: rotación + salud + mecanismo de
# reserva/reporte (P204/Fase3-4)
# ==============================================================================
# Formaliza las verificaciones ad-hoc hechas durante P204 (pedido del Operador:
# re-correrlas cuando se toque el mecanismo de nuevo, no reinventarlas cada
# vez). Corre LOCAL contra lib_registro.rb — sin pasar por HTTP/server.rb, mismo
# criterio que las pruebas aisladas de Fase 3.
#
# Todo lo destructivo (reserva, rotación, reportar) usa un provider/keys
# DESCARTABLES ('selftest', nunca un provider real) — nunca toca keys reales
# ni su estado. La única sección de solo-lectura ("salud actual") sí lee el
# registro real, pero nunca dispensa ni reserva nada (mismo espíritu que
# dry_run) — reporta el estado tal cual está, no lo cambia.
# ==============================================================================
# Uso: ruby tool_humo_pool.rb (correr como usuario 'nexxa' — dueño de
# registro.json — o con permisos de lectura/
# escritura sobre él)
# ==============================================================================
require_relative 'lib_registro'
require_relative 'lib_tokens'
require_relative 'lib_envelope'
require 'openssl'
require 'base64'
PROVIDER_TEST = 'selftest'
INDIVIDUO_TEST = 'selftest'
$fallas = 0
$total = 0
def test(nombre)
$total += 1
yield
puts " ✅ #{nombre}"
rescue StandardError => e
$fallas += 1
puts " ❌ #{nombre} — #{e.class}: #{e.message}"
end
def assert(cond, msg)
raise msg unless cond
end
def limpiar_provider_test
Nexxa::Registro.leer['keys']
.select { |k| k['provider'] == PROVIDER_TEST }
.each { |k| Nexxa::Registro.eliminar(provider: PROVIDER_TEST, identificador: k['identificador']) }
end
puts "\n🧪 Pool de tests NEXXA — rotación + salud + reserva/reporte (P204)\n\n"
# ------------------------------------------------------------------
puts '→ Salud actual (solo lectura, keys REALES — nunca dispensa)'
ahora = Time.now
providers_reales = Nexxa::Registro.leer['keys'].map { |k| k['provider'] }.uniq
test('lee el registro real sin explotar') do
assert(Nexxa::Registro.leer.is_a?(Hash), 'leer() no devolvió un Hash')
end
providers_reales.each do |provider|
keys = Nexxa::Registro.leer['keys'].select { |k| k['provider'] == provider }
keys.each do |k|
agotada = Time.parse(k['disponible_desde']) > ahora
reservada = !agotada && k['reservado_hasta'] && Time.parse(k['reservado_hasta']) > ahora
estado = if k['activo'] == false then 'desactivada'
elsif agotada then 'agotada'
elsif reservada then 'reservada'
else 'disponible'
end
icono = { 'disponible' => '🟢', 'reservada' => '🔵', 'agotada' => '🔴', 'desactivada' => '⚪' }[estado]
puts " #{icono} #{provider}/#{k['identificador']}: #{estado}"
end
end
# ------------------------------------------------------------------
puts "\n→ Mecanismo de reserva/reporte (provider descartable '#{PROVIDER_TEST}')"
limpiar_provider_test
Nexxa::Registro.registrar(provider: PROVIDER_TEST, identificador: 'k1', cuenta_origen: 'test', reset_segundos: 3)
test('key recén registrada está disponible') do
assert(Nexxa::Registro.disponible(PROVIDER_TEST), 'no debería estar nil')
end
test('reservar bloquea la key para otros consumidores') do
Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA')
assert(Nexxa::Registro.disponible(PROVIDER_TEST).nil?, 'sigue apareciendo disponible con reserva activa')
end
test('reportar rechaza a un individuo que no tiene la reserva') do
begin
Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testB', estado: 'sana')
raise 'no lanzó excepción'
rescue RuntimeError
# esperado
end
end
test("estado 'sana' renueva la reserva (sigue no disponible)") do
Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA', estado: 'sana')
assert(Nexxa::Registro.disponible(PROVIDER_TEST).nil?, 'debería seguir reservada tras "sana"')
end
test("estado 'liberada' libera de inmediato") do
Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA', estado: 'liberada')
assert(Nexxa::Registro.disponible(PROVIDER_TEST), 'debería estar disponible tras "liberada"')
end
test("estado 'agotada' con liberar_en_segundos aplica el valor custom, no reset_segundos") do
Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA')
Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA', estado: 'agotada', liberar_en_segundos: 2)
assert(Nexxa::Registro.disponible(PROVIDER_TEST).nil?, 'debería estar agotada inmediatamente después')
sleep 2.2
assert(Nexxa::Registro.disponible(PROVIDER_TEST), 'debería liberarse tras los 2s custom')
end
test('reserva sin ningún reporte vence sola (pasivo)') do
Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA')
state = Nexxa::Registro.leer
entrada = state['keys'].find { |k| k['identificador'] == 'k1' }
entrada['reservado_hasta'] = (Time.now - 1).iso8601(3)
Nexxa::Registro.guardar(state)
assert(Nexxa::Registro.disponible(PROVIDER_TEST), 'debería estar libre con reserva vencida')
end
# ------------------------------------------------------------------
puts "\n→ Rotación del pool (menos usada recientemente, no siempre la primera)"
limpiar_provider_test
%w[k1 k2 k3].each { |id| Nexxa::Registro.registrar(provider: PROVIDER_TEST, identificador: id, cuenta_origen: 'test', reset_segundos: 100) }
# ultimo_uso explícito y bien separado (determinismo — 3 registrar() seguidos
# pueden empatar en el mismo milisegundo según qué tan rápido corra la CPU/
# disco, sin relación con el mecanismo real que se está probando)
state = Nexxa::Registro.leer
base = Time.now - 30
%w[k1 k2 k3].each_with_index do |id, i|
entrada = state['keys'].find { |k| k['provider'] == PROVIDER_TEST && k['identificador'] == id }
entrada['ultimo_uso'] = (base + i).iso8601(3)
end
Nexxa::Registro.guardar(state)
test('6 pedidos seguidos rotan k1→k2→k3→k1→k2→k3, sin repetir de corrido') do
orden = []
6.times do
k = Nexxa::Registro.disponible(PROVIDER_TEST)
orden << k['identificador']
Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: k['identificador'], individuo: 'rot')
Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: k['identificador'], individuo: 'rot', estado: 'liberada')
# separación real entre picks — evita empates de milisegundo entre
# reservar() consecutivos en un loop apretado (nunca pasa en uso real:
# nadie dispensa+reporta 2 keys en el mismo milisegundo)
sleep 0.01
end
esperado = %w[k1 k2 k3 k1 k2 k3]
assert(orden == esperado, "orden real: #{orden.join('→')} (esperado: #{esperado.join('→')})")
end
test('una key agotada no entra en la rotación hasta liberarse') do
Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: 'k2', individuo: 'rot')
Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k2', individuo: 'rot', estado: 'agotada', liberar_en_segundos: 999)
3.times do
k = Nexxa::Registro.disponible(PROVIDER_TEST)
assert(k['identificador'] != 'k2', 'k2 no debería salir elegida estando agotada')
Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: k['identificador'], individuo: 'rot')
Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: k['identificador'], individuo: 'rot', estado: 'liberada')
end
end
limpiar_provider_test
# ------------------------------------------------------------------
puts "\n→ Cifrado de punta a punta (P204, envelope RSA-OAEP)"
def limpiar_individuo_test
state = Nexxa::Tokens.leer
state['tokens'].reject! { |t| t['individuo'] == INDIVIDUO_TEST }
Nexxa::Tokens.guardar(state)
end
limpiar_individuo_test
Nexxa::Tokens.generar(INDIVIDUO_TEST)
par_test = OpenSSL::PKey::RSA.generate(2048)
test('registrar_clave_publica guarda y releer coincide exacto') do
Nexxa::Tokens.registrar_clave_publica(individuo: INDIVIDUO_TEST, clave_publica_pem: par_test.public_key.to_pem)
assert(Nexxa::Tokens.clave_publica(INDIVIDUO_TEST) == par_test.public_key.to_pem, 'la clave releída no coincide con la guardada')
end
test('rechaza una clave pública inválida (no PEM)') do
begin
Nexxa::Tokens.registrar_clave_publica(individuo: INDIVIDUO_TEST, clave_publica_pem: 'no es una clave')
raise 'no lanzó excepción'
rescue RuntimeError
# esperado
end
end
test('rechaza registrar clave para un individuo sin token') do
begin
Nexxa::Tokens.registrar_clave_publica(individuo: 'no-existe-de-verdad', clave_publica_pem: par_test.public_key.to_pem)
raise 'no lanzó excepción'
rescue RuntimeError
# esperado
end
end
test('Envelope.cifrar_para produce algo distinto del valor real') do
valor = 'valor-de-prueba-no-es-un-secreto-real'
cifrado = Nexxa::Envelope.cifrar_para(par_test.public_key.to_pem, valor)
assert(cifrado != valor, 'el cifrado es igual al valor real — no cifró nada')
end
test('round-trip: cifrar con la pública + descifrar con la privada = valor original') do
valor = 'valor-de-prueba-no-es-un-secreto-real'
cifrado = Nexxa::Envelope.cifrar_para(par_test.public_key.to_pem, valor)
descifrado = par_test.private_decrypt(Base64.strict_decode64(cifrado), OpenSSL::PKey::RSA::PKCS1_OAEP_PADDING)
assert(descifrado == valor, "descifrado (#{descifrado.inspect}) no coincide con el original")
end
test('la clave pública sola NO alcanza para descifrar (asimetría real)') do
valor = 'valor-de-prueba-no-es-un-secreto-real'
cifrado = Nexxa::Envelope.cifrar_para(par_test.public_key.to_pem, valor)
begin
par_test.public_decrypt(Base64.strict_decode64(cifrado))
raise 'se pudo descifrar solo con la pública — esto NO debería pasar'
rescue OpenSSL::PKey::RSAError
# esperado — confirma que es asimétrico de verdad
end
end
test('sin clave pública registrada, empaquetar_valor cae a texto plano (compatibilidad)') do
assert(Nexxa::Tokens.clave_publica('individuo-sin-clave-nunca-registrada').nil?, 'debería ser nil para un individuo sin clave')
end
limpiar_individuo_test
# ------------------------------------------------------------------
puts "\n#{$fallas.zero? ? '✅' : '❌'} #{$total - $fallas}/#{$total} tests OK\n\n"
exit($fallas.zero? ? 0 : 1)