initial commit

Signed-off-by: ale <ale@manalejandro.com>
Este commit está contenido en:
ale
2025-09-20 19:00:44 +02:00
commit c8e3ccb07f
Se han modificado 14 ficheros con 1173 adiciones y 0 borrados

68
.env.example Archivo normal
Ver fichero

@@ -0,0 +1,68 @@
# Archivo de variables de entorno para CSF Web Admin Panel
# Copie este archivo a .env y modifique los valores según sea necesario
# ====== SEGURIDAD ======
# Clave secreta para JWT (CAMBIAR EN PRODUCCIÓN)
JWT_SECRET=csf-web-super-secret-key-change-this-in-production
# Credenciales de administrador por defecto
ADMIN_USERNAME=admin
ADMIN_PASSWORD=admin123
# ====== CONFIGURACIÓN WEB ======
# Puerto para la interfaz web
WEB_PORT=3000
# Dominio/hostname para la aplicación
WEB_HOSTNAME=localhost
# Modo de entorno
NODE_ENV=production
# ====== CONFIGURACIÓN CSF ======
# Rutas de configuración CSF
CSF_CONFIG_PATH=/etc/csf
CSF_LOG_PATH=/var/log/lfd
CSF_BIN_PATH=/usr/local/csf/bin
# Configuración de red CSF
CSF_TCP_IN=22,80,443,3000
CSF_TCP_OUT=22,25,53,80,113,443,587,993,995
CSF_UDP_IN=53
CSF_UDP_OUT=53,113,123
# ====== DOCKER ======
# Red Docker personalizada
DOCKER_NETWORK=172.20.0.0/24
# Timezone
TZ=America/Mexico_City
# ====== LOGGING ======
# Nivel de logging
LOG_LEVEL=info
# Rotación de logs
LOG_MAX_SIZE=100M
LOG_MAX_FILES=5
# ====== MONITOREO ======
# Interval de actualización de estadísticas (segundos)
STATS_UPDATE_INTERVAL=30
# Interval de actualización de logs (segundos)
LOGS_UPDATE_INTERVAL=10
# ====== ALERTAS ======
# Email para notificaciones (opcional)
ALERT_EMAIL=admin@example.com
# Webhook URL para notificaciones (opcional)
ALERT_WEBHOOK_URL=
# ====== BACKUP ======
# Directorio para backups automáticos
BACKUP_DIR=/backups
# Retención de backups (días)
BACKUP_RETENTION_DAYS=30

48
.gitignore vendido Archivo normal
Ver fichero

@@ -0,0 +1,48 @@
# Ignorar archivos de dependencias
node_modules/
npm-debug.log*
yarn-debug.log*
yarn-error.log*
# Next.js
.next/
out/
build/
# Variables de entorno
.env
.env.local
.env.development.local
.env.test.local
.env.production.local
# Logs
logs/
*.log
# Docker
*.pid
*.seed
*.pid.lock
# Archivos temporales
.tmp/
temp/
# IDE
.vscode/
.idea/
*.swp
*.swo
# Backups
backups/
*.backup
# Sistema
.DS_Store
Thumbs.db
# Archivos de construcción
dist/
.cache/

6
.gitmodules vendido Archivo normal
Ver fichero

@@ -0,0 +1,6 @@
[submodule "csf-web"]
path = csf-web
url = https://git.manalejandro.com/ale/csf-web.git
[submodule "scripts"]
path = scripts
url = https://github.com/waytotheweb/scripts

91
CHANGELOG.md Archivo normal
Ver fichero

