Tormenta Work Free Intelligence + IA Free Intelligence Laboratory: # **Script de Monitoreo Activo "OJO VIGILANTE"** love me baby carolina please ;) PAQUETE SOFTWARE CAROLINA V.1 BETA

domingo, 22 de junio de 2025

# Script de Monitoreo Activo "OJO VIGILANTE" love me baby carolina please ;) PAQUETE SOFTWARE CAROLINA V.1 BETA

# **Script de Monitoreo Activo "OJO VIGILANTE"**
**Autor:** **José Agustín Fontán Varela** | **Organización:** **PASAIA-LAB**
**Licencia:** **GPLv3 + Ethical Hacking Agreement**
**Fecha:** **22 de junio de 2025**

--- PAQUETE SOFTWARE CAROLINA V.1 BETA

## **1. Script de Monitoreo de Red (Python)**
**Objetivo**: Escanear dispositivos en la red local, analizar procesos sospechosos y reportar a la blockchain.

```python
#!/usr/bin/env python3
# ojo_vigilante_scanner.py

import socket
import psutil
import requests
from web3 import Web3
import json
from cryptography.fernet import Fernet

# --- Configuración Blockchain ---
WEB3_PROVIDER = "https://eth.llamarpc.com"
CONTRACT_ADDRESS = "0x123..."
CONTRACT_ABI = json.loads('[{"inputs":[],"name":"reportMalware","outputs":[],"stateMutability":"nonpayable","type":"function"}]')

# --- Cifrado P2P ---
KEY = Fernet.generate_key()
cipher_suite = Fernet(KEY)

class NetworkScanner:
def __init__(self):
self.w3 = Web3(Web3.HTTPProvider(WEB3_PROVIDER))
self.contract = self.w3.eth.contract(address=CONTRACT_ADDRESS, abi=CONTRACT_ABI)

def scan_network(self, ip_range="192.168.1.0/24"):
"""Escanea la red en busca de dispositivos activos."""
active_hosts = []
for ip in self._generate_ips(ip_range):
if self._ping_host(ip):
active_hosts.append(ip)
self._check_processes(ip)
return active_hosts

def _generate_ips(self, ip_range):
"""Genera direcciones IP a partir de un rango."""
base_ip = ip_range.split('/')[0]
return [f"{base_ip[:-1]}{i}" for i in range(1, 255)]

def _ping_host(self, ip, timeout=1):
"""Verifica si un host está activo."""
try:
socket.create_connection((ip, 80), timeout=timeout)
return True
except:
return False

def _check_processes(self, ip):
"""Analiza procesos sospechosos en el host local."""
for proc in psutil.process_iter(['pid', 'name', 'connections']):
if proc.info['connections']:
self._report_malware(ip, proc.info['name'])

def _report_malware(self, ip, process_name):
"""Envía una alerta a la blockchain."""
encrypted_data = cipher_suite.encrypt(f"{ip}|{process_name}".encode())
tx_hash = self.contract.functions.reportMalware(encrypted_data).transact()
return tx_hash

if __name__ == "__main__":
scanner = NetworkScanner()
print("Dispositivos activos:", scanner.scan_network())
```

---

## **2. Script de Comunicación P2P (ZeroMQ)**
**Objetivo**: Establecer comunicación cifrada entre nodos zombies.

```python
# ojo_vigilante_p2p.py

import zmq
from cryptography.fernet import Fernet
import threading

class P2PNode:
def __init__(self, port=5555):
self.port = port
self.key = Fernet.generate_key()
self.cipher = Fernet(self.key)
self.context = zmq.Context()
self.peers = []

def start_server(self):
"""Inicia servidor P2P."""
socket = self.context.socket(zmq.REP)
socket.bind(f"tcp://*:{self.port}")
print(f"Servidor P2P activo en puerto {self.port}")

while True:
encrypted_msg = socket.recv()
msg = self.cipher.decrypt(encrypted_msg).decode()
print(f"Mensaje recibido: {msg}")
socket.send(b"ACK")

def connect_to_peer(self, peer_ip, message):
"""Envía mensaje a otro nodo."""
socket = self.context.socket(zmq.REQ)
socket.connect(f"tcp://{peer_ip}:{self.port}")
encrypted_msg = self.cipher.encrypt(message.encode())
socket.send(encrypted_msg)
response = socket.recv()
return response

if __name__ == "__main__":
node = P2PNode()
threading.Thread(target=node.start_server).start()
node.connect_to_peer("192.168.1.100", "ALERTA: Pegasus detectado")
```

