# 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