Tests ADN / test (push) Canceled after 0s
- 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>
203 lines
7.3 KiB
Ruby
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
|