Logo

Mi Blog con Emacs y Esteroides

Emacs, IA y Linux: Poder y Simplicidad en tu Flujo de Trabajo

mybloggingnotes@gmail.com


22/04/2025

Automatizando Auditorías de Seguridad en Linux con Bash y Emacs

Introducción

En un entorno donde las amenazas cibernéticas evolucionan constantemente, realizar auditorías de seguridad en sistemas Linux es esencial para identificar vulnerabilidades como puertos abiertos, permisos inseguros o configuraciones riesgosas. Realizar estas tareas manualmente es tedioso y propenso a errores. Este post presenta un flujo de trabajo para automatizar auditorías de seguridad usando scripts en Bash, integrando los resultados en Emacs con Org-mode para un análisis interactivo y programando ejecuciones automáticas con `cron`. Combinamos la potencia de la terminal con la flexibilidad de Emacs para ofrecer una solución eficiente para usuarios avanzados de Linux.

Objetivos

  • Crear scripts en Bash para auditar puertos y permisos.
  • Integrar resultados en Org-mode para análisis interactivo en Emacs.
  • Automatizar auditorías con `cron` para ejecuciones periódicas.

Audiencia

Usuarios avanzados de Linux interesados en ciberseguridad, automatización y flujos de trabajo con Emacs.

Herramientas Requeridas

  • nmap: Escaneo de puertos y servicios.
  • find y stat: Verificación de permisos.
  • Bash: Scripts de automatización.
  • Emacs con Org-mode: Visualización y análisis.
  • cron: Programación de tareas.

Configuración Inicial

Instala las herramientas necesarias en un sistema Linux (por ejemplo, Ubuntu/Debian):

sudo apt update
sudo apt install nmap findutils coreutils bash emacs

Verifica que `cron` esté habilitado:

systemctl status cron

Configura Emacs para Org-mode y `emacsclient`. Añade a `~/.emacs` o `~/.config/emacs/init.el`:

