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

Artikel
10/16/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 säkerhetsverktyg för leveranskedjan som utvecklats av Notary Project-communityn och som stöds av Microsoft, 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
Tidsstämpling

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.2.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.2.0/notation_1.2.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.2.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.2.0/notation-azure-kv_1.2.0_linux_amd64.tar.gz --sha256sum 06bb5198af31ce11b08c4557ae4c2cbfb09878dfa6b637b7407ebc2d57b87b34
```
Visa en lista över tillgängliga plugin-program och bekräfta att azure-kv plugin-programmet med version 1.2.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.

AKV_SUB_ID=myAkvSubscriptionId
AKV_RG=myAkvResourceGroup
# 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.

ACR_SUB_ID=myAcrSubscriptionId
ACR_RG=myAcrResourceGroup
# 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.

Skydda åtkomstbehörigheter till ACR och AKV

När du arbetar med ACR och AKV är det viktigt att bevilja lämpliga behörigheter för att säkerställa säker och kontrollerad åtkomst. Du kan auktorisera åtkomst för olika entiteter, till exempel användarhuvudnamn, tjänstens huvudnamn eller hanterade identiteter, beroende på dina specifika scenarier. I den här självstudien har åtkomsten behörighet till en inloggad Azure-användare.

Auktorisera åtkomst till ACR

Rollerna AcrPull och AcrPush krävs för signering av containeravbildningar i ACR.

Ange den prenumeration som innehåller ACR-resursen
```
az account set --subscription $ACR_SUB_ID
```

Tilldela rollerna

USER_ID=$(az ad signed-in-user show --query id -o tsv)
az role assignment create --role "AcrPull" --role "AcrPush" --assignee $USER_ID --scope "/subscriptions/$ACR_SUB_ID/resourceGroups/$ACR_RG/providers/Microsoft.ContainerRegistry/registries/$ACR_NAME"

Auktorisera åtkomst till AKV

I det här avsnittet utforskar vi två alternativ för att auktorisera åtkomst till AKV.

Använda Azure RBAC (rekommenderas)

Följande roller krävs för signering med självsignerade certifikat:

Key Vault Certificates Officer för att skapa och läsa certifikat
Key Vault Certificates Userför att läsa befintliga certifikat
Key Vault Crypto User för signeringsåtgärder

Mer information om Key Vault-åtkomst med Azure RBAC finns i Använda en Azure RBAC för att hantera åtkomst.

Ange den prenumeration som innehåller AKV-resursen
```
az account set --subscription $AKV_SUB_ID
```

Tilldela rollerna

USER_ID=$(az ad signed-in-user show --query id -o tsv)
az role assignment create --role "Key Vault Certificates Officer" --role "Key Vault Crypto User" --assignee $USER_ID --scope "/subscriptions/$AKV_SUB_ID/resourceGroups/$AKV_RG/providers/Microsoft.KeyVault/vaults/$AKV_NAME"

Tilldela åtkomstprincip i AKV (äldre)

Följande behörigheter krävs för en identitet:

Create behörigheter för att skapa ett certifikat
Get behörigheter för att läsa befintliga certifikat
Sign behörigheter för signeringsåtgärder

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 $AKV_SUB_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.

Tidsstämpling

Sedan Notation v1.2.0-versionen stöder Notation RFC 3161-kompatibel tidsstämpling. Den här förbättringen utökar förtroendet för signaturer som skapats inom certifikatets giltighetsperiod genom att lita på en tidsstämplingsutfärdare (TSA), vilket möjliggör lyckad signaturverifiering även efter att certifikaten har upphört att gälla. Som bildsignerare bör du se till att du signerar containeravbildningar med tidsstämplar som genereras av en betrodd TSA. För att verifiera tidsstämplar bör du som bildverifierare se till att du litar på både bildsigneraren och tillhörande TSA och upprättar förtroende via förtroendelager och förtroendeprinciper. Tidsstämpling minskar kostnaderna genom att eliminera behovet av att regelbundet signera om bilder på grund av certifikatets upphörande, vilket är särskilt viktigt när du använder kortlivade certifikat. Detaljerade anvisningar om hur du signerar och verifierar med tidsstämpling finns i tidsstämplingsguiden för notarieprojekt.

Nästa steg

Notation tillhandahåller även CI/CD-lösningar i Azure Pipeline och GitHub Actions Workflow:

Verifiera signerad avbildningsdistribution i AKS eller Kubernetes:

Dela via