Publikationen / Sicherheitssteigerung im Software-Entwicklungsprozess: Eine detaillierte Anleitung für die Integration eines YubiKeys mit Git, Commit-Signing und GitLab
Tim Bastin
Tim Bastin
CTO
Jul 02, 2023

Sicherheitssteigerung im Software-Entwicklungsprozess: Eine detaillierte Anleitung für die Integration eines YubiKeys mit Git, Commit-Signing und GitLab

Bonn, Jul 02, 20231 Minuten Lesezeit
Softwareentwicklung sicher gestalten: Ausführliche Anleitung für die Anwendung von YubiKey, Commit-Signing und GitLab

In der heutigen, hochvernetzten Welt wird die Priorisierung von Sicherheitsmaßnahmen in der Softwareentwicklung immer wichtiger. Mit der steigenden Relevanz verteilter Versionsverwaltungssysteme wie Git und kontinuierlicher Integrationsplattformen wie GitLab geht auch eine erhöhte Gefahr von Angriffen auf die Software-Supply-Chain einher. Laut ENISA Report: "Threat Landscape for Supply Chain Attacks" versuchten 2021 62% der Angreifer das Vertrauen von Unternehmen in die eigene Software-Lieferkette auszunutzen und über diese Angriffe, wie beispielsweise das einschleusen von Malware, durchzuführen.

Englische Version des Artikels

In diesem Kontext wird die Implementierung einer robusten Sicherheitsinfrastruktur zu einer unverzichtbaren Anforderung. Ein Schlüsselelement zur Stärkung dieser Infrastruktur ist das Commit Signing. Commit Signing ist ein Sicherheitsmechanismus in Git, der den Autor eines Commits verifiziert und die Integrität des Commits gewährleistet. Bei aktiviertem Commit Signing werden Commits mit dem privaten Schlüssel des Autors signiert. Jeder, der den zugehörigen öffentlichen Schlüssel hat, kann die Signatur überprüfen und damit sicherstellen, dass der Commit tatsächlich vom angegebenen Autor stammt und nicht manipuliert wurde. Durch die Verifizierung des Autors eines Commits und die Gewährleistung der Integrität des Commits bietet das Commit Signing einen wirksamen Schutz gegen unautorisierte oder manipulierte Codeänderungen.

Um den Schutz noch weiter zu verstärken, kann der Einsatz eines YubiKeys in Betracht gezogen werden. Der YubiKey ist ein physisches Authentifizierungsgerät, das eine starke Zwei-Faktor- und Multi-Faktor-Authentifizierung bietet. Dieses Hardware-Gerät kann nicht nur kryptographische Schlüssel sicher speichern, sondern führt auch kryptographische Operationen auf dem Gerät selbst durch. Das bedeutet, dass ein privater Schlüssel nie das Gerät verlässt und daher nicht kopiert oder gestohlen werden kann.

Durch die Verwendung eines YubiKeys für das Commit Signing wird die Sicherheit dieses Prozesses deutlich erhöht und die Widerstandsfähigkeit der Software-Supply-Chain gegen Angriffe verbessert. Zusätzlich, lässt sich der YubiKey auch für den durch Git durchgeführten Verbindungsaufbau mittels SSH verwenden. Wenn ein Commit an ein Remote-Repository gesendet wird, fordert Git eine SSH-Authentifizierung an. Anstatt den privaten Schlüssel aus einer Datei auf dem Computer zu lesen, kommuniziert SSH mit dem YubiKey, um die notwendigen kryptographischen Operationen durchzuführen. Da der YubiKey physisch an den Computer angeschlossen sein muss, um diese Operationen durchzuführen, bietet dies eine starke Form der Zwei-Faktor-Authentifizierung: etwas, das gewusst werden muss (Passwort) und etwas, das besitzt werden muss (YubiKey).

Angesichts der zunehmenden Bedrohungen für die Software-Supply-Chain ist es von größter Bedeutung, dass alle verfügbaren Werkzeuge und Technologien genutzt werden, um den Softwareentwicklungsprozesse abzusichern. Die Kombination von Git, GitLab, Commit Signing und YubiKey bietet eine effektive Lösung, um diesen Herausforderungen zu begegnen. Der nächste Abschnitt beschreibt die konkrete Konfiguration aller Komponenten.

Sichern der SSH-Verbindung

Um den YubiKey mit Git für den SSH-Verbindungsaufbau unter MacOS zu verwenden, sind zusätzliche Schritte erforderlich, da die Standard-OpenSSH-Version auf MacOS nicht das Erstellen von geheimen Schlüsseln (secret keys) unterstützt. Die entsprechenden Schritte sind:

