Speichersichere Sprachen: Hat C++ ein Problem?

Keine Zeit? Hier die Kurzversion in 30 Sekunden.
- Die NSA empfiehlt seit November 2022 speichersichere Sprachen wie C#, Go, Java, Ruby, Rust und Swift und rät von C und C++ ab; Bjarne Stroustrup hat darauf schriftlich geantwortet.
- „Speichersicher“ heißt: Die Sprache verhindert Zugriffe außerhalb von Grenzen, auf freigegebenen Speicher oder auf Unfertiges, entweder zur Laufzeit oder schon beim Übersetzen.
- Modernes C++ kann viel davon abdecken: Smart Pointer,
std::span, Core Guidelines, Sanitizer, statische Analyse und Hardening-Flags, nur eben freiwillig.- Für Bestandscode wie C++Builder und VCL sind Sanitizer, Warnungen und saubere Besitzverhältnisse realistischer als eine Neuschreibung.
- Eine zweite Sprache lohnt sich bei neuen, klar abgegrenzten Komponenten, die fremde Eingaben verarbeiten.
Am 10. November hat die NSA ein Papier mit dem Titel „Software Memory Safety“ veröffentlicht. Es ist kurz, ohne Fachjargon geschrieben und richtet sich erkennbar an Leute, die Software einkaufen oder verantworten, nicht nur an Entwickler. Der Kern passt in einen Satz: Man solle, wo immer möglich, auf speichersichere Sprachen zu wechseln. Genannt werden unter anderem C#, Go, Java, Ruby, Rust und Swift. Auf der anderen Seite stehen C und C++.
Ich habe das Papier erst mit ein paar Wochen Abstand richtig gelesen, und mein erster Gedanke war nicht Empörung, sondern ein müdes „Ja, und?“. Mein zweiter Gedanke war: Wenn so etwas von einer Behörde kommt, wird es irgendwann in einer Ausschreibung stehen. Deshalb lohnt es sich, kurz zu sortieren, was dort eigentlich steht und was man als C++-Entwickler damit anfängt.
Was „speichersicher“ meint
Der Begriff klingt größer, als er ist. Gemeint ist eine Sprache, in der man bestimmte Fehler nicht machen kann, ohne es ausdrücklich zu wollen. Dazu gehören:
- Lesen oder Schreiben hinter dem Ende eines Puffers
- Zugriff auf Speicher, der schon freigegeben wurde (Use-after-free)
- Doppeltes Freigeben
- Zugriff auf nicht initialisierte Werte
- Wettläufe zwischen Threads auf denselben Daten, je nach Definition
Java und C# erledigen das mit Laufzeitprüfungen und einem Garbage Collector. Rust verlegt einen großen Teil der Prüfung in den Compiler, und wer das Sicherheitsnetz verlassen will, muss unsafe schreiben. Beides sind unterschiedliche Wege zum selben Ziel. Wichtig ist der Unterschied zu C und C++: Dort ist der Fehler der Normalfall, wenn man nicht aufpasst, und der Compiler sagt häufig gar nichts.
Warum das Thema Behörden interessiert, hatte ich schon in meinem Artikel „Rust neben C++“ im Juli angerissen: Microsoft und Google haben beide öffentlich angegeben, dass rund 70 % ihrer schweren Sicherheitslücken auf Speicherfehler zurückgehen. Das sind deren Zahlen, ich kann sie nicht prüfen. Aber wenn zwei Hersteller mit völlig verschiedenen Codebasen ähnliche Werte nennen, würde ich das nicht als Zufall abtun.
Die Erwiderung
Bjarne Stroustrup hat auf das Papier schriftlich reagiert, und ich gebe hier nur sinngemäß wieder, was ich verstanden habe. Sein Einwand lautet ungefähr so: C und C++ in einen Topf zu werfen, sei falsch. Modernes C++ könne mit Richtlinien und passenden Werkzeugen sicher benutzt werden, und der Weg dorthin müsse nicht über eine andere Sprache führen.
Beides stimmt aus meiner Sicht gleichzeitig. Es gibt einen riesigen Unterschied zwischen C-Code mit malloc, strcpy und Zeigerarithmetik und einem C++-Programm, das konsequent Standardcontainer und Smart Pointer nutzt. Nur: Das Papier beschreibt nicht, was man mit C++ tun kann, sondern was in der Praxis gebaut wird. Und in der Praxis steckt in vielen C++-Projekten eine Menge Code, der älter ist als std::unique_ptr. Die Sprache erlaubt das Sichere, sie erzwingt es aber nicht. Genau dieses „erlaubt, aber nicht erzwungen“ ist der Punkt, an dem die beiden Seiten aneinander vorbeireden.
Was C++ heute schon kann
Der Werkzeugkasten ist größer, als sein Ruf. Ein kleines Beispiel, wie sich ein klassischer Fehler entschärfen lässt:
#include <memory>
#include <span>
#include <vector>
int summe(std::span<const int> werte) {
int s = 0;
for (int w : werte) s += w;
return s;
}
int main() {
std::vector<int> daten{1, 2, 3, 4};
auto puffer = std::make_unique<int[]>(4);
puffer[0] = 7;
return summe(daten) + summe({puffer.get(), 1});
}std::span (seit C++20) transportiert Zeiger und Länge zusammen, statt zwei getrennter Parameter, die man verwechseln kann. std::unique_ptr räumt von selbst auf. Dazu kommen std::array, std::string_view und die Container mit at(), wenn man Prüfungen will. Das ersetzt nicht jede Prüfung, aber es macht den sicheren Weg zum bequemen.
Daneben gibt es Werkzeuge außerhalb der Sprache:
- Core Guidelines mit der Support-Bibliothek (GSL) beschreiben, wie man C++ ohne die gefährlichen Ecken schreibt. Prüfer wie
clang-tidyund die Analyse in Visual Studio kennen einen Teil davon. - Sanitizer (AddressSanitizer, UndefinedBehaviorSanitizer, ThreadSanitizer) finden in Tests Fehler, die sonst monatelang schlummern.
- Statische Analyse in Compilern und eigenständigen Werkzeugen, dazu Fuzzing für Code, der fremde Eingaben parst.
- Hardening: Stack-Schutz,
_FORTIFY_SOURCE, geprüfte Standardbibliothek (bei libstdc++ etwa über_GLIBCXX_ASSERTIONS), ASLR und DEP als Betriebssystemschutz. Das macht Fehler nicht unmöglich, aber schwerer ausnutzbar.
Der Haken ist immer derselbe: Das ist alles zusätzlich, und es fängt nur, was getestet oder analysiert wird. Ein Compiler, der delete zweimal auf denselben Zeiger durchwinkt, ist eben etwas anderes als einer, der es nicht übersetzt.
Was bei Bestandscode realistisch ist
Mir begegnen oft gewachsene Systeme mit C++Builder und VCL, bei denen Formulare, Komponenten und Ereignisse tief mit der Sprache verwoben sind. Dort würde ich nichts umschreiben. Die Rechnung geht nicht auf, und das GUI-Thema in anderen Sprachen ist ohnehin ein eigenes Kapitel.
Was ich stattdessen für sinnvoll halte, in grob steigendem Aufwand:
- Compilerwarnungen hochdrehen und wirklich lesen, nicht nur anhäufen.
- Neuen Code mit Smart Pointern und Containern schreiben, rohe Zeiger nur als Beobachter.
- Besitzverhältnisse in Altcode klären. Bei der VCL ist das teilweise schon durch das Owner-Prinzip der Komponenten geregelt, an den Rändern aber nicht.
- Sanitizer und statische Analyse, wo die Werkzeugkette es hergibt. Ob und wie weit das mit dem eigenen Compiler klappt, muss man ausprobieren. Notfalls läuft der fachliche Kern, der nicht von der VCL abhängt, in einem separaten Testprojekt mit einer anderen Toolchain.
- Module, die Fremdformate lesen oder Netzwerkdaten verarbeiten, per Fuzzing bearbeiten.
Das ist keine glamouröse Liste. Aber sie ist vermutlich billiger als jede Migration und bringt für die meisten Anwendungen mehr als jedes Sprachwechsel-Projekt.
Wo eine zweite Sprache hilft
Anders sieht es bei neuen Bausteinen aus. Ein Parser, ein Netzwerkdienst, ein Modul, das Dateien aus unsicherer Quelle öffnet: Dort ist die Schnittstelle klein und die Angriffsfläche groß. Ein Versuch mit Rust oder, je nach Umfeld, mit einer Sprache mit Garbage Collector kann sich lohnen. Mit Linux 6.1 im Dezember ist Rust erstmals offiziell im Kernel angekommen, zunächst als Grundlage, noch nicht in nennenswertem Umfang. Das ist ein Signal, aber kein Beweis, dass es im eigenen Projekt auch passt.
Die Gegenbewegung beobachte ich mit Interesse. Google hat im Juli Carbon vorgestellt, ausdrücklich als Experiment, und Herb Sutter hat im September mit cppfront einen anderen Weg gezeigt: eine neue Syntax („Cpp2“), die auf C++ übersetzt wird, mit sichereren Voreinstellungen. Beides ist früh, und ich würde nichts davon in ein Projekt einplanen. Es zeigt aber, dass die C++-Gemeinde das Thema ernst nimmt und nicht nur auf die Stroustrup-Antwort zeigt.
Was ich daraus mitnehme
Hat C++ ein Problem? Ich glaube, ja, aber nicht das, das im Papier steht. Die Sprache kann sicher sein, nur ist der unsichere Weg weiterhin der kürzeste, und der Compiler sagt selten Nein. Wer das ändern will, muss Disziplin über Werkzeuge erzwingen, nicht über gute Vorsätze.
Für mich heißt das ganz praktisch: In der CI laufen künftig Sanitizer, wo es geht. Neuer Code kommt ohne rohe new-Aufrufe aus. Und bei jedem neuen, exponierten Baustein stelle ich zumindest die Frage, ob er in C++ geschrieben werden muss. Die Antwort darf gern „ja“ lauten, aber nach einer Begründung und nicht aus Gewohnheit.
Wie geht ihr mit dem Papier um? Ist es bei euch schon ein Thema in Kundengesprächen, oder liest es bisher nur die Sicherheitsabteilung?
Beitragsbild: Foto SDRAM-Speichermodul von Mister rf, CC BY-SA 4.0 (via Wikimedia Commons; zugeschnitten auf 16:9).
Christian Ackermann
Softwareentwickler (C++, C, Java, C#) aus der Oberpfalz, bloggt seit 2001 über Linux, Technik und Kochen.