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 renvoient
errno_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 <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 <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 <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
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). |