SecCode/Rust

Examen final: Lo que debes saber

Temas

  1. Conceptos generales de programación con Rust
    1. Casos de uso, ventajas y desventajas del lenguaje
    2. Variables y mutabilidad
    3. Tipos de datos primitivos y sus operadores
    4. Funciones
    5. Ciclos y condiciones
    6. Tuplas
    7. Enumeraciones
    8. Estructuras
    9. Rasgos (traits) y sus implementaciones
    10. Funciones anónimas y clausuras (closures)
  2. Manejo general de errores en Rust
    1. Concepto de panic
    2. Enumeraciones Option y Result
    3. Uso de enunciados match y if let para procesar errores
    4. Métodos expect, unwrap, unwrap_or y unwrap_or_else
  3. Seguridad de memoria en Rust
    1. Concepto de propiedad (ownership) y movimientos
    2. Referencias y prestamos (borrowing)
    3. Tipos String, &str y Vec
    4. Colecciones, los métodos into_iter, iter e iter_mut, y los enunciado for equivalentes
    5. Rebanadas (slices)
    6. Rasgos Copy y Clone
  4. Aritmética segura en Rust
    1. Números enteros
      1. Concepto de desbordamiento aritmético entero
      2. Rangos de valores enteros con y sin signo
      3. Aritmética envolvente (wraparound) y saturada
      4. Métodos checked_*, overflowing_*, saturating_* y wrapping_*
    2. Números de punto flotantes
      1. Aproximación de igualdad: macro approx::relative_eq!
      2. Valores especiales de punto flotante IEEE 754 (NaN, +Inf, -Inf, 0.0 y -0.0) y las operaciones que los producen
    3. Conversión entre tipos numéricos
      1. Concepto de desbordamiento, truncamiento y pérdida de precisión al convertir entre enteros y flotantes
      2. Operador as y método try_into para realizar conversiones entre tipos numéricos
      3. Métodos de redondeo: round, floor y ceil
  5. Fallos famosos de software
    Generalidades de los siguientes errores y cómo se pudieron haber evitado:
    1. Ariane 5 Flight 501 Explosion
    2. CrowdStrike Falcon Sensor Outage
    3. Gangnam Style YouTube Counter Overflow
    4. Heartbleed Vulnerability
    5. Intel Pentium FDIV Bug
    6. Morris Worm
    7. Patriot Missile Time Truncation Error
    8. Therac-25 Radiation Overdoses
    9. Y2K Bug

Artículos permitidos durante el examen

NOTA: Una vez iniciado el examen, no se permite compartir ningún artículo con alguien más.

  1. Pluma, lápiz, borrador, sacapuntas.

  2. Calculador científica sencilla. No está permitido usar teléfono celular, calculadora programable, tableta, computadora o cualquier otro dispositivo electrónico.

  3. Acordeón personal de estudio con las siguientes características:


    1. Debe ser uno de los siguientes:

      • Tarjeta o ficha de trabajo de \(5 \times 8\) pulgadas (\(12.7 \times 20.32\) cm).

      • Media hoja tamaño carta (\(13.97 \times 21.59\) cm).

    2. Debe estar escritas a mano. No se permiten tarjetas/hojas impresas elaboradas en computadora.

    3. Está permitido escribir en ambos lados de la tarjeta/hoja.

    4. Debe incluir matrícula y nombre completo en la esquina superior izquierda de ambos lados de la tarjeta/hoja.

    5. No hay restricciones sobre el contenido específico escrito en la tarjeta/hoja.


