Files
dtic-DIIAA/servicios/nexxa/organismo/tool_humo_pool.rb
T
a60758875d
Tests ADN / test (push) Canceled after 0s
feat(nexxa): NEXXA versionada en dtic-DIIAA (1.3.0): pools por individuo mente/red, API por rol y gestión desde nexxa-web
- 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>
2026-10-04 16:42:13 -03:00

246 lines
10 KiB
Ruby

#!/usr/bin/env ruby
# frozen_string_literal: true
# tool_humo_pool.rb — Pool de tests de humo: rotación + salud + mecanismo de
# reserva/reporte (P204/Fase3-4)
# ==============================================================================
# Formaliza las verificaciones ad-hoc hechas durante P204 (pedido del Operador:
# re-correrlas cuando se toque el mecanismo de nuevo, no reinventarlas cada
# vez). Corre LOCAL contra lib_registro.rb — sin pasar por HTTP/server.rb, mismo
# criterio que las pruebas aisladas de Fase 3.
#
# Todo lo destructivo (reserva, rotación, reportar) usa un provider/keys
# DESCARTABLES ('selftest', nunca un provider real) — nunca toca keys reales
# ni su estado. La única sección de solo-lectura ("salud actual") sí lee el
# registro real, pero nunca dispensa ni reserva nada (mismo espíritu que
# dry_run) — reporta el estado tal cual está, no lo cambia.
# ==============================================================================
# Uso: ruby tool_humo_pool.rb (correr como usuario 'nexxa' — dueño de
# registro.json — o con permisos de lectura/
# escritura sobre él)
# ==============================================================================
require_relative 'lib_registro'
require_relative 'lib_tokens'
require_relative 'lib_envelope'
require 'openssl'
require 'base64'
PROVIDER_TEST = 'selftest'
INDIVIDUO_TEST = 'selftest'
$fallas = 0
$total = 0
def test(nombre)
$total += 1
yield
puts " ✅ #{nombre}"
rescue StandardError => e
$fallas += 1
puts " ❌ #{nombre} — #{e.class}: #{e.message}"
end
def assert(cond, msg)
raise msg unless cond
end
def limpiar_provider_test
Nexxa::Registro.leer['keys']
.select { |k| k['provider'] == PROVIDER_TEST }
.each { |k| Nexxa::Registro.eliminar(provider: PROVIDER_TEST, identificador: k['identificador']) }
end
puts "\n🧪 Pool de tests NEXXA — rotación + salud + reserva/reporte (P204)\n\n"
# ------------------------------------------------------------------
puts '→ Salud actual (solo lectura, keys REALES — nunca dispensa)'
ahora = Time.now
providers_reales = Nexxa::Registro.leer['keys'].map { |k| k['provider'] }.uniq
test('lee el registro real sin explotar') do
assert(Nexxa::Registro.leer.is_a?(Hash), 'leer() no devolvió un Hash')
end
providers_reales.each do |provider|
keys = Nexxa::Registro.leer['keys'].select { |k| k['provider'] == provider }
keys.each do |k|
agotada = Time.parse(k['disponible_desde']) > ahora
reservada = !agotada && k['reservado_hasta'] && Time.parse(k['reservado_hasta']) > ahora
estado = if k['activo'] == false then 'desactivada'
elsif agotada then 'agotada'
elsif reservada then 'reservada'
else 'disponible'
end
icono = { 'disponible' => '🟢', 'reservada' => '🔵', 'agotada' => '🔴', 'desactivada' => '⚪' }[estado]
puts " #{icono} #{provider}/#{k['identificador']}: #{estado}"
end
end
# ------------------------------------------------------------------
puts "\n→ Mecanismo de reserva/reporte (provider descartable '#{PROVIDER_TEST}')"
limpiar_provider_test
Nexxa::Registro.registrar(provider: PROVIDER_TEST, identificador: 'k1', cuenta_origen: 'test', reset_segundos: 3)
test('key recén registrada está disponible') do
assert(Nexxa::Registro.disponible(PROVIDER_TEST), 'no debería estar nil')
end
test('reservar bloquea la key para otros consumidores') do
Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA')
assert(Nexxa::Registro.disponible(PROVIDER_TEST).nil?, 'sigue apareciendo disponible con reserva activa')
end
test('reportar rechaza a un individuo que no tiene la reserva') do
begin
Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testB', estado: 'sana')
raise 'no lanzó excepción'
rescue RuntimeError
# esperado
end
end
test("estado 'sana' renueva la reserva (sigue no disponible)") do
Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA', estado: 'sana')
assert(Nexxa::Registro.disponible(PROVIDER_TEST).nil?, 'debería seguir reservada tras "sana"')
end
test("estado 'liberada' libera de inmediato") do
Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA', estado: 'liberada')
assert(Nexxa::Registro.disponible(PROVIDER_TEST), 'debería estar disponible tras "liberada"')
end
test("estado 'agotada' con liberar_en_segundos aplica el valor custom, no reset_segundos") do
Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA')
Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA', estado: 'agotada', liberar_en_segundos: 2)
assert(Nexxa::Registro.disponible(PROVIDER_TEST).nil?, 'debería estar agotada inmediatamente después')
sleep 2.2
assert(Nexxa::Registro.disponible(PROVIDER_TEST), 'debería liberarse tras los 2s custom')
end
test('reserva sin ningún reporte vence sola (pasivo)') do
Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: 'k1', individuo: 'testA')
state = Nexxa::Registro.leer
entrada = state['keys'].find { |k| k['identificador'] == 'k1' }
entrada['reservado_hasta'] = (Time.now - 1).iso8601(3)
Nexxa::Registro.guardar(state)
assert(Nexxa::Registro.disponible(PROVIDER_TEST), 'debería estar libre con reserva vencida')
end
# ------------------------------------------------------------------
puts "\n→ Rotación del pool (menos usada recientemente, no siempre la primera)"
limpiar_provider_test
%w[k1 k2 k3].each { |id| Nexxa::Registro.registrar(provider: PROVIDER_TEST, identificador: id, cuenta_origen: 'test', reset_segundos: 100) }
# ultimo_uso explícito y bien separado (determinismo — 3 registrar() seguidos
# pueden empatar en el mismo milisegundo según qué tan rápido corra la CPU/
# disco, sin relación con el mecanismo real que se está probando)
state = Nexxa::Registro.leer
base = Time.now - 30
%w[k1 k2 k3].each_with_index do |id, i|
entrada = state['keys'].find { |k| k['provider'] == PROVIDER_TEST && k['identificador'] == id }
entrada['ultimo_uso'] = (base + i).iso8601(3)
end
Nexxa::Registro.guardar(state)
test('6 pedidos seguidos rotan k1→k2→k3→k1→k2→k3, sin repetir de corrido') do
orden = []
6.times do
k = Nexxa::Registro.disponible(PROVIDER_TEST)
orden << k['identificador']
Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: k['identificador'], individuo: 'rot')
Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: k['identificador'], individuo: 'rot', estado: 'liberada')
# separación real entre picks — evita empates de milisegundo entre
# reservar() consecutivos en un loop apretado (nunca pasa en uso real:
# nadie dispensa+reporta 2 keys en el mismo milisegundo)
sleep 0.01
end
esperado = %w[k1 k2 k3 k1 k2 k3]
assert(orden == esperado, "orden real: #{orden.join('→')} (esperado: #{esperado.join('→')})")
end
test('una key agotada no entra en la rotación hasta liberarse') do
Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: 'k2', individuo: 'rot')
Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: 'k2', individuo: 'rot', estado: 'agotada', liberar_en_segundos: 999)
3.times do
k = Nexxa::Registro.disponible(PROVIDER_TEST)
assert(k['identificador'] != 'k2', 'k2 no debería salir elegida estando agotada')
Nexxa::Registro.reservar(provider: PROVIDER_TEST, identificador: k['identificador'], individuo: 'rot')
Nexxa::Registro.reportar(provider: PROVIDER_TEST, identificador: k['identificador'], individuo: 'rot', estado: 'liberada')
end
end
limpiar_provider_test
# ------------------------------------------------------------------
puts "\n→ Cifrado de punta a punta (P204, envelope RSA-OAEP)"
def limpiar_individuo_test
state = Nexxa::Tokens.leer
state['tokens'].reject! { |t| t['individuo'] == INDIVIDUO_TEST }
Nexxa::Tokens.guardar(state)
end
limpiar_individuo_test
Nexxa::Tokens.generar(INDIVIDUO_TEST)
par_test = OpenSSL::PKey::RSA.generate(2048)
test('registrar_clave_publica guarda y releer coincide exacto') do
Nexxa::Tokens.registrar_clave_publica(individuo: INDIVIDUO_TEST, clave_publica_pem: par_test.public_key.to_pem)
assert(Nexxa::Tokens.clave_publica(INDIVIDUO_TEST) == par_test.public_key.to_pem, 'la clave releída no coincide con la guardada')
end
test('rechaza una clave pública inválida (no PEM)') do
begin
Nexxa::Tokens.registrar_clave_publica(individuo: INDIVIDUO_TEST, clave_publica_pem: 'no es una clave')
raise 'no lanzó excepción'
rescue RuntimeError
# esperado
end
end
test('rechaza registrar clave para un individuo sin token') do
begin
Nexxa::Tokens.registrar_clave_publica(individuo: 'no-existe-de-verdad', clave_publica_pem: par_test.public_key.to_pem)
raise 'no lanzó excepción'
rescue RuntimeError
# esperado
end
end
test('Envelope.cifrar_para produce algo distinto del valor real') do
valor = 'valor-de-prueba-no-es-un-secreto-real'
cifrado = Nexxa::Envelope.cifrar_para(par_test.public_key.to_pem, valor)
assert(cifrado != valor, 'el cifrado es igual al valor real — no cifró nada')
end
test('round-trip: cifrar con la pública + descifrar con la privada = valor original') do
valor = 'valor-de-prueba-no-es-un-secreto-real'
cifrado = Nexxa::Envelope.cifrar_para(par_test.public_key.to_pem, valor)
descifrado = par_test.private_decrypt(Base64.strict_decode64(cifrado), OpenSSL::PKey::RSA::PKCS1_OAEP_PADDING)
assert(descifrado == valor, "descifrado (#{descifrado.inspect}) no coincide con el original")
end
test('la clave pública sola NO alcanza para descifrar (asimetría real)') do
valor = 'valor-de-prueba-no-es-un-secreto-real'
cifrado = Nexxa::Envelope.cifrar_para(par_test.public_key.to_pem, valor)
begin
par_test.public_decrypt(Base64.strict_decode64(cifrado))
raise 'se pudo descifrar solo con la pública — esto NO debería pasar'
rescue OpenSSL::PKey::RSAError
# esperado — confirma que es asimétrico de verdad
end
end
test('sin clave pública registrada, empaquetar_valor cae a texto plano (compatibilidad)') do
assert(Nexxa::Tokens.clave_publica('individuo-sin-clave-nunca-registrada').nil?, 'debería ser nil para un individuo sin clave')
end
limpiar_individuo_test
# ------------------------------------------------------------------
puts "\n#{$fallas.zero? ? '✅' : '❌'} #{$total - $fallas}/#{$total} tests OK\n\n"
exit($fallas.zero? ? 0 : 1)