Herramientas de Seguridad con Python
Python es una excelente opción para desarrollar herramientas de seguridad debido a su simplicidad, amplia biblioteca estándar y gran cantidad de librerías especializadas.
Escáner de Puertos Básico
Un escáner de puertos es una herramienta fundamental para evaluar la seguridad de una red. Aquí te muestro cómo crear uno básico:
import socket
import threading
import time
from concurrent.futures import ThreadPoolExecutor
class PortScanner:
def __init__(self, target, start_port=1, end_port=1024):
self.target = target
self.start_port = start_port
self.end_port = end_port
self.open_ports = []
def scan_port(self, port):
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.settimeout(1)
result = sock.connect_ex((self.target, port))
if result == 0:
service = self.get_service_name(port)
self.open_ports.append((port, service))
sock.close()
except:
pass
def get_service_name(self, port):
common_ports = {
21: "FTP",
22: "SSH",
23: "Telnet",
25: "SMTP",
53: "DNS",
80: "HTTP",
443: "HTTPS",
3306: "MySQL",
5432: "PostgreSQL"
}
return common_ports.get(port, "Unknown")
def scan(self):
print(f"Escaneando {self.target}...")
start_time = time.time()
with ThreadPoolExecutor(max_workers=100) as executor:
executor.map(self.scan_port, range(self.start_port, self.end_port + 1))
end_time = time.time()
print(f"Escaneo completado en {end_time - start_time:.2f} segundos")
for port, service in self.open_ports:
print(f"Puerto {port} ({service}) - ABIERTO")
# Uso
scanner = PortScanner("192.168.1.1")
scanner.scan()Analizador de Logs de Seguridad
Los logs son una fuente invaluable de información para detectar actividades sospechosas:
import re
from datetime import datetime
from collections import defaultdict
class SecurityLogAnalyzer:
def __init__(self):
self.suspicious_patterns = [
r'failed login',
r'brute force',
r'SQL injection',
r'XSS attack',
r'admin.*login'
]
self.alerts = []
def analyze_log_line(self, line):
timestamp = self.extract_timestamp(line)
ip_address = self.extract_ip(line)
for pattern in self.suspicious_patterns:
if re.search(pattern, line, re.IGNORECASE):
alert = {
'timestamp': timestamp,
'ip': ip_address,
'pattern': pattern,
'line': line.strip()
}
self.alerts.append(alert)
def extract_timestamp(self, line):
# Patrón básico para extraer timestamp
timestamp_pattern = r'(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})'
match = re.search(timestamp_pattern, line)
return match.group(1) if match else None
def extract_ip(self, line):
# Patrón para extraer IPs
ip_pattern = r'\b(?:\d{1,3}\.){3}\d{1,3}\b'
match = re.search(ip_pattern, line)
return match.group() if match else None
def generate_report(self):
print("=== REPORTE DE SEGURIDAD ===")
print(f"Total de alertas: {len(self.alerts)}")
# Agrupar por IP
ip_alerts = defaultdict(list)
for alert in self.alerts:
ip_alerts[alert['ip']].append(alert)
for ip, alerts in ip_alerts.items():
print(f"\nIP: {ip}")
print(f"Alertas: {len(alerts)}")
for alert in alerts[:3]: # Mostrar solo las primeras 3
print(f" - {alert['timestamp']}: {alert['pattern']}")
# Uso
analyzer = SecurityLogAnalyzer()
with open('security.log', 'r') as f:
for line in f:
analyzer.analyze_log_line(line)
analyzer.generate_report()Detector de Vulnerabilidades Web
Un detector básico de vulnerabilidades comunes en aplicaciones web:
import requests
from urllib.parse import urljoin, urlparse
import re
class WebVulnerabilityScanner:
def __init__(self, target_url):
self.target_url = target_url
self.session = requests.Session()
self.vulnerabilities = []
def test_sql_injection(self, url):
payloads = ["'", "1' OR '1'='1", "1; DROP TABLE users;--"]
for payload in payloads:
try:
response = self.session.get(f"{url}?id={payload}")
if self.detect_sql_error(response.text):
self.vulnerabilities.append({
'type': 'SQL Injection',
'url': url,
'payload': payload
})
except:
pass
def test_xss(self, url):
payloads = [
"<script>alert('XSS')</script>",
"<img src=x onerror=alert('XSS')>",
"javascript:alert('XSS')"
]
for payload in payloads:
try:
response = self.session.get(f"{url}?q={payload}")
if payload in response.text:
self.vulnerabilities.append({
'type': 'XSS',
'url': url,
'payload': payload
})
except:
pass
def detect_sql_error(self, content):
error_patterns = [
'SQL syntax',
'mysql_fetch',
'ORA-',
'PostgreSQL'
]
for pattern in error_patterns:
if re.search(pattern, content, re.IGNORECASE):
return True
return False
def scan(self):
print(f"Escaneando {self.target_url}...")
# Obtener enlaces de la página principal
try:
response = self.session.get(self.target_url)
links = re.findall(r'href=[\'"]?([^\'" >]+)', response.text)
for link in links[:10]: # Limitar a 10 enlaces
full_url = urljoin(self.target_url, link)
if urlparse(full_url).netloc == urlparse(self.target_url).netloc:
self.test_sql_injection(full_url)
self.test_xss(full_url)
except Exception as e:
print(f"Error: {e}")
def report(self):
print("\n=== REPORTE DE VULNERABILIDADES ===")
if not self.vulnerabilities:
print("No se encontraron vulnerabilidades.")
return
for vuln in self.vulnerabilities:
print(f"\nTipo: {vuln['type']}")
print(f"URL: {vuln['url']}")
print(f"Payload: {vuln['payload']}")
# Uso
scanner = WebVulnerabilityScanner("http://example.com")
scanner.scan()
scanner.report()Mejores Prácticas
1. Manejo de Errores
Siempre implementar manejo de excepciones robusto para evitar que las herramientas fallen.
2. Rate Limiting
Respetar los límites de velocidad para no sobrecargar los sistemas objetivo.
3. Logging
Implementar logging detallado para auditoría y debugging.
4. Configuración
Usar archivos de configuración para parámetros ajustables.
Conclusión
Estas herramientas básicas te proporcionarán una base sólida para comenzar con el desarrollo de herramientas de seguridad en Python. Recuerda siempre usar estas herramientas de manera ética y responsable.