Signieren von Containerimages mit Notation und Azure Key Vault mithilfe eines selbstsignierten Zertifikats

Artikel
02/23/2024

Das Signieren von Containerimages ist ein Prozess, der ihre Authentizität und Integrität sicherstellt. Dies wird erreicht, indem dem Containerimage eine digitale Signatur hinzugefügt wird, die während der Bereitstellung überprüft werden kann. Die Signatur hilft zu überprüfen, ob das Image von einem vertrauenswürdigen Herausgeber stammt und nicht geändert wurde. Notation ist ein vom Notary Project entwickeltes Open Source Supply Chain-Tool, das das Signieren und Überprüfen von Containerimages und anderen Artefakten unterstützt. Azure Key Vault (AKV) wird verwendet, um Zertifikate mit Signaturschlüsseln zu speichern, der von Notation mit dem AKV-Notation-Plug-In (azure-kv) verwendet werden kann, um Containerimages und andere Artefakte zu signieren und zu überprüfen. Mit dem Azure Container Registry (ACR) können Sie Signaturen an Containerimages und andere Artefakte anfügen und diese Signaturen anzeigen.

In diesem Tutorial wird Folgendes durchgeführt:

Installieren des Notation-Plug-Ins für CLI und AKV
Erstellen eines selbstsignierten Zertifikats in AKV
Erstellen und Pushen eines Containerimages mit ACR Tasks
Signieren eines Containerimages mit Notation-Plug-Ins für CLI und AKV
Überprüfen eines Containerimages anhand der Signatur mit der Notation-CLI

Voraussetzungen

Erstellen oder Verwenden einer Azure Container Registry zum Speichern von Containerimages und -signaturen
Erstellen oder Verwenden eines Azure Key Vault zum Verwalten von Zertifikaten
Installieren und Konfigurieren der neuesten Azure CLI oder Ausführen von Befehlen im Azure Cloud Shell

Installieren des Notation-Plug-Ins für CLI und AKV

Installieren von Notation v1.1.0 in einer Linux amd64-Umgebung Befolgen Sie die Notation-Installationsanleitung, um das Paket für andere Umgebungen herunterzuladen.

# Download, extract and install
curl -Lo notation.tar.gz https://github.com/notaryproject/notation/releases/download/v1.1.0/notation_1.1.0_linux_amd64.tar.gz
tar xvzf notation.tar.gz

# Copy the Notation binary to the desired bin directory in your $PATH, for example
cp ./notation /usr/local/bin

Installieren des Notation-Plug-Ins für Azure Key Vault (azure-kv) v1.0.2 in einer Linux amd64-Umgebung.

Hinweis

Die URL und die SHA-256-Prüfsumme für das Notation-Plug-In für Azure Key Vault finden Sie auf der Releaseseite des Plug-Ins.
```
notation plugin install --url https://github.com/Azure/notation-azure-kv/releases/download/v1.0.2/notation-azure-kv_1.0.2_linux_amd64.tar.gz --sha256sum f2b2e131a435b6a9742c202237b9aceda81859e6d4bd6242c2568ba556cee20e
```
Listen Sie die verfügbaren Plug-Ins auf, und vergewissern Sie sich, dass das Plug-In azure-kv mit der Version 1.0.2 in der Liste enthalten ist.
```
notation plugin ls
```

Konfigurieren von Umgebungsvariablen

Hinweis

Stellen Sie für die einfache Ausführung von Befehlen im Tutorial Werte für die Azure-Ressourcen bereit, die den vorhandenen ACR- und AKV-Ressourcen entsprechen.

Konfigurieren von AKV-Ressourcennamen:

# Name of the existing AKV used to store the signing keys
AKV_NAME=myakv
# Name of the certificate created in AKV
CERT_NAME=wabbit-networks-io
CERT_SUBJECT="CN=wabbit-networks.io,O=Notation,L=Seattle,ST=WA,C=US"
CERT_PATH=./${CERT_NAME}.pem

Konfigurieren von ACR- und Imageressourcennamen:

# Name of the existing registry example: myregistry.azurecr.io
ACR_NAME=myregistry
# Existing full domain of the ACR
REGISTRY=$ACR_NAME.azurecr.io
# Container name inside ACR where image will be stored
REPO=net-monitor
TAG=v1
IMAGE=$REGISTRY/${REPO}:$TAG
# Source code directory containing Dockerfile to build
IMAGE_SOURCE=https://github.com/wabbit-networks/net-monitor.git#main

