La seguridad del software es un tema que adquiere cada vez más relevancia en un mundo cada vez más digitalizado y dependiente de sistemas tecnológicos. Con la creciente complejidad de las aplicaciones y la diversidad de dispositivos conectados, la necesidad de contar con softwares robustos y resistentes a ataques es primordial. En este contexto, el lenguaje de programación Rust ha emergido como una solución prometedora para mitigar riesgos de seguridad inherentes a ciertas prácticas de codificación, sobre todo en sistemas críticos. Pero, ¿realmente usar Rust hace nuestro software más seguro? Para responder esta pregunta es fundamental revisar ejemplos concretos, analizar las propiedades técnicas del lenguaje y considerar investigaciones recientes que nos arrojan luz sobre este asunto. Para entender el impacto real de Rust en la seguridad del software, vale la pena examinar un caso emblemático que puso en evidencia los riesgos asociados al desarrollo con lenguajes tradicionales, especialmente C.
En 2021 se descubrió una vulnerabilidad crítica en el sistema operativo en tiempo real Nucleus, fabricado por Siemens y utilizado en más de 3 mil millones de dispositivos, incluyendo máquinas de ultrasonido, sistemas de almacenamiento y equipos para aviación. Este software debía operar en ambientes donde cualquier fallo podría tener consecuencias graves, sin embargo, un error en el manejo de respuestas DNS permitía a atacantes sobrescribir ubicaciones de memoria sensibles. Este fallo podía provocar desde un simple bloqueo de dispositivo hasta la reprogramación maliciosa del mismo. El núcleo de la vulnerabilidad estaba en cómo Nucleus procesaba respuestas DNS, confiando implícitamente en la entrada externa sin validarla de manera rigurosa. Cuando un atacante introducía respuestas DNS intencionalmente defectuosas, el sistema le permitía acceder a zonas de memoria que no debía, generando vulnerabilidades explotables.
Este caso, junto con otras cuatro bibliotecas de red vulnerables con problemas similares, se agruparon bajo el nombre colectivo de NAME:WRECK, señalando así un patrón común de fallos en la forma en la que el código de red fue escrito clásicamente. Al recibir este desafío por parte de consultores en seguridad, ingenieros decidieron realizar un experimento para comprobar si Rust podría evitar este tipo de vulnerabilidades. La hipótesis planteada no se quedó solo en la teoría de que “Rust es memory safe”, sino que también se enfocó en demostrar beneficios adicionales que el lenguaje podría aportar en escenarios reales, incluyendo la facilidad para detectar errores mediante pruebas, la reducción de gastos temporales y económicos en desarrollo y mantenimiento, y la garantía de que los errores no lleven a un fallo catastrófico del sistema. El experimento consistió en ofrecer a varios ingenieros un ejercicio basado en la codificación de un decodificador de nombres de dominio conforme a la RFC1035, el estándar que define la representación de nombres DNS. Para simular condiciones adversas que propician errores, como la falta de instrucciones completas y tiempo limitado, se retó a profesionales y pasantes a implementar esta funcionalidad.
Paralelamente, se prepararon un conjunto de pruebas estresantes y un fuzzer diseñado para revelar errores potenciales similares a los encontrados en Nucleus. Los resultados fueron reveladores. Mientras que el código original en C de Nucleus fallaba en diversos escenarios, llegando incluso a condiciones de bucle infinito o memoria corrupta que generaban vulnerabilidades explotables, las implementaciones en Rust se mostraron mucho más resilientes. Ninguna implementación en Rust permitió vulnerabilidades de ejecución arbitraria de código o corrupciones fatales, y en los pocos casos en que la entrada era inválida, el código Rust respondía con errores recuperables, evitando fallos críticos. Esto se debe en gran parte a que Rust impone una gestión estricta de memoria y alienta la escritura de código idiomático y seguro mediante su sistema de tipos y verificación en tiempo de compilación.
Además, todos los ingenieros que trabajaron con Rust usaron herramientas de pruebas automatizadas y fuzz testing que permitieron detectar y corregir errores en el proceso de desarrollo, algo que resulta menos sencillo en C y C++. En términos de eficiencia, el desarrollo en Rust también resultó ser más rápido comparado con una versión segura en C, que requirió al menos tres veces más tiempo para alcanzar un nivel de seguridad similar, un factor clave para reducir costos a largo plazo. La razón por la cual Rust contribuye a esta seguridad robusta puede encontrarse en sus características técnicas. A diferencia de C, que permite acceso indiscriminado a memoria y carece de mecanismos automáticos de verificación, Rust ofrece garantías de seguridad en tiempo de compilación que evitan problemas clásicos como desbordamientos de buffer, uso de punteros nulos o memoria libreada, y condiciones de carrera. Su arquitectura promueve la validación explícita de la entrada externa y trata de hacer inviables las acciones peligrosas antes de que el software siquiera se ejecute.
Para ilustrar esta ventaja, consideremos la función simplificada en C que decodifica un nombre DNS con formato RFC1035. En esta función se omiten controles esenciales como el tamaño del buffer o la validez de los bytes de longitud, exponiendo la función a sobrescrituras y lecturas fuera de límites que derivan en vulnerabilidades. El código Rust equivalente, por el contrario, implementa validaciones explícitas para cada segmento, limita el tamaño de salida y captura errores mediante el tipo Option. En un entorno real, estas diferencias podrían significar evitar accesos ilegítimos a memoria, fallos de software y ataques remotos. El manejo de la compresión en los nombres DNS, un aspecto delicado especificado en RFC1035, es otro ejemplo donde Rust brilla.
En C, el cálculo y desplazamiento de punteros puede derivar en bucles infinitos o referencias a memorias inválidas si la entrada está manipulada maliciosamente. En Rust, un control de rango riguroso y validaciones en cada paso evitan que dichas desviaciones ocurran, ayudando a asegurar la estabilidad del software. Sin embargo, no todo es perfecto o sencillo. La adopción de Rust en sistemas embebidos o en tiempo real presenta retos, como la gestión del heap en entornos con recursos limitados. Afortunadamente, la evolución del lenguaje ha incorporado soluciones como heapless::Vec que permiten controlar la alocación de memoria explícitamente, facilitando usos en este tipo de sistemas y manteniendo las garantías de seguridad.
El caso de Nucleus también revela una lección importante sobre cómo el enfoque de Rust fomenta mejores prácticas de desarrollo. La capacidad intrínseca para escribir pruebas unitarias y fuzzing promueve que los programadores piensen desde el inicio en escenarios límites, lo que eleva la calidad y robustez del producto final. Esta cultura de testing contribuye a mitigar riesgos y a capturar errores en etapas tempranas, reduciendo costos y retrasos. Por otro lado, el estudio demuestra que muchas vulnerabilidades derivan de confiar implícitamente en la entrada externa sin validación estricta y de usar herramientas que no ayudan a prevenir errores sino a ocultarlos. Rust ataca estas causas raíz imponiendo un modelo de propiedad de datos y validación que elimina gran parte del margen para errores inadvertidos.
