Skip to main content
We publish frequent updates to our documentation, and translation of this page may still be in progress. For the most current information, please visit the English documentation.

Verschlüsselte Geheimnisse

Verschlüsselte Geheimnisse ermöglichen es dir, vertrauliche Informationen in deiner Organisation, deinem Repository oder deinen Repositoryumgebungen.

Informationen zu verschlüsselten Geheimnissen

Geheimnisse sind verschlüsselte Variablen, die du in einer Organisation, einem Repository oder einer Repositoryumgebung erstellst. Du kannst diese Geheimnisse in GitHub Actions-Workflows verwenden. Mithilfe eines versiegelten Libsodium-Felds stellt GitHub sicher, dass die Geheimnisse verschlüsselt werden, bevor sie GitHub erreichen, und dies bis zur Verwendung in einem Workflow auch bleiben.

Für Geheimnisse, die auf Organisationsebene gespeichert sind, kannst Du Zugriffsrichtlinien festlegen, um zu kontrollieren, welche Repositorys die Organisations-Geheimnisse verwenden können. Geheimnisse auf Organisationsebene ermöglichen es Dir, Geheimnisse zwischen mehreren Repositories zu teilen, was die Notwendigkeit zur Erstellung von doppelten Geheimnissen verringert. Die Aktualisierung eines Organisationsgeheimnisses an nur einem Ort stellt außerdem sicher, dass die Änderung in allen Workflows aller Repositorys wirksam wird, die dieses Geheimnis verwenden.

Zur Steuerung des Zugriffs auf Geheimnisse, die auf der Umgebungsebene gespeichert sind, kannst du genehmigende Personen aktivieren. So kann ein Workflowauftrag erst dann auf Umgebungsgeheimnisse zugreifen, nachdem eine genehmigende Person die entsprechende Genehmigung erteilt hat.

Hinweis: Wenn deine GitHub Actions-Workflows auf Ressourcen eines Cloudanbieters zugreifen müssen, der OpenID Connect (OIDC) unterstützt, kannst du deine Workflows so konfigurieren, dass die Authentifizierung direkt beim Cloudanbieter erfolgt. Dadurch musst du diese Anmeldeinformationen nicht mehr als langlebige Geheimnisse speichern und profitierst zudem von weiteren Sicherheitsvorteilen. Weitere Informationen findest du unter Informationen zur Sicherheitshärtung mit OpenID Connect.

Benennen von Geheimnissen

Für Geheimnisnamen gelten folgende Regeln:

  • Namen dürfen nur alphanumerische Zeichen ([a-z], [A-Z], [0-9]) oder Unterstriche (_) enthalten. Leerzeichen sind nicht zulässig.

  • Namen dürfen nicht mit dem Präfix GITHUB_ beginnen.

  • Namen dürfen nicht mit einer Ziffer beginnen.

  • Bei Namen wird nicht zwischen Groß- und Kleinschreibung unterschieden.

  • Namen müssen auf der Ebene eindeutig sein, auf der sie erstellt werden.

    So muss ein auf der Umgebungsebene erstelltes Geheimnis einen eindeutigen Namen in dieser Umgebung besitzen, ein auf der Repositoryebene erstelltes Geheimnis einen eindeutigen Namen in diesem Repository und ein auf der Organisationsebene erstelltes Geheimnis einen eindeutigen Namen auf dieser Ebene.

    Wenn ein Geheimnis mit demselben Namen auf mehreren Ebenen vorhanden ist, erhält das Geheimnis auf der niedrigsten Ebene Vorrang. Wenn beispielsweise ein Geheimnis auf Organisationsebene denselben Namen wie ein Geheimnis auf Repositoryebene aufweist, erhält das Geheimnis auf Repositoryebene Vorrang. Analog dazu hat bei einem Geheimnis mit demselben Namen in einer Organisation, einem Repository und einer Umgebung das Geheimnis auf Umgebungsebene Vorrang.

Damit GitHub dein Geheimnis in Protokollen bearbeitet, verwende keine strukturierten Daten als Werte von Geheimnissen. Vermeide beispielsweise Geheimnisse zu erstellen, die JSON oder codierte Git-Blobs enthalten.

Zugreifen auf Geheimnisse

Um ein Geheimnis für eine Aktion verfügbar zu machen, legest du das Geheimnis als Eingabe oder Umgebungsvariable in der Workflow-Datei fest. In der README-Datei der Aktion erfährst Du, welche Eingaben und Umgebungsvariablen die Aktion erwartet. Weitere Informationen findest du unter Workflowsyntax für GitHub Actions.

