Signera containeravbildningar med Notation och Azure Key Vault med ett självsignerat certifikat

Artikel
04/27/2024

Signering av containeravbildningar är en process som säkerställer deras äkthet och integritet. Detta uppnås genom att lägga till en digital signatur i containeravbildningen, som kan verifieras under distributionen. Signaturen hjälper till att verifiera att avbildningen kommer från en betrodd utgivare och inte har ändrats. Notation är ett öppen källkod verktyg för leveranskedjan som utvecklats av Notary Project, som stöder signering och verifiering av containeravbildningar och andra artefakter. Azure Key Vault (AKV) används för att lagra certifikat med signeringsnycklar som kan användas av Notation med plugin-programmet Notation AKV (azure-kv) för att signera och verifiera containeravbildningar och andra artefakter. Med Azure Container Registry (ACR) kan du bifoga signaturer till containeravbildningar och andra artefakter samt visa dessa signaturer.

I den här självstudien:

Installera Plugin-programmet Notation CLI och AKV
Skapa ett självsignerat certifikat i AKV
Skapa och push-överföra en containeravbildning med ACR Tasks
Signera en containeravbildning med plugin-programmet Notation CLI och AKV
Verifiera en containeravbildning mot signaturen med Notation CLI

Förutsättningar

Skapa eller använda ett Azure Container Registry för att lagra containeravbildningar och signaturer
Skapa eller använda ett Azure Key Vault för att hantera certifikat
Installera och konfigurera de senaste Azure CLI- eller Kör-kommandona i Azure Cloud Shell

Installera Plugin-programmet Notation CLI och AKV

Installera Notation v1.1.0 i en Linux amd64-miljö. Följ installationsguiden för Notation för att ladda ned paketet för andra miljöer.

# 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

Installera plugin-programmet azure-kv Notation Azure Key Vault v1.1.0 i en Linux amd64-miljö.

Kommentar

URL:en och SHA256-kontrollsumman för plugin-programmet Notation Azure Key Vault finns på plugin-programmets versionssida.
```
notation plugin install --url https://github.com/Azure/notation-azure-kv/releases/download/v1.1.0/notation-azure-kv_1.1.0_linux_amd64.tar.gz --sha256sum 2fc959bf850275246b044203609202329d015005574fabbf3e6393345e49b884
```
Visa en lista över tillgängliga plugin-program och bekräfta att azure-kv plugin-programmet med version 1.1.0 ingår i listan.
```
notation plugin ls
```

Konfigurera miljövariabler

Kommentar

För enkel körning av kommandon i självstudien anger du värden för Azure-resurserna som matchar de befintliga ACR- och AKV-resurserna.

Konfigurera AKV-resursnamn.

# 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

Konfigurera ACR- och avbildningsresursnamn.

# 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

Mer information om Azure CLI och hur du loggar in med det finns i Logga in med Azure CLI.

Tilldela åtkomstprincip i AKV (Azure CLI)

Ett användarhuvudnamn med rätt behörigheter för åtkomstprinciper krävs för att skapa ett självsignerat certifikat och signera artefakter. Det här huvudkontot kan vara användarens huvudnamn, tjänstens huvudnamn eller en hanterad identitet. Det här huvudkontot behöver minst följande behörigheter:

Create behörigheter för certifikat
Get behörigheter för certifikat
Sign behörigheter för nycklar

I den här självstudien tilldelas åtkomstprincipen till en inloggad Azure-användare. Mer information om hur du tilldelar principer till ett huvudnamn finns i Tilldela åtkomstprincip.

Ange den prenumeration som innehåller AKV-resursen

az account set --subscription <your_subscription_id>

Ange åtkomstprincipen i 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

Viktigt!

Det här exemplet visar de minsta behörigheter som krävs för att skapa ett certifikat och signera en containeravbildning. Beroende på dina krav kan du behöva bevilja ytterligare behörigheter.

Skapa ett självsignerat certifikat i AKV (Azure CLI)

Följande steg visar hur du skapar ett självsignerat certifikat i testsyfte.

Skapa en certifikatprincipfil.

När certifikatprincipfilen körs enligt nedan skapar den ett giltigt certifikat som är kompatibelt med kravet på Notary Project-certifikat i AKV. Värdet för ekus är för kodsignering, men krävs inte för att notation ska signera artefakter. Ämnet används senare som förtroendeidentitet som användaren litar på under verifieringen.

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

Skapa certifikatet.

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

Signera en containeravbildning med plugin-programmet Notation CLI och AKV

