~/blog/2021/01/nach-solarwinds-wie-sicher-sind-bu.md

Nach SolarWinds: Wie sicher sind Build-Pipelines?

7 min
Beitragsbild: Nach SolarWinds: Wie sicher sind Build-Pipelines?

Keine Zeit? Hier die Kurzversion in 30 Sekunden.

  • Bei SolarWinds waren Updates der Orion-Software manipuliert. Laut SolarWinds haben bis zu rund 18.000 Kunden die betroffenen Versionen installiert.
  • Nach Berichten von Anfang Januar kam die Hintertür nicht aus dem Repository, sondern wurde während des Builds eingeschleust.
  • Damit rückt der Build-Server als Angriffsziel in den Blick, oft ist er schlechter geschützt als der Produktivbetrieb.
  • Hilfreich sind Least Privilege für die CI, kurzlebige Build-Umgebungen, Signaturen, reproduzierbare Builds und gepinnte Abhängigkeiten.
  • Ein Allheilmittel gibt es nicht, aber jeder dieser Schritte macht eine unbemerkte Manipulation schwieriger.

Ich gebe zu, dass ich die Meldungen der letzten Wochen zuerst als Problem anderer Leute abgehakt habe. Ein Netzwerküberwachungsprodukt, große Organisationen, Geheimdienst-Verdacht: weit weg von dem, was ich an einem normalen Tag baue. Dann habe ich die Berichte über den Build-Teil gelesen und mir ist unwohl geworden. Denn der Mechanismus ist nicht exotisch. Er betrifft jeden, der Software automatisiert baut und ausliefert, und das tun wir ja alle.

Ein Hinweis vorweg: Ich bin kein Sicherheitsforscher, und vieles in dem Fall ist noch nicht abschließend geklärt. Ich schreibe hier auf, was öffentlich bekannt ist, und ziehe daraus Schlüsse für den eigenen Alltag. Wo Details noch offen sind, sage ich das.

Was bisher bekannt ist

Angefangen hat es am 8. Dezember 2020: FireEye, selbst eine Sicherheitsfirma, meldete, dass bei ihr eingebrochen wurde. Am 13. Dezember kam dann raus, dass Updates der Orion-Software von SolarWinds manipuliert waren. Die eingeschleuste Hintertür wird von Sicherheitsfirmen SUNBURST genannt. Wer das manipulierte Update installiert hat, hatte damit Schadcode auf einem Server, der in vielen Netzen weitreichende Einblicke und Rechte hat.

Laut SolarWinds haben bis zu rund 18.000 Kunden die betroffenen Versionen installiert. Das ist eine Angabe des Herstellers, ich kann sie nicht überprüfen. Wichtig ist dabei: Installiert heißt nicht automatisch, dass jemand tatsächlich ausgespäht wurde. Aber die Größenordnung zeigt, warum so ein Weg für Angreifer attraktiv ist. Einmal an der richtigen Stelle, und der Hersteller liefert die Schadsoftware ganz offiziell an alle aus, mit gültiger Signatur und über den üblichen Update-Kanal.

Das Interessante: Der Code war sauber

Was mich am meisten beschäftigt, kam Anfang Januar. Dort wurde beschrieben, dass eine weitere Schadkomponente, SUNSPOT genannt, im Build-System lief. Sie hat nach diesen Berichten den Code erst während des Builds verändert. Der Quellcode im Repository blieb dabei unauffällig. Wer also die Quelltexte gelesen oder ein Code-Review gemacht hätte, hätte nichts gefunden.

Das ist der Gedanke, den ich nicht mehr loswerde. Wir investieren viel in Reviews, in Pull Requests, in statische Analyse. Alles richtig und wichtig. Aber all das schützt den Weg vom Entwickler ins Repository. Was danach passiert, nämlich Checkout, Kompilieren, Paketieren, Signieren, ist ein Stück Infrastruktur, das oft einfach läuft und dem man vertraut. Wenn dort jemand mitliest oder mitschreibt, sieht man es im Code nicht.

