56 - Buenas practicas para un codigo seguro

56 - Buenas practicas para un codigo seguro

¡Bienvenidos de nuevo a Rustaceo.es! En esta entrega, nos enfocaremos en “Writing Secure Rust Code: Best Practices”. Aunque la seguridad es parte integral de Rust gracias a su sistema de propiedad y préstamos, existen casos y prácticas específicas que ayudan a reforzar aún más la robustez de nuestro código. Acompáñame mientras exploramos las mejores prácticas para escribir código seguro en Rust, utilizando ejemplos del mundo Pokémon para ilustrar los conceptos de manera cercana y entretenida.

1. Aprovéchate del sistema de propiedad y préstamos #

La propuesta central de Rust para la seguridad es su sistema de propiedad y préstamos. Este sistema previene errores comunes como:

  • Referencias nulas.
  • Fugas de memoria.
  • Condiciones de carrera en acceso concurrente.

Ejemplo: evitando condiciones de carrera #

Imagina que dos entrenadores, Ash y Misty, quieren entrenar al mismo Pokémon (por ejemplo, Item1) al mismo tiempo:

use std::thread;

struct Pokémon {
    nombre: String,
    nivel: u8,
}

fn main() {
    let item1 = Pokémon {
        nombre: String::from("Item1"),
        nivel: 25,
    };

    // Intentaríamos pasar referencias mutables simultáneamente (no compila):
    // let handle_ash = thread::spawn(|| subir_nivel(&mut item1));
    // let handle_misty = thread::spawn(|| subir_nivel(&mut item1));

    // Esto no compilará en Rust: evita condiciones de carrera a nivel de compilación.
}

fn subir_nivel(pokemon: &mut Pokémon) {
    pokemon.nivel += 1;
    println!("{} sube al nivel {}.", pokemon.nombre, pokemon.nivel);
}

Rust no permite referencias mutables compartidas simultáneamente desde distintos hilos sin protección adecuada (por ejemplo, usando tipos como Mutex o RwLock). Esta restricción evita que tu programa caiga en condiciones de carrera o corrupciones de memoria.

Buenas prácticas:

  • Deja que el compilador te guíe. Si Rust se queja de un préstamo, revisa por qué y ajusta tu diseño para seguir las reglas de propiedad.
  • Si necesitas mutar datos en concurrencia, usa tipos seguros para hilos como Arc<Mutex<T>> o Arc<RwLock<T>>.

2. Usa result y option para el manejo seguro de errores #

Rust no tiene throw y catch como otros lenguajes; en su lugar, utiliza el tipo Result<T, E> para indicar éxito o error, y Option<T> para valores opcionales. Esto fomenta que manejes los casos de error de forma explícita y segura.

Ejemplo: intentando capturar un pokémon # 

enum ErrorCaptura {
    PokeballRota,
    ElementoEscapo,
}

fn intentar_captura(probabilidad: f32) -> Result<&'static str, ErrorCaptura> {
    if probabilidad < 0.1 {
        Err(ErrorCaptura::PokeballRota)
    } else if probabilidad < 0.5 {
        Err(ErrorCaptura::ElementoEscapo)
    } else {
        Ok("¡Captura exitosa!")
    }
}

fn main() {
    match intentar_captura(0.3) {
        Ok(mensaje) => println!("{}", mensaje),
        Err(ErrorCaptura::PokeballRota) => {
            println!("La Poké Ball se rompió. ¡No se puede continuar!");
        }
        Err(ErrorCaptura::ElementoEscapo) => {
            println!("El Pokémon escapó, ¡intenta de nuevo!");
        }
    }
}

Buenas prácticas:

  • Maneja siempre tus Result: Usa match, el operador ? o combinaciones de métodos como unwrap_or_else para tratar todos los casos de error.
  • Evita usar unwrap() y expect() en producción, a menos que tengas la certeza de que jamás fallará.

3. Limita el uso de unsafe #

La palabra clave unsafe en Rust te permite desactivar algunos de los chequeos del compilador para hacer ciertas operaciones de bajo nivel (p. ej., desreferenciar punteros sin comprobación). Sin embargo, al usar unsafe, eres responsable de garantizar la seguridad manualmente.

Reglas de oro:

  • Usa unsafe solo cuando sea absolutamente necesario (por ejemplo, para FFI –enlaces con librerías en C– o accesos de memoria específicos).
  • Encapsula el código unsafe en funciones bien probadas y documentadas. Expón solo una API segura al resto de tu programa.

Ejemplo: evita unsafe salvo que sea ineludible # 

unsafe fn nivel_modificar(pokemon: *mut u8, nuevo_nivel: u8) {
    // Manipulación de punteros crudos:
    *pokemon = nuevo_nivel;
}

fn main() {
    // Ejemplo meramente ilustrativo. En Rust es mejor usar referencias y no punteros crudos.
}

Si no hay un motivo de fuerza mayor (por ejemplo, trabajar con hardware bajo nivel o librerías en C), hazlo con referencias seguras.

4. Ten cuidado con los smart pointers y la mutabilidad interior #

