Files
dtic-DIIAA/servicios/nexxa/organismo/lib_auth.rb
T

202 lines
7.4 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'
require_relative 'lib_estado'
module Nexxa
module Auth
USERS_FILE = Estado.ruta('usuarios')
SESSIONS_FILE = Estado.ruta('sesiones')
PBKDF2_ITER = 100_000
SESSION_TTL = 8 * 3600 # 8 horas — re-login diario razonable
PERFILES_VALIDOS = %w[admin operador].freeze
# ---------- Usuarios ----------
# Estado vía Nexxa::Estado (P335/Fase 17)
def self.leer_usuarios
Estado.leer('usuarios', USERS_FILE, [])
end
def self.guardar_usuarios(lista)
Estado.guardar('usuarios', USERS_FILE, lista)
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)
Estado.mutar('usuarios', USERS_FILE, []) do |lista|
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
}
lista
end
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)
entrada = nil
Estado.mutar('usuarios', USERS_FILE, []) do |lista|
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
lista
end
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)
existia = nil
Estado.mutar('usuarios', USERS_FILE, []) do |lista|
existia = lista.reject! { |u| u['usuario'] == usuario.to_s.strip }
lista
end
!existia.nil?
end
def self.admins_activos
leer_usuarios.count { |u| u['perfil'] == 'admin' && u['activo'] != false }
end
# ---------- Sesiones ----------
def self.leer_sesiones
Estado.leer('sesiones', SESSIONS_FILE, {})
end
def self.guardar_sesiones(sesiones)
Estado.guardar('sesiones', SESSIONS_FILE, sesiones)
end
def self.crear_sesion(usuario, perfil)
token = SecureRandom.hex(32)
Estado.mutar('sesiones', SESSIONS_FILE, {}) do |sesiones|
sesiones[token] = {
'usuario' => usuario,
'perfil' => perfil,
'expira' => (Time.now + SESSION_TTL).iso8601
}
sesiones
end
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?
entrada = leer_sesiones[token]
return nil unless entrada
# Vencida: se borra con la escritura atómica de cerrar_sesion (la lectura de cada pedido web no toma bloqueo)
if Time.parse(entrada['expira']) < Time.now
cerrar_sesion(token)
return nil
end
{ 'usuario' => entrada['usuario'], 'perfil' => entrada['perfil'] }
end
def self.sesion_valida?(token)
!sesion(token).nil?
end
def self.cerrar_sesion(token)
existia = nil
Estado.mutar('sesiones', SESSIONS_FILE, {}) do |sesiones|
existia = sesiones.delete(token)
sesiones
end
!existia.nil?
end
end
end