az login

Weitere Informationen zur Azure CLI und zur Anmeldung mit der Azure CLI finden Sie unter Anmelden mit der Azure CLI.

Zuweisen einer Zugriffsrichtlinie in AKV (Azure CLI)

Ein Benutzerprinzipal mit den richtigen Zugriffsrichtlinienberechtigungen ist erforderlich, um ein selbstsigniertes Zertifikat zu erstellen und Artefakte zu signieren. Dieser Prinzipal kann ein Benutzerprinzipal, ein Dienstprinzipal oder eine verwaltete Identität sein. Dieser Prinzipal benötigt mindestens die folgenden Berechtigungen:

Create-Berechtigungen für Zertifikate
Get-Berechtigungen für Zertifikate
Sign-Berechtigungen für Schlüssel

In diesem Tutorial wird die Zugriffsrichtlinie einem angemeldeten Azure-Benutzer zugewiesen. Weitere Informationen zum Zuweisen von Richtlinien zu einem Prinzipal finden Sie unter Zuweisen einer Zugriffsrichtlinie.

Legt das Abonnement fest, das die AKV-Ressource enthält.

az account set --subscription <your_subscription_id>

Festlegen der Zugriffsrichtlinie in AKV

USER_ID=$(az ad signed-in-user show --query id -o tsv)
az keyvault set-policy -n $AKV_NAME --certificate-permissions create get --key-permissions sign --object-id $USER_ID

Wichtig

Dieses Beispiel zeigt die Mindestberechtigungen, die zum Erstellen eines Zertifikats und zum Signieren eines Containerimages erforderlich sind. Abhängig von Ihren Anforderungen müssen Sie möglicherweise zusätzliche Berechtigungen erteilen.

Erstellen eines selbstsignierten Zertifikats in AKV (Azure CLI)

In den folgenden Schritten wird das Erstellen eines selbstsignierten Zertifikats zu Testzwecken beschrieben.

Erstellen einer Zertifikatrichtliniendatei:

Sobald die Zertifikatrichtliniendatei wie unten ausgeführt wird, erstellt sie ein gültiges Zertifikat, das mit der Notary Project-Zertifikatanforderung in AKV kompatibel ist. Der Wert für ekus dient der Codesignatur, wird von Notation jedoch nicht zum Signieren von Artefakten benötigt. Der Antragsteller wird später als Vertrauensidentität verwendet, die Benutzer*innen während der Überprüfung angeben.

cat <<EOF > ./my_policy.json
{
    "issuerParameters": {
    "certificateTransparency": null,
    "name": "Self"
    },
    "keyProperties": {
      "exportable": false,
      "keySize": 2048,
      "keyType": "RSA",
      "reuseKey": true
    },
    "secretProperties": {
      "contentType": "application/x-pem-file"
    },
    "x509CertificateProperties": {
    "ekus": [
        "1.3.6.1.5.5.7.3.3"
    ],
    "keyUsage": [
        "digitalSignature"
    ],
    "subject": "$CERT_SUBJECT",
    "validityInMonths": 12
    }
}
EOF

Erstellen Sie das Zertifikat.

az keyvault certificate create -n $CERT_NAME --vault-name $AKV_NAME -p @my_policy.json

Signieren eines Containerimages mit Notation-Plug-Ins für CLI und AKV

Authentifizieren Sie sich bei Ihrer ACR-Instanz mithilfe Ihrer individuellen Azure-Identität.
```
az acr login --name $ACR_NAME
```

Wichtig

Wenn Sie Docker auf Ihrem System installiert haben und az acr login oder docker login zur Authentifizierung bei Ihrem ACR verwendet haben, sind Ihre Anmeldeinformationen bereits gespeichert und für die Notation verfügbar. In diesem Fall müssen Sie notation login nicht erneut ausführen, um sich bei Ihrem ACR zu authentifizieren. Weitere Informationen zu Authentifizierungsoptionen für Notation finden Sie unter Authentifizieren mit OCI-konformen Registrierungen.

