Umstieg von C/C++ auf Rust

Wir freuen uns sehr, dass Michael Schneeberger von Cudos beim diesjährigen Swiss Software Festival als Referent auf der Bühne stehen und diesen Vortrag halten durfte! Da uns das Thema am Herzen liegt, möchten wir diesen wertvollen Input natürlich auch mit unserer gesamten Community teilen. Viel Spass beim Lesen!

Bei Cudos begleiten wir Unternehmen seit vielen Jahren bei komplexen Softwareprojekten. In diesem Beitrag beleuchten wir, warum klassische Schutzmassnahmen bei C/C++-Programmen fehlschlagen und wie eine schrittweise Migration zu Rust das Sicherheitsniveau Ihrer Anwendungen radikal verbessert.

Wer Software entwickelt, kennt das ungleiche Duell: Während wir als Verteidiger jede noch so kleine Lücke schliessen müssen, benötigt ein Angreifer nur einen einzigen uninitialisierten Pointer, um ein System zu kompromittieren.

Seit über zwei Jahrzehnten stagnieren die Statistiken: Rund 70 % aller kritischen Sicherheitslücken (CVEs) in C/C++-Codebasen sind auf mangelnde Speichersicherheit zurückzuführen.

Warum klassische Schutzmassnahmen scheitern

In den letzten Jahrzehnten hat die Industrie drei Generationen von Gegenmassnahmen entwickelt. Keine davon konnte das Problem an der Wurzel packen:

• 1. Generation (Reaktives Patchen)
  Die Fehlerbehebung nach der Entdeckung. Dies bleibt ein endloser, langsamer Kreislauf, der den Angriffen stehts hinterherhinkt.
• 2. Generation (Runtime Mitigations)
  Techniken wie Stack Canaries, Sandboxing oder Control Flow Integrity (CFI). Diese erhöhen zwar die Hürde für Angriffe, eliminieren aber die eigentlichen Bugs im Code nicht.
• 3. Generation (Proaktive Erkennung)
  Fokus auf Fuzzing, statische Codeanalyse (SAST) und Sanitizer. Obwohl diese Werkzeuge äusserst effektiv sind, arbeiten sie nicht fehlerfrei und sind zudem oft kosten- und zeitintensiv.

Rust: "Secure by Design" statt Pflaster-Symptombekämpfung

Rust geht einen radikal anderen Weg. Durch ein striktes statisches Besitzmodell (Ownership) prüft der Compiler alle Speicherzugriffe bereits während der Build-Phase und nicht erst zur Laufzeit. Konzepte wie "Use-after-free" oder "Double-free" werden dadurch strukturell unmöglich gemacht.

Das Besondere daran: Rust benötigt keinen Garbage Collector (GC). Die Speicherbereinigung erfolgt stattdessen vollautomatisch, sobald eine Variable ihren Gültigkeitsbereich verlässt. Das Ergebnis ist eine Performance auf Augenhöhe mit C/C++ – kombiniert mit mathematisch bewiesener Sicherheit.

"Der Compiler prüft den gesamten Vertrag, bevor der Code überhaupt erst ausgeführt wird." — Prof. Ralf Jung, ETH Zürich

Die Praxis beweist es: Reale Erfolge aus der Industrie

Dass dies keine graue Theorie ist, zeigen die realen Daten von Google und grossen Industrieakteuren:

• Android OS
  Durch die konsequente Erhöhung des Anteils an speichersicherem Code konnte Google den Anteil an Memory-Safety-Vulnerabilities innerhalb von sechs Jahren von 76 % auf 20 % senken. Diese Migration führte bei Android zusätzlich zu einer viermal niedrigeren Rollback-Rate und reduzierte den Zeitaufwand für Code-Reviews um 25 %.
• Volvo Cars
  Die Erfahrungen zeigen eine 2- bis 4-fache Produktivitätssteigerung im Vergleich zur klassischen C++-Entwicklung – bei einer bemerkenswert niedrigen Fehlerrate von nur 0,25 Bugs pro tausend Zeilen Code (KLOC).

Die Migrationssteuer

Sicherheitsgarantien gibt es jedoch nicht gratis. Jedes Entwicklungsteam, das den Umstieg wagt, zahlt eine sogenannte "Migrationssteuer" (Migration Tax):

1. Steile Lernkurve
   Das Verständnis von Borrowing und Lifetimes erfordert ein grundlegendes Umdenken im Team.
2. Temporärer Geschwindigkeitsverlust
   Die anfängliche Entwicklungsgeschwindigkeit sinkt, während sich das Team an die strikten Vorgaben des Compilers gewöhnt.
3. Schnittstellen-Komplexität
   Die Verwaltung von Schnittstellen (Foreign Function Interface, FFI) zu bestehendem Legacy-Code erfordert zusätzliche Sorgfalt.

Lohnt sich der Umstieg?

Die klare Antwort lautet: Ja – wenn man es pragmatisch über eine partielle Migration angeht.

Niemand muss funktionierenden Legacy-Code von heute auf morgen komplett neu schreiben. Da die meisten neuen Sicherheitslücken in neu geschriebenem oder kürzlich verändertem Code entstehen, ist es am wirtschaftlichsten, neue Komponenten direkt in Rust zu implementieren.

💡 Profitipp: Schreiben Sie neue, kritische Komponenten direkt in Rust und binden Sie diese über Foreign Function Interfaces (FFI) nahtlos in Ihre bestehende C/C++-Infrastruktur ein. So minimieren Sie das Risiko und maximieren den Sicherheitsgewinn ab Tag eins.