Ich will nicht behaupten, dass dieser Fall der erste seiner Art war oder dass man ihn mit einem einzigen Trick hätte verhindern können. Es ist eher ein sehr deutlicher Anlass, sich anzuschauen, wie man selbst baut.

Der Build-Server als Kronjuwel

Wenn ich ehrlich auf meine eigenen Setups schaue, sieht der Build-Server oft so aus: ein Rechner oder eine VM, die über die Jahre gewachsen ist. Dutzende Plugins, ein paar Zugangsdaten für die Registry, ein Schlüssel zum Signieren, ein Token für das Repository. Jeder Job darf potenziell alles. Und der Zugang für die Wartung ist locker geregelt, weil „das ja nur die CI ist“.

Dabei hat dieser Rechner Zugriff auf genau das, was ein Angreifer will: den Quellcode, die Signaturschlüssel, die Veröffentlichungskanäle. Ich würde ihn deshalb gedanklich in dieselbe Klasse einordnen wie den Produktivserver, eher noch höher. Denn was dort eingeschleust wird, landet automatisch überall.

Konkret heißt das für mich:

  • Zugang zum Build-System streng einschränken, mit Zwei-Faktor-Anmeldung und einer kurzen Liste von Personen.
  • Plugins und Erweiterungen auf das Nötige reduzieren und aktuell halten.
  • Das Build-System nicht mit anderen Diensten im selben Netz vermischen, nur weil es praktisch ist.
  • Änderungen an der Pipeline-Konfiguration genauso reviewen wie Anwendungscode.

Letzteres wird gern vergessen. Ein Build-Skript, das einen zusätzlichen Schritt ausführt, ist eine Code-Änderung wie jede andere, nur eben eine, bei der keiner genau hinsieht.

Weniger Rechte, kürzere Lebensdauer

Das Prinzip der minimalen Rechte ist alt, aber bei CI-Systemen wird es selten durchgezogen. Ein Job, der nur Tests ausführt, braucht keinen Schlüssel zum Veröffentlichen. Ein Job, der ein Artefakt baut, braucht nicht unbedingt Schreibzugriff aufs Repository. Wenn man das trennt, hat ein kompromittierter Schritt weniger Möglichkeiten.

Dazu kommt die Lebensdauer. Ein Build-Agent, der monatelang läuft und Job für Job abarbeitet, sammelt Altlasten und Spuren. Wenn jeder Build in einer frischen, isolierten Umgebung startet, etwa in einem Container oder einer VM, die nach dem Lauf wieder verschwindet, hat es ein Angreifer schwerer, sich dauerhaft einzunisten. Er müsste bei jedem Lauf erneut hineinkommen. Das löst nicht alles, denn wer die Vorlage oder das Basis-Image verändert, ist trotzdem drin. Aber die Hürde steigt.

Ähnlich bei Zugangsdaten: Tokens, die nur für einen Lauf gelten oder wenigstens kurz, sind weniger wert, wenn sie abfließen, als ein Schlüssel, der seit drei Jahren unverändert in den Einstellungen liegt.

Signieren, vergleichen, nachrechnen

Signaturen sind ein zweischneidiges Thema, und der Fall zeigt das ziemlich bitter. Die manipulierten Updates trugen eine gültige Signatur. Eine Signatur sagt eben nur: Dieses Artefakt wurde mit diesem Schlüssel erzeugt. Sie sagt nicht, dass es aus dem geprüften Quellcode entstanden ist. Wer in der Build-Umgebung sitzt, kann ordentlich signieren lassen.

Trotzdem würde ich nicht auf Signaturen verzichten, im Gegenteil. Signierte Commits und signierte Artefakte machen vieles überprüfbar, was sonst nur Vertrauensfrage ist. Man sollte nur nicht glauben, dass sie allein reichen.