Du kannst verschlüsselte Geheimnisse in einer Workflow-Datei verwenden und lesen, wenn du auf die Datei Bearbeitungs-Zugriff hast. Weitere Informationen findest du unter Zugriffsberechtigungen für GitHub.

Warnung: GitHub redigiert automatisch Geheimnisse, die im Protokoll erfasst wurden. Du solltest Geheimnisse jedoch nicht absichtlich im Protokoll erfassen lassen.

Geheimnisse auf der Organisations- und Repositoryebene werden gelesen, wenn eine Workflowausführung in die Warteschlange eingereiht wird, während Geheimnisse auf der Umgebungsebene beim Starten eines Auftrags gelesen werden, der auf die Umgebung verweist.

Mit der REST-API kannst du Geheimnisse auch verwalten. Weitere Informationen findest du unter Geheimnisse.

Einschränken von Berechtigungen für Anmeldeinformationen

Beim Generieren von Anmeldeinformationen wird empfohlen, möglichst geringe Berechtigungen zu erteilen. Verwende z. B. anstelle von persönlichen Anmeldeinformationen Bereitstellungsschlüssel oder ein Dienstkonto. Ziehe in Erwägung, Nur-Lese-Berechtigungen zu gewähren, wenn dies ausreicht, und schränke den Zugriff so weit wie möglich ein. Wähle beim Generieren eines personal access token (classic) nur die nötigsten Bereiche aus. Wähle beim Generieren eines fine-grained personal access token die geringstmögliche Zugriffsberechtigung für das Repository aus.

Hinweis: Mit der REST-API kannst du Geheimnisse verwalten. Weitere Informationen findest du unter API für GitHub Actions-Geheimnisse.

Erstellen verschlüsselter Geheimnisse für ein Repository

Um Geheimnisse oder Variablen für ein persönliches Kontorepository zu erstellen, musst du Repositorybesitzer*in sein. Um Geheimnisse oder Variablen für ein Organisationsrepository zu erstellen, musst du über admin-Zugriff verfügen.

  1. Navigiere auf GitHub.com zur Hauptseite des Repositorys. 1. Klicke unter dem Repositorynamen auf Einstellungen. Schaltfläche „Repositoryeinstellungen“ 1. Wähle im Abschnitt Sicherheit der Randleiste Geheimnisse und Variablen, und klicke dann auf Aktionen. 1. Klicke auf die Registerkarte Geheimnisse. Registerkarte „Repositorygeheimnisse“
  2. Klicke auf Neues Repositorygeheimnis.
  3. Gib einen Namen für dein Geheimnis in das Eingabefeld Name ein.
  4. Gib den Wert für das Geheimnis ein.
  5. Klicke auf Geheimnis hinzufügen.

Wenn dein Repository über Umgebungsgeheimnisse verfügt oder auf Geheimnisse der übergeordneten Organisation zugreifen kann, werden diese Geheimnisse auch auf dieser Seite aufgeführt.

Weitere Informationen zu GitHub CLI findest du unter Informationen zu GitHub CLI.

Verwende zum Hinzufügen eines Geheimnisses auf Repositoryebene den Unterbefehl gh secret set. Ersetze secret-name durch den Namen deines Geheimnisses.

gh secret set SECRET_NAME

Du wirst von der CLI zur Eingabe eines Werts für das Geheimnis aufgefordert. Alternativ kannst du den Wert des Geheimnisses aus einer Datei lesen.

gh secret set SECRET_NAME < secret.txt

Verwende zum Auflisten aller Geheimnisse für das Repository den Unterbefehl gh secret list.

Erstellen verschlüsselter Geheimnisse für eine Umgebung

Um Geheimnisse oder Variablen für eine Umgebung in einem persönlichen Kontorepository zu erstellen, musst du Repositorybesitzer*in sein. Um Geheimnisse oder Variablen für eine Umgebung in einem Organisationsrepository zu erstellen, musst du über admin-Zugriff verfügen.

  1. Navigiere auf GitHub.com zur Hauptseite des Repositorys. 1. Klicke unter dem Repositorynamen auf Einstellungen. Schaltfläche „Repositoryeinstellungen“ 1. Klicke auf der linken Randleiste auf Umgebungen.
  2. Klicke auf die Umgebung, der du ein Geheimnis hinzufügen möchtest.
  3. Klicke unter Umgebungsgeheimnisse auf Geheimnis hinzufügen.
  4. Gib einen Namen für dein Geheimnis in das Eingabefeld Name ein.
  5. Gib den Wert für das Geheimnis ein.
  6. Klicke auf Geheimnis hinzufügen.

