Sunday, November 15, 2026

Codigo para ver via python cuantas conexiones soporta Nginx

import asyncio

import ssl

import time

import aiohttp


URL = "https://192.168.1.133"

USUARIOS_INICIALES = 100

INCREMENTO = 100

MAX_USUARIOS = 3000

TIMEOUT_SEGUNDOS = 20


# Ignorar errores de certificado SSL autofirmado (red local)

ssl_context = ssl.create_default_context()

ssl_context.check_hostname = False

ssl_context.verify_mode = ssl.CERT_NONE



def silenciar_errores_cierre_windows(loop, context):

    # Ignora el aviso cosmético WinError 10054 al cerrar sockets HTTPS en Windows

    excepcion = context.get("exception")

    if isinstance(excepcion, ConnectionResetError):

        return

    loop.default_exception_handler(context)



async def hacer_peticion(session):

    inicio = time.perf_counter()

    try:

        async with session.get(URL, ssl=ssl_context) as respuesta:

            await respuesta.read()

            tiempo = time.perf_counter() - inicio

            return respuesta.status == 200, tiempo, respuesta.status

    except Exception as e:

        tiempo = time.perf_counter() - inicio

        return False, tiempo, type(e).__name__



async def probar_oleada(cantidad_usuarios):

    connector = aiohttp.TCPConnector(limit=0, force_close=True)

    timeout = aiohttp.ClientTimeout(total=TIMEOUT_SEGUNDOS)


    async with aiohttp.ClientSession(

        connector=connector, timeout=timeout

    ) as session:

        tareas = [hacer_peticion(session) for _ in range(cantidad_usuarios)]

        resultados = await asyncio.gather(*tareas)


    exitosas = sum(1 for exito, _, _ in resultados if exito)

    fallidas = cantidad_usuarios - exitosas

    tiempos = [t for exito, t, _ in resultados if exito]

    tiempo_promedio = sum(tiempos) / len(tiempos) if tiempos else 0


    errores = [err for exito, _, err in resultados if not exito]

    primer_error = errores[0] if errores else "Ninguno"


    return exitosas, fallidas, tiempo_promedio, primer_error



async def main():

    loop = asyncio.get_running_loop()

    loop.set_exception_handler(silenciar_errores_cierre_windows)


    print(f"Iniciando prueba de carga contra {URL}...\n")

    max_soportadas = 0


    for usuarios in range(USUARIOS_INICIALES, MAX_USUARIOS + 1, INCREMENTO):

        print(f"Probando {usuarios} conexiones...", end="\r")

        exitosas, fallidas, tiempo_prom, primer_error = await probar_oleada(

            usuarios

        )

        print(

            f"Simultáneas: {usuarios:4d} | Éxitos: {exitosas:4d} | Fallos:"

            f" {fallidas:4d} | Tiempo prom: {tiempo_prom:.3f}s"

        )


        if fallidas == 0:

            max_soportadas = usuarios

        else:

            print(f"\n[!] Se detectaron fallos (Motivo: {primer_error}).")

            print("[!] Deteniendo prueba.")

            break


        await asyncio.sleep(2)


    print("\n" + "=" * 55)

    print(

        f"RESULTADO: Nginx soportó {max_soportadas} conexiones simultáneas sin"

        " errores."

    )

    print("=" * 55)



if __name__ == "__main__":

    asyncio.run(main())





Saturday, November 14, 2026

como filtrar en nginx peticiones solo de chile

 1. Instalar las dependencias y el módulo GeoIP2

Instala el módulo dinámico de GeoIP2 para Nginx y la herramienta para actualizar las bases de datos:
bash
sudo apt update
sudo apt install libnginx-mod-http-geoip2 geoipupdate
2. Obtener la base de datos GeoLite2 Country
MaxMind requiere una cuenta gratuita para descargar sus bases de datos:
  1. Regístrate en el sitio web de MaxMind y genera una License Key (clave de licencia).
  2. Configura tus credenciales en /etc/GeoIP.conf:
    text
    AccountID TU_ACCOUNT_ID
    LicenseKey TU_LICENSE_KEY
    EditionIDs GeoLite2-Country
    

  3. Ejecuta el comando para descargar la base de datos (se guardará en /usr/share/GeoIP/GeoLite2-Country.mmdb):
    bash
    sudo geoipupdate
    
    3. Configurar Nginx (nginx.conf)
Edita el archivo principal /etc/nginx/nginx.conf dentro del bloque http { ... } para cargar la base de datos y definir la regla de bloqueo:

tuve problemas con que no procesaba la red interna, asi que ajuste nuevamente.

http {
    # 1. Cargar la base de datos de países
    geoip2 /var/lib/GeoIP/GeoLite2-Country.mmdb {
        auto_reload 60m;
        $geoip2_metadata_country_build metadata build_epoch;
        $geoip2_data_country_code country iso_code;
    }

    # 2. Definir las IPs de red local permitidas
    geo $lan_ip {
        default no;
        127.0.0.1/32 yes;      # Localhost (la propia Raspberry Pi)
        192.168.0.0/16 yes;    # Todas las redes 192.168.x.x
        10.0.0.0/8 yes;        # Redes 10.x.x.x (si usas VPN o subredes)
        172.16.0.0/12 yes;     # Redes 172.16.x.x - 172.31.x.x (Docker/VLANs)
    }

    # 3. Permitir si es Sudamérica O si viene de la red local
    map "$geoip2_data_country_code:$lan_ip" $allowed_country {
        default no;
        ~^(AR|BO|BR|CL|CO|EC|FK|GF|GY|PE|PY|SR|UY|VE): yes; # Permite cualquier IP de Sudamérica
        ~:yes$ yes;                                         # Permite cualquier IP marcada en $lan_ip
    }


    # ... resto de tu configuración http ...
}
3. Verifica y recarga Nginx
Aplica los cambios comprobando primero que no haya errores de sintaxis:
bash
sudo nginx -t
sudo systemctl reload nginx
4.- Se deb agregar ademas
Abre el archivo de tu sitio web (normalmente está en /etc/nginx/sites-enabled/default o /etc/nginx/conf.d/tu-sitio.conf).
 # AQUÍ SÍ VA EL BLOQUEO: i
f ($allowed_country = no) 
{ 
 return 403; 
 }
y recargar.
sudo nginx -t && sudo systemctl reload nginx

para validar los bloqueos de otros paises se puede utilizar.
https://locabrowser.com/

Friday, November 13, 2026

mejora de seguridad en el nginx de la raspberry para bloquear SCAN tipico