(server-start)
(require 'org)
(setq org-startup-folded t)

Script de Auditoría en Bash

El script `securityaudit.sh` realiza:

  1. Escaneo de puertos con `nmap`.
  2. Verificación de permisos con `find`.
  3. Generación de un resumen en Org-mode que se abre en Emacs.

Código del Script

#!/bin/bash
# security_audit.sh
# Configuración
OUTPUT_DIR="$HOME/security_audit"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
REPORT_DIR="$OUTPUT_DIR/report_$TIMESTAMP"
mkdir -p "$REPORT_DIR"
# Escaneo de puertos
scan_ports() {
  local target="localhost"
  local output="$REPORT_DIR/nmap_scan.txt"
  echo "Escaneando puertos en $target..."
  nmap -sV "$target" > "$output" 2>&1
  [ $? -eq 0 ] && echo "Escaneo completado: $output" || echo "Error en nmap."
}
# Verificación de permisos
check_permissions() {
  local output="$REPORT_DIR/permissions_report.txt"
  echo "Verificando permisos inseguros..."
  echo "Archivos con escritura para 'otros':" > "$output"
  find /home -type f -perm -o+w >> "$output" 2>/dev/null
  echo -e "\nArchivos con ejecución para 'otros':" >> "$output"
  find /home -type f -perm -o+x >> "$output" 2>/dev/null
  echo "Verificación completada: $output"
}
# Ejecutar auditorías
scan_ports
check_permissions
# Generar resumen en Org-mode
SUMMARY="$REPORT_DIR/summary.org"
cat << EOF > "$SUMMARY"
#+TITLE: Reporte de Auditoría de Seguridad - $TIMESTAMP
#+DATE: $(date)
- Resumen de Auditoría
  - *Fecha*: $TIMESTAMP
  - *Escaneo de puertos*: [[file:nmap_scan.txt][Resultados de Nmap]]
  - *Permisos inseguros*: [[file:permissions_report.txt][Reporte de Permisos]]
-  Notas
  - Revisar puertos abiertos para servicios innecesarios.
  - Corregir permisos inseguros en archivos listados.
EOF
echo "Reporte generado: $SUMMARY"
emacsclient -c "$SUMMARY" 2>/dev/null || echo "Abre $SUMMARY manualmente."

Ejecución

Guarda el script, hazlo ejecutable y ejecútalo:

chmod +x security_audit.sh
./security_audit.sh

El script genera una carpeta en `~/securityaudit/reportYYYYMMDDHHMMSS` con:

  • `nmapscan.txt`: Resultados del escaneo de puertos.
  • `permissionsreport.txt`: Archivos con permisos inseguros.
  • `summary.org`: Resumen en Org-mode con enlaces.

Integración con Emacs y Org-mode

El archivo `summary.org` organiza los resultados en un formato interactivo. Para mejorar la experiencia, usamos funciones en Emacs (`securityaudit.el`) que procesan los reportes y generan un buffer dinámico.

Código de Emacs

;;; security_audit.el --- Funciones para auditorías de seguridad

(defun security-audit-process-report (report-dir)
  "Procesa un reporte y genera un buffer en Org-mode."
  (interactive "DDirectorio del reporte: ")
  (let ((nmap-file (concat report-dir "nmap_scan.txt"))
        (perm-file (concat report-dir "permissions_report.txt"))
        (buffer (get-buffer-create "*Security Audit Report*")))
    (with-current-buffer buffer
      (erase-buffer)
      (org-mode)
      (insert "#+TITLE: Auditoría de Seguridad\n")
      (insert "#+DATE: " (format-time-string "%Y-%m-%d %H:%M:%S") "\n\n")
      (insert "* Análisis de Puertos Abiertos\n")
      (if (file-exists-p nmap-file)
          (progn
            (insert "[[file:" nmap-file "][Ver resultados completos]]\n\n")
            (insert "Puertos destacados:\n")
            (with-temp-buffer
              (insert-file-contents nmap-file)
              (goto-char (point-min))
              (while (re-search-forward "\\([0-9]+/tcp\\s+open\\)" nil t)
                (insert "- " (match-string 1) "\n"))))
        (insert "No se encontraron resultados de nmap.\n\n"))
      (insert "* Permisos Inseguros\n")
      (if (file-exists-p perm-file)
          (insert "[[file:" perm-file "][Ver reporte de permisos]]\n\n")
        (insert "No se encontraron resultados de permisos.\n\n"))
      (insert "* Acciones Recomendadas\n")
      (insert "- Cerrar puertos innecesarios (ej., `ufw deny`).\n")
      (insert "- Ajustar permisos con `chmod`.\n"))
    (display-buffer buffer)))

(defun security-audit-open-latest ()
  "Abre el reporte más reciente en ~/security_audit."
  (interactive)
  (let ((audit-dir "~/security_audit"))
    (when (file-directory-p audit-dir)
      (let ((latest-dir (car (sort (directory-files audit-dir t "^report_") #'string>))))
        (if latest-dir
            (security-audit-process-report latest-dir)
          (message "No se encontraron reportes en %s" audit-dir))))))

(provide 'security_audit)
;;; security_audit.el ends here

Uso en Emacs

Carga `securityaudit.el` en Emacs y ejecuta:

M-x security-audit-open-latest

Esto genera un buffer `*Security Audit Report*` con un resumen interactivo, incluyendo enlaces a los resultados y recomendaciones.

Automatización con Cron

Programa el script para ejecutarse automáticamente con `cron`.

Configuración

Edita el crontab:

crontab -e

Añade una ejecución diaria a las 2:00 AM:

0 2 * * * /bin/bash /path/to/security_audit.sh >> /path/to/security_audit.log 2>&1

Verifica que `cron` esté activo:

systemctl status cron

Los reportes se generarán en `~/securityaudit` y podrán revisarse con `M-x security-audit-open-latest`.

Flujo de Trabajo (Diagrama)

El siguiente diagrama en PlantUML ilustra el proceso:

audit_workflow.png

Ejemplo Práctico

  1. Ejecuta el script:
./security_audit.sh
  1. Abre el reporte en Emacs:
M-x security-audit-open-latest
  1. Revisa los resultados, sigue los enlaces y aplica correcciones (por ejemplo, `ufw deny` para puertos o `chmod` para permisos).

Mejoras Adicionales

  • Notificaciones: Añade alertas con `notify-send`:
if grep -q "22/tcp open" "$REPORT_DIR/nmap_scan.txt"; then
  notify-send "Auditoría de Seguridad" "Puerto SSH abierto detectado."
fi
  • Exportar a PDF: Genera un PDF desde el reporte:
(with-current-buffer "*Security Audit Report*"
  (org-export-to-file 'pdf "security_report.pdf"))
  • Escaneo remoto: Modifica `scanports` para aceptar una IP:
scan_ports() {
  local target="${1:-localhost}"
  local output="$REPORT_DIR/nmap_scan.txt"
  echo "Escaneando puertos en $target..."
  nmap -sV "$target" > "$output" 2>&1
}
  • Integración con Git: Almacena reportes en un repositorio para historial.

Conclusión

Automatizar auditorías de seguridad con Bash y Emacs simplifica tareas complejas en un flujo eficiente. Los scripts en Bash escanean puertos y permisos, `cron` asegura ejecuciones regulares, y Emacs con Org-mode ofrece un entorno interactivo para análisis. Este enfoque es ideal para administradores de sistemas y entusiastas de Linux que buscan integrar ciberseguridad en su flujo de trabajo. ¡Implementa estas herramientas y fortalece tu seguridad con Emacs con Esteroides!

Referencias

Categoría: ciberseguridad linux emacs automatización org-mode tutoriales

Suscribirse al Feed RSS | Mapa del Sitio

© 2025 M.Castillo | Hecho con ❤️ en Emacs y org-static-blog

📊 Estadísticas Visit counter For Websites