V2 · Validación y Lógica de Negocio#

# validation-rules.yaml — Documento de referencia para el equipo

campos:
  email:
    formato: "RFC 5322"
    max_longitud: 254
    ejemplo: "usuario@dominio.com"

  tarjeta_credito:
    formato: "Luhn algorithm válido"
    longitud: [13, 16, 19]
    prefijos_permitidos: ["4", "5", "34", "37"]  # Visa, MC, Amex

  telefono:
    formato: "E.164"
    ejemplo: "+525512345678"

  codigo_postal_mx:
    formato: "5 dígitos numéricos"
    patron: "^[0-9]{5}$"

consistencia_logica:
  - "codigo_postal debe corresponder al estado indicado"
  - "fecha_fin debe ser posterior a fecha_inicio"
  - "descuento no puede hacer que el total sea negativo"

limites_negocio:
  transferencia_maxima_diaria_por_usuario: 50000  # MXN
  transferencia_maxima_global_por_dia: 10000000   # MXN
  intentos_login_maximos: 5
  productos_max_por_orden: 99

# ❌ MAL: blocklist (intentar bloquear lo malo es interminable)
def validar_nombre(nombre: str) -> bool:
    palabras_prohibidas = ['<script>', 'DROP', 'SELECT', '--', ';']
    for palabra in palabras_prohibidas:
        if palabra.lower() in nombre.lower():
            return False
    return True
# Un atacante siempre puede encontrar una variante que no esté en la lista

# ✅ BIEN: allowlist (solo permitir lo que sabemos que es válido)
import re

def validar_nombre(nombre: str) -> bool:
    # Solo letras (incluyendo acentos y ñ), espacios y guiones. Máx 100 chars.
    patron = r'^[a-zA-ZáéíóúÁÉÍÓÚñÑüÜ\s\-]{1,100}$'
    return bool(re.match(patron, nombre))

print(validar_nombre("María José"))      # True ✅
print(validar_nombre("<script>alert"))   # False ✅
print(validar_nombre("O'Brien"))         # False (apostrofe no permitido)
# Si O'Brien es un caso de uso real, agrégalo al patrón explícitamente

// ❌ MAL: solo validar en el cliente
// El atacante puede enviar requests directamente con Postman/curl y saltar esto
document.getElementById('form').addEventListener('submit', (e) => {
  const edad = parseInt(document.getElementById('edad').value);
  if (edad < 18) {
    e.preventDefault();
    alert('Debes ser mayor de edad');
  }
  // Si el JS es deshabilitado o saltado, no hay protección
});

// ✅ BIEN: validar SIEMPRE en el servidor (adicionalmente al cliente si quieres)
// --- servidor (Node.js/Express) ---
app.post('/registro', (req, res) => {
  const { edad, email, nombre } = req.body;

  const errores = [];

  if (!Number.isInteger(edad) || edad < 18 || edad > 120) {
    errores.push('Edad inválida: debe ser un número entre 18 y 120');
  }

  if (!/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email)) {
    errores.push('Email con formato inválido');
  }

  if (!/^[a-zA-ZáéíóúñÑ\s]{2,100}$/.test(nombre)) {
    errores.push('Nombre inválido');
  }

  if (errores.length > 0) {
    return res.status(400).json({ errores });
  }

  // Proceder con el registro
});

from datetime import date
from pydantic import BaseModel, validator

class Reservacion(BaseModel):
    fecha_entrada: date
    fecha_salida: date
    habitaciones: int
    huespedes: int

    @validator('fecha_salida')
    def salida_posterior_a_entrada(cls, v, values):
        if 'fecha_entrada' in values and v <= values['fecha_entrada']:
            raise ValueError('La fecha de salida debe ser posterior a la de entrada')
        return v

    @validator('fecha_entrada')
    def no_en_pasado(cls, v):
        if v < date.today():
            raise ValueError('No se puede reservar en el pasado')
        return v

    @validator('huespedes')
    def huespedes_vs_habitaciones(cls, v, values):
        if 'habitaciones' in values:
            max_huespedes = values['habitaciones'] * 4  # máximo 4 por habitación
            if v > max_huespedes:
                raise ValueError(f'Máximo {max_huespedes} huéspedes para {values["habitaciones"]} habitaciones')
        return v

# Uso
try:
    reservacion = Reservacion(
        fecha_entrada=date(2025, 3, 10),
        fecha_salida=date(2025, 3, 8),   # ← Error: salida antes de entrada
        habitaciones=2,
        huespedes=3
    )
except ValueError as e:
    print(e)  # "La fecha de salida debe ser posterior a la de entrada"

# Escenario: proceso de compra en e-commerce
# El atacante intenta ir directamente al paso 3 sin pagar

from enum import Enum

class PasoCompra(Enum):
    CARRITO = 1
    DATOS_ENVIO = 2
    PAGO = 3
    CONFIRMACION = 4

# ❌ MAL: confiar en el frontend para indicar el paso actual
@app.route('/confirmar-orden', methods=['POST'])
def confirmar_orden():
    orden_id = request.json['orden_id']
    # Procesar confirmación sin verificar si ya se pagó
    crear_orden(orden_id)  # ← El atacante obtiene su orden gratis