Erstellen und Pushen eines neuen Images mit ACR Tasks: Verwenden Sie immer den Digestwert, um das Image für die Signatur zu identifizieren, da Tags veränderlich sind und überschrieben werden können.
```
DIGEST=$(az acr build -r $ACR_NAME -t $REGISTRY/${REPO}:$TAG $IMAGE_SOURCE --no-logs --query "outputImages[0].digest" -o tsv)
IMAGE=$REGISTRY/${REPO}@$DIGEST
```
Wenn das Image in diesem Tutorial bereits erstellt wurde und in der Registrierung gespeichert ist, dient das Tag der Einfachheit halber als Bezeichner für dieses Image.
```
IMAGE=$REGISTRY/${REPO}:$TAG
```
Rufen Sie die Schlüssel-ID des Signaturschlüssels ab. Ein Zertifikat in AKV kann mehrere Versionen aufweisen. Der folgende Befehl ruft die Schlüssel-ID der neuesten Version ab.
```
KEY_ID=$(az keyvault certificate show -n $CERT_NAME --vault-name $AKV_NAME --query 'kid' -o tsv)
```
Signieren Sie das Containerimage mit dem COSE-Signaturformat mit der Signaturschlüssel-ID. Um mit einem selbstsignierten Zertifikat zu signieren, müssen Sie den Plug-In-Konfigurationswert self_signed=true festlegen.
```
notation sign --signature-format cose --id $KEY_ID --plugin azure-kv --plugin-config self_signed=true $IMAGE
```
Zeigen Sie das Diagramm der signierten Images und der zugehörigen Signaturen an.
```
notation ls $IMAGE
```

Überprüfen eines Containerimages mit Notation-CLI

Um das Containerimage zu überprüfen, fügen Sie das Stammzertifikat, das das Blattzertifikat signiert, dem Vertrauensspeicher hinzu, und erstellen Sie Vertrauensrichtlinien für die Überprüfung. Für das selbstsignierte Zertifikat, das in diesem Tutorial verwendet wird, ist das Stammzertifikat das selbstsignierte Zertifikat selbst.

Herunterladen des öffentlichen Zertifikats:

az keyvault certificate download --name $CERT_NAME --vault-name $AKV_NAME --file $CERT_PATH

Fügen Sie das heruntergeladene öffentliche Zertifikat dem benannten Vertrauensspeicher zur Signaturüberprüfung hinzu.
```
STORE_TYPE="ca"
STORE_NAME="wabbit-networks.io"
notation cert add --type $STORE_TYPE --store $STORE_NAME $CERT_PATH
```
Listen Sie das Zertifikat für die Bestätigung auf.
```
notation cert ls
```
Konfigurieren Sie die Vertrauensrichtlinie vor der Überprüfung.

Vertrauensrichtlinien ermöglichen es Benutzern, präzise abgestimmte Überprüfungsrichtlinien anzugeben. Im folgenden Beispiel wird eine Vertrauensstellungsrichtlinie mit dem Namen wabbit-networks-images konfiguriert, die für alle Artefakte in $REGISTRY/$REPO gilt und den benannten Vertrauensspeicher $STORE_NAME vom Typ $STORE_TYPE verwendet. Außerdem wird davon ausgegangen, dass der Benutzer einer bestimmten Identität mit dem X.509-Thema $CERT_SUBJECT vertraut. Weitere Informationen finden Sie in der Spezifikation des Vertrauensspeichers und der Vertrauensrichtlinie.
```
cat <<EOF > ./trustpolicy.json
{
    "version": "1.0",
    "trustPolicies": [
        {
            "name": "wabbit-networks-images",
            "registryScopes": [ "$REGISTRY/$REPO" ],
            "signatureVerification": {
                "level" : "strict" 
            },
            "trustStores": [ "$STORE_TYPE:$STORE_NAME" ],
            "trustedIdentities": [
                "x509.subject: $CERT_SUBJECT"
            ]
        }
    ]
}
EOF
```
Verwenden Sie notation policy, um die Vertrauensrichtlinienkonfiguration aus einer zuvor erstellten JSON-Datei zu importieren.
```
notation policy import ./trustpolicy.json
notation policy show
```
Verwenden Sie notation verify, um zu überprüfen, ob das Containerimage seit der Buildzeit nicht geändert wurde.
```
notation verify $IMAGE
```
Nach erfolgreicher Überprüfung des Images mithilfe der Vertrauensrichtlinie wird der SHA-256-Digest des überprüften Images in einer Ausgabemeldung zum Erfolg zurückgegeben.

Nächste Schritte

Siehe Verwenden der Imageintegrität zum Überprüfen signierter Images vor der Bereitstellung in Ihren Azure Kubernetes Service-Clustern (AKS) (Vorschau) und Ratify in Azure, um mit der Überprüfung und Überwachung signierter Bilder zu beginnen, bevor Sie sie auf AKS bereitstellen.