Autentisera till din ACR med hjälp av din enskilda Azure-identitet.
```
az acr login --name $ACR_NAME
```

Viktigt!

Om du har Docker installerat på systemet och använt az acr login eller docker login för att autentisera till din ACR, är dina autentiseringsuppgifter redan lagrade och tillgängliga för notation. I det här fallet behöver du inte köra notation login igen för att autentisera till din ACR. Mer information om autentiseringsalternativ för notation finns i Autentisera med OCI-kompatibla register.

Skapa och push-överföra en ny avbildning med ACR Tasks. Använd alltid sammandragsvärdet för att identifiera avbildningen för signering eftersom taggarna är föränderliga och kan skrivas över.
```
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
```
I den här självstudien, om avbildningen redan har skapats och lagras i registret, fungerar taggen som en identifierare för avbildningen för enkelhetens skull.
```
IMAGE=$REGISTRY/${REPO}:$TAG
```
Hämta nyckel-ID:t för signeringsnyckeln. Ett certifikat i AKV kan ha flera versioner. Följande kommando hämtar nyckel-ID:t för den senaste versionen.
```
KEY_ID=$(az keyvault certificate show -n $CERT_NAME --vault-name $AKV_NAME --query 'kid' -o tsv)
```

Signera containeravbildningen med COSE-signaturformatet med hjälp av signeringsnyckelns ID. Om du vill signera med ett självsignerat certifikat måste du ange konfigurationsvärdet för plugin-programmet self_signed=true.

notation sign --signature-format cose --id $KEY_ID --plugin azure-kv --plugin-config self_signed=true $IMAGE

För att autentisera med AKV provas som standard följande typer av autentiseringsuppgifter om det är aktiverat i ordning:

Om du vill ange en typ av autentiseringsuppgifter använder du ytterligare en plugin-konfiguration med namnet credential_type. Du kan till exempel uttryckligen ange credential_type till för att azurecli använda Azure CLI-autentiseringsuppgifter, vilket visas nedan:

notation sign --signature-format cose --id $KEY_ID --plugin azure-kv --plugin-config self_signed=true --plugin-config credential_type=azurecli $IMAGE

Se tabellen nedan för värdena för för olika typer av credential_type autentiseringsuppgifter.

Typ av autentiseringsuppgifter	Värde för `credential_type`
Miljöautentiseringsuppgifter	`environment`
Autentiseringsuppgifter för arbetsbelastningsidentitet	`workloadid`
Autentiseringsuppgifter för hanterad identitet	`managedid`
Azure CLI-autentiseringsuppgifter	`azurecli`

Visa grafen över signerade bilder och associerade signaturer.
```
notation ls $IMAGE
```

Verifiera en containeravbildning med Notation CLI

Om du vill verifiera containeravbildningen lägger du till rotcertifikatet som signerar lövcertifikatet i förtroendearkivet och skapar förtroendeprinciper för verifiering. För det självsignerade certifikat som används i den här självstudien är rotcertifikatet det självsignerade certifikatet.

Ladda ned offentligt certifikat.

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

Lägg till det nedladdade offentliga certifikatet i det namngivna förtroendearkivet för signaturverifiering.

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

Visa en lista över certifikatet som ska bekräftas.
```
notation cert ls
```
Konfigurera förtroendeprincip före verifiering.

Med förtroendeprinciper kan användare ange finjusterade verifieringsprinciper. I följande exempel konfigureras en förtroendeprincip med namnet wabbit-networks-images, som gäller för alla artefakter i $REGISTRY/$REPO och använder det namngivna förtroendearkivet $STORE_NAME av typen $STORE_TYPE. Det förutsätter också att användaren litar på en specifik identitet med X.509-ämnet $CERT_SUBJECT. Mer information finns i Specifikation för förtroendelagring och förtroendeprincip.
```
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
```
Använd notation policy för att importera konfigurationen av förtroendeprincipen från en JSON-fil som vi skapade tidigare.
```
notation policy import ./trustpolicy.json
notation policy show
```
Använd notation verify för att kontrollera att containeravbildningen inte har ändrats sedan byggtiden.
```
notation verify $IMAGE
```
När avbildningen har verifierats med hjälp av förtroendeprincipen returneras sha256-sammanfattningen av den verifierade avbildningen i ett lyckat utdatameddelande.

Nästa steg

Se Använda avbildningsintegritet för att verifiera signerade avbildningar innan du distribuerar dem till dina AKS-kluster (Azure Kubernetes Service) (förhandsversion) och Ratificering i Azure för att komma igång med att verifiera och granska signerade avbildningar innan du distribuerar dem på AKS.