Signer des images conteneur avec Notation et Azure Key Vault à l'aide d'un certificat auto-signé

Article
02/29/2024

La signature d'images conteneur est un processus qui garantit leur authenticité et leur intégrité. Pour ce faire, ajoutez une signature numérique à l'image conteneur, qui peut être validée pendant le déploiement. La signature permet de vérifier que l'image provient d'un éditeur approuvé et qu'elle n'a pas été modifiée. Notation est un outil de chaîne logistique open source développé par le Projet Notary, qui prend en charge la signature et la vérification d'images conteneur et d'autres artefacts. Azure Key Vault (AKV) est utilisé pour stocker des certificats avec des clés de signature qui peuvent être utilisées par Notation avec le plug-in AKV de Notation (azure-kv) pour signer et vérifier les images conteneur et d'autres artefacts. L'Azure Container Registry (ACR) vous permet d'attacher des signatures à des images conteneur et à d'autres artefacts, ainsi que d'afficher ces signatures.

Dans ce tutoriel :

Installer l'interface CLI de Notation et le plug-in AKV
Créer un certificat auto-signé dans AKV
Générez et envoyez (push) une image conteneur avec ACR Tasks.
Signer une image conteneur avec l'interface CLI de Notation et le plug-in AKV
Valider une image conteneur par rapport à la signature avec l'interface CLI de Notation

Prérequis

Créer ou utiliser un Azure Container Registry pour stocker des images conteneurs et des signatures
Créer ou utiliser un Azure Key Vault pour la gestion des certificats
Installer et configurer les dernières commandes Azure CLI ou Exécuter dans Azure Cloud Shell

Installer l'interface CLI de Notation et le plug-in AKV

Installez Notation v1.1.0 sur un environnement Linux amd64. Suivez le Guide d’installation de Notation pour télécharger le package pour d’autres environnements.

# 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

Installez le plug-in Notation Azure Key Vault azure-kv v1.0.2 sur un environnement Linux amd64.

Remarque

L’URL et la somme de contrôle SHA256 du plug-in Notation Azure Key Vault se trouvent dans la page de version du plug-in.
```
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
```
Listez les plug-ins disponibles et vérifiez que le plug-in azure-kv avec la version 1.0.2 est inclus dans la liste.
```
notation plugin ls
```

Configuration des variables d’environnement

Notes

Pour faciliter l’exécution des commandes dans le tutoriel, fournissez des valeurs pour les ressources Azure afin de faire correspondre les ressources ACR et AKV existantes.

Configurez les noms de ressources AKV.

# 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

Configurez les noms de ressources ACR et d’image.

# 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

Pour en savoir plus sur Azure CLI et sur la façon de se connecter avec elle, reportez-vous à Se connecter avec Azure CLI.

Affecter une stratégie d'accès dans AKV (Azure CLI)

Un principal d'utilisateur disposant des autorisations de stratégie d'accès appropriées est nécessaire pour créer un certificat auto-signé et signer des artefacts. Ce principal peut être un principal d'utilisateur, un principal de service, ou une identité managée. Au minimum, ce principal a besoin des autorisations suivantes :

Create autorisations pour les certificats
Get autorisations pour les certificats
Sign autorisations pour les clés

Dans ce tutoriel, la stratégie d'accès est attribuée à un utilisateur Azure connecté. Pour en savoir plus sur l'attribution d'une stratégie à un principal, reportez-vous à Attribuer une stratégie d'accès.

Définir l'abonnement qui contient la ressource AKV

az account set --subscription <your_subscription_id>

Définir la stratégie d'accès dans 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

Important

Cet exemple montre les autorisations minimales nécessaires pour créer un certificat et signer une image conteneur. Selon vos besoins, vous devrez peut-être accorder des autorisations supplémentaires.

Créer un certificat auto-signé dans AKV (Azure CLI)

Les étapes suivantes montrent comment créer un certificat auto-signé à des fins de test.

Créez un fichier de stratégie de certificat

Une fois le fichier de stratégie de certificat exécuté comme ci-dessous, il crée un certificat de signature valide compatible avec les exigences du certificat de Projet Notary dans AKV. La valeur pour ekus est destinée à la signature de code, mais n'est pas requise pour signer des artefacts avec Notation. L’objet est utilisé ultérieurement comme identité de confiance que l’utilisateur approuve lors de la vérification.

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

