Files
dtic-DIIAA/servicios/nexxa/organismo/server.rb
T

965 lines
37 KiB
Ruby

#!/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
COMMIT_FILE = File.expand_path('COMMIT', __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).
#
# Cache busting (P335, 2026-10-04): los .js/.css los sirve un FileHandler estático y el navegador se quedaba con el
# app.js viejo tras un deploy (el Operador veía el menú Pools nuevo pero la sección vacía). Al servir el HTML se le
# agrega ?v=<VERSION> a cada /js/ y /css/: cada versión nueva obliga a bajar los archivos nuevos. El HTML en sí no se
# cachea (no-cache), así siempre trae la versión vigente.
def html_con_version(ruta)
# encoding explícito: systemd corre con locale C (US-ASCII) y el gsub sobre un HTML con acentos daba 500 (1.4.1)
File.read(ruta, encoding: 'UTF-8').gsub(%r{(["'])(/(?:js|css)/[^"'?]+\.(?:js|css))\1}) { "#{$1}#{$2}?v=#{version_actual}#{$1}" }
end
server.mount_proc '/' do |req, res|
res.status = 200
res.content_type = 'text/html; charset=utf-8'
res['Cache-Control'] = 'no-cache'
res.body = html_con_version(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'
# commit: el que dejó `gemma nexxa desplegar` (organismo/COMMIT, generado al desplegar, nunca en el repo — P335/F15)
commit = File.exist?(COMMIT_FILE) ? File.read(COMMIT_FILE).strip : nil
res.body = { version: version_actual, commit: commit }.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
# Cada key trae en qué pools está (P335/Fase 12): la sección APIs lo muestra y avisa al eliminar
pools = Nexxa::Pools.leer
res.body = Nexxa::Registro.todas.map { |k| k.merge('pools' => Nexxa::Pools.de_key(k['provider'], k['identificador'], pools)) }.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
# Renombrar primero (P335/Fase 13): registro + pools; el resto de los campos se aplica sobre el nombre nuevo
nuevo = body['identificador'].to_s.strip
if !nuevo.empty? && nuevo != identificador
Nexxa::Registro.renombrar(provider: provider, de: identificador, a: nuevo, usuario: sesion_actual(req)&.dig('usuario'))
Nexxa::Pools.renombrar_key(provider: provider, de: identificador, a: nuevo)
identificador = nuevo
end
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 = e.message.start_with?('Key no encontrada') ? 404 : 409
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}
# PUT /pools/<individuo>/<rol> body {refs: ["prov/id", ...]} (reemplaza; [] = vaciar)
# POST /pools/<individuo>/<rol>/<provider>/<identificador>/mover (al otro rol)
# 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)
if partes.size == 5 && partes[4] == 'mover'
a = Nexxa::Pools.mover(individuo: partes[0], de: partes[1], provider: partes[2], identificador: partes[3])
return responder(res, 200, { individuo: partes[0], de: partes[1], a: a })
end
return responder(res, 400, { error: 'Uso: POST /pools/<individuo>/<mente|red> {provider, identificador} | POST /pools/<individuo>/<rol>/<provider>/<id>/mover' }) 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
# Editar el pool entero desde nexxa-web (P335/Fase 12): valida todas las refs antes de escribir
def do_PUT(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: PUT /pools/<individuo>/<mente|red> {refs: ["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
return responder(res, 400, { error: "Falta 'refs' (lista; vacía = vaciar el pool)" }) unless body['refs'].is_a?(Array)
pool = Nexxa::Pools.reemplazar(individuo: partes[0], rol: partes[1], refs: body['refs'])
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
# Cada individuo trae el resumen de sus pools (P335/Fase 12): Individuos y Dashboard lo muestran
res.body = Nexxa::Tokens.listar.map { |c| c.merge('pools' => Nexxa::Pools.resumen(c['individuo'])) }.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)
Nexxa::Pools.olvidar_individuo(individuo) if revocado # sin token no pide: sus pools no quedan colgados
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'
# Del mismo pool (rol) o del mismo provider, elegida y reservada en un solo paso atómico (P335/Fase 17)
siguiente = Nexxa::Pools.dispensar(individuo, nombre)
if siguiente&.dig('valor_cifrado')
valor_siguiente = Nexxa::Registro.descifrar(siguiente['valor_cifrado'])
resp[:siguiente] = { provider: siguiente['provider'], identificador: siguiente['identificador'] }
.merge(empaquetar_valor(individuo, valor_siguiente))
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 }
# Elegir y reservar en UN paso atómico (P335/Fase 17): antes se elegía y se reservaba después, y dos consumidores
# simultáneos podían recibir la misma key. dry_run solo mira, nunca reserva.
key = req.query['dry_run'] ? Nexxa::Pools.disponible(individuo, nombre) : Nexxa::Pools.dispensar(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 = key['valor_cifrado'] && Nexxa::Registro.descifrar(key['valor_cifrado'])
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
# La reserva corta de contención (P204/Fase3, D045 §8) ya la aplicó dispensar: no asume agotamiento (eso lo
# decide el consumidor vía POST .../reportar), solo evita que 2 consumidores reciban la misma key.
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