Seguridad en Flask

La seguridad en aplicaciones web representa uno de los aspectos más críticos del desarrollo moderno. Flask, como framework minimalista, proporciona las herramientas fundamentales para construir aplicaciones seguras, pero requiere que los desarrolladores implementen conscientemente las medidas de protección necesarias.

Las aplicaciones Flask enfrentan las mismas vulnerabilidades que cualquier aplicación web: inyección SQL, cross-site scripting (XSS), cross-site request forgery (CSRF), y exposición de datos sensibles. La diferencia radica en que Flask te otorga control total sobre cómo implementar las defensas contra estas amenazas.

Configuración segura del entorno

La configuración de Flask debe establecer bases sólidas de seguridad desde el primer momento. La clave secreta representa el elemento más fundamental de esta configuración.

import secrets
from flask import Flask

app = Flask(__name__)

# Generar una clave secreta criptográficamente segura
app.config['SECRET_KEY'] = secrets.token_hex(32)

# Configuraciones de seguridad esenciales
app.config['SESSION_COOKIE_SECURE'] = True
app.config['SESSION_COOKIE_HTTPONLY'] = True
app.config['SESSION_COOKIE_SAMESITE'] = 'Lax'

La clave secreta debe ser única, impredecible y mantenerse confidencial. Flask la utiliza para firmar cookies de sesión y tokens CSRF, por lo que su compromiso expone toda la aplicación.

Las configuraciones de cookies establecen barreras adicionales: SECURE garantiza transmisión solo por HTTPS, HTTPONLY previene acceso desde JavaScript, y SAMESITE mitiga ataques CSRF.

Gestión de sesiones seguras

Las sesiones en Flask almacenan información del usuario entre peticiones. Su implementación segura requiere atención a varios aspectos críticos.

from flask import session, request
from datetime import datetime, timedelta

@app.before_request
def make_session_permanent():
    session.permanent = True
    app.permanent_session_lifetime = timedelta(minutes=30)

@app.route('/login', methods=['POST'])
def login():
    # Validación de credenciales
    if validate_user(request.form['username'], request.form['password']):
        # Regenerar ID de sesión tras autenticación exitosa
        session.regenerate()
        session['user_id'] = user.id
        session['login_time'] = datetime.utcnow().isoformat()
        return redirect('/dashboard')
    
    return render_template('login.html', error='Credenciales inválidas')

La regeneración del identificador de sesión tras la autenticación previene ataques de fijación de sesión. Establecer un tiempo de vida limitado reduce la ventana de exposición en caso de compromiso.

Validación y sanitización de datos

La validación de entrada constituye la primera línea de defensa contra múltiples vectores de ataque. Flask-WTF proporciona herramientas robustas para este propósito.

from flask_wtf import FlaskForm
from wtforms import StringField, EmailField, PasswordField
from wtforms.validators import DataRequired, Email, Length, Regexp

class UserRegistrationForm(FlaskForm):
    username = StringField('Usuario', validators=[
        DataRequired(),
        Length(min=3, max=20),
        Regexp(r'^[a-zA-Z0-9_]+$', message='Solo letras, números y guiones bajos')
    ])
    
    email = EmailField('Email', validators=[
        DataRequired(),
        Email(message='Formato de email inválido')
    ])
    
    password = PasswordField('Contraseña', validators=[
        DataRequired(),
        Length(min=8, message='Mínimo 8 caracteres')
    ])

@app.route('/register', methods=['GET', 'POST'])
def register():
    form = UserRegistrationForm()
    
    if form.validate_on_submit():
        # Los datos han sido validados automáticamente
        user_data = {
            'username': form.username.data,
            'email': form.email.data,
            'password': hash_password(form.password.data)
        }
        create_user(user_data)
        return redirect('/login')
    
    return render_template('register.html', form=form)

Los validadores de WTForms verifican formato, longitud y patrones antes de que los datos lleguen a la lógica de negocio. Esta validación del lado del servidor es imprescindible, independientemente de cualquier validación JavaScript en el cliente.

Protección contra CSRF

Los ataques CSRF explotan la confianza que una aplicación tiene en el navegador del usuario. Flask-WTF incluye protección automática contra estos ataques.

from flask_wtf.csrf import CSRFProtect

csrf = CSRFProtect(app)

# Protección automática para formularios con FlaskForm
class TransferForm(FlaskForm):
    recipient = StringField('Destinatario', validators=[DataRequired()])
    amount = DecimalField('Cantidad', validators=[DataRequired()])

# Para peticiones AJAX, incluir token CSRF
@app.route('/api/transfer', methods=['POST'])
def api_transfer():
    # El token CSRF se valida automáticamente
    data = request.get_json()
    
    if not data or 'recipient' not in data:
        return jsonify({'error': 'Datos incompletos'}), 400
    
    # Procesar transferencia
    return jsonify({'status': 'success'})

El token CSRF debe incluirse en todas las peticiones que modifiquen estado. Para peticiones AJAX, el token se puede obtener desde una meta tag en el HTML:

<meta name="csrf-token" content="{{ csrf_token() }}">

