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
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:
co-authored by
Claude Opus 5.5
GEMMA
parent
50ac0d0fdf
commit
a60758875d
@@ -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
|
||||
Reference in New Issue
Block a user