Saltar al contenido

Lección 15 de 24 · Lectura y práctica

Principios de Seguridad en Rust

Concepto claveLa seguridad en Rust para sistemas críticos se basa en tres pilares fundamentales: seguridad de memoria garantizada por el compilador, concurrencia sin data races mediante el sistema de ownership, y verificación en.

Del concepto a la práctica

Taller de esta lección

La seguridad comienza con invariantes explícitas. Para un evento de orden, una invariante sencilla puede ser “el identificador no es cero y el volumen es positivo”. Validar al crear el valor evita que cada función posterior repita suposiciones y reduce caminos ambiguos.

Ejemplo resuelto

rust
struct Orden { id: u64, cantidad: u32 }
impl Orden {
    fn nueva(id: u64, cantidad: u32) -> Result<Self, &'static str> {
        if id == 0 || cantidad == 0 { Err("orden inválida") }
        else { Ok(Self { id, cantidad }) }
    }
}
fn main() { println!("{}", Orden::nueva(7, 3).is_ok()); }

La salida es true; Orden válida no puede construirse mediante ese constructor con datos inválidos.

Pruébalo

  1. Prueba id cero.

  2. Prueba cantidad cero.

  3. Conserva el Result.

  4. Usa solo órdenes válidas en el procesamiento.

Comprueba tu resultado

Error frecuente: validar solo en la interfaz y confiar en llamadas internas. Corrección: valida en el límite de creación del tipo.

Ejercicio: nueva(7,3) debe ser válida, nueva(0,3) y nueva(7,0) deben devolver Err("orden inválida").

El constructor protege solo llamadas que lo usan. Para impedir literales inválidos desde otros módulos, encapsula Orden con campos privados dentro de su módulo y expón nueva y getters. El mismo módulo aún puede romper invariantes: los tipos y pruebas deben acompañar la disciplina de API. Memoria segura no implica que una orden tenga permiso comercial o cumpla todos los límites de cuenta.

Diagrama de decisión con ramas Sí y No y un bucle que procesa cada elemento de una lista.
CursaloMapa de práctica
Cómo avanza un programa

Una condición decide qué camino ejecuta el programa. Un bucle repite una operación mientras queden elementos, y termina cuando la lista se agota. Separar ambas ideas ayuda a seguir el flujo y comprobar casos límite.

Ver la infografía en tamaño completo ↗
Fuentes para profundizar

Concepto clave

La seguridad en Rust para sistemas críticos se basa en tres pilares fundamentales: seguridad de memoria garantizada por el compilador, concurrencia sin data races mediante el sistema de ownership, y verificación en tiempo de compilación que elimina clases enteras de vulnerabilidades. En sistemas de baja latencia y alta seguridad, como sistemas de trading financiero o control industrial, un error de seguridad puede costar millones o poner vidas en riesgo.

Imagina construir un puente colgante: Rust actúa como el ingeniero que verifica cada cálculo estructural antes de que se fabrique el primer perno. El compilador inspeccica cada conexión de datos, cada acceso concurrente, y cada ciclo de vida de recursos, rechazando diseños inseguros. Esto contrasta con lenguajes como C++ donde los errores de seguridad a menudo se descubren durante pruebas o, peor, en producción.

Cómo funciona en la práctica

Veamos un ejemplo de cómo Rust previene vulnerabilidades comunes en sistemas críticos. Considera un sistema de procesamiento de transacciones financieras donde múltiples hilos acceden a datos compartidos:

use std::sync::{Arc, Mutex};
use std::thread;

struct Transaction {
    id: u64,
    amount: f64,
    timestamp: u64,
}

fn process_transactions(transactions: Arc>>) {
    let mut guard = transactions.lock().unwrap();
    // El compilador garantiza que solo este hilo tiene acceso exclusivo
    for tx in guard.iter_mut() {
        // Procesamiento seguro sin data races
        if tx.amount > 10000.0 {
            tx.amount *= 1.001; // Aplicar comisión
        }
    }
    // Al salir del scope, el Mutex se libera automáticamente
}

fn main() {
    let transactions = Arc::new(Mutex::new(vec![
        Transaction { id: 1, amount: 5000.0, timestamp: 1234567890 },
        Transaction { id: 2, amount: 15000.0, timestamp: 1234567891 },
    ]));
    
    let handles: Vec<_> = (0..4)
        .map(|_| {
            let txs = Arc::clone(&transactions);
            thread::spawn(move || process_transactions(txs))
        })
        .collect();
    
    for handle in handles {
        handle.join().unwrap();
    }
}

