Créer, signer et vérifier des images conteneur à l’aide d’Azure Key Vault (préversion)

Article
03/09/2023
5 minutes pour lire

Azure Key Vault (AKV) est utilisé pour stocker une clé de signature qui peut être utilisée par notation avec le plug-in AKV de notation (azure-kv) pour signer et vérifier les images conteneur et d’autres artefacts. Azure Container Registry (ACR) vous permet d’attacher ces signatures à l’aide des commandes CLI az ou oras.

Les conteneurs signés permettent aux utilisateurs d’assurer que les déploiements sont générés à partir d’une entité approuvée et que l’artefact n’a pas été falsifié depuis leur création. L’artefact signé garantit l’intégrité et l’authenticité avant que l’utilisateur n’extrait un artefact dans n’importe quel environnement et évite les attaques.

Dans ce tutoriel :

Stocker un certificat de signature dans Azure Key Vault
Signer une image conteneur avec notation
Vérifier une signature d’image conteneur avec notation

Prérequis

Créer un ACR et s’y connecter avec l’artefact OCI activé

Créer ou utiliser un Key Vault Azure

Ce tutoriel peut être exécuté dans Azure Cloud Shell

Installer l’interface CLI de notation et le plug-in AKV

Installez la notation v1.0.0-rc.1 avec prise en charge du plug-in sur un environnement Linux. Vous pouvez également télécharger le package pour d’autres environnements à partir de la page de mise en production.

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

# Copy the notation cli to the desired bin directory in your PATH
cp ./notation /usr/local/bin

Installez le plug-in de notation Azure Key Vault pour la signature et la vérification à distance.

Notes

Le répertoire du plug-in varie en fonction du système d’exploitation utilisé. Le chemin d’accès au répertoire ci-dessous suppose Ubuntu. Pour plus d’informations, consultez l’article de configuration de notation.

# Create a directory for the plugin
mkdir -p ~/.config/notation/plugins/azure-kv

# Download the plugin
curl -Lo notation-azure-kv.tar.gz \
    https://github.com/Azure/notation-azure-kv/releases/download/v0.5.0-rc.1/notation-azure-kv_0.5.0-rc.1_Linux_amd64.tar.gz

# Extract to the plugin directory
tar xvzf notation-azure-kv.tar.gz -C ~/.config/notation/plugins/azure-kv notation-azure-kv