@@ -0,0 +1,91 @@
# Changelog
Todos los cambios notables de este proyecto serán documentados en este archivo.
El formato está basado en [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
y este proyecto adhiere a [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
## [1.0.0] - 2025-09-20
### Agregado
- Panel de administración web completo para CSF
- Autenticación segura con JWT
- Dashboard en tiempo real con WebSockets
- Gestión completa de reglas de firewall (allow/deny/temporal)
- Visualización de logs del sistema y firewall
- Estadísticas del servidor en tiempo real
- Dockerfiles para CSF y aplicación web
- Docker Compose para orquestación
- Script de despliegue automatizado
- API REST completa para interactuar con CSF
- Interfaz responsive con Tailwind CSS
- Sistema de notificaciones y alertas
- Monitoreo de conexiones activas
- Backup y restauración de configuraciones
### Características Principales
- **Framework**: Next.js 15 con App Router
- **UI**: React 19 + Tailwind CSS
- **Backend**: API Routes con Node.js
- **Base de Datos**: Archivos de configuración CSF nativos
- **Tiempo Real**: Socket.IO para actualizaciones en vivo
- **Autenticación**: JWT con cookies httpOnly
- **Containerización**: Docker + Docker Compose
- **Monitoreo**: Logs, métricas y estadísticas del sistema
### Seguridad
- Autenticación por defecto (admin/admin123)
- Headers de seguridad configurados
- Validación de entrada en todas las APIs
- Acceso restringido a comandos del sistema
- Logs de auditoría completos
### Docker
- Contenedor CSF optimizado para producción
- Contenedor web con Next.js standalone
- Networking seguro entre contenedores
- Volúmenes persistentes para configuraciones
- Healthchecks para ambos servicios
### APIs Implementadas
- `/api/auth` - Autenticación de usuarios
- `/api/csf` - Control del firewall CSF
- `/api/rules` - Gestión de reglas
- `/api/logs` - Acceso a logs del sistema
- `/api/stats` - Estadísticas del servidor
- `/api/config` - Configuración de CSF
- `/api/socket` - WebSocket para tiempo real
### Componentes UI
- Dashboard principal con navegación por pestañas
- Tarjeta de estado del firewall con controles
- Tabla de reglas con búsqueda y filtros
- Visor de logs con expansión de detalles
- Gráficos de estadísticas del sistema
- Formularios de login y gestión de reglas
- Indicadores de conexión en tiempo real
### Notas de Seguridad
⚠️ **IMPORTANTE**:
- Cambiar credenciales por defecto antes de usar en producción
- Configurar HTTPS para acceso externo
- Revisar configuraciones de firewall antes del despliegue
- Hacer backup de configuraciones existentes
### Instalación
```bash
# Clonar proyecto
git clone [repository-url]
cd csf-web-admin
# Configurar entorno
cp .env.example .env
# Desplegar
./deploy.sh
```
### Acceso
- URL: http://localhost:3000
- Usuario: admin
- Contraseña: admin123

99
Dockerfile.csf Archivo normal
Ver fichero

@@ -0,0 +1,99 @@
# Dockerfile para CSF (ConfigServer Security & Firewall)
FROM ubuntu:22.04
# Evitar prompts interactivos durante la instalación
ENV DEBIAN_FRONTEND=noninteractive
# Instalar dependencias del sistema
RUN apt-get update && apt-get install -y \
perl \
wget \
curl \
unzip \
iptables \
ip6tables \
ipset \
fail2ban \
logrotate \
rsyslog \
cron \
nano \
net-tools \
procps \
iproute2 \
dnsutils \
&& rm -rf /var/lib/apt/lists/*
# Crear directorios necesarios
RUN mkdir -p /usr/local/csf \
&& mkdir -p /etc/csf \
&& mkdir -p /var/lib/csf \
&& mkdir -p /var/log/lfd
# Copiar archivos CSF desde el directorio local
COPY scripts/csf/ /tmp/csf/
# Instalar CSF
RUN cd /tmp/csf && \
cp -r * /usr/local/csf/ && \
chmod +x /usr/local/csf/bin/csf && \
chmod +x /usr/local/csf/bin/lfd && \
ln -sf /usr/local/csf/bin/csf /usr/local/bin/csf && \
ln -sf /usr/local/csf/bin/lfd /usr/local/bin/lfd
# Copiar archivos de configuración
RUN cp /usr/local/csf/csf.conf /etc/csf/ && \
cp /usr/local/csf/csf.allow /etc/csf/ && \
cp /usr/local/csf/csf.deny /etc/csf/ && \
cp /usr/local/csf/csf.ignore /etc/csf/ && \
cp /usr/local/csf/csf.pignore /etc/csf/ && \
cp /usr/local/csf/csf.fignore /etc/csf/ && \
cp /usr/local/csf/csf.blocklists /etc/csf/ && \
cp /usr/local/csf/csf.logfiles /etc/csf/
# Configurar CSF para producción en contenedor
RUN sed -i 's/TESTING = "1"/TESTING = "0"/' /etc/csf/csf.conf && \
sed -i 's/RESTRICT_SYSLOG = "0"/RESTRICT_SYSLOG = "3"/' /etc/csf/csf.conf && \
sed -i 's/AUTO_UPDATES = "1"/AUTO_UPDATES = "0"/' /etc/csf/csf.conf && \
sed -i 's/LF_DAEMON = "1"/LF_DAEMON = "0"/' /etc/csf/csf.conf
# Configurar puertos básicos
RUN echo 'TCP_IN = "22,80,443,3000"' >> /etc/csf/csf.conf && \
echo 'TCP_OUT = "22,25,53,80,113,443,587,993,995"' >> /etc/csf/csf.conf && \
echo 'UDP_IN = "53"' >> /etc/csf/csf.conf && \
echo 'UDP_OUT = "53,113,123"' >> /etc/csf/csf.conf
# Permitir acceso desde la red de Docker
RUN echo '172.16.0.0/12 # Docker network' >> /etc/csf/csf.allow && \
echo '192.168.0.0/16 # Private network' >> /etc/csf/csf.allow && \
echo '10.0.0.0/8 # Private network' >> /etc/csf/csf.allow
# Configurar rsyslog para contenedor
RUN sed -i 's/#module(load="imudp")/module(load="imudp")/' /etc/rsyslog.conf && \
sed -i 's/#input(type="imudp" port="514")/input(type="imudp" port="514")/' /etc/rsyslog.conf
# Crear script de inicio
COPY docker/csf-start.sh /usr/local/bin/csf-start.sh
RUN chmod +x /usr/local/bin/csf-start.sh
# Script de entrypoint
COPY docker/entrypoint.sh /entrypoint.sh
RUN chmod +x /entrypoint.sh
# Exponer puertos
EXPOSE 22 80 443 3000
# Variables de entorno
ENV CSF_CONFIG_PATH=/etc/csf
ENV CSF_LOG_PATH=/var/log/lfd
# Volúmenes para persistencia
VOLUME ["/etc/csf", "/var/log/lfd", "/var/lib/csf"]
# Healthcheck
HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
CMD /usr/local/csf/bin/csf --status > /dev/null 2>&1 || exit 1
# Punto de entrada
ENTRYPOINT ["/entrypoint.sh"]
CMD ["csf"]

55
Dockerfile.web Archivo normal
Ver fichero

@@ -0,0 +1,55 @@
# Dockerfile para CSF Web Interface (Next.js)
FROM node:18-alpine AS base
# Instalar dependencias necesarias
RUN apk add --no-cache libc6-compat
# Establecer directorio de trabajo
WORKDIR /app
# Instalar dependencias
FROM base AS deps
COPY csf-web/package.json csf-web/package-lock.json* ./
RUN npm ci --legacy-peer-deps
# Construir la aplicación
FROM base AS builder
WORKDIR /app
COPY --from=deps /app/node_modules ./node_modules
COPY csf-web/ .
# Generar build de producción
RUN npm run build
# Imagen de producción
FROM base AS runner
WORKDIR /app
ENV NODE_ENV=production
# Crear usuario no-root
RUN addgroup --system --gid 1001 nodejs
RUN adduser --system --uid 1001 nextjs
# Copiar archivos necesarios
COPY --from=builder /app/public ./public
COPY --from=builder --chown=nextjs:nodejs /app/.next/standalone ./
COPY --from=builder --chown=nextjs:nodejs /app/.next/static ./.next/static
# Variables de entorno
ENV PORT=3000
ENV HOSTNAME="0.0.0.0"
ENV JWT_SECRET="csf-web-jwt-secret-change-in-production"
# Exponer puerto
EXPOSE 3000
# Cambiar a usuario no-root
USER nextjs
# Healthcheck
HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
CMD curl -f http://localhost:3000/api/health || exit 1
# Comando de inicio
CMD ["node", "server.js"]

43
LICENSE Archivo normal
Ver fichero

@@ -0,0 +1,43 @@
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We use the GNU General Public License for
most of our software; it applies also to any other work released this way
by its authors. You can apply it to your programs, too.
[Full GPL v3 license text would continue here...]
---
CSF Web Admin Panel
Copyright (C) 2025
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <https://www.gnu.org/licenses/>.
ConfigServer Security & Firewall (CSF) is copyright © ConfigServer Services
and is licensed under their own terms. This project provides a web interface
for CSF and does not modify or redistribute CSF itself.

295
README.md Archivo normal
Ver fichero

@@ -0,0 +1,295 @@
# CSF Web Admin Panel
Panel de administración web moderno para **ConfigServer Security & Firewall (CSF)** construido con Next.js 15 y Docker.
![CSF Web Admin Panel](https://img.shields.io/badge/CSF-Web%20Admin-blue)
![Docker](https://img.shields.io/badge/Docker-Ready-blue)
![Next.js](https://img.shields.io/badge/Next.js-15-black)
![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue)
## 🚀 Características
- **Panel de Control Moderno**: Interfaz web responsive y moderna
- **Gestión Completa de CSF**: Control total del firewall desde el navegador
- **Monitoreo en Tiempo Real**: WebSockets para estadísticas y logs en vivo
- **Autenticación Segura**: Sistema de login con JWT
- **Gestión de Reglas**: Agregar, eliminar y gestionar reglas de firewall
- **Visualización de Logs**: Monitoreo de actividad del firewall
- **Estadísticas del Sistema**: CPU, memoria, disco y red
- **Dockerizado**: Despliegue fácil con Docker y Docker Compose
## 📋 Requisitos Previos
- Docker 20.10 o superior
- Docker Compose 2.0 o superior
- 2GB RAM mínimo
- Acceso root/privilegiado para iptables
## 🛠️ Instalación Rápida
1. **Clonar el repositorio**:
```bash
git clone <repository-url>
cd csf-web-admin
```
2. **Configurar variables de entorno**:
```bash
cp .env.example .env
# Editar .env con sus configuraciones
```
3. **Desplegar con un comando**:
```bash
./deploy.sh
```
4. **Acceder al panel**:
- URL: http://localhost:3000
- Usuario: `admin`
- Contraseña: `admin123`
## 🐳 Despliegue Manual con Docker
### Construcción de Imágenes
```bash
# Construir imagen CSF
docker build -f Dockerfile.csf -t csf-firewall .
# Construir imagen Web
docker build -f Dockerfile.web -t csf-web .
```
### Ejecutar con Docker Compose
```bash
# Iniciar servicios
docker-compose up -d
# Ver logs
docker-compose logs -f
# Detener servicios
docker-compose down
```
## 📁 Estructura del Proyecto
```
csf-web-admin/
├── 📁 csf-web/ # Aplicación Next.js
│ ├── 📁 src/
│ │ ├── 📁 app/ # App Router (Next.js 15)
│ │ ├── 📁 components/ # Componentes React
│ │ ├── 📁 hooks/ # Hooks personalizados
│ │ ├── 📁 lib/ # Utilidades
│ │ ├── 📁 store/ # Estado global (Zustand)
│ │ └── 📁 types/ # Tipos TypeScript
│ ├── 📄 package.json
│ └── 📄 next.config.mjs
├── 📁 scripts/ # Scripts CSF originales
│ └── 📁 csf/ # Código fuente CSF
├── 📁 docker/ # Scripts Docker
│ ├── 📄 entrypoint.sh
│ └── 📄 csf-start.sh
├── 📄 Dockerfile.csf # Dockerfile para CSF
├── 📄 Dockerfile.web # Dockerfile para Web
├── 📄 docker-compose.yml # Orquestación
├── 📄 deploy.sh # Script de despliegue
├── 📄 .env.example # Variables de entorno
└── 📄 README.md
```
## 🎛️ Características del Panel
### Dashboard Principal
- Estado del firewall en tiempo real
- Estadísticas del sistema (CPU, RAM, Disco)
- Conexiones activas
- Resumen de reglas
### Gestión de Reglas
- Agregar/eliminar reglas allow/deny
- Búsqueda y filtrado de reglas
- Gestión de bloqueos temporales
- Validación de direcciones IP
### Monitoreo de Logs
- Logs en tiempo real
- Filtrado por tipo y nivel
- Exportación de logs
- Análisis de patrones de ataque
### Configuración
- Modificación de configuraciones CSF
- Gestión de puertos TCP/UDP
- Configuración de alertas
- Backup y restauración
## 🔧 Configuración
### Variables de Entorno Principales
```bash
# Seguridad
JWT_SECRET=tu-clave-secreta-aqui
ADMIN_USERNAME=admin
ADMIN_PASSWORD=contraseña-segura
# Red
WEB_PORT=3000
CSF_TCP_IN=22,80,443,3000
CSF_TCP_OUT=22,25,53,80,113,443,587,993,995
# Paths
CSF_CONFIG_PATH=/etc/csf
CSF_LOG_PATH=/var/log/lfd
```
### Configuración de CSF
El contenedor CSF se configura automáticamente con:
- Modo de prueba deshabilitado
- Acceso permitido desde redes Docker
- Logs habilitados
- Auto-updates deshabilitado
## 📊 API Endpoints
### Autenticación
- `POST /api/auth` - Login
- `GET /api/auth` - Verificar sesión
- `DELETE /api/auth` - Logout
### Control CSF
- `GET /api/csf?action=status` - Estado del firewall
- `POST /api/csf` - Ejecutar comandos (start, stop, restart)
### Reglas
- `GET /api/rules?type=all` - Obtener reglas
- `POST /api/rules` - Agregar regla
- `DELETE /api/rules` - Eliminar regla
### Logs y Estadísticas
- `GET /api/logs?type=firewall` - Logs del firewall
- `GET /api/stats` - Estadísticas del sistema
### WebSocket
- `/api/socket` - Datos en tiempo real
## 🔒 Seguridad
### Autenticación
- JWT con cookies httpOnly
- Protección CSRF
- Validación de permisos
### Red
- Comunicación interna entre contenedores
- Headers de seguridad configurados
- Acceso restringido a APIs
### Firewall
- Configuración segura por defecto
- Backup automático de configuraciones
- Logs de auditoría completos
## 🚨 Resolución de Problemas
### Contenedor CSF no inicia
```bash
# Verificar privilegios
docker-compose logs csf
# Verificar capacidades
docker run --rm --privileged csf-firewall csf --check
```
### Web interface no conecta
```bash
# Verificar logs
docker-compose logs csf-web
# Verificar conectividad
curl http://localhost:3000/api/health
```
### Problemas de iptables
```bash
# Verificar módulos del kernel
lsmod | grep ip_tables
# Verificar capacidades del contenedor
docker inspect csf-firewall | grep -i cap
```
## 📈 Monitoreo y Logs
### Logs del Sistema
```bash
# Logs de CSF
docker-compose exec csf tail -f /var/log/lfd/lfd.log
# Logs de la web
docker-compose logs -f csf-web
# Logs combinados
docker-compose logs -f
```
### Métricas
- CPU y memoria en tiempo real
- Conexiones de red activas
- Estadísticas de reglas de firewall
- Actividad de bloqueos
## 🔄 Backup y Restauración
### Crear Backup
```bash
./deploy.sh backup
```
### Restaurar Configuración
```bash
# Restaurar volúmenes desde backup
docker run --rm -v csf_config:/target -v $(pwd)/backups/latest:/source alpine cp -a /source/. /target/
```
## 🛡️ Mejores Prácticas
1. **Cambiar credenciales por defecto**
2. **Usar HTTPS en producción**
3. **Configurar backup automático**
4. **Monitorear logs regularmente**
5. **Actualizar contenedores periódicamente**
6. **Restringir acceso de red**
## 🤝 Contribuir
1. Fork el proyecto
2. Crear rama feature (`git checkout -b feature/AmazingFeature`)
3. Commit cambios (`git commit -m 'Add AmazingFeature'`)
4. Push a la rama (`git push origin feature/AmazingFeature`)
5. Abrir Pull Request
## 📝 Licencia
Este proyecto está bajo la Licencia GPL v3. Ver `LICENSE` para más detalles.
## 🙏 Reconocimientos
- [ConfigServer Services](https://configserver.com/) por CSF
- [Next.js](https://nextjs.org/) por el framework web
- [Docker](https://docker.com/) por la containerización
## 📞 Soporte
- 🐛 [Reportar Bug](../../issues)
- 💡 [Solicitar Feature](../../issues)
- 📧 Email: support@example.com
---
**⚠️ IMPORTANTE**: Este es un sistema de seguridad crítico. Siempre pruebe en un entorno de desarrollo antes de desplegar en producción.

1
csf-web Submódulo

Submodule csf-web added at b1ff5c9cde

225
deploy.sh Archivo ejecutable
Ver fichero

@@ -0,0 +1,225 @@
#!/bin/bash
# Script de despliegue para CSF Web Admin Panel
set -e
# Colores para output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# Función para logs
log() {
echo -e "${GREEN}[$(date +'%Y-%m-%d %H:%M:%S')] $1${NC}"
}
warn() {
echo -e "${YELLOW}[$(date +'%Y-%m-%d %H:%M:%S')] WARNING: $1${NC}"
}
error() {
echo -e "${RED}[$(date +'%Y-%m-%d %H:%M:%S')] ERROR: $1${NC}"
}
info() {
echo -e "${BLUE}[$(date +'%Y-%m-%d %H:%M:%S')] INFO: $1${NC}"
}
# Banner
echo "=================================================="
echo " CSF Web Admin Panel - Deployment Script"
echo " ConfigServer Security & Firewall Management"
echo "=================================================="
echo
# Verificar requisitos previos
log "Verificando requisitos previos..."
# Verificar Docker
if ! command -v docker &> /dev/null; then
error "Docker no está instalado. Por favor instale Docker primero."
exit 1
fi
# Verificar Docker Compose
if ! command -v docker-compose &> /dev/null && ! docker compose version &> /dev/null; then
error "Docker Compose no está instalado. Por favor instale Docker Compose primero."
exit 1
fi
# Verificar que estamos en el directorio correcto
if [ ! -f "docker-compose.yml" ]; then
error "docker-compose.yml no encontrado. Ejecute este script desde el directorio raíz del proyecto."
exit 1
fi
# Verificar archivos CSF
if [ ! -d "scripts/csf" ]; then
error "Directorio scripts/csf no encontrado. Asegúrese de que los archivos CSF estén presentes."
exit 1
fi
log "Requisitos previos verificados ✓"
# Configurar variables de entorno
if [ ! -f ".env" ]; then
warn "Archivo .env no encontrado. Creando desde .env.example..."
if [ -f ".env.example" ]; then
cp .env.example .env
warn "Por favor edite el archivo .env con sus configuraciones antes de continuar."
read -p "¿Desea continuar con la configuración por defecto? (y/N): " -n 1 -r
echo
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
info "Edite el archivo .env y ejecute el script nuevamente."
exit 0
fi
else
error "Archivo .env.example no encontrado."
exit 1
fi
fi
# Cargar variables de entorno
source .env
log "Variables de entorno cargadas ✓"
# Función para construir e iniciar servicios
deploy() {
log "Iniciando despliegue de CSF Web Admin Panel..."
# Detener servicios existentes
info "Deteniendo servicios existentes..."
docker-compose down --remove-orphans || true
# Construir imágenes
log "Construyendo imágenes Docker..."
docker-compose build --no-cache
# Iniciar servicios
log "Iniciando servicios..."
docker-compose up -d
# Esperar a que los servicios estén listos
log "Esperando a que los servicios estén listos..."
sleep 30
# Verificar estado de los servicios
info "Verificando estado de los servicios..."
docker-compose ps
# Verificar salud de los servicios
log "Verificando salud de los servicios..."
# Verificar CSF
if docker-compose exec -T csf /usr/local/csf/bin/csf --status > /dev/null 2>&1; then
log "CSF Firewall: SALUDABLE ✓"
else
warn "CSF Firewall: Posibles problemas"
fi
# Verificar Web Interface
if curl -f http://localhost:${WEB_PORT:-3000}/api/health > /dev/null 2>&1; then
log "Web Interface: SALUDABLE ✓"
else
warn "Web Interface: Posibles problemas"
fi
log "Despliegue completado!"
echo
info "Acceda al panel de administración en: http://localhost:${WEB_PORT:-3000}"
info "Usuario por defecto: ${ADMIN_USERNAME:-admin}"
info "Contraseña por defecto: ${ADMIN_PASSWORD:-admin123}"
echo
warn "IMPORTANTE: Cambie las credenciales por defecto antes de usar en producción."
}
# Función para mostrar logs
show_logs() {
echo "Mostrando logs de los servicios..."
docker-compose logs -f
}
# Función para detener servicios
stop() {
log "Deteniendo servicios..."
docker-compose down
log "Servicios detenidos ✓"
}
# Función para limpiar todo
clean() {
warn "Esta operación eliminará todos los contenedores, imágenes y volúmenes relacionados."
read -p "¿Está seguro? (y/N): " -n 1 -r
echo
if [[ $REPLY =~ ^[Yy]$ ]]; then
log "Limpiando sistema..."
docker-compose down -v --remove-orphans
docker system prune -f
docker volume prune -f
log "Limpieza completada ✓"
else
info "Operación cancelada."
fi
}
# Función para backup
backup() {
log "Creando backup de configuraciones..."
BACKUP_DIR="${BACKUP_DIR:-./backups}/$(date +%Y%m%d_%H%M%S)"
mkdir -p "$BACKUP_DIR"
# Backup de volúmenes Docker
docker run --rm -v csf_config:/source -v "$PWD/$BACKUP_DIR":/backup alpine tar czf /backup/csf_config.tar.gz -C /source .
docker run --rm -v csf_logs:/source -v "$PWD/$BACKUP_DIR":/backup alpine tar czf /backup/csf_logs.tar.gz -C /source .
# Backup de archivo .env
cp .env "$BACKUP_DIR/"
log "Backup creado en: $BACKUP_DIR"
}
# Función de ayuda
show_help() {
echo "Uso: $0 [COMANDO]"
echo
echo "Comandos disponibles:"
echo " deploy - Desplegar CSF Web Admin Panel"
echo " logs - Mostrar logs de los servicios"
echo " stop - Detener servicios"
echo " clean - Limpiar contenedores y volúmenes"
echo " backup - Crear backup de configuraciones"
echo " help - Mostrar esta ayuda"
echo
echo "Si no se especifica comando, se ejecutará 'deploy'"
}
# Procesar argumentos
case "${1:-deploy}" in
deploy)
deploy
;;
logs)
show_logs
;;
stop)
stop
;;
clean)
clean
;;
backup)
backup
;;
help|--help|-h)
show_help
;;
*)
error "Comando desconocido: $1"
show_help
exit 1
;;
esac

102
docker-compose.yml Archivo normal
Ver fichero

@@ -0,0 +1,102 @@
version: '3.8'
services:
# Contenedor CSF Firewall
csf:
build:
context: .
dockerfile: Dockerfile.csf
container_name: csf-firewall
privileged: true
network_mode: host
restart: unless-stopped
volumes:
# Configuración persistente
- csf_config:/etc/csf
- csf_logs:/var/log/lfd
- csf_lib:/var/lib/csf
# Acceso a logs del sistema host (opcional)
- /var/log:/var/log/host:ro
environment:
- CSF_CONFIG_PATH=/etc/csf
- CSF_LOG_PATH=/var/log/lfd
- DEBIAN_FRONTEND=noninteractive
cap_add:
- NET_ADMIN
- NET_RAW
- SYS_MODULE
- SYS_ADMIN
devices:
- /dev/net/tun
healthcheck:
test: ["CMD", "/usr/local/csf/bin/csf", "--status"]
interval: 30s
timeout: 10s
retries: 3
start_period: 30s
# Contenedor Web Interface
csf-web:
build:
context: .
dockerfile: Dockerfile.web
container_name: csf-web-interface
restart: unless-stopped
ports:
- "3000:3000"
volumes:
# Acceso a archivos de configuración CSF
- csf_config:/etc/csf:ro
- csf_logs:/var/log/lfd:ro
environment:
- NODE_ENV=production
- PORT=3000
- HOSTNAME=0.0.0.0
- JWT_SECRET=${JWT_SECRET:-csf-web-secret-change-this}
- CSF_CONFIG_PATH=/etc/csf
- CSF_LOG_PATH=/var/log/lfd
depends_on:
csf:
condition: service_healthy
networks:
- csf-network
healthcheck:
test: ["CMD", "curl", "-f", "http://localhost:3000/api/health"]
interval: 30s
timeout: 10s
retries: 3
start_period: 30s
# Servicio de monitoreo de logs (opcional)
log-monitor:
image: busybox
container_name: csf-log-monitor
restart: unless-stopped
volumes:
- csf_logs:/logs:ro
command: tail -f /logs/lfd.log
depends_on:
- csf
networks:
- csf-network
# Redes
networks:
csf-network:
driver: bridge
name: csf-network
ipam:
config:
- subnet: 172.20.0.0/24
# Volúmenes persistentes
volumes:
csf_config:
name: csf_config
driver: local
csf_logs:
name: csf_logs
driver: local
csf_lib:
name: csf_lib
driver: local

56
docker/csf-start.sh Archivo normal
Ver fichero

@@ -0,0 +1,56 @@
#!/bin/bash
# Script de inicio para CSF en contenedor Docker
set -e
echo "Iniciando ConfigServer Security & Firewall (CSF)..."
# Verificar que los archivos de configuración existen
if [ ! -f /etc/csf/csf.conf ]; then
echo "Error: Archivo de configuración CSF no encontrado"
exit 1
fi
# Crear directorios de log si no existen
mkdir -p /var/log/lfd
mkdir -p /var/lib/csf
# Verificar y corregir permisos
chmod 600 /etc/csf/csf.conf
chmod 600 /etc/csf/csf.allow
chmod 600 /etc/csf/csf.deny
chmod 755 /usr/local/csf/bin/csf
chmod 755 /usr/local/csf/bin/lfd
# Inicializar iptables si es necesario
if ! iptables -L > /dev/null 2>&1; then
echo "Inicializando iptables..."
iptables -F
iptables -X
iptables -Z
iptables -t nat -F
iptables -t nat -X
iptables -t mangle -F
iptables -t mangle -X
fi
# Verificar configuración CSF
echo "Verificando configuración CSF..."
if ! /usr/local/csf/bin/csf --check; then
echo "Advertencia: Verificación de CSF falló, continuando de todos modos..."
fi
# Iniciar CSF
echo "Iniciando CSF..."
/usr/local/csf/bin/csf --start
# Verificar estado
if /usr/local/csf/bin/csf --status > /dev/null 2>&1; then
echo "CSF iniciado correctamente"
else
echo "Error: CSF no pudo iniciarse correctamente"
exit 1
fi
echo "CSF está ejecutándose"

83
docker/entrypoint.sh Archivo normal
Ver fichero

@@ -0,0 +1,83 @@
#!/bin/bash
# Entrypoint para el contenedor CSF
set -e
# Función para manejo de señales
cleanup() {
echo "Recibida señal de terminación..."
# Detener CSF de forma controlada
if [ -x /usr/local/csf/bin/csf ]; then
echo "Deteniendo CSF..."
/usr/local/csf/bin/csf --stop || true
fi
# Detener LFD si está ejecutándose
if pidof lfd > /dev/null; then
echo "Deteniendo LFD..."
killall lfd || true
fi
# Detener rsyslog
if pidof rsyslogd > /dev/null; then
echo "Deteniendo rsyslog..."
killall rsyslogd || true
fi
echo "Limpieza completada"
exit 0
}
# Configurar manejo de señales
trap cleanup SIGTERM SIGINT
# Iniciar rsyslog en background
echo "Iniciando rsyslog..."
rsyslogd &
# Esperar un momento para que rsyslog se inicie
sleep 2
# Verificar capacidades necesarias
if [ ! -w /proc/sys/net/ipv4/ip_forward ]; then
echo "Advertencia: No se pueden modificar configuraciones de red del kernel"
echo "Asegúrese de ejecutar el contenedor con --privileged o las capacidades necesarias"
fi
case "$1" in
csf)
echo "Iniciando CSF en modo contenedor..."
# Ejecutar script de inicio de CSF
/usr/local/bin/csf-start.sh
# Mantener el contenedor ejecutándose
echo "CSF iniciado. Manteniendo contenedor activo..."
# Loop infinito para mantener el contenedor vivo
while true; do
# Verificar cada 30 segundos que CSF sigue ejecutándose
if ! /usr/local/csf/bin/csf --status > /dev/null 2>&1; then
echo "CSF no está ejecutándose. Reintentando inicio..."
/usr/local/bin/csf-start.sh || {
echo "Error: No se pudo reiniciar CSF"
cleanup
exit 1
}
fi
sleep 30
done
;;
bash|sh)
echo "Iniciando shell interactivo..."
exec /bin/bash
;;
*)
echo "Ejecutando comando personalizado: $@"
exec "$@"
;;
esac

1
scripts Submódulo

Submodule scripts added at 2923c43f8f