Fonctions de sécurité C

Dans le langage C, pour améliorer la sécurité du code, en particulier pour empêcher des problèmes de sécurité courants tels que le débordement de tampon, la norme C11 a introduit certainesfonctions sécurisées, également appeléesAnnexe Kfonctions de bibliothèque standard. Ces fonctions sécurisées sont principalement des versions améliorées des fonctions standard de manipulation de chaînes et de mémoire, offrant une meilleure détection et gestion des erreurs en ajoutant des paramètres (tels que la taille du tampon).

Caractéristiques des fonctions de sécurité :

  • Vérification de la taille du tamponToutes les fonctions sécurisées exigent que le paramètre de taille du tampon de destination soit passé pour éviter un débordement de tampon.
  • Vérification de la valeur de retour: La plupart des fonctions renvoienterrno_tLes codes d'erreur de ce type peuvent être vérifiés afin de déterminer si la fonction a été exécutée avec succès.
  • Meilleure gestion des erreurs: lorsque la taille du tampon est insuffisante ou que d'autres problèmes surviennent, ces fonctions renvoient un code d'erreur et tentent d'effacer ou d'initialiser le tampon de sortie.

Les fonctions sécurisées sont bien prises en charge dans des compilateurs tels que Visual Studio, mais peuvent ne pas être disponibles dans certaines versions plus anciennes de compilateurs, il faut donc prêter attention à la compatibilité.

Voici une comparaison des fonctions sécurisées courantes en C et de leurs fonctions traditionnelles correspondantes :

1. Fonctions sécurisées pour les opérations sur les chaînes

strcpy_s: version sécurisée de strcpy, copie la chaîne et vérifie la taille du tampon cible.

errno_t strcpy_s(char *dest, rsize_t destsz, const char *src);

strcat_sVersion sécurisée de strcat, ajoute la chaîne source à la fin de la chaîne de destination et vérifie la taille du tampon.

errno_t strcat_s(char *dest, rsize_t destsz, const char *src);

strncpy_s: version sécurisée de strncpy, copie jusqu'à n caractères et vérifie la taille du tampon.

errno_t strncpy_s(char *dest, rsize_t destsz, const char *src, rsize_t count);

strncat_sVersion sécurisée de strncat, ajoute au plus n caractères à la fin de la chaîne de destination et vérifie la taille du tampon.

errno_t strncat_s(char *dest, rsize_t destsz, const char *src, rsize_t count);

strtok_sVersion sécurisée de strtok, introduit un paramètre de contexte pour résoudre les problèmes de sûreté des threads.

char *strtok_s(char *str, const char *delim, char **context);

2. Fonctions sécurisées pour la sortie formatée

sprintf_sVersion sécurisée de sprintf, vérifie la taille du tampon lors du formatage de la sortie vers une chaîne.

int sprintf_s(char *buffer, rsize_t buffer_size, const char *format, ...);

snprintf_sVersion sécurisée de snprintf, limite le nombre de caractères et vérifie la taille du tampon lors de la sortie formatée.

int snprintf_s(char *buffer, rsize_t buffer_size, const char *format, ...);

vsprintf_sVersion sécurisée de vsprintf, accepte une liste d'arguments va_list et vérifie la taille du tampon.

int vsprintf_s(char *buffer, rsize_t buffer_size, const char *format, va_list argptr);

3. Fonctions de sécurité des opérations de mémoire

memcpy_s: Version sécurisée de memcpy, vérifie la taille du tampon cible lors de la copie d'une région mémoire.

errno_t memcpy_s(void *dest, rsize_t destsz, const void *src, rsize_t count);

memmove_s: Version sécurisée de memmove, copie des régions de mémoire, autorise le chevauchement et vérifie la taille du tampon cible.

errno_t memmove_s(void *dest, rsize_t destsz, const void *src, rsize_t count);

memset_sVersion sécurisée de memset, remplit le bloc de mémoire avec le caractère spécifié et vérifie la taille du tampon.

errno_t memset_s(void *dest, rsize_t destsz, int ch, rsize_t count);

4. Autres fonctions de sécurité courantes

