Fonctionnalités de sécurité dans le CRT

De nombreuses anciennes fonctions CRT ont de nouvelles versions plus sécurisées. Si une fonction sécurisée existe, l’ancienne version moins sécurisée est marquée comme déconseillée. La nouvelle version a le _s suffixe (« secure ») .

Dans ce contexte, « déconseillé » signifie que l’utilisation de la fonction n’est pas recommandée. Cela ne signifie pas que la fonction sera supprimée du CRT.

Les fonctions sécurisées n’empêchent pas ou ne corrigent pas les erreurs de sécurité. Au lieu de cela, ils interceptent les erreurs lorsqu’elles se produisent. Ils effectuent des vérifications supplémentaires pour les conditions d’erreur. En cas d’erreur, ils appellent un gestionnaire d’erreurs (voir validation des paramètres).

Par exemple, la strcpy fonction ne peut pas indiquer si la chaîne qu’elle copie est trop grande pour la mémoire tampon de destination. Son équivalent sécurisé, strcpy_sprend la taille de la mémoire tampon en tant que paramètre. Par conséquent, il peut déterminer si un dépassement de mémoire tampon se produit. Si vous utilisez strcpy_s pour copier 11 caractères dans une mémoire tampon de 10 caractères, c’est une erreur de votre part ; strcpy_s ne peut pas corriger votre erreur. Toutefois, il peut détecter votre erreur et vous informer en appelant le gestionnaire de paramètres non valide.

Suppression des avertissements de désapprobation

Il existe plusieurs façons de supprimer les avertissements de désapprobation pour les anciennes fonctions moins sécurisées. Le plus simple est de définir _CRT_SECURE_NO_WARNINGS ou d’utiliser le warning pragma. L’un ou l’autre désactive les avertissements de dépréciation, mais les problèmes de sécurité qui ont provoqué l’existence des avertissements existent toujours. Il est préférable de laisser les avertissements de dépréciation activés et de tirer parti des nouvelles fonctionnalités de sécurité CRT.

En C++, le moyen le plus simple d’éliminer les avertissements de dépréciation consiste à utiliser des surcharges de modèle sécurisées. Les surcharges éliminent les avertissements de dépréciation dans de nombreux cas. Ils remplacent les appels aux fonctions déconseillées par des appels aux versions sécurisées des fonctions. Par exemple, prenez l'appel déconseillé à strcpy :

char szBuf[10];
strcpy(szBuf, "test"); // warning: deprecated

L'affectation de la valeur 1 à _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES supprime l'avertissement en modifiant l'appel strcpy à strcpy_s, ce qui empêche les dépassements de mémoire tampon. Pour plus d'informations, consultez Sécuriser les surcharges de modèle.

Pour les fonctions déconseillées sans surcharges de modèle sécurisées, vous devez envisager de mettre à jour manuellement votre code pour utiliser les versions sécurisées.

Une autre source d'avertissements de désapprobation, sans rapport avec la sécurité, sont les fonctions POSIX. Remplacez les noms de fonctions POSIX par leurs équivalents standard (par exemple, changez access en _access) ou désactivez les avertissements de dépréciation liés à POSIX en définissant _CRT_NONSTDC_NO_WARNINGS. Pour plus d'informations, voir Compatibilité.

Fonctionnalités de sécurité supplémentaires

Voici quelques-unes des fonctionnalités de sécurité :

• Validation des paramètres

  Fonctions sécurisées, et bon nombre de leurs équivalents non sécurisés, valident les paramètres. La validation peut inclure :

  • NULL Recherche de valeurs.
  • Vérifier la validité des valeurs énumérées.
  • Vérifier que les valeurs intégrales sont comprises dans des plages valides.

  Pour plus d’informations, consultez Validation des paramètres.

  Un gestionnaire de paramètres non valides est également accessible au développeur. Lorsqu’une fonction rencontre un paramètre non valide, au lieu d’affirmer et de quitter l’application, le CRT vous permet de vérifier ces problèmes via _set_invalid_parameter_handler ou _set_thread_local_invalid_parameter_handler.

• Mémoires tampons dimensionnées

  Vous devez passer la taille de la mémoire tampon à n’importe quelle fonction sécurisée qui écrit dans une mémoire tampon. Les versions sécurisées valident que la mémoire tampon est suffisamment grande avant de l’écrire. La validation permet d’éviter les erreurs de dépassement de mémoire tampon dangereuses qui pourraient permettre l’exécution de code malveillant. Ces fonctions retournent généralement un code d’erreur errno et appellent le gestionnaire de paramètres non valide si la taille de la mémoire tampon est trop petite. Les fonctions qui lisent les mémoires tampons d'entrée, telles que gets, ont des versions sécurisées qui nécessitent que vous spécifiez une taille maximale.

• Arrêt Null

  Certaines fonctions qui ont laissé des chaînes potentiellement non terminées ont des versions sécurisées, ce qui garantit que les chaînes sont correctement terminées par null.

• Rapport d’erreurs amélioré

  Les fonctions sécurisées retournent des codes d’erreur avec plus d’informations d’erreur que celles disponibles avec les fonctions préexistantes. Les fonctions sécurisées et la plupart des fonctions préexistantes sont désormais définies errno et retournent souvent un errno type de code pour fournir un meilleur rapport d’erreurs.

• Sécurité du système de fichiers

  Les API d'E/S de fichier sécurisées prennent en charge par défaut l'accès sécurisé aux fichiers.

• Sécurité de Windows

  Les API de traitement sécurisées appliquent des stratégies de sécurité et permettent de spécifier les listes de contrôle d'accès.

• Mise en forme de la vérification de la syntaxe de chaîne

  Les chaînes non valides sont détectées, par exemple lorsque vous utilisez des caractères de champ de type incorrects dans des chaînes de printf format.

Voir aussi

Validation des paramètres
Surcharges de modèle sécurisées
Fichiers C runtime (CRT) et bibliothèque standard C++ (STL) .lib