Wenn du ein Geheimnis für eine Umgebung hinzufügen möchtest, verwende den Unterbefehl gh secret set mit dem Flag --env oder -e und dem Namen der Umgebung.

gh secret set --env ENV_NAME SECRET_NAME

Wenn du alle Geheimnisse für eine Umgebung auflisten möchtest, verwende den Unterbefehl gh secret list mit dem Flag --env oder -e und dem Namen der Umgebung.

gh secret list --env ENV_NAME

Erstellen verschlüsselter Geheimnisse für eine Organisation

Beim Erstellen eines Geheimnisses oder einer Variable in einer Organisation kannst du mit einer Richtlinie den Zugriff jeweils nach Repository einschränken. Du kannst beispielsweise allen Repositorys Zugriff gewähren oder nur private Repositorys oder eine angegebene Liste von Repositorys zulassen.

Um Geheimnisse oder Variablen auf Organisationsebene zu erstellen, musst du über admin-Zugriff verfügen.

  1. Navigiere auf GitHub.com zur Hauptseite der Organisation. 1. Klicke unter deinem Organisationsnamen auf Einstellungen. Schaltfläche „Organisationseinstellungen“ 1. Wähle im Abschnitt Sicherheit der Randleiste Geheimnisse und Variablen, und klicke dann auf Aktionen. 1. Klicke auf die Registerkarte Geheimnisse. Registerkarte „Organisationsgeheimnisse“
  2. Klicke auf Neues Organisationsgeheimnis.
  3. Gib einen Namen für dein Geheimnis in das Eingabefeld Name ein.
  4. Gib den Wert für das Geheimnis ein.
  5. Wähle in der Dropdownliste Repositoryzugriff eine Zugriffsrichtlinie aus.
  6. Klicke auf Geheimnis hinzufügen.

Hinweis: Standardmäßig erfolgt die GitHub CLI-Authentifizierung mit den Bereichen repo und read:org. Zur Verwaltung von Organisationsgeheimnissen musst du zusätzlich den Bereich admin:org autorisieren.

gh auth login --scopes "admin:org"

Wenn du ein Geheimnis für eine Organisation hinzufügen möchtest, verwende den Unterbefehl gh secret set mit dem Flag --org oder -o und dem Namen der Organisation.

gh secret set --org ORG_NAME SECRET_NAME

Standardmäßig ist das Geheimnis nur für private Repositorys verfügbar. Wenn du angeben möchtest, dass das Geheimnis für alle Repositorys innerhalb der Organisation verfügbar sein soll, verwende das Flag --visibility oder -v.

gh secret set --org ORG_NAME SECRET_NAME --visibility all

Wenn du angeben möchtest, dass das Geheimnis für ausgewählte Repositorys innerhalb der Organisation verfügbar sein soll, verwende das Flag --repos oder -r.

gh secret set --org ORG_NAME SECRET_NAME --repos REPO-NAME-1, REPO-NAME-2"

Wenn du alle Geheimnisse für eine Organisation auflisten möchtest, verwende den Unterbefehl gh secret list mit dem Flag --org oder -o und dem Namen der Organisation.

gh secret list --org ORG_NAME

Überprüfen des Zugriffs auf Organisationsgeheimnisse

Du kannst überprüfen, welche Zugriffsrichtlinien auf ein Geheimnis in deiner Organisation angewendet werden.

  1. Navigiere auf GitHub.com zur Hauptseite der Organisation. 1. Klicke unter deinem Organisationsnamen auf Einstellungen. Schaltfläche „Organisationseinstellungen“ 1. Wähle im Abschnitt Sicherheit der Randleiste Geheimnisse und Variablen, und klicke dann auf Aktionen.
  2. Die Liste der Geheimnisse enthält alle konfigurierten Berechtigungen und Richtlinien. Beispiel: Liste der Geheimnisse
  3. Klicke auf Aktualisieren, um weitere Details zu den konfigurierten Berechtigungen des jeweiligen Geheimnisses anzuzeigen.

Verwenden verschlüsselter Geheimnisse in einem Workflow

Hinweise:

  • Mit Ausnahme von GITHUB_TOKEN werden Geheimnisse nicht an den Runner übergeben, wenn ein Workflow von einem geforkten Repository aus ausgelöst wird.
  • Geheimnisse werden nicht automatisch an wiederverwendbare Workflows übergeben. Weitere Informationen findest du unter Wiederverwenden von Workflows.

