Die 5 wichtigsten Tipps für C++-Sicherheit

C++ ist zu einem zentralen Bestandteil der modernen Tech-Branche geworden. Die Sprache kommt für viele verschiedene Zwecke zum Einsatz, etwa für Desktop-Anwendungen, Server-Anwendungen, Spiele, Virtual Reality, Firmware für das Internet der Dinge und sogar als Grundlage für viele moderne Programmiersprachen.

Seit der ersten Veröffentlichung von C++ im Jahr 1985 als Erweiterung der Programmiersprache C ist die Sprache auf Systemprogrammierung und die Entwicklung eingebetteter Ressourcen ausgerichtet.

Wie bei jeder weit verbreiteten oder nutzerorientierten Entwicklung ist es wichtig, Sicherheitsaspekte in die gesamte Anwendung zu integrieren. Sehen wir uns also einige Sicherheitstipps an, die Sie beim Entwickeln mit C++ beachten sollten.

1. Eingaben in C++-Anwendungen validieren und bereinigen

Der sichere Umgang mit Nutzereingaben ist entscheidend, um eine Anwendung vor unerwünschten Zugriffen zu schützen. C++ wird seit Jahren intensiv eingesetzt, weil die Sprache eine objektorientierte Speicherverwaltung ermöglicht. Diese ist zwar besonders nützlich für die Anwendungsentwicklung, kann von böswilligen Akteuren jedoch auch als Angriffsvektor genutzt werden.

Eine Möglichkeit ist, die Funktion std:cin zur Verarbeitung von Variablen zu verwenden. Sie lässt sich auf verschiedene Arten einsetzen, zum Beispiel:

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}

In dieser Funktion löscht cin.clear() die Fehlerstatus-Flags und cin.ignore() entfernt alle Zeichen im Stream bis zum Zeilenumbruch. Achten Sie darauf, Fehlermeldungen so zu verarbeiten, dass sie nicht in der Ausgabe für Endnutzer erscheinen. Fehler- und Warnmeldungen können unerwünschte Angriffsvektoren offenlegen.

2. Pufferüberläufe und -unterläufe

Prüfen Sie bei der Verarbeitung von Nutzereingaben in C++ unbedingt deren Länge, Wertebereich, Format und Typ. Da die Interaktion mit dem zugrunde liegenden Betriebssystem granularer ist, kann es zu einem Pufferüberlauf kommen, wenn Funktionen mit großen Eingabepuffern aufgerufen werden.

Ein arithmetischer Überlauf kann auftreten, wenn ein Rechenergebnis die durch den Ausdruckstyp darstellbaren Werte überschreitet. Zum Beispiel:

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

Die obige Funktion gibt als Antwort 0 aus, da x eine vorzeichenlose Ganzzahl ist, die Werte zwischen 0 und 65535 darstellen kann. Wird dieser Bereich überschritten, kann der Wert nicht durch unit16_t dargestellt werden, was zu einem Überlauf führt.

Eine Möglichkeit, Über- und Unterläufe zu behandeln, besteht darin, beim Verarbeiten eines Variablentyps Grenzwerte zwischen dessen Minimal- und Maximalwert festzulegen. So wird erkannt, wenn ein Wert die Bereichsgrenzen über- oder unterschreitet. Mit Templates lässt sich dieser Bereich festlegen und damit eine wiederverwendbare allgemeine Fehlerbehandlung einrichten.

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}

Achten Sie darauf, bei der Verwendung von C++ undefiniertes Verhalten zu vermeiden. Die meisten Compiler weisen beim Erstellen Ihrer Anwendung auf undefiniertes Verhalten hin. GCC und Clang bieten beispielsweise das Flag -fsanitize=undefined flag.

Seien Sie außerdem vorsichtig mit Funktionen wie strcpy() und strcat() aus der C++-Bibliothek. Sie sind zwar für die Verarbeitung von Variablen nützlich, können aber zu Über- und Unterläufen führen, wenn der zu speichernde Wert den verfügbaren Speicherplatz überschreitet.

3. Fehlerhafte Dateisystemoperationen können Path-Traversal-Schwachstellen verursachen

Ein unsachgemäßer Umgang mit Dateien kann zu Path-Traversal-Schwachstellen führen. Das ist in jedem Framework gefährlich, besonders aber in einem Betriebssystem mit einer granularen Programmiersprache wie C++. In C++ werden Dateien als Stream und als Abstraktion behandelt, die Stream-Ein- und -Ausgaben darstellt. Je nach Codestruktur kann ein Stream eine Folge von Zeichen mit unbestimmter Länge sein.

C++ verwendet verschiedene Techniken zur Dateiverarbeitung, darunter ifstream(), ofstream() , und fstream(). Diese Funktionen leiten sich von den Klassenverbünden fstreambase und iostream ab und dienen der Verwaltung der in fstream deklarierten Fisk-Dateien.