# ✅ BIEN: verificar el estado en el servidor antes de avanzar
@app.route('/confirmar-orden', methods=['POST'])
def confirmar_orden():
    orden_id = request.json['orden_id']
    orden = db.get_orden(orden_id)

    # Verificar que el paso anterior (pago) fue completado
    if orden.estado != PasoCompra.PAGO:
        return jsonify({'error': 'Debe completar el pago antes de confirmar'}), 400

    if not orden.pago_verificado:
        return jsonify({'error': 'El pago no ha sido verificado'}), 400

    # Solo si todo está en orden, avanzar
    orden.estado = PasoCompra.CONFIRMACION
    db.save(orden)
    return jsonify({'mensaje': 'Orden confirmada exitosamente'})

# Escenario: transferencia bancaria entre cuentas
# Si falla a la mitad, no queremos que el dinero desaparezca

# ❌ MAL: dos operaciones independientes, si falla la segunda el dinero se pierde
def transferir_mal(origen_id, destino_id, monto):
    cuenta_origen = db.get_cuenta(origen_id)
    cuenta_origen.saldo -= monto
    db.save(cuenta_origen)          # ← Si el servidor falla aquí...

    cuenta_destino = db.get_cuenta(destino_id)
    cuenta_destino.saldo += monto   # ← ...esto nunca se ejecuta
    db.save(cuenta_destino)

# ✅ BIEN: usar transacción (todo o nada)
from sqlalchemy.orm import Session

def transferir_bien(db: Session, origen_id: int, destino_id: int, monto: float):
    try:
        cuenta_origen = db.query(Cuenta).filter_by(id=origen_id).with_for_update().first()
        cuenta_destino = db.query(Cuenta).filter_by(id=destino_id).with_for_update().first()

        if cuenta_origen.saldo < monto:
            raise ValueError("Saldo insuficiente")

        cuenta_origen.saldo -= monto
        cuenta_destino.saldo += monto

        db.commit()  # Solo se confirma si ambas operaciones tuvieron éxito
        return True

    except Exception as e:
        db.rollback()  # Si algo falla, se revierten TODOS los cambios
        raise e

# Escenario: dos usuarios intentan comprar el último asiento al mismo tiempo

# ❌ MAL: verificar disponibilidad y reservar en pasos separados
def reservar_asiento_mal(asiento_id, usuario_id):
    asiento = db.get_asiento(asiento_id)
    if asiento.disponible:          # ← Dos usuarios pasan esta verificación
        asiento.disponible = False  #   simultáneamente y ambos reservan
        asiento.usuario_id = usuario_id
        db.save(asiento)
        return True
    return False

# ✅ BIEN: usar bloqueo pesimista (SELECT FOR UPDATE) o transacción con check
def reservar_asiento_bien(db: Session, asiento_id: int, usuario_id: int):
    with db.begin():
        # WITH FOR UPDATE bloquea la fila hasta que terminemos
        asiento = db.query(Asiento)\
                    .filter_by(id=asiento_id, disponible=True)\
                    .with_for_update()\
                    .first()

        if not asiento:
            return {'exito': False, 'mensaje': 'Asiento no disponible'}

        asiento.disponible = False
        asiento.usuario_id = usuario_id
        # El commit al salir del bloque libera el bloqueo
        return {'exito': True, 'mensaje': 'Asiento reservado'}

# Usando Flask-Limiter

from flask_limiter import Limiter
from flask_limiter.util import get_remote_address

limiter = Limiter(
    app,
    key_func=get_remote_address,
    default_limits=["200 per day", "50 per hour"]
)

@app.route('/login', methods=['POST'])
@limiter.limit("5 per minute")  # Máx 5 intentos de login por minuto por IP
def login():
    ...

@app.route('/api/transferencia', methods=['POST'])
@limiter.limit("10 per hour;3 per minute")  # Límite por tiempo y volumen
def transferencia():
    ...

@app.route('/api/exportar-datos', methods=['GET'])
@limiter.limit("1 per day")  # Exportaciones: una por día
def exportar_datos():
    ...

import time
from datetime import datetime, timedelta

# Escenario: formulario de registro
# Un bot puede completarlo en milisegundos; un humano tarda varios segundos

@app.route('/registro', methods=['POST'])
def registro():
    tiempo_inicio = session.get('formulario_inicio')
    tiempo_actual = datetime.now()

    if tiempo_inicio:
        tiempo_transcurrido = tiempo_actual - datetime.fromisoformat(tiempo_inicio)

        # Un humano real tarda al menos 3 segundos en llenar el formulario
        if tiempo_transcurrido < timedelta(seconds=3):
            return jsonify({'error': 'Interacción demasiado rápida'}), 429

        # También verificar que no tardó demasiado (token expirado)
        if tiempo_transcurrido > timedelta(minutes=30):
            return jsonify({'error': 'Formulario expirado, recarga la página'}), 400

    # Procesar registro...

@app.route('/registro', methods=['GET'])
def mostrar_formulario():
    session['formulario_inicio'] = datetime.now().isoformat()
    return render_template('registro.html')