El sistema de ownership de Rust garantiza que:

  1. No hay accesos concurrentes no sincronizados (data races)
  2. La memoria se libera automáticamente cuando ya no se necesita
  3. Los punteros nulos o dangling no existen en código seguro

Caso de estudio

Consideremos un sistema de control de frenos automotriz donde la latencia y seguridad son críticas. En sistemas tradicionales escritos en C, errores como use-after-free o buffer overflows han causado fallos catastróficos. En Rust, implementaríamos:

Requisito de seguridadSolución en RustBeneficio
Respuesta en <10msUso de no_std y allocadores personalizadosSin overhead de runtime, latencia predecible
Sin corrupción de memoriaVerificación de bounds en arrays, lifetimes estrictosEliminación de buffer overflows en tiempo de compilación
Concurrencia seguraSend y Sync traits, channels de std::syncData races imposibles en código seguro
Validación de entradasTipos newtype y validación tempranaInvariantes mantenidas en todo el sistema
En pruebas de penetración realizadas por la NSA sobre sistemas críticos, Rust redujo vulnerabilidades de memoria en un 95% comparado con C/C++ en código base equivalente.

Errores comunes

Al desarrollar sistemas críticos en Rust, incluso programadores avanzados cometen estos errores:

  1. Abuso de unsafe por rendimiento: Usar bloques unsafe sin justificación real de medición. Solución: Medir primero, usar unsafe solo cuando sea necesario y documentar cada invariante.
  2. Ignorar el sistema de tipos para validación: Usar tipos primitivos donde tipos newtype mejorarían la seguridad. Ejemplo: struct Pressure(f64) en lugar de f64 para presión de frenos.
  3. Manejo incorrecto de errores en código concurrente: Usar unwrap() en producción en lugar de manejo de errores robusto con Result y ? operator.
  4. No considerar side-channels: En sistemas de alta seguridad, tiempos de ejecución pueden filtrar información. Usar operaciones de tiempo constante cuando sea necesario.
  5. Subestimar el borrow checker en sistemas complejos: Intentar luchar contra el compilador en lugar de rediseñar la arquitectura de datos.

Checklist de dominio

  • Puedo explicar cómo el sistema de ownership previene use-after-free sin garbage collector
  • Implementé un sistema concurrente con al menos 4 hilos que procesa datos compartidos sin data races
  • Identifiqué y justifiqué el uso de unsafe en una optimización real medida con benchmarks
  • Diseñé tipos que encapsulan invariantes de dominio (ej: temperaturas válidas, presiones seguras)
  • Implementé manejo de errores completo en un sistema que debe recuperarse de fallos sin perder datos
  • Optimicé un hot path para latencia sub-milisegundo manteniendo seguridad garantizada
  • Audité código Rust existente identificando potenciales violaciones de seguridad

Implementacion de un sistema de procesamiento de transacciones seguro y de baja latencia

Desarrolla un sistema que procese transacciones financieras con estos requisitos:

  1. Procesar 10,000 transacciones/segundo con latencia <1ms por transaccion
  2. Garantizar que ninguna transaccion se pierda o duplique
  3. Validar cada transaccion: monto positivo, ID unico, timestamp valido
  4. Implementar concurrencia segura con 4 workers
  5. Manejar errores graciosamente (transacciones invalidas se registran pero no procesan)

Pasos:

  1. Crea una estructura Transaction con campos: id: u64, amount: f64, timestamp: u128
  2. Implementa un validador que retorne Result<Transaction, ValidationError>
  3. Crea un channel MPSC (multiple producer, single consumer) para enviar transacciones a workers
  4. Implementa 4 workers que procesen transacciones concurrentemente
  5. Usa Arc<Mutex<Vec<Transaction>>> para resultados finales
  6. Mide el rendimiento con std::time::Instant
  7. Genera 10,000 transacciones de prueba (algunas invalidas)
Pistas
  • Considera usar crossbeam-channel para mejor rendimiento en canales
  • Implementa el trait From para convertir tipos de error
  • Usa rayon para paralelismo de datos si el procesamiento es CPU-bound

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Sigue con Rust para Trading: Concurrencia, Seguridad y Baja Latencia

Esta lección forma parte de un curso de Cursalo. Revisa su programa y elige entre la compra individual o el acceso a toda la escuela.

Si ya tenías acceso a este curso, entra con tu cuenta: tus derechos y tu progreso se conservan. No necesitas comprarlo de nuevo.

01 / ELEGIR UNA RUTA

El próximo paso

Aprende IA mientras construyes algo que sí necesitas.

Empieza por el curso inicial o explora el catálogo para encontrar una práctica alineada con tu trabajo.