Spannender finde ich den Ansatz der reproduzierbaren Builds. Die Idee: Aus demselben Quellcode und derselben Umgebung soll bei jedem Bauen bitgenau dasselbe Ergebnis herauskommen. Dann kann ein zweiter, unabhängiger Build das Ergebnis nachrechnen. Weicht es ab, stimmt etwas nicht. Das Projekt reproducible-builds.org sammelt seit Jahren Erfahrungen und Werkzeuge dazu, vor allem aus der Welt der Linux-Distributionen. Im eigenen Projekt ist das nicht billig, weil Zeitstempel, Reihenfolgen und Pfade überall Unterschiede hineintragen. Aber genau für Fälle wie diesen wäre es ein wirksames Mittel, und selbst ein Teilerfolg bringt Erkenntnisse.

Außerdem gibt es mit in-toto einen Ansatz, die ganze Kette zu beschreiben und zu prüfen: Wer hat welchen Schritt ausgeführt, welche Eingaben und Ausgaben gab es, und passt das zu dem, was vorher festgelegt wurde? Ich habe mich damit noch nicht praktisch beschäftigt und kann es nicht bewerten. Die Richtung leuchtet mir ein: nicht nur das Endprodukt prüfen, sondern den Weg dorthin.

Abhängigkeiten und der Blick nach draußen

Zur Lieferkette gehört nicht nur der eigene Build, sondern alles, was hineinfließt. Bibliotheken, Plugins, Basis-Images, Skripte, die man aus dem Netz zieht. Ich versuche deshalb, Versionen festzunageln, also nicht „neueste“ zu laden, sondern eine bestimmte Version, am besten mit Prüfsumme. Lock-Dateien helfen dabei, wenn man sie wirklich einsetzt und nicht bei jedem Konflikt löscht. Ein neues Update dann bewusst zu übernehmen, kostet etwas Zeit, gibt aber einen Moment, in dem man hinschauen kann.

Und dann gibt es noch die Frage, was ein Build-Server eigentlich nach draußen sprechen darf. Die Schadsoftware musste ja irgendwie mit ihren Auftraggebern in Kontakt treten. In vielen Umgebungen darf der Build-Rechner beliebig ins Internet, weil er Pakete laden muss. Man kann das enger fassen: Zugriff nur auf die Registries und Server, die wirklich gebraucht werden, und Alarm bei allem anderen. Das Überwachen ausgehender Verbindungen ist keine Garantie, aber ein ungewöhnliches Ziel fällt dort womöglich auf, während im Code nichts zu sehen ist.

Was ich daraus mitnehme

Ich habe mir eine kleine Liste gemacht, die ich bei meinen eigenen Projekten abarbeiten will: Wer hat Zugriff aufs Build-System? Welche Jobs haben welche Schlüssel? Wo laden wir etwas ungeprüft aus dem Netz? Was könnte ich reproduzierbar machen? Keine Raketenwissenschaft, aber ich fürchte, bei den meisten Projekten, auch bei meinen, würde schon die erste Frage zu einem unangenehmen Schweigen führen.

Was mich außerdem nachdenklich macht: Der Vorfall zeigt, dass Vertrauen in Lieferketten nicht skaliert. Wir verlassen uns darauf, dass Hersteller sauber bauen, und die Hersteller verlassen sich auf ihre Zulieferer und Werkzeuge. Irgendwo in dieser Kette sitzt immer ein Build-Server, den jemand mal eingerichtet und seitdem nicht mehr angefasst hat. Das lässt sich nicht von heute auf morgen ändern, und ich bin gespannt, welche Standards und Werkzeuge sich in den nächsten Jahren durchsetzen.

Bis dahin hilft wohl nur, im Kleinen anzufangen. Wie sieht das bei euch aus: Wer darf bei euch die CI anfassen, und wann habt ihr zuletzt nachgeschaut?

Beitragsbild: Foto Containerterminal Tollerort, Hamburg von Huhu Uet, CC BY-SA 3.0 (via Wikimedia Commons; zugeschnitten auf 16:9).

$ whoami
Christian Ackermann

Softwareentwickler (C++, C, Java, C#) aus der Oberpfalz, bloggt seit 2001 über Linux, Technik und Kochen.