5 conseils essentiels pour sécuriser C++

C++ est devenu un pilier de l’industrie technologique moderne. Il est utilisé à de nombreuses fins : applications de bureau et serveur, jeux vidéo, réalité virtuelle, micrologiciels pour l’Internet des objets, et même comme fondement de nombreux langages de programmation modernes.

Depuis sa première publication en 1985, en tant qu’extension du langage de programmation C, C++ a été conçu pour la programmation système et le développement de ressources embarquées.

Comme pour tout développement largement adopté ou utilisé, il est important d’intégrer la sécurité à chaque étape de l’application. Voici donc quelques conseils de sécurité à garder à l’esprit lorsque vous développez en C++.

1. Valider et assainir les entrées des applications C++

La gestion des entrées utilisateur est essentielle pour protéger une application contre les intrusions. C++ est utilisé depuis longtemps, notamment parce qu’il permet de manipuler la mémoire selon les principes de la programmation orientée objet. Cette capacité, particulièrement utile au développement d’applications, peut aussi être exploitée comme vecteur d’attaque par des acteurs malveillants.

Vous pouvez notamment utiliser la fonction std:cin pour gérer les variables. Voici quelques exemples :

1int main()
2{
3    int varnum;
4
5    while (true) {
6        cout << "Enter a number: ";
7        if (cin >> varnum) {
8            break;
9        } else {
10            cout << "Enter a valid number!\n";
11            cin.clear();
12            cin.ignore(numeric_limits<std::streamsize>::max(), '\n');
13        }
14    }
15
16    return EXIT_SUCCESS;
17}

Dans cette fonction, cin.clear() efface les indicateurs d’état d’erreur et cin.ignore() supprime tous les caractères restants dans le flux jusqu’au caractère de nouvelle ligne. Il est important de gérer ces messages d’erreur pour qu’ils ne s’affichent pas dans les résultats présentés à l’utilisateur final. Les messages d’erreur et d’alerte peuvent révéler des vecteurs d’attaque indésirables.

2. Débordements et sous-débordements de tampon

Lorsque vous gérez des entrées utilisateur en C++, vérifiez leur longueur, leur plage, leur format et leur type. L’interaction plus granulaire avec le système d’exploitation sous-jacent signifie qu’une fonction recevant un tampon d’entrée trop volumineux peut être exposée à une attaque par débordement.

Un débordement arithmétique peut se produire lorsque le résultat d’une opération dépasse les valeurs représentables par le type de l’expression. Par exemple :

1uint16_t x = 65535;
2x++;
3
4std::cout << x;

La fonction ci-dessus renvoie 0, car x est un entier non signé pouvant représenter des valeurs comprises entre 0 et 65535. Si la valeur dépasse cette plage, unit16_t ne peut pas la représenter, ce qui provoque un débordement.

Pour gérer les débordements et les sous-débordements, vous pouvez définir une vérification qui compare la valeur d’une variable à ses limites minimale et maximale, afin de détecter toute valeur qui dépasse ces limites. Les templates permettent de définir cette plage et de mettre en place une vérification réutilisable pour tous les cas.

1#include <limits>
2
3template <typename V>
4constexpr bool AdditionOverflows(const V& a, const V& b) {
5    return (b >= 0) && (a > std::numeric_limits<V>::max() - b);
6}
7
8template <typename V>
9constexpr bool AdditionUnderflows(const V& a, const V& b) {
10    return (b < 0) && (a < std::numeric_limits<V>::min() - b);
11}

Lorsque vous utilisez C++, veillez à éviter tout comportement indéfini. La plupart des compilateurs vous avertissent de ce type de comportement lors de la compilation de votre application. GCC et Clang, par exemple, proposent l’option -fsanitize=undefined flag.

Soyez également prudent avec des fonctions comme strcpy() et strcat() en C++. Bien qu’elles soient utiles pour gérer les variables, elles peuvent provoquer des débordements ou des sous-débordements si la valeur stockée dépasse la capacité du type de stockage.

3. Des opérations incorrectes sur le système de fichiers peuvent entraîner des vulnérabilités de traversée de chemin

Une mauvaise gestion des fichiers peut entraîner des vulnérabilités de traversée de chemin. Ce risque existe dans tous les frameworks, mais il est particulièrement important dans un système d’exploitation où un langage aussi granulaire que C++ est utilisé. En C++, les fichiers sont gérés sous forme de flux, une abstraction qui représente les entrées et sorties de données. Selon la structure du code, un flux peut être une séquence de caractères de longueur indéfinie.

