import csv
import json
import os
import re
import smtplib
from collections import Counter
from datetime import datetime
from email.message import EmailMessage
import geoip2.database
# ================= CONFIGURACIÓN =================
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
HISTORIAL_CSV = os.path.join(BASE_DIR, 'ips_sospechosas.csv')
PATRONES_FILE = os.path.join(BASE_DIR, 'patrones_ataque.txt')
CACHE_PAISES_FILE = os.path.join(BASE_DIR, 'cache_paises.json')
LOG_FILE = '/var/log/nginx/access.log'
POSICION_FILE = '/tmp/nginx_log_offset.txt'
GEOIP_DB_PATH = '/var/lib/GeoIP/GeoLite2-Country.mmdb'
# Credenciales de correo
TU_GMAIL = 'tu_correo@gmail.com'
CLAVE_APP = 'xxxx xxxx xxxx xxxx'
DESTINATARIO = 'destinatario@dominio.com'
# Umbrales diferenciados
UMBRAL_FIRMA_ATAQUE = 1 # 1 solo intento a ruta de vulnerabilidad dispara alerta
UMBRAL_ERRORES_GENERICOS = 15 # 15 errores 404/403 genéricos disparan alerta
IPS_IGNORADAS = {'127.0.0.1', '::1'}
# Lista de países permitidos en tu regla de Nginx (Sudamérica)
PAISES_SUDAMERICA = {
'AR', 'BO', 'BR', 'CL', 'CO', 'EC', 'FK',
'GF', 'GY', 'PE', 'PY', 'SR', 'UY', 'VE'
}
EXTENSIONES_ESTATICAS = (
'.css', '.js', '.png', '.jpg', '.jpeg', '.gif', '.ico', '.woff', '.woff2', '.svg', '.map'
)
LOG_REGEX = re.compile(
r'^(?P<ip>\S+) \S+ \S+ \[.*?\] "(?P<metodo>\S+) (?P<ruta>\S+) \S+" (?P<status>\d{3})'
)
# ================= FUNCIONES =================
def cargar_patrones_ataque():
"""Carga los patrones desde patrones_ataque.txt ignorando comentarios y líneas vacías."""
if not os.path.exists(PATRONES_FILE):
print(f"Aviso: No se encontro {PATRONES_FILE}, usando patrones por defecto.")
return ('.env', '.git', 'wp-login', 'phpmyadmin', '../')
with open(PATRONES_FILE, 'r', encoding='utf-8', errors='ignore') as f:
patrones = [
linea.strip().lower()
for linea in f
if linea.strip() and not linea.strip().startswith('#')
]
return tuple(patrones)
def obtener_ultima_posicion():
if os.path.exists(POSICION_FILE):
with open(POSICION_FILE, 'r') as f:
contenido = f.read().strip()
return int(contenido) if contenido.isdigit() else 0
return 0
def guardar_posicion(posicion):
with open(POSICION_FILE, 'w') as f:
f.write(str(posicion))
def cargar_cache_paises():
if os.path.exists(CACHE_PAISES_FILE):
try:
with open(CACHE_PAISES_FILE, 'r', encoding='utf-8') as f:
return json.load(f)
except Exception:
return {}
return {}
def guardar_cache_paises(cache):
try:
with open(CACHE_PAISES_FILE, 'w', encoding='utf-8') as f:
json.dump(cache, f, indent=2)
except Exception:
pass
def resolver_paises_lote(lista_ips):
"""Consulta el código de país directamente desde la base de datos local GeoLite2."""
cache = cargar_cache_paises()
resultados = {}
if not os.path.exists(GEOIP_DB_PATH):
print(f"Error: No se encuentra la base de datos GeoIP en {GEOIP_DB_PATH}")
return {ip: 'DESCONOCIDO' for ip in lista_ips}
with geoip2.database.Reader(GEOIP_DB_PATH) as reader:
for ip in lista_ips:
if ip in cache and cache[ip] != 'DESCONOCIDO':
resultados[ip] = cache[ip]
continue
try:
resp = reader.country(ip)
pais = resp.country.iso_code or 'DESCONOCIDO'
except Exception:
pais = 'DESCONOCIDO'
resultados[ip] = pais
cache[ip] = pais
guardar_cache_paises(cache)
return resultados
def registrar_en_csv(registros):
"""Guarda el historial de IPs sospechosas en un CSV local."""
archivo_nuevo = not os.path.exists(HISTORIAL_CSV)
with open(HISTORIAL_CSV, 'a', newline='', encoding='utf-8') as f:
writer = csv.writer(f)
if archivo_nuevo:
writer.writerow([
'Fecha_Hora', 'IP', 'Pais', 'Region_Permitida',
'Tipo_Deteccion', 'Peticiones_Sospechosas', 'Muestra_Rutas'
])
for item in registros:
writer.writerow([
item['fecha'],
item['ip'],
item['pais'],
item['region'],
item['tipo'],
item['conteo'],
' | '.join(item['ejemplos'])
])
def clasificar_peticion(metodo, ruta, status, patrones_ataque):
"""Devuelve 'FIRMA_ATAQUE', 'ERROR_GENERICO' o None si es tráfico normal."""
ruta_sin_params = ruta.split('?')[0].lower()
ruta_lower = ruta.lower()
if any(patron in ruta_lower for patron in patrones_ataque):
return 'FIRMA_ATAQUE'
if metodo not in ('GET', 'POST', 'HEAD'):
return 'FIRMA_ATAQUE'
if ruta_sin_params.endswith(EXTENSIONES_ESTATICAS):
return None
if status in ('401', '403', '404', '429', '444'):
return 'ERROR_GENERICO'
return None
def enviar_correo(cuerpo):
msg = EmailMessage()
msg.set_content(cuerpo)
msg['Subject'] = 'ALERTA: Escaneo o ataque detectado en Nginx'
msg['From'] = TU_GMAIL
msg['To'] = DESTINATARIO
servidor_smtp = 'smtp.' + 'gmail.com'
with smtplib.SMTP_SSL(servidor_smtp, 465, timeout=10) as smtp:
smtp.login(TU_GMAIL, CLAVE_APP)
smtp.send_message(msg)
print("-> Correo enviado exitosamente.")
def revisar_logs():
if not os.path.exists(LOG_FILE):
print(f"Error: No existe el archivo {LOG_FILE}")
return
patrones_ataque = cargar_patrones_ataque()
ultima_pos = obtener_ultima_posicion()
tamano_actual = os.path.getsize(LOG_FILE)
if tamano_actual < ultima_pos:
print("Log rotado detectado. Reiniciando lectura desde 0.")
ultima_pos = 0
with open(LOG_FILE, 'r', encoding='utf-8', errors='ignore') as f:
f.seek(ultima_pos)
lineas_nuevas = f.readlines()
nueva_pos = f.tell()
guardar_posicion(nueva_pos)
if not lineas_nuevas:
print("Sin lineas nuevas desde la ultima revision (0 lineas leidas).")
return
print(f"Se leyeron {len(lineas_nuevas)} lineas nuevas en esta pasada.")
conteo_firmas = Counter()
conteo_errores = Counter()
detalles_rutas = {}
for linea in lineas_nuevas:
match = LOG_REGEX.match(linea.strip())
if not match:
continue
ip = match.group('ip')
if ip in IPS_IGNORADAS:
continue
metodo = match.group('metodo')
ruta = match.group('ruta')
status = match.group('status')
clasificacion = clasificar_peticion(metodo, ruta, status, patrones_ataque)
if clasificacion == 'FIRMA_ATAQUE':
conteo_firmas[ip] += 1
detalles_rutas.setdefault(ip, set()).add(f"[{status}] {metodo} {ruta[:50]}")
elif clasificacion == 'ERROR_GENERICO':
conteo_errores[ip] += 1
detalles_rutas.setdefault(ip, set()).add(f"[{status}] {metodo} {ruta[:50]}")
ips_alertar = {}
for ip, count in conteo_firmas.items():
if count >= UMBRAL_FIRMA_ATAQUE:
ips_alertar[ip] = ('Escaneo de Vulnerabilidades', count + conteo_errores[ip])
for ip, count in conteo_errores.items():
if ip not in ips_alertar and count >= UMBRAL_ERRORES_GENERICOS:
ips_alertar[ip] = ('Rafaga de Errores HTTP', count)
if not ips_alertar:
print("Trafico normal. Ninguna IP supero los umbrales de alerta.")
return
paises_resueltos = resolver_paises_lote(list(ips_alertar.keys()))
ahora = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
registros_csv = []
mensaje = "Se detecto actividad sospechosa hacia Nginx:\n\n"
for ip, (tipo_alerta, total_count) in ips_alertar.items():
pais = paises_resueltos.get(ip, 'DESCONOCIDO')
en_sudamerica = "Sudamerica (Permitida)" if pais in PAISES_SUDAMERICA else "Fuera de Sudamerica"
ejemplos = list(detalles_rutas.get(ip, []))[:6]
registros_csv.append({
'fecha': ahora,
'ip': ip,
'pais': pais,
'region': en_sudamerica,
'tipo': tipo_alerta,
'conteo': total_count,
'ejemplos': ejemplos
})
mensaje += f"- IP: {ip} | Pais: {pais} ({en_sudamerica}) | Tipo: {tipo_alerta} | Intentos: {total_count}\n"
for ej in ejemplos:
mensaje += f" * {ej}\n"
mensaje += "\n"
registrar_en_csv(registros_csv)
mensaje += f"Registro guardado en: {HISTORIAL_CSV}\n"
print(f"Alerta activada para {len(ips_alertar)} IP(s). Guardado en {HISTORIAL_CSV}.")
enviar_correo(mensaje)
if __name__ == "__main__":
revisar_logs()


