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 fallos y vulnerabilidades explotables en aplicaciones C/C++. Estas violaciones de acceso a memoria se producen cuando el código intenta leer o escribir memoria que no le pertenece, normalmente a través de desviaciones de punteros nulos, desbordamientos de búfer, punteros colgantes o acceso a memoria liberada. Un solo segfault puede hacer caer los servidores de producción, pero lo que es peor, muchos patrones de segfault son explotables para la ejecución de código arbitrario.

Por qué es importante

Implicaciones para la seguridad: Los desbordamientos de búfer y las vulnerabilidades "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 código shell o manipular el flujo de control del programa. La vulnerabilidad Heartbleed de 2014 era una sobrelectura de búfer. Los exploits modernos siguen centrándose en estos patrones porque proporcionan acceso directo a la memoria a los atacantes.

Estabilidad del sistema: Los fallos de segmentación bloquean la aplicación inmediatamente sin degradación gradual. En los sistemas de producción, esto significa que se pierden peticiones, se interrumpen transacciones y se corrompe el estado. A diferencia de las excepciones de lenguajes de alto nivel, que pueden ser capturadas, los fallos de segmentación terminan el proceso, requiriendo procedimientos de reinicio y recuperación.Ampliación de la superficie de ataque: Cada desviación de puntero no comprobada, strcpy, memcpyo el acceso a matrices 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 forma que permitan explotar otra.

Ejemplos de códigos

❌ 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: En strcpy() provoca un desbordamiento del búfer si la entrada supera los 63 bytes, lo que permite a los atacantes sobrescribir la memoria de la pila. La dirección get_config_value() pierde memoria en cada llamada y crea un riesgo de puntero colgante si los que llaman liberan la memoria mientras otro código sigue haciendo referencia a ella.

✅ 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: La comprobación de punteros nulos evita fallos por desreferencia. La asignación dinámica elimina los límites fijos de tamaño de los búferes. Copia con comprobación de límites con strncpy() evita el desbordamiento. Despejar la semántica de propiedad en get_config_value() donde la persona que llama proporciona memoria evita confusiones de asignación y fugas.

Conclusión

La seguridad de memoria en C y C++ requiere una 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. La detección de estos patrones antes de la producción evita tanto fallos como vulnerabilidades explotables.