C++ propose plusieurs techniques de gestion des fichiers, dont ifstream(), ofstream() , et fstream(). Ces fonctions dérivent des groupes de classes fstreambase et iostream, et servent à gérer les fichiers fisk déclarés dans fstream.

Les différentes classes de gestion des fichiers se distinguent ainsi :

• ofstream : cette classe représente le flux de sortie et sert à créer des fichiers pour y écrire des informations.

• ifstream : cette classe représente le flux d’entrée de fichier et sert à lire des informations depuis des fichiers.

• fstream : cette classe permet de lire des fichiers et d’y écrire.

Il est important de gérer les flux de fichiers de manière sécurisée. Commencez par appeler new_file.open() pour créer un nouveau fichier, puis écrivez les données dans le fichier. Enfin, fermez le fichier une fois l’opération terminée et prévoyez une instruction catch pour gérer les erreurs susceptibles de se produire pendant le transfert.

Par exemple :

1#include <iostream>
2#include <fstream>
3using namespace std;
4int main()
5{
6    fstream newFile; 
7    newFile.open("file_write.txt",ios::out);  
8
9    if(!newFile) 
10    {
11        cout<<"File failed";
12    }
13    else
14    {
15        cout<<"File created";
16        newFile<<"File write";    //File write
17        newFile.close(); // Close file 
18    }   
19    return 0;
20}

4. Limiter l’utilisation de system() et des appels d’exécution de processus pour éviter l’injection de commandes

Comme dans de nombreux autres langages, les interactions directes avec le système par le biais de fonctions dans le code doivent être abordées avec beaucoup de prudence. En C++, les fonctions comme system() sont à éviter ou à utiliser avec précaution. Ces fonctions système varient selon le chipset et le matériel sur lesquels l’application s’exécute.

Veillez également à installer et exécuter l’application de manière à autoriser des fonctions exécutables supplémentaires comme exec(), execp() , et CreateProcess(). Là encore, utilisez-les avec prudence, car elles peuvent donner accès au système d’exploitation sous-jacent.

N’oubliez pas que les applications C++ disposent d’un accès beaucoup plus granulaire aux informations critiques du système, ce qui peut exposer davantage d’activités malveillantes et de chemins vulnérables.

5. Analyser les bibliothèques de votre projet avec un outil complet d’analyse statique du code

Pour préserver la sécurité, il est essentiel de surveiller les chemins potentiellement vulnérables dans les bibliothèques et dépendances de votre projet. Ces chemins peuvent permettre des comportements indésirables de la part d’acteurs malveillants, en particulier dans les projets C++ installés sur différents systèmes et à différents niveaux de l’architecture.

L’analyse statique du code, ou SCA, est utile, car elle peut vous alerter des vulnérabilités potentielles pendant le développement d’une application et vous avertir lorsqu’une vulnérabilité est détectée dans le projet déployé.

Premiers pas avec l’analyse SCA de C++ par Snyk

Pour commencer à utiliser Snyk, installez la Snyk CLI dans votre environnement de développement. Vous pouvez installer la CLI de plusieurs façons, notamment avec npm, Yarn ou des exécutables autonomes.

Connectez ensuite la CLI à votre compte Snyk. Si vous n’avez pas encore de compte Snyk, l’inscription est rapide et facile. Rendez-vous sur la page d’inscription et suivez les étapes pour commencer.

Une fois la CLI installée et connecté à votre compte Snyk, exécutez snyk auth depuis la ligne de commande pour terminer la connexion. Un lien d’authentification s’affichera et une fenêtre de navigateur s’ouvrira automatiquement sur la page d’authentification. Cliquez sur Authenticate et vous pourrez utiliser la Snyk CLI.

Pour terminer, accédez au répertoire racine du projet à analyser et exécutez snyk test –unmanaged. L’analyse repérera le dossier à la racine du projet qui contient les bibliothèques open source, puis analysera son contenu.

Une fois l’analyse terminée, vous verrez tous les résultats et pourrez les examiner plus en détail. J’apprécie particulièrement la possibilité d’approfondir les problèmes détectés en suivant les liens fournis dans les résultats, afin de mieux comprendre les vulnérabilités.

Inscrivez-vous dès maintenant et lancez vos analyses

En tant que développeurs, professionnels DevOps et acteurs du secteur technologique, nous devons donner la priorité à la sécurité et tout faire pour protéger les applications que nous créons. Intégrer la sécurité au développement des applications nous aide à protéger les utilisateurs finaux ainsi que leurs données.