_itoa_set_ultoa_sVersion sécurisée des fonctions de conversion d'entiers, vérifie la taille du tampon de destination lors de la conversion d'entiers en chaînes.

errno_t _itoa_s(int value, char *buffer, size_t buffer_size, int radix);
errno_t _ultoa_s(unsigned long value, char *buffer, size_t buffer_size, int radix);

_strlwr_set_strupr_sVersions sécurisées qui convertissent les chaînes en minuscules ou en majuscules.

errno_t _strlwr_s(char *str, size_t numberOfElements);
errno_t _strupr_s(char *str, size_t numberOfElements);

Exemple

Les exemples suivants montrent l'utilisation des fonctions sécurisées C pour les opérations sur les chaînes et les opérations de mémoire, démontrant comment elles évitent les problèmes courants de dépassement de tampon et offrent une approche de programmation plus sûre.

Exemple 1 : strcpy_s et strcat_s

Exemple

#include <stdio.h>
#include <string.h>

int main() {
    char dest[20]; // La taille du tampon de destination est 20
    const char *src = "Hello, World!";

    // Utiliser strcpy_s pour copier src dans dest
    if (strcpy_s(dest, sizeof(dest), src) != 0) {
        printf("strcpy_s a échoué !\n");
        return 1; // Retourner le code d'erreur
    } else {
        printf("Après strcpy_s : %s\n", dest);
    }

    // Utiliser strcat_s pour ajouter " C Language" à dest
    const char *appendStr = " C Language";
    if (strcat_s(dest, sizeof(dest), appendStr) != 0) {
        printf("strcat_s a échoué !\n");
        return 1; // Retourner le code d'erreur
    } else {
        printf("Après strcat_s : %s\n", dest);
    }

    return 0;
}

Sortie :

After strcpy_s: Hello, World!
strcat_s failed!

Dans le code ci-dessus, strcpy_s a copié avec succès la chaîne "Hello, World!" dans dest, mais comme dest a une taille de 20, ce qui est insuffisant pour contenir "Hello, World! C Language", strcat_s détectera que le tampon est insuffisant et renverra un code d'erreur.

Exemple 2 : memcpy_s

Exemple

#include <stdio.h>
#include <string.h>

int main() {
    char src[] = "Sensitive Data";
    char dest[15]; // La taille du tampon de destination est de 15

    // Utiliser memcpy_s pour copier les données vers dest
    if (memcpy_s(dest, sizeof(dest), src, strlen(src) + 1) != 0) {
        printf("memcpy_s failed!\n");
        return 1; // Retourner le code d'erreur
    } else {
        printf("After memcpy_s: %s\n", dest);
    }

    return 0;
}

Sortie :

After memcpy_s: Sensitive Data

Dans cet exemple, memcpy_s vérifie si le tampon de destination dest est suffisamment grand pour accueillir les données de src, y compris le caractère nul à la fin de la chaîne. Si destsz est inférieur à strlen(src) + 1, la fonction renvoie une erreur et n'effectue pas la copie de mémoire.

Exemple 3 : strtok_s

Exemple

#include <stdio.h>
#include <string.h>

int main() {
    char str[] = "apple,orange,banana";
    char *token;
    char *context = NULL;

    // Utiliser strtok_s pour diviser la chaîne
    token = strtok_s(str, ",", &context);
    while (token != NULL) {
        printf("Jeton : %s\n", token);
        token = strtok_s(NULL, ",", &context);
    }

    return 0;
}

Sortie :

Token: apple
Token: orange
Token: banana

Dans cet exemple, strtok_s utilise le paramètre context pour sauvegarder les informations de contexte lors du découpage de la chaîne, évitant ainsi le problème de non-sûreté vis-à-vis des threads de strtok.

Exemple 4 : sprintf_s

Exemple

#include <stdio.h>

