Fase 3: Comunicaciones y Redes Industriales

📖 Teoría a Estudiar

El Análisis Estático (Static Code Analysis)

Se llama "Estático" porque analiza tu código fuente sin necesidad de compilarlo ni ejecutarlo en el hardware físico. Es un software de auditoría algorítmica. Un Linter (como Cppcheck o PC-Lint) lee tu código, rastrea cada variable, simula todos los caminos posibles de cada condicional (IF/ELSE) e intenta matemáticamente probar si puedes destruir la memoria.

El Estándar MISRA C

El lenguaje C fue diseñado para escribir Sistemas Operativos de forma rápida, no de forma segura. Tiene Comportamientos Indefinidos (Undefined Behavior). Para solucionar esto, las empresas automotrices y aeroespaciales crearon el estándar MISRA C (Motor Industry Software Reliability Association). Es un conjunto de reglas draconianas que debes seguir para escribir C.

Por ejemplo, MISRA C prohíbe el uso de la memoria dinámica (malloc/free) porque puede causar fragmentación a largo plazo. Exige que todo bloque `if` tenga sus llaves `{}`. Prohíbe declarar variables sin inicializarlas. Un Linter escanea tu código en busca de violaciones a estas reglas.

⚙️ Ejercicios Prácticos

Ejercicio 1: Analizaremos una función real del módulo Modbus de nuestro Despachador. Veremos cómo el "Código Sucio" compila sin errores pero es una bomba de tiempo. Luego veremos lo que un Linter como Cppcheck nos gritaría en la pantalla, y finalmente refactorizaremos hacia un "Código Limpio" que cumpla con el estándar industrial.

1. El Código Sucio (Vulnerable)

Este código engaña al compilador. Compilará con 0 Warnings, pero si un paquete Modbus llega con un tamaño malicioso reportado de `15`, destruirá la memoria RAM vecina al arreglo.

// =======================================================
// CÓDIGO PELIGROSO (No pasaría auditoría)
// =======================================================
#include <stdint.h>

void Procesar_Paquete_Modbus(uint8_t *datos_recibidos, uint8_t tamaño_reportado) {
    
    // 1. Variable no inicializada (MISRA C Rule 9.1)
    // El arreglo contendrá basura aleatoria de la RAM.
    uint8_t buffer_local[10]; 
    
    // 2. Variable declarada pero no inicializada
    int i; 
    
    // 3. Vulnerabilidad crítica de Buffer Overflow
    // Si 'tamaño_reportado' es 15, escribiremos fuera del buffer de 10.
    for (i = 0; i < tamaño_reportado; i++) {
        buffer_local[i] = datos_recibidos[i];
    }
    
    // 4. Posible desreferenciación de Puntero Nulo (Null Pointer Dereference)
    // ¿Qué pasa si 'datos_recibidos' llega como NULL? El sistema hará un HardFault.
    uint8_t checksum = datos_recibidos[tamaño_reportado - 1];
}
        

2. El Reporte del Linter (Output Simulado)

Si ejecutamos la herramienta cppcheck --enable=all --rule-file=misra.txt main.c, el motor estático detendrá el proceso de integración continua y nos arrojará esto:

[modbus.c:16]: (error) Array 'buffer_local[10]' accessed at index 14, which is out of bounds.
[modbus.c:13]: (warning) Uninitialized variable: i
[modbus.c:10]: (style) [MISRA C 2012 Rule 9.1] Automatic variable 'buffer_local' is not initialized.
[modbus.c:22]: (error) Null pointer dereference: datos_recibidos. Missing NULL check.
        

3. El Código Limpio (Seguro e Industrial)

Refactorizamos aplicando Programación Defensiva (Defensive Programming) para apaciguar al Linter y garantizar la seguridad vitalicia de la máquina.

// =======================================================
// CÓDIGO LIMPIO (MISRA C Compliant)
// =======================================================
#include <stdint.h>
#include <stddef.h> // Para obtener 'NULL'

#define MAX_PAYLOAD_SIZE 10U

void Procesar_Paquete_Modbus(const uint8_t *datos_recibidos, uint8_t tamaño_reportado) {
    
    // 1. Guard Clause: Verificación estricta de Punteros Nulos
    // El 'const' en la firma garantiza que la función no modificará el arreglo origen accidentalmente.
    if (datos_recibidos == NULL) {
        return; // Abortar de inmediato
    }
    
    // 2. Guard Clause: Prevención matemática de Buffer Overflow
    if (tamaño_reportado > MAX_PAYLOAD_SIZE) {
        return; // Abortar ataque malicioso o ruido
    }
    
    // 3. Inicialización absoluta (Zero-Initialization)
    // Garantiza un estado determinista limpio (Regla MISRA 9.1)
    uint8_t buffer_local[MAX_PAYLOAD_SIZE] = { 0U };
    
    // 4. Declaración de iterador en el ámbito local más reducido posible (C99)
    for (uint8_t i = 0U; i < tamaño_reportado; i++) {
        buffer_local[i] = datos_recibidos[i];
    }
    
    // El sistema ahora es matemáticamente inquebrantable.
    // ... (Procesamiento del payload seguro)
}
        

📝 Resumen del Día

• El compilador de C es permisivo por naturaleza; traduce sintaxis válida a ensamblador sin importarle si la lógica subyacente puede causar fallas destructivas de memoria en Tiempo de Ejecución.
• El **Análisis Estático (Static Code Analysis)** es una herramienta que lee el código fuente antes de la compilación y deduce todos los caminos de ejecución posibles, detectando cuellos de botella lógicos, variables no inicializadas y divisiones por cero.
• MISRA C es el conjunto de reglas más estricto del mundo para la escritura en C. Prohíbe construcciones ambiguas y fuerza la inicialización y el chequeo paranoico de límites.
• Los **Guard Clauses (Cláusulas de Guardia)** son declaraciones `if` al inicio de las funciones que verifican los peores escenarios (`NULL pointers`, tamaños fuera de rango) y abortan la función prematuramente, simplificando la indentación y blindando el proceso.