Prevención de inyección SQL

La inyección SQL representa una de las vulnerabilidades más peligrosas en aplicaciones web. SQLAlchemy, el ORM más utilizado con Flask, proporciona protección natural cuando se usa correctamente.

from flask_sqlalchemy import SQLAlchemy
from sqlalchemy import text

db = SQLAlchemy(app)

# Forma SEGURA: usando el ORM
@app.route('/user/<int:user_id>')
def get_user(user_id):
    user = User.query.filter_by(id=user_id).first_or_404()
    return render_template('user.html', user=user)

# Forma SEGURA: consultas parametrizadas para SQL directo
@app.route('/search')
def search_users():
    query = request.args.get('q', '')
    
    # Usar parámetros nombrados
    result = db.session.execute(
        text("SELECT * FROM users WHERE username LIKE :pattern"),
        {'pattern': f'%{query}%'}
    )
    
    users = result.fetchall()
    return render_template('search_results.html', users=users)

Nunca construyas consultas SQL concatenando strings directamente. Los parámetros garantizan que los datos del usuario se traten como valores, no como código ejecutable.

Manejo seguro de archivos

La subida de archivos introduce vectores de ataque únicos que requieren validación exhaustiva tanto del contenido como de los metadatos.

import os
from werkzeug.utils import secure_filename
from werkzeug.datastructures import FileStorage

ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg', 'gif', 'pdf'}
MAX_FILE_SIZE = 5 * 1024 * 1024  # 5MB

def allowed_file(filename):
    return '.' in filename and \
           filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS

@app.route('/upload', methods=['POST'])
def upload_file():
    if 'file' not in request.files:
        return jsonify({'error': 'No se seleccionó archivo'}), 400
    
    file = request.files['file']
    
    if file.filename == '':
        return jsonify({'error': 'Nombre de archivo vacío'}), 400
    
    # Validaciones de seguridad
    if not allowed_file(file.filename):
        return jsonify({'error': 'Tipo de archivo no permitido'}), 400
    
    if len(file.read()) > MAX_FILE_SIZE:
        return jsonify({'error': 'Archivo demasiado grande'}), 400
    
    file.seek(0)  # Resetear puntero tras leer el tamaño
    
    # Sanitizar nombre de archivo
    filename = secure_filename(file.filename)
    
    # Generar nombre único para evitar colisiones
    unique_filename = f"{secrets.token_hex(8)}_{filename}"
    
    file_path = os.path.join(app.config['UPLOAD_FOLDER'], unique_filename)
    file.save(file_path)
    
    return jsonify({'filename': unique_filename}), 200

La función secure_filename elimina caracteres peligrosos del nombre del archivo. Generar nombres únicos previene tanto colisiones como ataques que dependan de nombres predecibles.

Autenticación y autorización

La autenticación verifica la identidad del usuario, mientras que la autorización determina qué acciones puede realizar. Flask-Login simplifica la gestión de usuarios autenticados.

from flask_login import LoginManager, UserMixin, login_required, current_user
from functools import wraps

login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = 'login'

class User(UserMixin, db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    role = db.Column(db.String(20), default='user')

@login_manager.user_loader
def load_user(user_id):
    return User.query.get(int(user_id))

# Decorador personalizado para autorización por roles
def role_required(role):
    def decorator(f):
        @wraps(f)
        @login_required
        def decorated_function(*args, **kwargs):
            if current_user.role != role:
                abort(403)
            return f(*args, **kwargs)
        return decorated_function
    return decorator

@app.route('/admin')
@role_required('admin')
def admin_panel():
    return render_template('admin.html')

Los decoradores de autorización proporcionan un mecanismo limpio para proteger rutas basándose en roles o permisos específicos.

Logging y monitoreo de seguridad

El logging de eventos de seguridad permite detectar y responder a intentos de ataque. Flask utiliza el sistema de logging estándar de Python.

import logging
from flask import request, g
from datetime import datetime

# Configurar logging de seguridad
security_logger = logging.getLogger('security')
handler = logging.FileHandler('security.log')
handler.setFormatter(logging.Formatter(
    '%(asctime)s - %(levelname)s - %(message)s'
))
security_logger.addHandler(handler)
security_logger.setLevel(logging.WARNING)

@app.before_request
def log_security_events():
    # Detectar intentos de acceso sospechosos
    suspicious_patterns = ['<script', 'union select', '../', 'cmd=']
    
    for param in request.args.values():
        for pattern in suspicious_patterns:
            if pattern.lower() in param.lower():
                security_logger.warning(
                    f"Patrón sospechoso detectado: {pattern} "
                    f"desde IP {request.remote_addr} "
                    f"en URL {request.url}"
                )

@app.errorhandler(403)
def forbidden(error):
    security_logger.warning(
        f"Acceso denegado a {request.url} "
        f"desde IP {request.remote_addr} "
        f"Usuario: {getattr(current_user, 'username', 'Anónimo')}"
    )
    return render_template('403.html'), 403

El monitoreo proactivo de patrones sospechosos en las peticiones ayuda a identificar ataques en curso y ajustar las defensas accordingly.