V1 · Codificación y Sanitización#

# ❌ MAL: decodificando dos veces
import urllib.parse

user_input = "%2527DROP TABLE users%253B"
first_decode = urllib.parse.unquote(user_input)   # → %27DROP TABLE users%3B
second_decode = urllib.parse.unquote(first_decode) # → 'DROP TABLE users;  ← PELIGROSO

# ✅ BIEN: decodificar una sola vez y luego usar la consulta parametrizada
user_input = "%27usuario"
decoded = urllib.parse.unquote(user_input)  # → 'usuario  (solo una vez)

# Usar inmediatamente en consulta parametrizada
cursor.execute("SELECT * FROM users WHERE name = ?", (decoded,))

import sqlite3

conn = sqlite3.connect("app.db")
cursor = conn.cursor()

# ❌ MAL: concatenar directamente (vulnerable a SQL Injection)
username = "admin' OR '1'='1"
query = f"SELECT * FROM users WHERE username = '{username}'"
# Genera: SELECT * FROM users WHERE username = 'admin' OR '1'='1'
# ¡El atacante accede a TODOS los usuarios!

# ✅ BIEN: consulta parametrizada
cursor.execute("SELECT * FROM users WHERE username = ?", (username,))
user = cursor.fetchone()

// ❌ MAL: insertar HTML directamente desde input del usuario
const userInput = '<script>document.cookie</script>';
document.getElementById('greeting').innerHTML = `Hola, ${userInput}`;
// El script malicioso se ejecuta en el navegador de la víctima

// ✅ BIEN: usar textContent en lugar de innerHTML
document.getElementById('greeting').textContent = `Hola, ${userInput}`;
// Se muestra como texto plano: Hola, <script>document.cookie</script>

// ✅ BIEN en backend (Python con Flask + Jinja2): auto-escaping activado
// {{ user_input }}  → escapa automáticamente los caracteres peligrosos
// {{ user_input | safe }}  → ¡NUNCA uses |safe con datos del usuario!

import subprocess

# ❌ MAL: ejecutar comandos con input del usuario directamente
filename = "informe.pdf; rm -rf /"
os.system(f"convert {filename} output.png")  # ¡Borra el sistema!

# ✅ BIEN: usar lista de argumentos (sin shell=True)
filename = "informe.pdf"
subprocess.run(["convert", filename, "output.png"], shell=False)

# ✅ BIEN: validar con allowlist primero
import re
if not re.match(r'^[a-zA-Z0-9_\-\.]+\.pdf$', filename):
    raise ValueError("Nombre de archivo inválido")
subprocess.run(["convert", filename, "output.png"], shell=False)

// ❌ MAL: construir URLs con datos del usuario sin validar
const redirectUrl = req.query.redirect; // Podría ser: javascript:alert('XSS')
res.redirect(redirectUrl);

// ✅ BIEN: validar contra una lista de protocolos y dominios permitidos
const ALLOWED_DOMAINS = ['miapp.com', 'api.miapp.com'];

function isSafeUrl(url) {
  try {
    const parsed = new URL(url);
    return ['http:', 'https:'].includes(parsed.protocol) &&
           ALLOWED_DOMAINS.includes(parsed.hostname);
  } catch {
    return false;
  }
}

const redirectUrl = req.query.redirect;
if (isSafeUrl(redirectUrl)) {
  res.redirect(redirectUrl);
} else {
  res.redirect('/home'); // fallback seguro
}

// ❌ MAL: insertar HTML del usuario directamente
const userHtml = '<p>Hola</p><script>robarContrasena()</script>';
document.getElementById('content').innerHTML = userHtml;

// ✅ BIEN: sanitizar con DOMPurify antes de insertar
import DOMPurify from 'dompurify';

const cleanHtml = DOMPurify.sanitize(userHtml);
// Resultado: <p>Hola</p>  (el script fue eliminado)
document.getElementById('content').innerHTML = cleanHtml;

// Configuración más estricta: solo permitir ciertas etiquetas
const strictClean = DOMPurify.sanitize(userHtml, {
  ALLOWED_TAGS: ['p', 'b', 'i', 'em', 'strong', 'a'],
  ALLOWED_ATTR: ['href']
});

// ❌ MAL: usar eval con input del usuario
const formula = req.body.formula; // podría ser: "process.exit(1)"
const resultado = eval(formula);

// ✅ BIEN: usar un parser matemático seguro
import { evaluate } from 'mathjs';

try {
  // mathjs solo evalúa expresiones matemáticas, no código arbitrario
  const resultado = evaluate(formula);
} catch (e) {
  res.status(400).json({ error: "Fórmula inválida" });
}

import ipaddress
import urllib.parse

ALLOWED_DOMAINS = ['api.servicio-externo.com']

def is_safe_url(url: str) -> bool:
    try:
        parsed = urllib.parse.urlparse(url)

        # Solo permitir HTTPS
        if parsed.scheme != 'https':
            return False

        # Solo dominios permitidos
        if parsed.netloc not in ALLOWED_DOMAINS:
            return False

        # Bloquear IPs privadas / localhost
        try:
            ip = ipaddress.ip_address(parsed.hostname)
            if ip.is_private or ip.is_loopback:
                return False
        except ValueError:
            pass  # Es un hostname, no una IP → OK

        return True
    except Exception:
        return False

# Uso
url = request.args.get('webhook_url')
if not is_safe_url(url):
    abort(400, "URL no permitida")

response = requests.get(url, timeout=5)

// ❌ MAL: gets() no verifica el tamaño → buffer overflow
char buffer[64];
gets(buffer); // Si el input tiene más de 63 chars, sobreescribe memoria

// ✅ BIEN: fgets() con límite explícito
char buffer[64];
fgets(buffer, sizeof(buffer), stdin); // Nunca lee más de 63 chars + null terminator

// ✅ MEJOR en C++: usar std::string que gestiona memoria automáticamente
#include <string>
std::string input;
std::getline(std::cin, input); // Sin límite fijo, sin overflow

# ❌ MAL: parser XML con entidades externas habilitadas
import xml.etree.ElementTree as ET

# Un atacante podría enviar:
# <?xml version="1.0"?>
# <!DOCTYPE foo [<!ENTITY xxe SYSTEM "file:///etc/passwd">]>
# <data>&xxe;</data>

tree = ET.parse('user_input.xml')  # Podría leer archivos del servidor

# ✅ BIEN: usar defusedxml que deshabilita todas las características peligrosas
import defusedxml.ElementTree as SafeET

try:
    tree = SafeET.parse('user_input.xml')
except defusedxml.DTDForbidden:
    abort(400, "XML con DTD no permitido")

import pickle, json

# ❌ MAL: pickle con datos del usuario permite ejecución de código arbitrario
data = request.get_data()
obj = pickle.loads(data)  # ¡NUNCA hagas esto con datos externos!

# ✅ BIEN: usar JSON con validación de estructura
import json
from pydantic import BaseModel

class UserData(BaseModel):
    nombre: str
    edad: int

raw = request.get_json()
try:
    user = UserData(**raw)  # Valida tipos y estructura
except Exception:
    abort(400, "Datos inválidos")