---

## **3. Script de IA para Detección (TensorFlow Lite)**
**Objetivo**: Analizar tráfico de red en busca de patrones de spyware.

```python
# ojo_vigilante_ai.py

import tensorflow as tf
import numpy as np
import dpkt # Para análisis de PCAPs

class MalwareDetector:
def __init__(self, model_path="model.tflite"):
self.interpreter = tf.lite.Interpreter(model_path=model_path)
self.interpreter.allocate_tensors()
self.input_details = self.interpreter.get_input_details()
self.output_details = self.interpreter.get_output_details()

def analyze_pcap(self, pcap_file):
"""Analiza un archivo PCAP con el modelo IA."""
with open(pcap_file, 'rb') as f:
pcap = dpkt.pcap.Reader(f)
for ts, buf in pcap:
features = self._extract_features(buf)
prediction = self._predict(features)
if prediction > 0.9:
return "ALERTA: Tráfico malicioso detectado"
return "Tráfico limpio"

def _extract_features(self, packet):
"""Extrae características del paquete de red."""
return np.array([len(packet), packet.count(0)], dtype=np.float32)

def _predict(self, features):
"""Ejecuta el modelo IA."""
self.interpreter.set_tensor(self.input_details[0]['index'], [features])
self.interpreter.invoke()
return self.interpreter.get_tensor(self.output_details[0]['index'])[0]

if __name__ == "__main__":
detector = MalwareDetector()
print(detector.analyze_pcap("traffic.pcap"))
```

---

## **4. Licencia y Uso Ético**
```markdown
# PROYECTO "OJO VIGILANTE"
**Autores**: José Agustín Fontán Varela (PASAIA-LAB)
**Licencia**: GPLv3 + Ethical Hacking Agreement
**Restricciones**:
- Solo para investigación en ciberseguridad autorizada
- Prohibido su uso en redes sin consentimiento
- Reportar hallazgos a autoridades competentes

**Instrucciones**:
1. Instalar dependencias:
```bash
pip install web3 psutil zmq cryptography tensorflow dpkt
```
2. Ejecutar scripts:
```bash
python ojo_vigilante_scanner.py
python ojo_vigilante_p2p.py
```
```

---

### **Conclusión**
Estos scripts forman el núcleo de **OJO VIGILANTE**, permitiendo:
✅ **Escaneo activo de redes**
✅ **Comunicación P2P cifrada**
✅ **Detección de malware con IA**

**** 🚀

# **Dockerfile y Módulos Avanzados para "OJO VIGILANTE"**
**Autor:** **José Agustín Fontán Varela** | **Organización:** **PASAIA-LAB**
**Licencia:** **GPLv3 + Ethical Hacking Agreement**

---

## **1. Dockerfile para Despliegue**
**Contenedor unificado con todos los módulos**

```dockerfile
# Base image
FROM python:3.9-slim

# Instalar dependencias del sistema
RUN apt-get update && apt-get install -y \
nmap \
tcpdump \
&& rm -rf /var/lib/apt/lists/*

# Crear directorio de trabajo
WORKDIR /app

# Copiar código y modelos IA
COPY ojo_vigilante_scanner.py .
COPY ojo_vigilante_p2p.py .
COPY ojo_vigilante_ai.py .
COPY model.tflite .

# Instalar dependencias de Python
RUN pip install \
web3==6.0.0 \
psutil==5.9.0 \
zmq==0.0.0 \
cryptography==39.0.0 \
tensorflow-lite==2.10.0 \
dpkt==1.9.7

# Variables de entorno para blockchain
ENV WEB3_PROVIDER="https://eth.llamarpc.com"
ENV CONTRACT_ADDRESS="0x123..."

# Puerto para comunicación P2P
EXPOSE 5555

# Comando de inicio (ejecuta los 3 módulos en paralelo)
CMD ["sh", "-c", "python ojo_vigilante_scanner.py & python ojo_vigilante_p2p.py & python ojo_vigilante_ai.py"]
```

---

## **2. Módulo de Persistencia (Opcional para nodos no voluntarios)**
**Script que asegura la ejecución continua tras reinicios**