Wenn du für eine Aktion ein Geheimnis als Eingabe- oder Umgebungsvariable bereitstellen möchtest, kannst du mithilfe des secrets-Kontexts auf Geheimnisse zugreifen, die du in deinem Repository erstellt hast. Weitere Informationen findest du unter Kontexte und Workflowsyntax für GitHub Actions.

steps:
  - name: Hello world action
    with: # Set the secret as an input
      super_secret: ${{ secrets.SuperSecret }}
    env: # Or as an environment variable
      super_secret: ${{ secrets.SuperSecret }}

In if:-Bedingungen kann nicht direkt auf Geheimnisse verwiesen werden. Erwäge stattdessen, Geheimnisse als Umgebungsvariablen auf Auftragsebene festzulegen, und verweise dann auf die Umgebungsvariablen, um Schritte im Auftrag bedingt auszuführen. Weitere Informationen findest du unter Kontextverfügbarkeit und jobs.<job_id>.steps[*].if.

Wurde kein Geheimnis festgelegt, gibt ein Ausdruck, der auf das Geheimnis verweist (z. B. ${{ secrets.SuperSecret }} im Beispiel), eine leere Zeichenfolge zurück.

Wann immer dies möglich ist, vermeide die Übergabe von Geheimnissen zwischen Prozessen von der Befehlszeile aus. Befehlszeilenprozesse sind möglicherweise für andere Benutzer*innen sichtbar (mit dem Befehl ps) oder können durch Sicherheitsüberwachungsereignisse erfasst werden. Verwende zum Schutz von Geheimnissen Umgebungsvariablen, STDIN oder andere Methoden, die vom Zielprozess unterstützt werden.

Wenn du Geheimnisse innerhalb einer Kommandozeile übergeben musst, umschließe sie im Rahmen der gültigen Quotierungsregeln. Geheimnisse enthalten oft Sonderzeichen, die in deiner Shell unbeabsichtigte Wirkungen entfalten können. Um diese Sonderzeichen zu vermeiden, verwende deine Umgebungsvariablen mit Anführungszeichen. Beispiel:

Beispiel mit Bash

steps:
  - shell: bash
    env:
      SUPER_SECRET: ${{ secrets.SuperSecret }}
    run: |
      example-command "$SUPER_SECRET"

Beispiel mit PowerShell

steps:
  - shell: pwsh
    env:
      SUPER_SECRET: ${{ secrets.SuperSecret }}
    run: |
      example-command "$env:SUPER_SECRET"

Beispiel mit Cmd.exe

steps:
  - shell: cmd
    env:
      SUPER_SECRET: ${{ secrets.SuperSecret }}
    run: |
      example-command "%SUPER_SECRET%"

Einschränkungen für Geheimnisse

Du kannst bis zu 1.000 Organisationsgeheimnisse, 100 Repositorygeheimnisse und 100 Umgebungsgeheimnisse speichern.

Ein Workflow, der in einem Repository erstellt wurde, kann auf die folgende Anzahl von Geheimnissen zugreifen:

  • Alle 100 Repositorygeheimnisse.
  • Wurde dem Repository der Zugriff auf mehr als 100 Geheimnisse auf Organisationsebene zugewiesen, kann der Workflow nur die ersten 100 Organisationsgeheimnisse (alphabetisch nach dem Namen des Geheimnisses sortiert) verwenden.
  • Alle 100 Umgebungsgeheimnisse.

Geheimnisse sind auf 48 KB beschränkt. Weitere Informationen zum Speichern größerer Geheimnisse findest du unter der Problemumgehung Speichern großer Geheimnisse unten.

Speichern großer Geheimnisse

Um Geheimnisse zu verwenden, die größer als 48 KB sind, kannst du mit einer Problemumgehung verschlüsselte Geheimnisse in deinem Repository speichern und die Passphrase zur Entschlüsselung als Geheimnis auf GitHub speichern. Mit gpg kannst du z. B. eine Datei mit deinem Geheimnis lokal verschlüsseln, bevor du die verschlüsselte Datei in deinem Repository auf GitHub eincheckst. Weitere Informationen findest du unter gpg manpage.