Ejemplos de pregunta

  1. Según Microsoft, ¿qué porcentaje de sus vulnerabilidades de software está relacionado con problemas de seguridad de memoria?

    1. 3%
    2. 12%
    3. 37%
    4. 70%
    5. 99%

  2. Se trata de un problema de memoria en el que se escriben datos fuera de los límites de un arreglo.

    1. Memory leak
    2. Buffer overflow
    3. Race condition
    4. Stack overflow
    5. Fandango on core

  3. ¿Cuál de las siguientes áreas es un caso de uso primario y destacado para Rust, dada su combinación única de seguridad de memoria, concurrencia y alto rendimiento?

    1. Programación de sistemas de bajo nivel, sistemas operativos, firmware y desarrollo de backends de alto rendimiento
    2. Desarrollo de scripts de shell para automatización
    3. Modelado de datos en bases de datos relacionales tradicionales
    4. Aplicaciones web de front-end con interfaz de usuario complejas
    5. Aplicaciones de Inteligencia Artificial (IA) donde la velocidad de inferencia no es crítica

  4. En Rust, por defecto, las variables son:

    1. De tipo String, pero no i32
    2. Siempre declaradas como let mut
    3. Tipos que implementan el rasgo Copy
    4. Mutables, lo que significa que su valor puede cambiar después de la inicialización
    5. Inmutables, lo que significa que su valor no puede cambiar después de la inicialización a menos que se use la palabra clave mut

  5. En Rust, cuando se pasa un objeto (que no implementa Copy) a una función por valor, ¿qué ocurre por defecto con el concepto de propiedad (ownership)?

    1. Se produce un error de compilación
    2. El objeto original se vuelve mutable dentro de la función
    3. Se crea una referencia inmutable (préstamo) al objeto original
    4. La propiedad (ownership) se mueve al nuevo ámbito de la función
    5. Se crea una copia profunda del objeto y la propiedad de esa copia se transfiere

  6. ¿Cuál es el resultado de compilar y correr (si es posible) el siguiente código de Rust? 

    fn main() {
    let data: Vec<i32> = vec![1, 2, 3];
    let mut sum: i32 = 0;
    for elem in &data {
        sum += *elem;
    }
    println!("{:?}:{}", data, sum);
}
    1. La salida del programa es: [1, 2, 3]:0
    2. La salida del programa es: [1, 2, 3]:6
    3. La salida del programa es: [1, 3, 6]:6
    4. El programa no compila
    5. El programa entra en pánico al momento de ejecutarse

  7. ¿Qué estructura de datos de Rust permite agrupar valores de diferentes tipos en una única unidad, con acceso a sus elementos por desestructuración o por índice numérico?

    1. Un vector
    2. Una tupla
    3. Un arreglo
    4. Una estructura
    5. Una enumeración

  8. ¿Cuál es el resultado de compilar y correr (si es posible) el siguiente código de Rust? 

    fn main() {
    let mut nombres: Vec<String> = vec![
        "b".to_string(),
        "c".to_string(),
        "a".to_string(),
        "e".to_string(),
        "d".to_string()];
    let mut todos: String = "".to_string();
    nombres.sort();
    for nombre in nombres {
        todos.push_str(&nombre);
    }
    println!("{:?}:{}", nombres, todos);
}
    1. La salida del programa es: ["a", "b", "c", "d", "e"]:abcde
    2. La salida del programa es: ["b", "c", "a", "e", "d"]:abcde
    3. La salida del programa es: ["b", "c", "a", "e", "d"]:bcaed
    4. El programa no compila
    5. El programa entra en pánico al momento de ejecutarse

  9. Para iterar sobre un Vec<T> y obtener referencias mutables a sus elementos, permitiendo modificarlos, ¿qué método de iteración se debe usar?

    1. clone()
    2. iter()
    3. iter_mut()
    4. into_iter()
    5. for_each()

  10. ¿Cuál es el resultado de compilar y correr (si es posible) el siguiente código de Rust? 

    fn main() {
    let x: u8 = 25;
    println!("{:?} {:?} {:?} {:?}",
        x.saturating_mul(x),
        x.wrapping_mul(x),
        x.checked_mul(x),
        x.overflowing_mul(x)
    );
}
    1. La salida del programa es: 255 113 None (113, true)
    2. La salida del programa es: 255 113 (113, false) None
    3. La salida del programa es: 625 Some(113) 113 (625, false)
    4. El programa no compila
    5. El programa entra en pánico al momento de ejecutarse

  11. El Gangnam Style YouTube Counter Overflow fue un ejemplo de desbordamiento aritmético. ¿Cómo se pudo haber evitado este fallo de software en el contador de vistas?

    1. Forzando un panic! cuando el contador se desborda
    2. Usando un tipo entero sin signo en lugar de uno con signo
    3. Usando un tipo de punto flotante en lugar de un tipo entero
    4. Utilizando un tipo entero de mayor capacidad (por ejemplo, de 32 bits a 64 bits)
    5. Usando aritmética envolvente (wrapping_*) para que el contador volviera a cero

  12. ¿Cuál fue la causa principal del fallo de software que llevó a la explosión del cohete Ariane 5 Flight 501?

    1. Un panic! intencional en el código de navegación
    2. Una condición de carrera debido a la concurrencia no segura
    3. Un error de conversión de tipos al intentar usar un Result incorrectamente
    4. Una falla de seguridad de memoria (buffer overflow) debido a punteros inseguros
    5. Un error de desbordamiento de enteros (integer overflow) al convertir un número de punto flotante de 64 bits a un entero de 16 bits sin manejo adecuado de errores

Respuestas

  1. d
  2. b
  3. a
  4. e
  5. d
  6. b
  7. b
  8. d
  9. c
  10. a
  11. d
  12. e