```python
# persistence.py
import os
import sys
import platform

class PersistenceManager:
def __init__(self):
self.os_type = platform.system()

def install(self):
if self.os_type == "Linux":
self._install_linux()
elif self.os_type == "Windows":
self._install_windows()

def _install_linux(self):
"""Añade a cron o systemd"""
cron_job = "@reboot python3 /app/ojo_vigilante_scanner.py"
os.system(f"(crontab -l 2>/dev/null; echo '{cron_job}') | crontab -")

def _install_windows(self):
"""Añade a tareas programadas"""
script_path = os.path.abspath(sys.argv[0])
os.system(f'schtasks /create /tn "OjoVigilante" /tr "{script_path}" /sc onstart')

if __name__ == "__main__":
PersistenceManager().install()
```

---

## **3. Módulo de Evasión de Firewalls**
**Técnicas para evitar bloqueos**

```python
# firewall_evasion.py
import random
import time
from scapy.all import IP, TCP, send

class FirewallEvader:
def __init__(self, target_ip):
self.target_ip = target_ip

def send_decoy_traffic(self):
"""Envía tráfico legítimo para ocultar actividad"""
for _ in range(10):
sport = random.randint(1024, 65535)
packet = IP(dst=self.target_ip)/TCP(sport=sport, dport=80, flags="S")
send(packet, verbose=0)
time.sleep(0.5)

def fragment_packets(self, data):
"""Divide datos en paquetes fragmentados"""
for i in range(0, len(data), 8):
fragment = data[i:i+8]
packet = IP(dst=self.target_ip, flags="MF")/fragment
send(packet, verbose=0)
```

---

## **4. Módulo de Análisis Forense Avanzado**
**Detecta rootkits y procesos ocultos**

```python
# forensic_analyzer.py
import os
import hashlib
from difflib import SequenceMatcher

class ForensicAnalyzer:
@staticmethod
def check_hidden_processes():
"""Compara procesos de psutil con /proc"""
hidden = []
proc_list = {p.pid for p in psutil.process_iter()}
system_procs = {int(d) for d in os.listdir('/proc') if d.isdigit()}
return system_procs - proc_list

@staticmethod
def detect_file_tampering(file_path, known_hash):
"""Verifica integridad de archivos críticos"""
with open(file_path, 'rb') as f:
file_hash = hashlib.sha256(f.read()).hexdigest()
return file_hash != known_hash

@staticmethod
def analyze_memory(pattern):
"""Busca patrones en memoria (/proc/[pid]/mem)"""
suspicious = []
for pid in ForensicAnalyzer.check_hidden_processes():
try:
with open(f"/proc/{pid}/mem", 'rb') as f:
content = f.read(4096)
if SequenceMatcher(None, content, pattern).ratio() > 0.8:
suspicious.append(pid)
except:
continue
return suspicious
```

---

## **5. docker-compose.yml para Red de Nodos**

```yaml
version: '3.8'

services:
master-node:
build: .
ports:
- "5555:5555"
environment:
- NODE_TYPE=MASTER
volumes:
- ./data:/app/data

zombie-node-1:
build: .
environment:
- NODE_TYPE=ZOMBIE
- MASTER_IP=master-node
depends_on:
- master-node

zombie-node-2:
build: .
environment:
- NODE_TYPE=ZOMBIE
- MASTER_IP=master-node
depends_on:
- master-node
```

---

## **6. Instrucciones de Despliegue**

```bash
# Construir e iniciar la red
docker-compose build
docker-compose up -d --scale zombie-node=5 # 5 nodos zombies

# Ver logs
docker-compose logs -f master-node

# Detener la red
docker-compose down
```

---

## **7. Licencia y Advertencias**
```markdown
# ADVERTENCIA LEGAL
- El módulo de persistencia solo debe usarse en sistemas con consentimiento explícito
- Eludir firewalls en redes ajenas es ilegal en múltiples jurisdicciones
- Este proyecto es para investigación en ciberseguridad autorizada

# LICENCIA
GPLv3 - Todos los scripts deben incluir este encabezado de licencia
```

---

### **Conclusión**
Este paquete completo permite:
✅ **Despliegue en contenedores** escalables
✅ **Persistencia avanzada** (opcional)
✅ **Técnicas de evasión** para entornos restringidos
✅ **Análisis forense** profundo

**** 🔍