Warnung: Vergewissere dich, dass deine Geheimnisse beim Ausführen des Workflows nicht gedruckt werden. Wenn du diesen Workaround verwendest, redigiert GitHub keine Geheimnisse, die in Protokollen gedruckt werden.

  1. Führe in deinem Terminal den folgenden Befehl aus, um die Datei mit deinem Geheimnis mithilfe von gpg und dem AES256-Verschlüsselungsalgorithmus zu verschlüsseln. In diesem Beispiel ist my_secret.json die Datei, die das Geheimnis enthält.

    gpg --symmetric --cipher-algo AES256 my_secret.json
    
  2. Du wirst aufgefordert, eine Passphrase einzugeben. Merke dir die Passphrase, denn du musst ein neues Geheimnis auf GitHub mit der Passphrase als Wert erstellen.

  3. Erstelle ein neues Geheimnis, das die Passphrase enthält. Erstelle z. B. ein neues Geheimnis mit dem Namen LARGE_SECRET_PASSPHRASE, und lege den Wert des Geheimnisses auf die Passphrase fest, die du im vorherigen Schritt verwendet hast.

  4. Kopiere deine verschlüsselte Datei in einen Pfad in deinem Repository, und committe sie. In diesem Beispiel lautet die verschlüsselte Datei my_secret.json.gpg.

    Warnung: Kopiere die verschlüsselte my_secret.json.gpg-Datei, die mit der Dateierweiterung .gpg endet, und nicht die unverschlüsselte my_secret.json-Datei.

    git add my_secret.json.gpg
    git commit -m "Add new encrypted secret JSON file"
    
  5. Erstelle ein Shellskript in deinem Repository, um die Geheimnisdatei zu entschlüsseln. In diesem Beispiel heißt das Skript decrypt_secret.sh.

    #!/bin/sh
    
    # Decrypt the file
    mkdir $HOME/secrets
    # --batch to prevent interactive command
    # --yes to assume "yes" for questions
    gpg --quiet --batch --yes --decrypt --passphrase="$LARGE_SECRET_PASSPHRASE" \
    --output $HOME/secrets/my_secret.json my_secret.json.gpg
    
  6. Stelle sicher, dass dein Shell-Skript ausführbar ist, bevor du es in deinem Repository eincheckst.

    chmod +x decrypt_secret.sh
    git add decrypt_secret.sh
    git commit -m "Add new decryption script"
    git push
    
  7. Verwende in deinem GitHub Actions-Workflow einen step, um das Shellskript aufzurufen und das Geheimnis zu entschlüsseln. Verwende für eine Kopie deines Repositorys in der Umgebung, in der dein Workflow ausgeführt wird, die Aktion actions/checkout. Verweise relativ zum Stamm des Repositorys mithilfe des Befehls run auf dein Shellskript.

    name: Workflows with large secrets
    
    on: push
    
    jobs:
      my-job:
        name: My Job
        runs-on: ubuntu-latest
        steps:
          - uses: actions/checkout@v3
          - name: Decrypt large secret
            run: ./decrypt_secret.sh
            env:
              LARGE_SECRET_PASSPHRASE: ${{ secrets.LARGE_SECRET_PASSPHRASE }}
          # This command is just an example to show your secret being printed
          # Ensure you remove any print statements of your secrets. GitHub does
          # not hide secrets that use this workaround.
          - name: Test printing your secret (Remove this step in production)
            run: cat $HOME/secrets/my_secret.json
    

Speichern binärer Base64-Blobs als Geheimnisse

Mithilfe der Base64-Codierung kannst du kleine binäre Blobs als Geheimnisse speichern. Anschließend kannst du in deinem Workflow auf das Geheimnis verweisen und es zur Verwendung im Runner decodieren. Informationen zu den Größenbeschränkungen findest du unter Grenzwerte für Geheimnisse.

Hinweis: Base64 ermöglicht nur eine Konvertierung von Binärdaten in Text und ersetzt nicht die eigentliche Verschlüsselung.

  1. Verwende base64, um die Datei in eine Base64-Zeichenfolge zu codieren. Beispiel:

    $ base64 -i cert.der -o cert.base64
    
  2. Erstelle ein Geheimnis, das die Base64-Zeichenfolge enthält. Beispiel:

    $ gh secret set CERTIFICATE_BASE64 < cert.base64
    ✓ Set secret CERTIFICATE_BASE64 for octocat/octorepo
    
  3. Leite das Geheimnis per Pipeline an base64 --decode weiter, um vom Runner auf die Base64-Zeichenfolge zuzugreifen. Beispiel:

    name: Retrieve Base64 secret
    on:
      push:
        branches: [ octo-branch ]
    jobs:
      decode-secret:
        runs-on: ubuntu-latest
        steps:
          - uses: actions/checkout@v3
          - name: Retrieve the secret and decode it to a file
            env:
              CERTIFICATE_BASE64: ${{ secrets.CERTIFICATE_BASE64 }}
            run: |
              echo $CERTIFICATE_BASE64 | base64 --decode > cert.der
          - name: Show certificate information
            run: |
              openssl x509 -in cert.der -inform DER -text -noout