int main() {
    char buffer[50];
    int num = 42;
    const char *str = "Bonjour";

    // Utiliser sprintf_s pour formater la chaîne et vérifier la taille du tampon
    if (sprintf_s(buffer, sizeof(buffer), "Nombre : %d, Chaîne : %s", num, str) < 0) {
        printf("sprintf_s a échoué !"\n");
        return 1; // Retourner le code d'erreur
    } else {
        printf("Chaîne formatée : %s\n", buffer);
    }

    return 0;
}

Sortie :

Formatted String: Number: 42, String: Hello

Ici, sprintf_s accepte la taille du tampon comme paramètre lors du formatage de la chaîne. Si la chaîne formatée dépasse la taille du tampon, la fonction renvoie une erreur, évitant ainsi un débordement de tampon.

Les exemples ci-dessus illustrent des manières d’utiliser les fonctions de sécurité C pour la copie de chaînes, la concaténation, la copie de mémoire, la découpe de chaînes et la sortie formatée. Ces fonctions fournissent des vérifications de taille de tampon, ce qui améliore considérablement la sécurité du code.


Manuel de référence

Les fonctions sécurisées sont principalement conçues pour prévenir les débordements de tampon. Ce type de vulnérabilité provient généralement du fait que les fonctions ne vérifient pas la taille du tampon de destination.

Les normes actuelles de fonctions sécurisées largement répandues proviennent principalement de l’annexe K (interfaces de vérification des limites) de la norme C11, ainsi que de versions améliorées fournies par divers systèmes d’exploitation (comme MSVC CRT sous Windows).

Le tableau suivant présente un tableau de référence des fonctions sécurisées C.

1. Traitement des chaînes

C’est le domaine le plus sujet aux débordements, et les fonctions sécurisées exigent généralement que la taille du tampon de destination soit passée en paramètre.

Fonction d’origine (non sécurisée) Fonctions de remplacement sécurisées Principales améliorations
strcpy strcpy_s Ajoute un paramètre de taille du tampon de destination ; si la chaîne source est trop longue, un gestionnaire de contraintes est appelé.
strcat strcat_s Ajoute un paramètre pour la taille de l'espace restant du tampon de destination afin d'éviter tout accès hors limites lors de la concaténation.
strncpy strncpy_s S'assurer que la chaîne cible se termine par\0à la fin, et ajout d'une vérification des erreurs à l'exécution.
strtok strtok_s Introduit un pointeur de contexte, ce qui le rendsûr pour les threadset plus robuste.
strlen strnlen_s Ajouter une longueur maximale de vérification pour éviter les boucles infinies dans des données erronées sans\0un terminateur nul.

2. Entrées/sorties formatées

Les fonctions de formatage non sûres peuvent entraîner des vulnérabilités de chaîne de format ou des débordements de tampon.

Fonction d’origine (non sécurisée) Fonctions de remplacement sécurisées Principales améliorations
sprintf snprintf / sprintf_s snprintfLimiter le nombre de caractères écrits ;sprintf_sVérifier la validité de la chaîne de format.
vsprintf vsnprintf_s Ajoute des limites de taille de tampon, adaptées aux listes d'arguments variables.
scanf scanf_s Pair%set%cspécificateurs de conversion, etc.,ForceNécessite de fournir la taille du tampon.
fscanf fscanf_s Ajouter une limite de longueur lors de la lecture d'une entrée de fichier.
sscanf sscanf_s Ajouter une limite de longueur lors de la lecture depuis une chaîne de caractères.

3. Entrée/sortie standard
Fonction d’origine (non sécurisée) Fonctions de remplacement sécurisées Principales améliorations
gets gets_s / fgets getsObsolète en C11.gets_sDoit spécifier la limite supérieure de lecture.
tmpnam tmpnam_s Ajoute la vérification de la taille du tampon pour les noms de fichiers temporaires générés.

4. Opérations sur la mémoire

Fonction d’origine (non sécurisée) Fonctions de remplacement sécurisées Principales améliorations
memcpy memcpy_s Ajoute la vérification de la taille du tampon de destination. En cas de chevauchement ou de dépassement, une erreur est renvoyée.
memmove memmove_s Ajoute la vérification de la limite de taille lors de la manipulation de régions de mémoire qui se chevauchent.
memset memset_s Garantit que le compilateur n'omet pas les opérations d'effacement de mémoire en raison de l'optimisation (couramment utilisées pour effacer des données sensibles telles que les mots de passe).
autres extensions