En la captura se observa que la IP 192.168.1.111 está ejecutando un escaneo automatizado usando python-requests/2.32.5 con payloads típicos de OWASP Top 10 (XSS con <script>, Path Traversal con ../etc/passwd, SQL Injection con ' OR 1=1--) que generan errores 404 masivos.

Para bloquear este comportamiento automáticamente en tu Raspberry Pi, la solución estándar y más efectiva es instalar Fail2ban combinado con reglas en Nginx.
1. Instalar y configurar Fail2ban (Bloqueo automático por IP)
Fail2ban lee los logs de Nginx en tiempo real y bloquea la IP en el firewall (iptables o ufw) cuando supera un límite de errores.
  • Instala Fail2ban:
    bash
    sudo apt update && sudo apt install fail2ban -y
    
    Crea un archivo de configuración local:
  • bash
    sudo nano /etc/fail2ban/jail.local
    
    Agrega la siguiente regla para bloquear cualquier IP que genere demasiados errores 404 (como tu escáner) o ataques de fuerza bruta:
  • ini
    [nginx-escaneo-404]
    enabled = true
    port = http,https
    filter = nginx-escaneo-404
    logpath = /var/log/nginx/access.log
    maxretry = 10
    findtime = 60
    bantime = 3600
    
    (Esto bloqueará durante 1 hora (3600 seg) a cualquier IP que cometa 10 errores en 60 segundos).
  • Crea el filtro para detectar los errores 404:
    bash
    sudo nano /etc/fail2ban/filter.d/nginx-escaneo-404.conf
    
    Pega dentro exactamente esto:
    ini
    [Definition]
    failregex = ^<HOST> -.*"(GET|POST|HEAD).*HTTP.*" 404
    ignoreregex =
    
    Reinicia Fail2ban para activar la defensa:
  • bash
    sudo systemctl restart fail2ban
    
    2. Bloquear el User-Agent del escáner en Nginx
En tu log todas las peticiones llevan la firma "python-requests/2.32.5". Puedes rechazar ese agente (y otros escáneres comunes como sqlmap, nikto o curl) directamente desde Nginx antes de que lleguen a tu aplicación.
  • Edita la configuración de tu sitio en Nginx (usualmente /etc/nginx/sites-available/default):
    bash
    sudo nano /etc/nginx/sites-available/default
    
    Dentro del bloque server { ... }, agrega esta condición:
  • nginx
    if ($http_user_agent ~* (python-requests|sqlmap|nikto|nmap|masscan)) {
        return 403;
    }
    
    Verifica y recarga Nginx:
  • bash
    sudo nginx -t && sudo systemctl reload nginx
    
    3. Limitar la velocidad de peticiones (Rate Limiting)
Para frenar ataques de fuerza bruta en rutas críticas como /login.php, configura un límite de peticiones por segundo en Nginx.
  • En /etc/nginx/nginx.conf (dentro del bloque http { ... }), define la zona de memoria:
    nginx
    limit_req_zone $binary_remote_addr zone=antibruteforce:10m rate=2r/s;
    
    En tu bloque server { ... }, aplica el límite:
  • nginx
    location / {
        limit_req zone=antibruteforce burst=5 nodelay;
        try_files $uri $uri/ =404;
    }
    
    Cómo verificar que el bloqueo funciona
  • Revisar IPs baneadas por Fail2ban: Ejecuta sudo fail2ban-client status nginx-escaneo-404. Verás la IP 192.168.1.111 en la lista de Banned IP list.
  • Desbloquear tu IP de prueba: Cuando termines tus pruebas de laboratorio, libera tu máquina ejecutando:
    bash
    sudo fail2ban-client set nginx-escaneo-404 unbanip 192.168.1.111

    #antes permitia scanear, ya no llegan mas solicitudes y devuelve 403



Thursday, November 5, 2026

listar los servicios de Windows que no son nativos de Microsoft (servicios de terceros o aplicaciones instaladas) via PowerShell.

Esto genera un CSV leyendo una carpeta en especifico. 

Get-CimInstance Win32_Service |

Where-Object {

    $_.PathName -match 'D:\\Services\\'

} |

Select-Object Name, DisplayName, State, StartMode, PathName |

Export-Csv "D:\Services\ListadoServicios.csv" -NoTypeInformation -Encoding UTF8



Saturday, September 12, 2026

Auditor top 10 owasp en python usando modelo gemma4:e2b

 # 1. Install the full python3 suite (needed for virtual environments)

sudo apt update && sudo apt install python3-full -y


# 2. Create a virtual environment named "venv" in your current directory

python3 -m venv venv


# 3. Activate the virtual environment

source venv/bin/activate


# 4. Install your packages safely inside this isolated environment

pip install ollama requests


import sys

import socket

import requests

import ollama

import json

import urllib3

import re

import time

import os

from urllib.parse import urlparse

 

# --- IMPORTACIÓN DE SENSORES NVIDIA ---

try:

    import pynvml

    pynvml.nvmlInit()

    HAS_GPU = True

except Exception:

    HAS_GPU = False

 

# Desactivar advertencias de certificados SSL no válidos

urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

 

MODEL_NAME = "gemma4:e2b"

 

# --- MÉTRICAS GLOBALES ---

METRICAS_LLM = {

    "total_tokens_eval": 0,

    "total_tokens_gen": 0,

    "total_tiempo_ollama": 0.0,

    "vram_muestras": []

}

 

def obtener_vram_actual() -> float:

    """Obtiene el consumo de VRAM actual de la primera GPU Nvidia en Gigabytes (GB)."""

    if not HAS_GPU:

        return 0.0

    try:

        handle = pynvml.nvmlDeviceGetHandleByIndex(0)

        info = pynvml.nvmlDeviceGetMemoryInfo(handle)

        return info.used / (1024 ** 3)

    except Exception:

        return 0.0

 

def obtener_ip(url: str) -> str:

    """Extrae el dominio de la URL y resuelve su dirección IP."""

    try:

        parsed_url = urlparse(url)

        dominio = parsed_url.netloc if parsed_url.netloc else parsed_url.path.split('/')[0]

        if ':' in dominio:

            dominio = dominio.split(':')[0]

        return socket.gethostbyname(dominio)

    except Exception:

        return "No se pudo resolver la IP"

 

def limpiar_nombre_dominio(url: str) -> str:

    """Limpia la URL para dejar un nombre de archivo válido basado en el dominio."""

    parsed_url = urlparse(url)

    dominio = parsed_url.netloc if parsed_url.netloc else parsed_url.path.split('/')[0]

    dominio = dominio.split(':')[0]

    return re.sub(r'[^\w\.-]', '_', dominio)

 

def consultar_al_modelo(prompt: str) -> str:

    """Envía un prompt a gemma4:e2b y acumula métricas de rendimiento."""

    try:

        response = ollama.generate(

            model=MODEL_NAME,

            prompt=prompt,

            options={

                "temperature": 0.1,

                "top_p": 0.9

            }

        )

       

        METRICAS_LLM["total_tokens_eval"] += response.get("prompt_eval_count", 0)

        METRICAS_LLM["total_tokens_gen"] += response.get("eval_count", 0)

       

        tiempo_segundos = response.get("total_duration", 0) / 1_000_000_000

        METRICAS_LLM["total_tiempo_ollama"] += tiempo_segundos

       

        return response['response']

    except Exception as e:

        return f"Error al conectar con el modelo: {e}"

 

def auditar_punto_owasp(base_url: str, categoria_owasp: str, endpoint: str, lista_resumen: list):

    print(f"\n[+] Analizando {categoria_owasp} en {base_url}{endpoint}...")

   

    prompt_payload = f"""

    Actúa como un experto en ciberseguridad. Para la categoría '{categoria_owasp}',

    genera una lista de 3 payloads comunes en formato JSON plano (ej. ["payload1", "payload2", "payload3"]).

    Solo devuelve la lista JSON, nada de texto adicional.

    """

    respuesta_payloads = consultar_al_modelo(prompt_payload)

   

    try:

        payloads = json.loads(respuesta_payloads)

    except:

        payloads = ["' OR 1=1 --", "<script>alert(1)</script>", "../etc/passwd"]

 

    vulnerable_en_categoria = "NO"

 

    for payload in payloads:

        url_prueba = f"{base_url}{endpoint}"

        params = {"input": payload, "search": payload, "id": payload, "url": payload}

       

        try:

            print(f"    [*] Probando payload: {payload}")

            response = requests.get(url_prueba, params=params, timeout=5, verify=False)

           

            if response.status_code == 404:

                print(f"    [!] Advertencia: El endpoint devuelve 404 (No encontrado).")

            elif response.status_code == 403:

                print(f"    [!] Advertencia: Acceso denegado 403 (WAF / Cloudflare activo).")

 

            prompt_analisis = f"""

            Analiza la siguiente respuesta HTTP del servidor para determinar si el payload '{payload}'

            explotó con éxito una vulnerabilidad de la categoría {categoria_owasp}.

           

            Código de Estado: {response.status_code}

            Cuerpo de la respuesta (primeros 500 caracteres):

            {response.text[:500] if response.text else '[Cuerpo Vacío]'}

           

            Responde estrictamente con este formato:

            DIAMETRO: [SÍ o NO o SOSPECHOSO]

            RAZÓN: (Tu breve explicación aquí)

            """

            analisis = consultar_al_modelo(prompt_analisis)

            print(f"    [Resultado AI]:\n{analisis}")

           

            lineas_analisis = analisis.upper().split('\n')

            for linea in lineas_analisis:

                if "DIAMETRO:" in linea:

                    if "SÍ" in linea or "SI" in linea:

                        vulnerable_en_categoria = "SÍ"

                        break

                    elif "SOSPECHOSO" in linea and vulnerable_en_categoria != "SÍ":

                        vulnerable_en_categoria = "SOSPECHOSO"

               

        except requests.exceptions.RequestException as e:

            print(f"    [-] Error de conexión en este payload: {e}")

            vulnerable_en_categoria = "ERROR DE CONEXIÓN"

 

    vram_actual = obtener_vram_actual()

    if HAS_GPU:

        print(f"    [GPU Info]: VRAM en uso actual: {vram_actual:.2f} GB")

        METRICAS_LLM["vram_muestras"].append(vram_actual)

 

    lista_resumen.append({

        "categoria": categoria_owasp,

        "endpoint": endpoint,

        "estado": vulnerable_en_categoria,

        "vram_alcanzada": vram_actual if HAS_GPU else None

    })

 

if __name__ == "__main__":

    if len(sys.argv) < 2:

        print("\n[!] Error: No especificaste el sitio web objetivo.")

        print("Uso correcto: python3 audit.py <URL_DEL_SITIO>")

        print("Ejemplo:      python3 audit.py https://n1g.cl\n")

        sys.exit(1)

 

    target_url = sys.argv[1].rstrip("/")

    target_ip = obtener_ip(target_url)

    nombre_limpio = limpiar_nombre_dominio(target_url)

   

    user_home = os.path.expanduser("~")

    report_file = os.path.join(user_home, f"reporte_{nombre_limpio}.txt")

   

    print(f"Iniciando escáner OWASP asistido por AI ({MODEL_NAME})")

    print(f"Objetivo base: {target_url}")

    print(f"IP objetivo:   {target_ip}")

    print(f"Archivo de salida asignado: {report_file}")

   

    if not HAS_GPU:

        print("[!] Advertencia: No se detectó GPU Nvidia compatible. Monitoreo VRAM desactivado.")

   

    resumen_final = []

   

    pruebas = [

        {"categoria": "A01:2021-Broken Access Control", "endpoint": "/view.php"},

        {"categoria": "A02:2021-Cryptographic Failures", "endpoint": "/config.json"},

        {"categoria": "A03:2021-Injection", "endpoint": "/login.php"},

        {"categoria": "A04:2021-Insecure Design", "endpoint": "/checkout"},

        {"categoria": "A05:2021-Security Misconfiguration", "endpoint": "/admin/"},

        {"categoria": "A06:2021-Vulnerable and Outdated Components", "endpoint": "/api/v1/"},

        {"categoria": "A07:2021-Identification and Authentication Failures", "endpoint": "/reset-password"},

        {"categoria": "A08:2021-Software and Data Integrity Failures", "endpoint": "/update"},

        {"categoria": "A09:2021-Security Logging and Monitoring Failures", "endpoint": "/logs/"},

        {"categoria": "A10:2021-Server-Side Request Forgery (SSRF)", "endpoint": "/webhook"}

    ]

   

    inicio_proceso = time.time()

   

    for prueba in pruebas:

        auditar_punto_owasp(target_url, prueba["categoria"], prueba["endpoint"], resumen_final)

       

    tiempo_total_proceso = time.time() - inicio_proceso

   

    tps_generacion = 0.0

    if METRICAS_LLM["total_tiempo_ollama"] > 0:

        tps_generacion = METRICAS_LLM["total_tokens_gen"] / METRICAS_LLM["total_tiempo_ollama"]

 

    vram_promedio = 0.0

    if METRICAS_LLM["vram_muestras"]:

        vram_promedio = sum(METRICAS_LLM["vram_muestras"]) / len(METRICAS_LLM["vram_muestras"])

 

    lineas_reporte = []

    lineas_reporte.append("\n" + "="*50)

    lineas_reporte.append(" RESUMEN DE AUDITORÍA OWASP TOP 10")

    lineas_reporte.append(f" Objetivo: {target_url}")

    lineas_reporte.append(f" IP:       {target_ip}")

    lineas_reporte.append("="*50)

   

    for i, item in enumerate(resumen_final, start=1):

        lineas_reporte.append(f"{i}. {item['categoria']}")

        lineas_reporte.append(f"   - Objetivo: {item['endpoint']}")

        lineas_reporte.append(f"   - Estado: {item['estado']}")

        if item['vram_alcanzada'] is not None:

            lineas_reporte.append(f"   - VRAM Usada: {item['vram_alcanzada']:.2f} GB")

        lineas_reporte.append("-" * 50)

       

    lineas_reporte.append("\n" + "="*50)

    lineas_reporte.append(" MÉTRICAS DE RENDIMIENTO Y PROCESAMIENTO")

    lineas_reporte.append("="*50)

    lineas_reporte.append(f" Tiempo total del proceso:       {tiempo_total_proceso:.2f} segundos")

    lineas_reporte.append(f" Tiempo neto en Ollama (LLM):   {METRICAS_LLM['total_tiempo_ollama']:.2f} segundos")

    lineas_reporte.append(f" Tokens de entrada procesados:  {METRICAS_LLM['total_tokens_eval']} tokens")

    lineas_reporte.append(f" Tokens de salida generados:    {METRICAS_LLM['total_tokens_gen']} tokens")

    lineas_reporte.append(f" Velocidad de respuesta (LLM):  {tps_generacion:.2f} tokens/seg")

    if HAS_GPU:

        lineas_reporte.append(f" Consumo de VRAM Promedio:      {vram_promedio:.2f} GB")

    lineas_reporte.append("="*50)

   

    texto_final = "\n".join(lineas_reporte)

    print(texto_final)

   

    try:

        with open(report_file, "w", encoding="utf-8") as f:

            f.write(texto_final)

        print(f"\n[+] El reporte ha sido guardado exitosamente en: {report_file}\n")

    except Exception as error_guardado:

        print(f"\n[!] Error inesperado al escribir el reporte en disco: {error_guardado}")

   

    if HAS_GPU:

        try:

            pynvml.nvmlShutdown()

        except Exception:

            pass


#para ejecutar
python3 auditor.py https://tusitio