1. (nur MacOS) Installieren von OpenSSH mit Homebrew

MacOS-Benutzer müssen zunächst eine aktualisierte Version von OpenSSH installieren, die das Erstellen von geheimen Schlüsseln unterstützt (sk). Dies kann mit dem Paketmanager Homebrew erfolgen. Wenn Homebrew auf Ihrem System noch nicht installiert ist, können Sie es von der offiziellen Website herunterladen. Installieren Sie dann OpenSSH mit dem folgenden Terminalbefehl: brew install openssh

2. (nur MacOS) Sicherstellen, dass die korrekte OpenSSH-Version verwendet wird

Als nächstes müssen Sie sicherstellen, dass Ihr System die gerade installierte Version von OpenSSH verwendet und nicht die Standardversion von MacOS. Sie können dies überprüfen, indem Sie das folgende Kommando im Terminal ausführen: which ssh-keygen. Die Ausgabe sollte Folgendem entsprechen: /opt/homebrew/bin/ssh-keygen

Sollte dem nicht so sein, müssen Sie Ihre Shell-Konfigurationsdatei (.zshrc, .bashrc, etc.) ändern. Fügen Sie die folgende Zeile hinzu, um den Pfad der OpenSSH-Version, die Sie gerade installiert haben, zur PATH-Umgebungsvariablen hinzuzufügen: export PATH=$(brew --prefix openssh)/bin:$PATH

Sie müssen die Konfigurationsdatei neu laden oder ein neues Terminalfenster öffnen, damit diese Änderung wirksam wird. Beispielsweise durch: source .zshrc

3. Generieren Sie den SSH-Schlüssel

Nachdem Sie sichergestellt haben, dass Sie die korrekte OpenSSH-Version verwenden, können Sie einen neuen SSH-Schlüssel generieren. Dazu verwenden Sie den Befehl ssh-keygen mit einem speziellen Typ, welcher auf den YubiKey abgelegt werden kann.

Sie können entweder einen Schlüssel des Typs ed25519-sk oder ecdsa-sk generieren. Beide Schlüsseltypen bieten eine starke Sicherheit, aber ed25519-sk ist neuer und wird oft als sicherer angesehen.

ssh-keygen -t ed25519-sk -O resident -O application=ssh -O verify-required

Bei der Ausführung dieser Befehle werden Sie aufgefordert, Ihr YubiKey-Gerät einzustecken und zu berühren, um die Schlüsselgenerierung zu bestätigen. Sie können auch aufgefordert werden, ein Passwort für den Schlüssel einzugeben, um eine zusätzliche Sicherheitsebene hinzuzufügen.

Mit diesen Schritten haben Sie einen neuen SSH-Schlüssel auf Ihrem YubiKey generiert, der jetzt bereit ist, für sichere SSH-Verbindungen, unter anderem von Git, verwendet zu werden.

4. Hinterlegen des öffentlichen Schlüssels in GitLab

Nachdem Sie Ihren neuen SSH-Schlüssel generiert haben, müssen Sie Ihren öffentlichen Schlüssel in GitLab hinterlegen. Dadurch wird GitLab ermöglicht, Sie zu authentifizieren, wenn Sie SSH verwenden, um eine Verbindung zu Ihrem Repository herzustellen.

Befolgen Sie diese Schritte, um Ihren öffentlichen Schlüssel in GitLab zu hinterlegen:

  1. Öffnen Sie zunächst das Terminal und geben Sie den folgenden Befehl ein, um den Inhalt Ihres öffentlichen Schlüssels anzuzeigen (ersetzen Sie "id_ed25519_sk.pub" oder "id_ecdsa_sk.pub" durch den tatsächlichen Pfad zu Ihrer öffentlichen Schlüsseldatei):

    cat ~/.ssh/id_ed25519_sk.pub
    
  2. Kopieren Sie den gesamten Ausgabetext, der Ihren öffentlichen Schlüssel darstellt.

  3. Melden Sie sich nun in Ihrem GitLab-Konto an und navigieren Sie zu den Einstellungen Ihres Kontos (klicken Sie auf Ihr Profilbild in der rechten oberen Ecke und wählen Sie "Settings").

  4. Auf der linken Seite klicken Sie auf "SSH Keys".

  5. Fügen Sie nun Ihren öffentlichen Schlüssel in das Feld "Key" ein. Sie können optional einen Titel für den Schlüssel angeben, um ihn leichter zu identifizieren. Klicken Sie auf "Add Key", um den Schlüssel zu Ihrem Konto hinzuzufügen.

