Files
dtic-DIIAA/servicios/nexxa/organismo/lib_auth.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

203 lines
7.3 KiB
Ruby

# frozen_string_literal: true
# lib_auth.rb — Usuarios y sesiones del panel web de NEXXA (P201/Fase4)
# ==============================================================================
# Reemplaza el diseño original (nginx Basic Auth + credencial en candados de
# GEMMA) por corrección explícita del Operador: NEXXA resuelve su propia auth,
# sin dependencia de GEMMA — mismo espíritu de independencia que ya tienen
# lib_tokens.rb (individuos F1) y lib_cripto.rb (master key propia).
#
# Multi-usuario con perfil (corrección 2026-08-03 — el diseño original de un
# solo Operador binario no alcanzaba, el Operador pidió CRUD de usuarios real,
# gateado por perfil): dos perfiles, sin inventar granularidad no pedida —
# - 'admin' → todo, incluida la gestión de usuarios (crear/editar/borrar)
# - 'operador' → todo lo demás (keys, consumidores), sin gestión de usuarios
#
# No reinventa primitivas de seguridad (pedido explícito del Operador): usa
# exactamente el mismo algoritmo ya probado en producción en
# gemma/tools/candados/core/lib_cripto.rb (Armonía Integral) — PBKDF2-HMAC-SHA256,
# 100k iteraciones, salt random — en vez de SHA256 plano (adecuado para el
# token aleatorio de lib_tokens.rb, pero no para una password humana).
#
# Sesión: token aleatorio de alta entropía (mismo patrón que Tokens.generar),
# guardado server-side con expiración, entregado como cookie. HttpOnly/Secure/
# SameSite se arman a mano en el header Set-Cookie (server.rb) porque el
# WEBrick::Cookie de esta versión de Ruby no expone esos atributos — ver
# comentario en server.rb.
# ==============================================================================
require 'json'
require 'securerandom'
require 'openssl'
require 'base64'
require 'time'
module Nexxa
module Auth
USERS_FILE = File.expand_path('.usuarios.json', __dir__).freeze
SESSIONS_FILE = File.expand_path('.sessions.json', __dir__).freeze
PBKDF2_ITER = 100_000
SESSION_TTL = 8 * 3600 # 8 horas — re-login diario razonable
PERFILES_VALIDOS = %w[admin operador].freeze
# ---------- Usuarios ----------
def self.leer_usuarios
return [] unless File.exist?(USERS_FILE)
JSON.parse(File.read(USERS_FILE))
rescue JSON::ParserError
[]
end
def self.guardar_usuarios(lista)
File.write(USERS_FILE, JSON.pretty_generate(lista) + "\n")
File.chmod(0o600, USERS_FILE)
end
def self.derivar(password, salt)
OpenSSL::PKCS5.pbkdf2_hmac(password, salt, PBKDF2_ITER, 32, 'SHA256')
end
# Crea un usuario nuevo — devuelve la password EN CLARO solo si el
# caller la generó (bootstrap por cli_admin.rb), o la recibe ya elegida
# (alta vía panel por un admin). Nunca se persiste ni se loguea en claro.
# raise si el usuario ya existe o el perfil no es válido.
def self.crear_usuario(usuario:, password:, perfil:)
usuario = usuario.to_s.strip
raise 'Usuario vacío' if usuario.empty?
raise "Perfil inválido: #{perfil} (válidos: #{PERFILES_VALIDOS.join(', ')})" unless PERFILES_VALIDOS.include?(perfil)
lista = leer_usuarios
raise "Usuario '#{usuario}' ya existe" if lista.any? { |u| u['usuario'] == usuario }
salt = SecureRandom.random_bytes(16)
hash = derivar(password, salt)
lista << {
'usuario' => usuario,
'perfil' => perfil,
'salt' => Base64.strict_encode64(salt),
'hash' => Base64.strict_encode64(hash),
'activo' => true,
'creado' => Time.now.iso8601
}
guardar_usuarios(lista)
usuario
end
# Verifica usuario+password — devuelve el registro (sin salt/hash) si es
# válido y está activo, nil si no. Comparación de tiempo constante.
def self.autenticar(usuario:, password:)
entrada = leer_usuarios.find { |u| u['usuario'] == usuario.to_s.strip && u['activo'] != false }
return nil unless entrada
salt = Base64.strict_decode64(entrada['salt'])
hash_guardado = Base64.strict_decode64(entrada['hash'])
hash_calculado = derivar(password.to_s, salt)
return nil unless hash_guardado.bytesize == hash_calculado.bytesize &&
OpenSSL.fixed_length_secure_compare(hash_guardado, hash_calculado)
entrada.reject { |k, _| %w[salt hash].include?(k) }
end
# Todos los usuarios, solo metadata — NUNCA salt/hash (Regla 15).
def self.listar
leer_usuarios.map { |u| u.reject { |k, _| %w[salt hash].include?(k) } }
end
def self.existe?(usuario)
leer_usuarios.any? { |u| u['usuario'] == usuario.to_s.strip }
end
# Edita perfil/activo de un usuario existente. password_nueva opcional
# (rotación). raise si no existe o el perfil no es válido.
def self.actualizar(usuario:, perfil: nil, activo: nil, password_nueva: nil)
lista = leer_usuarios
entrada = lista.find { |u| u['usuario'] == usuario.to_s.strip }
raise "Usuario '#{usuario}' no encontrado" unless entrada
if perfil
raise "Perfil inválido: #{perfil} (válidos: #{PERFILES_VALIDOS.join(', ')})" unless PERFILES_VALIDOS.include?(perfil)
entrada['perfil'] = perfil
end
entrada['activo'] = activo unless activo.nil?
if password_nueva && !password_nueva.to_s.strip.empty?
salt = SecureRandom.random_bytes(16)
entrada['salt'] = Base64.strict_encode64(salt)
entrada['hash'] = Base64.strict_encode64(derivar(password_nueva, salt))
end
guardar_usuarios(lista)
entrada.reject { |k, _| %w[salt hash].include?(k) }
end
# Elimina un usuario — destructivo. El caller (server.rb) es responsable
# de impedir que el último admin se borre a sí mismo (guardia de negocio,
# no de esta capa de datos).
def self.eliminar(usuario)
lista = leer_usuarios
existia = lista.reject! { |u| u['usuario'] == usuario.to_s.strip }
guardar_usuarios(lista) if existia
!existia.nil?
end
def self.admins_activos
leer_usuarios.count { |u| u['perfil'] == 'admin' && u['activo'] != false }
end
# ---------- Sesiones ----------
def self.leer_sesiones
return {} unless File.exist?(SESSIONS_FILE)
JSON.parse(File.read(SESSIONS_FILE))
rescue JSON::ParserError
{}
end
def self.guardar_sesiones(sesiones)
File.write(SESSIONS_FILE, JSON.pretty_generate(sesiones) + "\n")
File.chmod(0o600, SESSIONS_FILE)
end
def self.crear_sesion(usuario, perfil)
token = SecureRandom.hex(32)
sesiones = leer_sesiones
sesiones[token] = {
'usuario' => usuario,
'perfil' => perfil,
'expira' => (Time.now + SESSION_TTL).iso8601
}
guardar_sesiones(sesiones)
token
end
# Devuelve {usuario, perfil} de la sesión si es válida, nil si no.
def self.sesion(token)
return nil if token.to_s.strip.empty?
sesiones = leer_sesiones
entrada = sesiones[token]
return nil unless entrada
if Time.parse(entrada['expira']) < Time.now
sesiones.delete(token)
guardar_sesiones(sesiones)
return nil
end
{ 'usuario' => entrada['usuario'], 'perfil' => entrada['perfil'] }
end
def self.sesion_valida?(token)
!sesion(token).nil?
end
def self.cerrar_sesion(token)
sesiones = leer_sesiones
existia = sesiones.delete(token)
guardar_sesiones(sesiones) if existia
!existia.nil?
end
end
end