Rust contra inyecciones SQL y XSS: escribiendo web de forma segura

¿Por qué Rust es el nuevo estándar de seguridad en la web?

Cuando se trata de seguridad web, muchos desarrolladores piensan inmediatamente en ORM, consultas preparadas y escape de HTML. Pero, ¿y si le dijera que el propio lenguaje de programación puede asumir la mayor parte de este trabajo? Eso es exactamente lo que hace Rust: un lenguaje que no perdona errores, pero tampoco permite cometerlos.

En este artículo, analizaremos cómo la seguridad de Rust se manifiesta en los dos ataques más críticos a aplicaciones web: inyecciones SQL y XSS (Cross-Site Scripting). Verá ejemplos de código reales, una comparación con Python y comprenderá por qué Rust se está convirtiendo en la opción número uno para proyectos donde el precio del error es la seguridad del usuario.

Cómo Rust previene las inyecciones SQL: de la teoría a la práctica

La inyección SQL es un clásico. Todos sabemos que debemos usar consultas preparadas. Pero en Rust, este patrón está integrado en la cultura del lenguaje a nivel de tipos y del sistema borrow checker.

Comparación de enfoques: Python vs Rust

Mire este código típico en Python que podría ser vulnerable:

# Python (peligroso)\nuser_input = "'; DROP TABLE users; --"\nquery = f"SELECT * FROM users WHERE name = '{user_input}'"\ncursor.execute(query)\n

Incluso si usa psycopg2, podría olvidar accidentalmente el escape. Rust, en cambio, le obliga a pensar de otra manera.

En Rust, con las bibliotecas sqlx o diesel, no puede simplemente insertar una cadena en una consulta: el sistema de tipos no lo permite:

// Rust con sqlx (seguro)\nuse sqlx::PgPool;\n\nlet user_input = "'; DROP TABLE users; --";\nlet user: Option<User> = sqlx::query_as(\n    "SELECT * FROM users WHERE name = $1"\n)\n.bind(&user_input) // Enlace type-safe\n.fetch_optional(&pool)\n.await?;\n

Observe $1 y .bind(). Rust no permite insertar un valor directamente en la cadena de la consulta. Esto no es solo una convención, es un requisito de compilación. La seguridad de Rust aquí se manifiesta en que físicamente no puede crear una inyección SQL si usa las bibliotecas correctas.

¿Por qué funciona a nivel de tipos?

En Rust, la cadena de la consulta y los datos son tipos diferentes. Bibliotecas como sqlx verifican las consultas en tiempo de compilación (compile-time checked queries). Si intenta hacer algo peligroso, el código simplemente no compilará:

// ¡Esto no compilará!\nlet query = format!("SELECT * FROM users WHERE name = '{}'", user_input);\nsqlx::query(&query); // Error: se espera &str, no String con interpolación\n

El sistema de propiedad (ownership) y préstamo (borrowing) no le permite "tragar" accidentalmente datos peligrosos. Esto no es magia, es disciplina de ingeniería integrada en el lenguaje.

Protección contra XSS: escape y verificación automática

XSS es cuando un atacante inyecta scripts en su HTML. En Rust, puede protegerse en varios niveles, y algunas verificaciones ocurren incluso antes de ejecutar el programa.

Motores de plantillas con escape automático

En Python, usa jinja2 con autoescape=true. En Rust, existen askama o maud que hacen lo mismo, pero con seguridad de tipos. Aquí hay un ejemplo con askama:

// Rust con askama (motor de plantillas)\nuse askama::Template;\n\n#[derive(Template)]\n#[template(source = "<h1>¡Hola, {{ name }}!</h1>", ext = "html")]\nstruct HelloTemplate {\n    name: String,\n}\n\nfn main() {\n    let t = HelloTemplate {\n        name: "<script>alert('XSS')</script>".to_string(),\n    };\n    let rendered = t.render().unwrap();\n    // Salida: <h1>¡Hola, &lt;script&gt;...</h1>\n    // ¡Las etiquetas se escapan automáticamente!\n}\n

Observe