#!/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/ → 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/

//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= 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// — editar cuenta_origen/reset_segundos/activo # DELETE /keys// — 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///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///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//' }.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//' }.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// body {provider, identificador} # PUT /pools// body {refs: ["prov/id", ...]} (reemplaza; [] = vaciar) # POST /pools/////mover (al otro rol) # DELETE /pools//// 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// {provider, identificador} | POST /pools/////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// {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////' }) 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/ — 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/' }.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/ — editar perfil/activo/password, body {perfil, activo, password} # DELETE /usuarios/ — 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/' }.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/' }.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/ — 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//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: 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 )' }.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//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//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//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/' }.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 )' }.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 )' }.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/ (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