Sécuriser les surcharges de modèleSecure Template Overloads

Microsoft a déprécié de nombreuses fonctions de bibliothèque Runtime C (CRT) au profit de versions plus sécurisées.Microsoft has deprecated many C Runtime library (CRT) functions in favor of security-enhanced versions. Par exemple, strcpy_s est le remplacement le plus sécurisé pour strcpy.For example, strcpy_s is the more secure replacement for strcpy. Les fonctions dépréciées sont des sources courantes de bogues de sécurité, car elles n’empêchent pas les opérations qui peuvent écraser la mémoire.The deprecated functions are common sources of security bugs, because they do not prevent operations that can overwrite memory. Par défaut, le compilateur génère un avertissement de dépréciation quand vous utilisez l’une de ces fonctions.By default, the compiler produces a deprecation warning when you use one of these functions. Le CRT fournit des surcharges de modèle C++ pour ces fonctions afin de faciliter la transition vers des variantes plus sécurisées.The CRT provides C++ template overloads for these functions to help ease the transition to the more secure variants.

Par exemple, cet extrait de code génère un avertissement, car strcpy est dépréciée :For example, this code snippet generates a warning because strcpy is deprecated:

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

L’avertissement de dépréciation est là pour vous indiquer que votre code peut présenter un risque.The deprecation warning is there to tell you that your code may be unsafe. Si vous avez vérifié que votre code ne peut pas écraser la mémoire, vous avez plusieurs options.If you have verified that your code can't overwrite memory, you have several choices. Vous pouvez choisir d’ignorer l’avertissement ; vous pouvez définir le symbole _CRT_SECURE_NO_WARNINGS avant les instructions include pour les en-têtes CRT pour supprimer l’avertissement, ou vous pouvez mettre à jour votre code pour utiliser strcpy_s :You can choose to ignore the warning, you can define the symbol _CRT_SECURE_NO_WARNINGS before the include statements for the CRT headers to suppress the warning, or you can update your code to use strcpy_s:

char szBuf[10];
strcpy_s(szBuf, 10, "test"); // security-enhanced _s function

Les surcharges de modèle fournissent des options supplémentaires.The template overloads provide additional choices. Si vous affectez à _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES la valeur 1, cela active des surcharges de modèle de fonctions CRT standard qui appellent automatiquement les variantes plus sécurisées.If you define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES to 1, this enables template overloads of standard CRT functions that call the more secure variants automatically. Si _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES a la valeur 1, aucune modification de votre code n’est nécessaire.If _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES is 1, then no changes to your code are necessary. Dans les coulisses, l’appel à strcpy est remplacé par un appel à strcpy_s avec l’argument de taille fourni automatiquement.Behind the scenes, the call to strcpy is changed to a call to strcpy_s with the size argument supplied automatically.

#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1

// ...

char szBuf[10];
strcpy(szBuf, "test"); // ==> strcpy_s(szBuf, 10, "test")

La macro _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES n’affecte pas les fonctions qui acceptent un nombre, par exemple strncpy.The macro _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES does not affect the functions that take a count, such as strncpy. Pour activer les surcharges de modèle pour les fonctions de nombre, affectez à _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT la valeur 1.To enable template overloads for the count functions, define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT to 1. Avant cela, toutefois, vérifiez que votre code obtient le nombre de caractères, et non la taille de la mémoire tampon (une erreur courante).Before doing so, however, make sure that your code passes the count of characters, not the size of the buffer (a common mistake). En outre, du code qui écrit explicitement une marque de fin null à la fin de la mémoire tampon après l’appel de fonction n’est pas nécessaire si la variante sécurisée est appelée.Also, code that explicitly writes a null terminator at the end of the buffer after the function call is unnecessary if the secure variant is called. Si vous avez besoin du comportement de la troncation, consultez _TRUNCATE.If you need truncation behavior, see _TRUNCATE.

Notes

La macro _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT nécessite que la valeur 1 soit également définie pour _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES.The macro _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT requires that _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES is also defined as 1. Si _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT a la valeur 1 et _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES a la valeur 0, l’application n’effectue aucune surcharge de modèle.If _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT is defined as 1 and _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES is defined as 0, the application will not perform any template overloads.

Quand vous affectez à _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES la valeur 1, elle permet des surcharges de modèle des variantes sécurisées (noms se terminant par « _s »).When you define _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES to 1, it enables template overloads of the secure variants (names ending in "_s"). Dans ce cas, si _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES a la valeur 1, une petite modification doit être apportée au code d’origine :In this case, if _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES is 1, then one small change must be made to the original code:

#define _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES 1

// ...

char szBuf[10];
strcpy_s(szBuf, "test"); // ==> strcpy_s(szBuf, 10, "test")

Seul le nom de la fonction doit être modifié (en ajoutant « _s ») ; la surcharge de modèle prend soin de fournir l’argument de taille.Only the name of the function needs to be changed (by adding "_s"); the template overload takes care of providing the size argument.

Par défaut, _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES et _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT ont la valeur 0 (sont désactivées) et _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES a la valeur 1 (est activée).By default, _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES and _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT are defined as 0 (disabled) and _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES is defined as 1 (enabled).

Notez que ces surcharges de modèle fonctionnent uniquement pour les tableaux statiques.Note that these template overloads only work for static arrays. Les mémoires tampons allouées dynamiquement nécessitent des modifications du code source supplémentaires.Dynamically allocated buffers require additional source code changes. Nouvel examen des exemples ci-dessus :Revisiting the above examples:

#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 1

// ...

char *szBuf = (char*)malloc(10);
strcpy(szBuf, "test"); // still deprecated; you have to change it to
                       // strcpy_s(szBuf, 10, "test");

Et de ceci :And this:

#define _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES 1

// ...

char *szBuf = (char*)malloc(10);
strcpy_s(szBuf, "test"); // doesn't compile; you have to change it to
                         // strcpy_s(szBuf, 10, "test");

Voir aussiSee also

Fonctionnalités de sécurité dans la bibliothèque CRTSecurity Features in the CRT
Fonctionnalités de bibliothèque CRTCRT Library Features