Tests ADN / test (push) Canceled after 0s
PATCH /keys acepta 'identificador': renombra en el registro y en todos los pools, deja el evento 'renombrada (antes X)' en usos y lo rechaza si la key está reservada o el nombre existe (409). Campo Identificador en el panel de edición. Los chips de pools de APIs se refrescan tras cambiar un pool. Suite: humo HTTP 63, pools 45, revertir 10. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Co-Authored-By: GEMMA <noreply@gemma.dtic>
965 lines
37 KiB
Ruby
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
|
|
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'
|
|
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
|
|
# 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'
|
|
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
|