Jetzt ist Ihr YubiKey für die Verwendung mit SSH in GitLab konfiguriert. Wenn Sie versuchen, per SSH auf GitLab zuzugreifen, fordert Ihr System Sie auf, Ihren YubiKey einzustecken und zu berühren, um die Aktion zu bestätigen.

5. Testen der Verbindung

Nachdem Sie Ihren öffentlichen SSH-Schlüssel in GitLab hinterlegt haben, sollten Sie die Verbindung testen, um sicherzustellen, dass alles ordnungsgemäß eingerichtet ist.

Sie können dies tun, indem Sie versuchen, per SSH eine Verbindung zu GitLab herzustellen. Geben Sie dazu den folgenden Befehl in Ihr Terminal ein:

ssh -T git@gitlab.com

Wenn Sie dazu aufgefordert werden, fügen Sie Ihren YubiKey ein und berühren Sie ihn zur Bestätigung.

Wenn die Einrichtung erfolgreich war, erhalten Sie eine Nachricht, die etwa so lautet:

Welcome to GitLab, @username!

Hierbei steht @username für Ihren GitLab-Benutzernamen. Wenn Sie diese Nachricht sehen, bedeutet das, dass Ihr YubiKey erfolgreich für die SSH-Verbindung mit GitLab eingerichtet wurde.

Wenn Sie stattdessen eine Fehlermeldung erhalten, überprüfen Sie bitte die vorherigen Schritte und stellen Sie sicher, dass Sie Ihren öffentlichen Schlüssel korrekt in GitLab eingetragen haben und dass Ihr YubiKey ordnungsgemäß funktioniert.

Sichern der Git-Commits mittels YubiKey

Sobald Ihr YubiKey für die Verwendung mit SSH in GitLab konfiguriert ist, können Sie ihn auch für die Absicherung Ihrer Git-Commits verwenden. Dies wird erreicht, indem Sie Ihren YubiKey für das Signieren von Commits verwenden. Hier sind die Schritte, um das zu erreichen:

1. Installieren notwendiger Werkzeuge

Zunächst müssen Sie einige Werkzeuge installieren, die für die Verwendung von GPG und YubiKey erforderlich sind. Die genauen Schritte hängen von Ihrem Betriebssystem ab:

MacOS

brew install gnupg2
brew install pinentry-mac
brew install ykman
brew install yubikey-personalization

Linux

sudo add-apt-repository ppa:yubico/stable
sudo apt-get update
sudo apt-get install pcscd scdaemon pcsc-tools gnupg2 gnupg-agent
sudo apt-get install yubikey-manager yubikey-personalization-gui yubikey-personalization

2. Erstellen Sie einen GPG-Schlüssel auf Ihrem YubiKey

Um Ihren YubiKey zum Signieren von Git-Commits zu verwenden, benötigen Sie einen GPG-Schlüssel auf Ihrem Gerät. Wenn Sie noch keinen haben, können Sie einen mit dem folgenden Befehl erstellen:

gpg --card-edit

# > admin
# > generate

Geben Sie admin ein, um in den Admin-Modus zu wechseln. Danach geben Sie generate ein, um den Schlüsselgenerierungsprozess zu starten. Sie werden aufgefordert, die Details für Ihren Schlüssel einzugeben, einschließlich Name, E-Mail-Adresse und Passwort.

3. Ermitteln der Key-ID

Nachdem Sie Ihren GPG-Schlüssel erstellt haben, müssen Sie die ID des Schlüssels ermitteln. Sie können dies mit dem folgenden Befehl tun:

gpg --card-status


Reader ...........: Yubico Yubikey XXX
Application ID ...: XXXXX
Version ..........: X.X
Manufacturer .....: Yubico
Serial number ....: XXXXX
Name of cardholder: [not set]
Language prefs ...: [not set]
Sex ..............: unspecified
URL of public key : [not set]
Login data .......: [not set]
Signature PIN ....: forced
Key attributes ...: rsa4096 rsa4096 rsa4096
Max. PIN lengths .: 127 127 127
PIN retry counter : 3 3 3
Signature counter : 0
Signature key ....: XXXX XXXX XXXX XXXX XXXX  XXXX XXXX XXXX XXXX XXXX
  created ....: 2023-01-01 00:00:00
Encryption key....: XXXX XXXX XXXX XXXX XXXX  XXXX XXXX XXXX XXXX XXXX
  created ....: 2023-01-01 00:00:00