Répertoriez les plug-ins disponibles et vérifier que le plug-in est disponible.
```
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 Azure Key Vault used to store the signing keys
AKV_NAME=<your-unique-keyvault-name>
# New desired key name used to sign and verify
KEY_NAME=wabbit-networks-io
CERT_SUBJECT="CN=wabbit-networks.io,O=Notary,L=Seattle,ST=WA,C=US"
CERT_PATH=./${KEY_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

Stocker le certificat de signature dans AKV

Si vous disposez d’un certificat existant, chargez-le dans AKV. Pour plus d’informations sur l’utilisation de votre propre clé de signature, consultez les exigences de certificat de signature. Sinon, créez un certificat auto-signé x509 qui le stocke dans AKV pour la signature à distance à l’aide des étapes ci-dessous.

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

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 la notation dans AKV. L’utilisation améliorée de la clé répertoriée est destinée à la signature de code, mais n’est pas requise pour la notation afin de signer des artefacts. L’objet est utilisé ultérieurement comme identité de confiance que l’utilisateur utilise lors de la vérification.
```
cat <<EOF > ./my_policy.json
{
    "issuerParameters": {
    "certificateTransparency": null,
    "name": "Self"
    },
    "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 $KEY_NAME --vault-name $AKV_NAME -p @my_policy.json

Obtenez l’ID de clé du certificat.

KEY_ID=$(az keyvault certificate show -n $KEY_NAME --vault-name $AKV_NAME --query 'kid' -o tsv)

Téléchargez le certificat public.

CERT_ID=$(az keyvault certificate show -n $KEY_NAME --vault-name $AKV_NAME --query 'id' -o tsv)
az keyvault certificate download --file $CERT_PATH --id $CERT_ID --encoding PEM

Ajoutez une clé de signature référençant l’ID de clé.
```
notation key add $KEY_NAME --plugin azure-kv --id $KEY_ID
```
Répertoriez les clés à confirmer.
```
notation key ls
```

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épertorier le certificat à confirmer
```
notation cert ls
```

Générer et signer une image conteneur

Générez et envoyez (push) une nouvelle image avec ACR Tasks.
```
az acr build -r $ACR_NAME -t $IMAGE $IMAGE_SOURCE
```

S’authentifier avec votre identité Azure AD individuelle pour utiliser un jeton ACR.

export USER_NAME="00000000-0000-0000-0000-000000000000"
export PASSWORD=$(az acr login --name $ACR_NAME --expose-token --output tsv --query accessToken)
notation login -u $USER_NAME -p $PASSWORD $REGISTRY

Signez l’image conteneur avec le format de signature COSE à l’aide de la clé de signature ajoutée à l’étape précédente.
```
notation sign --signature-format cose --key $KEY_NAME $IMAGE
```
Affichez le graphique des images signées et des signatures associées.
```
notation ls $IMAGE
```

Afficher le graphique des artefacts avec l’interface CLI ORAS (facultatif)

La prise en charge d’ACR pour les artefacts OCI active un graphique lié d’artefacts de chaîne d’approvisionnement qui peuvent être consultés via l’interface CLI ORAS ou Azure CLI.

Les images signées peuvent être consultées avec l’interface CLI ORAS.

oras login -u $USER_NAME -p $PASSWORD $REGISTRY
oras discover -o tree $IMAGE

Afficher le graphique des artefacts avec l’interface Azure CLI (facultatif)

Répertoriez les détails du manifeste pour l’image du conteneur.
```
az acr manifest show-metadata $IMAGE -o jsonc
```

Génère un résultat, montrant le digest représentant la signature du notaire v2.

{
  "changeableAttributes": {
    "deleteEnabled": true,
    "listEnabled": true,
    "readEnabled": true,
    "writeEnabled": true
  },
  "createdTime": "2022-05-13T23:15:54.3478293Z",
  "digest": "sha256:effba96d9b7092a0de4fa6710f6e73bf8c838e4fbd536e95de94915777b18613",
  "lastUpdateTime": "2022-05-13T23:15:54.3478293Z",
  "name": "v1",
  "quarantineState": "Passed",
  "signed": false
}

Vérifier l’image de conteneur

Configurez la stratégie de confiance avant la vérification.

La stratégie de confiance est un document JSON nommé trustpolicy.json, qui est stocké dans le répertoire de configuration de la notation. Les utilisateurs qui vérifient les artefacts signés à partir d’un registre utilisent la stratégie de confiance pour spécifier les identités approuvées qui signent les artefacts et le niveau de vérification de signature à utiliser.

Utilisez la commande suivante pour configurer la stratégie de confiance pour ce tutoriel. Une fois la commande exécutée, une stratégie de confiance nommée wabbit-networks-images est créée. Cette stratégie de confiance s’applique à tous les artefacts stockés dans les référentiels définis dans $REGISTRY/$REPO. L’identité de confiance que l’utilisateur utilise a l’objet x509 $CERT_SUBJECT à partir de l’étape précédente et est stockée sous le magasin de confiance nommé $STORE_NAME de type $STORE_TYPE. Pour plus d’informations, consultez Magasin de confiance et spécification de stratégie de confiance.
```
cat <<EOF > $HOME/.config/notation/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
```
La commande de notation peut également vous aider à vous assurer que l’image conteneur n’a pas été falsifiée depuis le moment de la génération en comparant sha avec ce qui se trouve dans le registre.
```
notation verify $IMAGE
```
En cas de vérification réussie de l’image à l’aide de la stratégie de confiance, le condensé sha256 de l’image vérifiée est retourné dans un message de sortie réussi.

Étapes suivantes

Consultez Appliquer une stratégie pour déployer uniquement des images de conteneur signées sur Azure Kubernetes Service (AKS) à l’aide de la ratification et de l’opérateur de contrôle.