Seguridad de aplicaciones Rust: top-10 vulnerabilidades para principiantes

Seguridad de aplicaciones Rust: top-10 vulnerabilidades para principiantes

Rust es considerado uno de los lenguajes de programación más seguros gracias a su sistema de propiedad (ownership) y su tipado estricto. Sin embargo, incluso en Rust se pueden cometer errores, especialmente al usar bloques unsafe o al trabajar incorrectamente con bibliotecas externas. En este artículo analizaremos las 10 principales vulnerabilidades que enfrentan los desarrolladores principiantes en Rust y mostraremos cómo evitarlas.

1. Uso inseguro de código unsafe

La principal característica de Rust es la seguridad de la memoria sin un recolector de basura. Sin embargo, la palabra clave unsafe desactiva parte de las verificaciones del compilador. Los novatos a menudo abusan de ella sin comprender las consecuencias.

// Peligroso: desreferenciar un puntero crudo sin verificación\nfn dangerous() {\n    let ptr = 0x12345 as *const i32;\n    unsafe {\n        println!("Valor: {}", *ptr); // Puede causar segfault\n    }\n}\n\n// Seguro: usamos métodos verificados\nfn safe() {\n    let x = 42;\n    let ptr = &x as *const i32;\n    unsafe {\n        if !ptr.is_null() {\n            println!("Valor: {}", *ptr);\n        }\n    }\n}

Recomendación: Use unsafe solo cuando sea realmente necesario, y siempre verifique que los punteros no sean nulos.

2. Fugas de memoria mediante Box::leak y ciclos con Rc

Aunque Rust previene la mayoría de las fugas de memoria, las referencias cíclicas con Rc o RefCell pueden provocar fugas. También es peligroso Box::leak, que "olvida" intencionalmente la memoria.

use std::rc::Rc;\nuse std::cell::RefCell;\n\n#[derive(Debug)]\nstruct Node {\n    value: i32,\n    next: Option<Rc<RefCell<Node>>>,\n}\n\nfn create_cycle() {\n    let a = Rc::new(RefCell::new(Node { value: 1, next: None }));\n    let b = Rc::new(RefCell::new(Node { value: 2, next: None }));\n    \n    // Creamos un ciclo: a -> b -> a\n    a.borrow_mut().next = Some(b.clone());\n    b.borrow_mut().next = Some(a.clone());\n    // ¡La memoria nunca se liberará!\n}

Solución: Use Weak<T> para romper referencias cíclicas o revise la arquitectura.

3. Condiciones de carrera (Data Races) en código multihilo

Rust garantiza la ausencia de condiciones de carrera en código seguro, pero con un uso incorrecto de unsafe o de los traits Send/Sync pueden surgir problemas.

use std::thread;\nuse std::sync::Arc;\nuse std::sync::Mutex;\n\n// Peligroso: compartir estado mutable sin sincronización\nfn data_race_example() {\n    let mut counter = 0;\n    let mut handles = vec![];\n    \n    for _ in 0..10 {\n        handles.push(thread::spawn(|| {\n            counter += 1; // Error de compilación: cannot borrow\n        }));\n    }\n}\n\n// Seguro: usamos Mutex\nfn safe_mutex() {\n    let counter = Arc::new(Mutex::new(0));\n    let mut handles = vec![];\n    \n    for _ in 0..10 {\n        let counter = Arc::clone(&counter);\n        handles.push(thread::spawn(move || {\n            let mut num = counter.lock().unwrap();\n            *num += 1;\n        }));\n    }\n}

4. Desbordamiento de búfer (Buffer Overflow)

En Rust, el desbordamiento de búfer es poco probable en código seguro, pero es posible al usar unsafe o al trabajar con FFI (Foreign Function Interface).

// Peligroso: copia insegura en un búfer\nfn unsafe_copy(src: &[u8], dst: &mut [u8]) {\n    unsafe {\n        std::ptr::copy_nonoverlapping(\n            src.as_ptr(),\n            dst.as_mut_ptr(),\n            src.len() // Si src.len() > dst.len() - ¡desbordamiento!\n        );\n    }\n}\n\n// Seguro: usamos slice::copy_from_slice\nfn safe_copy(src: &[u8], dst: &mut [u8]) {\n    if src.len() <= dst.len