Authentication key: XXXX XXXX XXXX XXXX XXXX  XXXX XXXX XXXX XXXX XXXX
  created ....: 2023-01-01 00:00:00
General key info..: pub  rsa4096/XXXXXXXXXXXXXXXX 2018-01-01 NAME <EMAIL>
sec>  rsa4096/XXXXXXXXXXXXXXXX  created: 2023-01-01  expires: never  <=== HIER
                                card-no: 0000 00000000
ssb>  rsa4096/XXXXXXXXXXXXXXXX  created: 2023-01-01  expires: never
                                card-no: 0000 00000000
ssb>  rsa4096/XXXXXXXXXXXXXXXX  created: 2023-01-01  expires: never
                                card-no: 0000 00000000

3. Exportieren des Offentlichen Schlüssels

Um den öffentlichen Teil Ihres GPG-Schlüssels zu exportieren, können Sie den Befehl gpg --armor --export verwenden, gefolgt von der ID Ihres Schlüssels. Dieser Befehl gibt den öffentlichen Schlüssel im "ASCII armor"-Format aus, einer Textdarstellung, die leicht in Emails oder Textdateien eingefügt werden kann.

Hier ist ein Beispiel dafür, wie Sie den öffentlichen Teil eines GPG-Schlüssels exportieren können. Ersetzen Sie in diesem Befehl your-key-id durch die tatsächliche ID Ihres Schlüssels:

gpg --armor --export your-key-id > key.pub

4. Hinterlegen des GPG-Schlüssels in GitLab

Melden Sie sich dann in Ihrem GitLab-Konto an, gehen Sie zu den Einstellungen Ihres Kontos und klicken Sie auf der linken Seite auf "GPG Keys". Fügen Sie Ihren öffentlichen GPG-Schlüssel in das Feld "Key" ein und klicken Sie auf "Add key". Kopieren Sie hierfür einfach den Inhalt der angelegten Datei key.pub.

5. Konfiguration von Git

Die Konfiguration von Git erfolgt über eine Reihe von Konfigurationsdateien, die verschiedene Einstellungen enthalten können. Die Hauptkonfigurationsdatei ist .gitconfig, die sich normalerweise im Home-Verzeichnis des Benutzers befindet (~/.gitconfig).

Sie können die Konfigurationsdatei mit einem Texteditor Ihrer Wahl öffnen und bearbeiten. Git liest diese Datei und verwendet die darin definierten Einstellungen jedes Mal, wenn es ausgeführt wird.

Ändern Sie Ihre .gitconfig so ab, dass sie die folgenden Einstellungen enthält:

[user]
    name = Ihr Name
    email = ihre.email@beispiel.de
    signingkey = your-key-id
[commit]
    gpgsign = true

5. Testen des Signaturprozesses

Nachdem Sie Ihren GPG-Schlüssel in Git und GitLab konfiguriert haben, sollten Sie den Signaturprozess testen, um sicherzustellen, dass alles ordnungsgemäß funktioniert. Dies können Sie tun, indem Sie einen neuen Commit erstellen und prüfen, ob er ordnungsgemäß signiert wurde.

Navigieren Sie zunächst zu einem lokalen Git-Repository auf Ihrem Computer, führen Sie einen Commit durch und überprüfen Sie die Signatur mittels:

git log --show-signature

Wenn alles ordnungsgemäß eingerichtet ist, sollte die Ausgabe des Befehls Folgendes enthalten:

gpg: Signature made ...
gpg: using RSA key <your-key-id>

Auch in GitLab sollte dieser Commit nun als verifiziert markiert werden.

Troubleshooting

Bei Problemen, welche auf ein "Invalides Format" hindeuten, kann folgende GPG Konfiguration helfen:

export GPG_TTY=$(tty)

Die Absicherung des Softwareentwicklungsprozesses ist eine kontinuierliche und notwendige Aufgabe in unserer digitalen Welt. Durch die Implementierung von Commit Signing und die Verwendung von YubiKey in Kombination mit Git und GitLab können wir die Integrität unserer Codebasis schützen und die Vertrauenswürdigkeit unserer Software-Lieferkette gewährleisten. Mit der hier bereitgestellten detaillierten Anleitung hoffen wir, dass Sie einen klaren Weg zur Integration dieser wertvollen Sicherheitstools in Ihren eigenen Software-Entwicklungsprozess finden. Die Reise zur Stärkung der Software-Sicherheit ist lang und erfordert kontinuierliche Anstrengungen, aber mit den richtigen Werkzeugen und Kenntnissen können wir gemeinsam eine sicherere und vertrauenswürdige digitale Zukunft gestalten.