Regla
Prevenir común segmentación fallo patrones.
Nulo puntero desreferencias, búferes desbordamientos,
y uso después de libre errores causan fallos y seguridad de seguridad.

Lenguajes compatibles: C/C++

Introducción

Los fallos de segmentación siguen siendo la fuente más común de caídas y vulnerabilidades explotables en aplicaciones C/C++. Estas violaciones de acceso a memoria ocurren cuando el código intenta leer o escribir en memoria que no le pertenece, típicamente a través de desreferencias de punteros nulos, desbordamientos de búfer, punteros colgantes o acceso a memoria liberada. Un único segfault puede tumbar servidores de producción, pero peor aún, muchos patrones de segfault son explotables para la ejecución arbitraria de código.

Por qué es importante

Implicaciones de seguridad: Los desbordamientos de búfer y las vulnerabilidades de uso después de liberación (use-after-free) son la base de la mayoría de los exploits de corrupción de memoria. Los atacantes los aprovechan para sobrescribir direcciones de retorno, inyectar shellcode o manipular el flujo de control del programa. La vulnerabilidad Heartbleed de 2014 fue una lectura excesiva de búfer (buffer over-read). Los exploits modernos siguen apuntando a estos patrones porque proporcionan acceso directo a la memoria a los atacantes.

Estabilidad del sistema: Las fallas de segmentación bloquean su aplicación de inmediato sin una degradación elegante. En sistemas de producción, esto significa solicitudes perdidas, transacciones interrumpidas y estado corrupto. A diferencia de las excepciones de lenguajes de alto nivel que pueden ser capturadas, las fallas de segmentación terminan el proceso, requiriendo procedimientos de reinicio y recuperación.Expansión de la superficie de ataque: Cada desreferencia de puntero no verificada, strcpy, memcpy, o el acceso a arrays sin comprobación de límites es un punto de entrada potencial para la explotación. Los atacantes encadenan estas vulnerabilidades, utilizando una para corromper la memoria de formas que permiten explotar otra.

Ejemplos de código

❌ No conforme:

void process_user_data(const char* input) {
    char buffer[64];
    strcpy(buffer, input);  // No bounds checking

    char* token = strtok(buffer, ",");
    while (token != NULL) {
        process_token(token);
        token = strtok(NULL, ",");
    }
}

int* get_config_value(int key) {
    int* value = (int*)malloc(sizeof(int));
    *value = lookup_config(key);
    return value;  // Caller must free, but no documentation
}

Por qué es inseguro: El strcpy() la llamada provoca un desbordamiento de búfer si la entrada excede los 63 bytes, permitiendo a los atacantes sobrescribir la memoria de la pila. El get_config_value() la función filtra memoria en cada llamada y crea un riesgo de puntero colgante si quienes la llaman liberan la memoria mientras otro código aún la referencia.

✅ Conforme:

void process_user_data(const char* input) {
    if (!input) return;

    size_t input_len = strlen(input);
    char* buffer = malloc(input_len + 1);
    if (!buffer) return;

    strncpy(buffer, input, input_len);
    buffer[input_len] = '\0';

    char* token = strtok(buffer, ",");
    while (token != NULL) {
        process_token(token);
        token = strtok(NULL, ",");
    }

    free(buffer);
}

int get_config_value(int key, int* out_value) {
    if (!out_value) return -1;

    *out_value = lookup_config(key);
    return 0;  // Caller owns out_value memory
}

Por qué es seguro: Las comprobaciones de punteros nulos evitan fallos de desreferenciación. La asignación dinámica elimina los límites de tamaño de búfer fijos. La copia con comprobación de límites con strncpy() evita el desbordamiento. Semántica de propiedad clara en get_config_value() donde el llamador proporciona memoria para evitar confusiones en la asignación y fugas.

Conclusión

La seguridad de la memoria en C y C++ requiere programación defensiva en cada operación de puntero y asignación de memoria. Los fallos de segmentación no son inevitables, se pueden prevenir mediante comprobaciones de nulos consistentes, validación de límites y patrones claros de propiedad de la memoria. Detectar estos patrones antes de la producción previene tanto los fallos como las vulnerabilidades explotables.