Die verschiedenen Klassen zur Dateiverarbeitung unterscheiden sich wie folgt:

• ofstream: Diese Klasse bezeichnet den Ausgabestream und wird zum Erstellen von Dateien verwendet, in die Informationen geschrieben werden.

• ifstream: Diese Klasse bezeichnet den Eingabestream für Dateien und wird zum Lesen von Informationen aus Dateien verwendet.

• fstream: Diese Klasse kann sowohl zum Lesen als auch zum Schreiben von Dateien verwendet werden.

Achten Sie darauf, Dateistreams sicher zu verarbeiten. Beginnen Sie mit new_file.open(), um eine neue Datei zu öffnen, und schreiben Sie anschließend den Dateistream in die Datei. Schließen Sie die Datei, sobald Sie fertig sind, und verwenden Sie eine Catch-Anweisung für mögliche Fehler, die während der Übertragung auftreten.

Zum Beispiel:

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. Verwenden Sie system()- und Prozessausführungsaufrufe nur eingeschränkt, um Command Injection zu vermeiden

Wie bei vielen anderen Programmiersprachen sollten Sie bei der Interaktion mit dem Kernsystem über codebasierte Funktionen sehr vorsichtig vorgehen. In C++ sollten Funktionen wie system() vermieden oder mit Bedacht eingesetzt werden. Diese systembasierten Funktionen unterscheiden sich je nach Chipsatz und Hardware, auf denen die Anwendung ausgeführt wird.

Stellen Sie außerdem sicher, dass die Anwendung so installiert und ausgeführt wird, dass zusätzliche ausführbare Funktionen wie exec(), execp() , und CreateProcess() möglich sind. Gehen Sie dabei jedoch ebenfalls vorsichtig vor, insbesondere weil diese Funktionen den Zugriff auf das Kernbetriebssystem ermöglichen können.

Beachten Sie, dass C++-Anwendungen deutlich granularer auf kritische Systeminformationen zugreifen können. Dadurch können mehr böswillige Aktivitäten und anfällige Pfade offengelegt werden.

5. Projektbibliotheken mit einem umfassenden Tool für statische Codeanalyse scannen

Es ist wichtig, potenziell anfällige Pfade in Ihren Projektbibliotheken und Abhängigkeiten im Blick zu behalten, um die Sicherheit zu gewährleisten. Solche Pfade können böswilligen Akteuren unerwünschte Aktionen ermöglichen. Das gilt insbesondere für C++-Projekte, die auf verschiedenen Systemen und Architektur-Ebenen installiert werden.

Statische Codeanalyse, kurz SCA, ist hilfreich, weil sie Sie während der Entwicklung einer Anwendung auf potenzielle Schwachstellen hinweisen und Sie benachrichtigen kann, wenn eine Schwachstelle in einem bereitgestellten Projekt entdeckt wird.

Mit Snyk mit SCA-Scans für C++ starten

Um mit Snyk zu starten, müssen Sie die Snyk CLI in Ihrer Entwicklungsumgebung installieren. Dafür gibt es verschiedene Möglichkeiten, darunter npm, Yarn und eigenständige ausführbare Dateien.

Als Nächstes verbinden Sie die CLI mit Ihrem Snyk-Konto. Wenn Sie noch kein Snyk-Konto haben, können Sie sich schnell und einfach registrieren. Rufen Sie dazu die Registrierungsseite auf und folgen Sie den Schritten.

Nachdem Sie die CLI installiert und sich bei Ihrem Snyk-Konto angemeldet haben, führen Sie in der Befehlszeile snyk auth aus, um die Verbindung zu Ihrem Konto abzuschließen. Dadurch wird ein Authentifizierungslink erstellt und automatisch eine Browserseite zur Authentifizierung geöffnet. Klicken Sie auf Authenticate, und schon können Sie die Snyk CLI verwenden.

Navigieren Sie nun als letzten Schritt zum Stammverzeichnis des Projekts, das Sie scannen möchten, und führen Sie snyk test –unmanaged aus. Beim Scan wird der Ordner im Projektstammverzeichnis ermittelt, der die Open-Source-Bibliotheken enthält, und anschließend gescannt.

Nach Abschluss sehen Sie die vollständigen Scan-Ergebnisse und können diese weiter untersuchen. Besonders hilfreich ist, dass Sie sich über die Links aus dem Scan näher mit den gefundenen Problemen und den jeweiligen Schwachstellen befassen können.

Jetzt registrieren und mit dem Scannen loslegen

Für uns als Entwickler, DevOps-Fachleute und Technologieexperten ist es wichtig, Sicherheit zu priorisieren und alles dafür zu tun, dass die von uns entwickelten Anwendungen geschützt sind. Wenn Sicherheit von Anfang an in die Anwendungsentwicklung integriert wird, lassen sich Endnutzer und ihre Daten besser schützen.