Règle
Empêcher commun segmentation de segmentation modèles.
Pointeur pointeur déréférences, débordements débordements de mémoire tampon,
et erreurs de type "use-after-free erreurs provoquent plantages et sécurité sécurité.

Langues prises en charge : C/C++

Introduction

Les fautes de segmentation restent la source la plus courante de pannes et de vulnérabilités exploitables dans les applications C/C++. Ces violations d'accès à la mémoire se produisent lorsque le code tente de lire ou d'écrire de la mémoire qu'il ne possède pas, généralement par le biais de déréférencements de pointeurs nuls, de débordements de mémoire tampon, de pointeurs pendants ou d'accès à de la mémoire libérée. Un seul défaut de ségrégation peut entraîner l'arrêt des serveurs de production, mais pire encore, de nombreux modèles de défauts de ségrégation peuvent être exploités pour l'exécution de codes arbitraires.

Pourquoi c'est important

Implications en matière de sécurité : Les débordements de mémoire tampon et les vulnérabilités de type "use-after-free" sont à la base de la plupart des exploits de corruption de mémoire. Les attaquants les exploitent pour écraser les adresses de retour, injecter du shellcode ou manipuler le flux de contrôle du programme. La vulnérabilité Heartbleed de 2014 était une lecture excessive de la mémoire tampon. Les exploits modernes ciblent toujours ces modèles parce qu'ils permettent aux attaquants d'accéder directement à la mémoire.

Stabilité du système : Les erreurs de segmentation provoquent un crash immédiat de votre application, sans dégradation gracieuse. Dans les systèmes de production, cela se traduit par des requêtes abandonnées, des transactions interrompues et des états corrompus. Contrairement aux exceptions des langages de plus haut niveau qui peuvent être rattrapées, les erreurs de segmentation mettent fin au processus, ce qui nécessite des procédures de redémarrage et de récupération.Extension de la surface d'attaque : Chaque déréférencement de pointeur non vérifié, strcpy, memcpyou l'accès à un tableau sans vérification des limites est un point d'entrée potentiel pour l'exploitation. Les attaquants enchaînent ces vulnérabilités, en utilisant l'une d'entre elles pour corrompre la mémoire de manière à pouvoir en exploiter une autre.

Exemples de code

❌ Non 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
}

Pourquoi ce n'est pas sûr : Le strcpy() provoque un débordement de tampon si l'entrée dépasse 63 octets, ce qui permet aux attaquants d'écraser la mémoire de la pile. L'appel get_config_value() laisse échapper de la mémoire à chaque appel et crée un risque de dangling pointer si les appelants libèrent la mémoire alors que d'autres codes y font encore référence.

✅ 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
}

Pourquoi c'est sûr : La vérification des pointeurs nuls permet d'éviter les accidents dus au déréférencement. L'allocation dynamique élimine les limites de taille des tampons fixes. La copie avec contrôle des limites avec strncpy() évite les débordements. La sémantique de propriété claire dans get_config_value() où l'appelant fournit la mémoire afin d'éviter les confusions et les fuites d'allocation.

Conclusion

La sécurité de la mémoire en C et C++ nécessite une programmation défensive à chaque opération de pointeur et d'allocation de mémoire. Les erreurs de segmentation ne sont pas inévitables, elles peuvent être évitées grâce à des contrôles de nullité cohérents, à la validation des limites et à des modèles clairs de propriété de la mémoire. La détection de ces schémas avant la production permet d'éviter à la fois les plantages et les vulnérabilités exploitables.