232 lines
8.2 KiB
Ruby
Executable File
232 lines
8.2 KiB
Ruby
Executable File
#!/usr/bin/env ruby
|
||
# script: alta_nodo.rb
|
||
# Uso: ruby automatizacion/alta_nodo.rb <IP> <HOSTNAME> [USUARIO]
|
||
# Descripción: Automatiza la configuración SSH y la documentación del ADN para un nuevo nodo.
|
||
|
||
require 'fileutils'
|
||
require 'date'
|
||
require 'json'
|
||
require 'time'
|
||
|
||
# --- Configuración ---
|
||
ADN_DIR = File.expand_path('../adn', __dir__)
|
||
NODOS_DIR = File.join(ADN_DIR, 'nodos')
|
||
ONTOLOGIA_FILE = File.join(ADN_DIR, '01_ontologia.md')
|
||
SSH_CONFIG_FILE = File.expand_path('~/.ssh/config')
|
||
SSH_PUB_KEY = File.expand_path('~/.ssh/id_rsa.pub')
|
||
|
||
# --- Argumentos ---
|
||
ip = ARGV[0]
|
||
user = ARGV[1] || 'rmonla'
|
||
|
||
unless ip
|
||
puts "❌ Error: Falta la IP."
|
||
puts "Uso correcto: ruby automatizacion/alta_nodo.rb <IP> [USUARIO]"
|
||
puts "Ejemplo: ruby automatizacion/alta_nodo.rb 10.0.10.205 rmonla"
|
||
exit 1
|
||
end
|
||
|
||
puts "--- 🚀 Iniciando Alta de Nodo: #{ip} con Usuario: #{user} ---"
|
||
|
||
# --- 🚨 PROTOCOLO DE SEGURIDAD (CANDADO JIT) ---
|
||
TOKEN_FILE = File.expand_path('../.agent_token', __dir__)
|
||
|
||
def verificar_autorizacion!
|
||
unless File.exist?(TOKEN_FILE)
|
||
puts "\n⛔ ACCESO DENEGADO: No se encontró token de autorización."
|
||
puts "🔒 Protocolo de seguridad activo. El Agente requiere permiso explícito."
|
||
puts "👉 Ejecuta: ruby automatizacion/candado.rb"
|
||
exit 1
|
||
end
|
||
|
||
begin
|
||
token = JSON.parse(File.read(TOKEN_FILE))
|
||
expires_at = Time.parse(token['expires_at'])
|
||
|
||
if Time.now > expires_at
|
||
puts "\n⛔ ACCESO DENEGADO: El token de autorización ha EXPIRADO."
|
||
puts "💀 Expiró a las: #{expires_at.strftime('%H:%M:%S')}"
|
||
puts "👉 Ejecuta nuevamente: ruby automatizacion/candado.rb"
|
||
exit 1
|
||
end
|
||
|
||
puts "🔓 Autorización Verificada (Válida hasta #{expires_at.strftime('%H:%M:%S')})"
|
||
rescue => e
|
||
puts "\n❌ Error al verificar token: #{e.message}"
|
||
exit 1
|
||
end
|
||
end
|
||
|
||
verificar_autorizacion!
|
||
# -----------------------------------------------
|
||
|
||
# Variable para trackear si tenemos acceso sin password/interactivo
|
||
ssh_access_ok = false
|
||
|
||
# Detectamos si necesitamos flags legacy
|
||
# Intentamos primero con flags modernos, si falla, probamos con legacy
|
||
ssh_flags = "-o ConnectTimeout=5 -o StrictHostKeyChecking=no"
|
||
ssh_legacy_flags = "#{ssh_flags} -o PubkeyAcceptedAlgorithms=+ssh-rsa -o HostKeyAlgorithms=+ssh-rsa"
|
||
|
||
# --- 0. Detección de Hostname y Verificación de Acceso ---
|
||
puts "\n🔍 0. Detectando Hostname y Verificando Acceso..."
|
||
begin
|
||
# Probamos conexión con BatchMode para ver si ya entramos sin password
|
||
check_cmd = "ssh -o BatchMode=yes #{ssh_legacy_flags} #{user}@#{ip} hostname 2>/dev/null"
|
||
hostname = `#{check_cmd}`.strip
|
||
|
||
if $?.success? && !hostname.empty?
|
||
puts "✅ Acceso SSH verificado (Sin contraseña)."
|
||
puts "✅ Hostname detectado: #{hostname}"
|
||
ssh_access_ok = true
|
||
else
|
||
puts "⚠️ Acceso directo no disponible. Intentando conexión interactiva (pedirá password)..."
|
||
# Usamos flags legacy aquí también por si acaso
|
||
hostname = `ssh #{ssh_legacy_flags} #{user}@#{ip} hostname`.strip
|
||
|
||
if $?.success? && !hostname.empty?
|
||
puts "✅ Hostname detectado: #{hostname}"
|
||
else
|
||
puts "❌ No se pudo obtener el hostname. Verifica la IP y credenciales."
|
||
exit 1
|
||
end
|
||
end
|
||
rescue => e
|
||
puts "❌ Error al intentar conectar: #{e.message}"
|
||
exit 1
|
||
end
|
||
|
||
# --- 1. Configuración SSH Local ---
|
||
puts "\n🔧 1. Configurando SSH Local..."
|
||
|
||
if File.read(SSH_CONFIG_FILE).include?("Host #{hostname}")
|
||
puts "ℹ️ Host '#{hostname}' ya existe en #{SSH_CONFIG_FILE}."
|
||
else
|
||
puts "📝 Agregando '#{hostname}' a #{SSH_CONFIG_FILE}..."
|
||
File.open(SSH_CONFIG_FILE, 'a') do |f|
|
||
f.puts "\nHost #{hostname}"
|
||
f.puts " HostName #{ip}"
|
||
f.puts " User #{user}"
|
||
f.puts " StrictHostKeyChecking no"
|
||
f.puts " PubkeyAcceptedAlgorithms +ssh-rsa"
|
||
f.puts " HostKeyAlgorithms +ssh-rsa"
|
||
end
|
||
puts "✅ Configuración SSH actualizada (con soporte legacy)."
|
||
end
|
||
|
||
# --- 2. Copia de Claves SSH ---
|
||
if ssh_access_ok
|
||
puts "\n🔑 2. Copia de Claves SSH: OMITIDO (Ya tienes acceso)."
|
||
else
|
||
puts "\n🔑 2. Instalando Clave SSH en #{user}@#{ip}..."
|
||
if File.exist?(SSH_PUB_KEY)
|
||
# ssh-copy-id pedirá password una única vez aquí
|
||
# Pasamos opciones legacy explícitamente
|
||
system("ssh-copy-id #{ssh_legacy_flags} -i #{SSH_PUB_KEY} #{user}@#{ip}")
|
||
|
||
if $?.success?
|
||
puts "✅ Clave instalada exitosamente."
|
||
ssh_access_ok = true
|
||
else
|
||
puts "⚠️ Falló ssh-copy-id. Quizás debas hacerlo manualmente o verificar password."
|
||
end
|
||
else
|
||
puts "❌ No se encontró clave pública en #{SSH_PUB_KEY}."
|
||
end
|
||
end
|
||
|
||
require 'json'
|
||
|
||
# --- 3. Relevamiento de Hardware (Extracción Cruda & Procesamiento Local) ---
|
||
puts "\n🔍 3. Extrayendo Datos Crudos del Nodo (Procesamiento Local)..."
|
||
|
||
# Script remoto minimalista: Solo "cat" de archivos clave y lsblk
|
||
# Usamos delimitadores únicos para separar bloques
|
||
# Agregamos recolección de evidencia para detección de roles
|
||
remote_script = <<~SHELL
|
||
echo "---START_HOSTNAME---"; cat /etc/hostname
|
||
echo "---START_CPUINFO---"; cat /proc/cpuinfo
|
||
echo "---START_MEMINFO---"; cat /proc/meminfo
|
||
echo "---START_OSRELEASE---"; cat /etc/os-release
|
||
echo "---START_LSBLK---"; lsblk -d -o NAME,SIZE,MODEL,TYPE -J 2>/dev/null || lsblk -d -o NAME,SIZE,MODEL,TYPE
|
||
echo "---START_PROCESSES---"; ps -ef --sort=-%mem | head -n 20
|
||
echo "---START_PORTS---"; ss -tuln 2>/dev/null || netstat -tuln 2>/dev/null
|
||
echo "---START_MARKERS---"
|
||
[ -d "/etc/xen" ] && echo "xen_config_dir_exists"
|
||
[ -d "/etc/pve" ] && echo "pve_config_dir_exists"
|
||
[ -d "/var/lib/docker" ] && echo "docker_lib_dir_exists"
|
||
[ -f "/usr/bin/dockerd" ] && echo "dockerd_bin_exists"
|
||
[ -f "/opt/xensource/bin/xe" ] && echo "citrix_xe_bin_exists"
|
||
SHELL
|
||
|
||
safe_script = remote_script.gsub('"', '\\"')
|
||
# Usamos flags legacy para la sonda también
|
||
raw_output = `ssh #{ssh_legacy_flags} #{hostname} "#{safe_script}"`
|
||
|
||
# Parsers Locales (Host-Side Logic)
|
||
def parse_block(output, key)
|
||
return "" unless output.include?("---START_#{key}---")
|
||
output.split("---START_#{key}---")[1].split("---START_")[0].strip
|
||
rescue
|
||
""
|
||
end
|
||
|
||
hostname_raw = parse_block(raw_output, 'HOSTNAME')
|
||
cpuinfo_raw = parse_block(raw_output, 'CPUINFO')
|
||
meminfo_raw = parse_block(raw_output, 'MEMINFO')
|
||
osrelease_raw = parse_block(raw_output, 'OSRELEASE')
|
||
lsblk_raw = parse_block(raw_output, 'LSBLK')
|
||
processes_raw = parse_block(raw_output, 'PROCESSES')
|
||
ports_raw = parse_block(raw_output, 'PORTS')
|
||
markers_raw = parse_block(raw_output, 'MARKERS')
|
||
|
||
# Analizador de CPU (Local)
|
||
cpu_model = cpuinfo_raw.scan(/model name\s+:\s+(.*)/).flatten.first || "Unknown"
|
||
cpu_cores = cpuinfo_raw.scan(/^processor\s+:/).count
|
||
cpu_arch = "x86_64" # Default (podría sacarse de flags en cpuinfo 'lm' = long mode)
|
||
|
||
# Analizador de RAM (Local)
|
||
mem_total_kb = meminfo_raw.scan(/MemTotal:\s+(\d+)\s+kB/).flatten.first.to_i
|
||
mem_total_human = "#{(mem_total_kb / 1024.0 / 1024.0).round(2)} GiB"
|
||
|
||
# Analizador de OS (Local)
|
||
os_distro = osrelease_raw.scan(/PRETTY_NAME="(.*)"/).flatten.first || "Unknown Linux"
|
||
os_kernel_ver = "Linux (Kernel ver. unknown)" # Kernel version requiring 'uname -r', keeping simple for now or parsing from /proc/version if needed later
|
||
|
||
params = {}
|
||
params[:timestamp] = Time.now.to_s
|
||
params[:connector] = { ip: ip, user: user, hostname_detected: hostname_raw.empty? ? hostname : hostname_raw }
|
||
|
||
params[:cpu] = { model: cpu_model, cores: cpu_cores, arch: cpu_arch }
|
||
params[:ram] = { total: mem_total_human, raw: mem_total_kb * 1024 }
|
||
params[:os] = { distro: os_distro, kernel: os_kernel_ver } # Simplified
|
||
|
||
# Procesamiento de Discos (Local)
|
||
if lsblk_raw.strip.start_with?("{")
|
||
begin
|
||
params[:disks] = JSON.parse(lsblk_raw)
|
||
rescue
|
||
params[:disks] = { format: 'raw', content: lsblk_raw }
|
||
end
|
||
else
|
||
params[:disks] = { format: 'text', content: lsblk_raw }
|
||
end
|
||
|
||
# Evidencia para Inteligencia de Agente
|
||
params[:evidence] = {
|
||
processes: processes_raw.lines.map(&:strip),
|
||
ports: ports_raw.lines.map(&:strip),
|
||
file_markers: markers_raw.lines.map(&:strip)
|
||
}
|
||
|
||
puts " ✅ Datos crudos extraídos y procesados localmente."
|
||
|
||
# --- 4. Salida para el Agente (STDOUT) ---
|
||
puts "\n💾 4. Telemetría Final (Para consumo del Agente)..."
|
||
puts "---START_PAYLOAD---"
|
||
puts JSON.pretty_generate(params)
|
||
puts "---END_PAYLOAD---"
|
||
|
||
puts "\n✅ Proceso finalizado. Copia el bloque JSON anterior si necesitas procesarlo manualmente, o deja que el Agente lo lea."
|
||
|