Créez le certificat

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

Signer une image conteneur avec l'interface CLI de Notation et le plug-in AKV

Authentifiez-vous auprès de votre ACR à l'aide de votre identité Azure individuelle.
```
az acr login --name $ACR_NAME
```

Important

Si vous avez installé Docker sur votre système et utilisé az acr login ou docker login pour vous authentifier auprès de votre ACR, c'est que vos informations d'identification sont déjà stockées et disponibles dans Notation. Dans ce cas, vous n'avez pas besoin de réexécuter notation login pour vous authentifier auprès de votre ACR. Pour en savoir plus sur les options d'authentification pour Notation, reportez-vous à Authentifier avec des registres conformes à OCI.

Générez et envoyez (push) une nouvelle image avec ACR Tasks. Utilisez toujours la valeur de synthèse pour identifier l'image à signer, car les étiquettes sont mutables et peuvent être remplacées.
```
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
```
Dans ce tutoriel, si l'image a déjà été créée et est stockée dans le registre, l'étiquette sert d'identificateur pour cette image pour plus de commodité.
```
IMAGE=$REGISTRY/${REPO}:$TAG
```
Obtenez l'ID de clé de la clé de signature. Un certificat dans AKV peut avoir plusieurs versions. La commande suivante obtient l'ID de clé de la dernière version.
```
KEY_ID=$(az keyvault certificate show -n $CERT_NAME --vault-name $AKV_NAME --query 'kid' -o tsv)
```
Signez l'image conteneur avec le format de signature COSE à l'aide de la clé de signature. Pour signer avec un certificat auto-signé, vous devez définir la valeur self_signed=true de configuration du plug-in.
```
notation sign --signature-format cose --id $KEY_ID --plugin azure-kv --plugin-config self_signed=true $IMAGE
```
Affichez le graphique des images signées et des signatures associées.
```
notation ls $IMAGE
```

Vérifier une image conteneur avec l'interface CLI de Notation

Pour vérifier l'image conteneur, ajoutez le certificat racine qui signe le certificat nœud terminal au magasin de confiance et créez des stratégies de confiance pour vérification. Pour le certificat auto-signé utilisé dans ce tutoriel, le certificat racine est le certificat auto-signé lui-même.

Téléchargez le certificat public.

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

Ajoutez le certificat public téléchargé au magasin de confiance nommé pour la vérification de la signature.

STORE_TYPE="ca"
STORE_NAME="wabbit-networks.io"
notation cert add --type $STORE_TYPE --store $STORE_NAME $CERT_PATH

Répertoriez le certificat à confirmer.
```
notation cert ls
```
Configurez la stratégie de confiance avant la vérification.

Les stratégies d'approbation permettent aux utilisateurs de spécifier des stratégies de vérification affinées. L'exemple suivant configure une stratégie de confiance nommée wabbit-networks-images, qui s'applique à tous les artefacts dans $REGISTRY/$REPO et utilise le magasin de confiance $STORE_NAME nommé de type $STORE_TYPE. Il suppose également que l'utilisateur approuve une identité spécifique avec l'objet X.509 $CERT_SUBJECT. Pour plus d'informations, reportez-vous à Magasin de confiance et spécification de stratégie de confiance.
```
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
```
Utilisez notation policy pour importer la configuration de la stratégie de confiance à partir d’un fichier JSON que nous avons créé précédemment.
```
notation policy import ./trustpolicy.json
notation policy show
```
Utilisez notation verify pour vérifier que l'image conteneur n'a pas été modifiée depuis sa création.
```
notation verify $IMAGE
```
En cas de vérification réussie de l’image à l’aide de la stratégie de confiance, la synthèse sha256 de l’image vérifiée est retournée dans un message de sortie réussi.

Étapes suivantes

Consultez Utiliser l’intégrité des images pour valider les images signées avant de les déployer sur vos clusters Azure Kubernetes Service (préversion) et Ratifier sur Azure pour commencer à vérifier et auditer les images signées avant de les déployer sur AKS.