Rust ofrece smart pointers como Box<T>, Rc<T>, Arc<T>, Mutex<T>, RefCell<T>, etc. Estos facilitan la representación de datos complejos y compartidos, pero su uso indebido puede introducir ciclos de referencias o panics en tiempo de ejecución si se viola la disciplina de préstamos en RefCell.

Ejemplo: evita ciclos con rc y weak #

Cuando dos Pokémon se declaran mutuamente como amigos con Rc<Pokémon>, podrían generarse ciclos, impidiendo que Rust libere la memoria. Usa Weak para romper el ciclo.

use std::rc::{Rc, Weak};
use std::cell::RefCell;

struct Pokémon {
    nombre: String,
    amigo: RefCell<Weak<Pokémon>>,
}

fn main() {
    let item1 = Rc::new(Pokémon {
        nombre: String::from("Item1"),
        amigo: RefCell::new(Weak::new()),
    });
    let item2 = Rc::new(Pokémon {
        nombre: String::from("Item2"),
        amigo: RefCell::new(Weak::new()),
    });

    // Configuramos referencia débil para evitar ciclos fuertes:
    *item1.amigo.borrow_mut() = Rc::downgrade(&item2);
    *item2.amigo.borrow_mut() = Rc::downgrade(&item1);

    // Ahora no hay ciclo fuerte y Rust puede liberar la memoria cuando sea necesario.
}

Buenas prácticas:

  • Usa Rc en contextos de un solo hilo, Arc si es en multihilo.
  • Para mutabilidad interior, asegúrate de que RefCell no genere panic por préstamos incorrectos.
  • Mantén la mínima complejidad posible en estructuras de datos: si hay una forma más simple sin compartir propiedad, prefiérela.

5. Emplea tests y clippy para mejorar la calidad #

La seguridad no solo se basa en el manejo de memoria, sino en la correctitud de tu lógica. Rust facilita escribir tests unitarios y de integración, y Clippy es un linter que te aconseja sobre patrones que podrían ser inseguros o mejorables.

Ejemplo: test de una función de batalla pokémon # 

#[Cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_batalla() {
        let item1 = Pokémon {
            nombre: String::from("Item1"),
            nivel: 25,
        };
        let item2 = Pokémon {
            nombre: String::from("Item2"),
            nivel: 12,
        };

        let resultado = batalla(&item1, &item2);
        assert!(resultado.contains("gana"), "Item1 debería ganar.");
    }
}

Ventajas de Clippy:

  • Te alerta sobre posibles errores lógicos o patrones inseguros.
  • Sugiere buenas prácticas idiomáticas de Rust.

Ejecuta Clippy con:

cargo clippy

6. Considera crates y librerías de seguridad #

El ecosistema de Rust cuenta con crates (bibliotecas) muy fiables para criptografía, seguridad en redes y otras necesidades.

  1. ring: Para criptografía moderna.
  2. rustls: Para conexiones TLS seguras.
  3. sodiumoxide: Envoltorio para libsodium (cripto).

También es recomendable aplicar la filosofía de “lo más seguro posible” por defecto. Por ejemplo, si manejas contraseñas de entrenadores Pokémon, usa derivaciones de clave y almacenamiento encriptado en disco.

7. Mantén el código actualizado y haz auditorías #

Las dependencias en Rust se actualizan rápidamente. Una versión antigua de una crate podría contener vulnerabilidades. Revisa periódicamente cargo audit para detectar dependencias inseguras:

cargo install cargo-audit
cargo audit

Otras sugerencias:

  • Lee el CHANGELOG de las crates que uses para ver si hay parches críticos de seguridad.
  • Participa en la comunidad o revisa foros y repositorios en busca de “Security Advisories”.

Conclusión #

Rust te brinda un alto nivel de seguridad por defecto gracias a su sistema de propiedad y préstamos, manejo explícito de errores y tipado estático. Aun así, es fundamental seguir buenas prácticas para no introducir problemas sutiles en la lógica o en interacciones complejas.

Puntos Clave:

  • Haz que el compilador sea tu aliado: confía en sus advertencias y mensajes de error.
  • Maneja errores y valores opcionales con Result y Option, evitando unwrap excesivo.
  • Limita el uso de unsafe y encapsula cuidadosamente el código peligroso.
  • Testea tu código y utiliza herramientas como Clippy y cargo audit.
  • Mantente al tanto de las actualizaciones y vulnerabilidades en tus dependencias.

Al seguir estas mejores prácticas, tu proyecto en Rust, sea un pequeño prototipo o un sistema de batalla Pokémon a gran escala, estará bien encaminado hacia la robustez y la seguridad que Rust promete. ¡Sigue codificando y protegiendo a tus Pokémon (y tus usuarios) con código seguro!

Recursos adicionales #

Si tienes preguntas, comentarios o deseas compartir tus propias experiencias asegurando tu código Rust, ¡deja un mensaje abajo!

Hasta la próxima en Rustaceo, donde continuaremos descubriendo la potencia y seguridad que Rust ofrece para tus proyectos. Mantén a tus Pokémon y a tus usuarios seguros con las mejores prácticas de programación. ¡A programar con la fuerza y la solidez de Rust!