Assinar imagens de contêiner com o Notation e o Azure Key Vault usando um certificado autoassinado

Artigo
02/26/2024

A assinatura de imagens de contêiner é um processo que garante autenticidade e integridade. Isso é feito adicionando uma assinatura digital à imagem de contêiner, que pode ser validada durante a implantação. A assinatura ajuda a verificar se a imagem é de um editor confiável e se não foi modificada. O Notation é uma ferramenta de cadeia de suprimentos de código aberto desenvolvida pelo Notary Project, que oferece suporte à assinatura e verificação de imagens de contêiner e outros artefatos. O AKV (Azure Key Vault) é usado para armazenar certificados com chaves de assinatura que podem ser usadas pelo Notation com o plug-in Notation AKV (azure-kv) para assinar e verificar imagens de contêiner e outros artefatos. O ACR (Registro de Contêiner do Azure) permite anexar assinaturas a imagens de contêiner e outros artefatos, bem como exibir essas assinaturas.

Neste tutorial:

Instalar a CLI do Notation e o plug-in AKV
Criar um certificado autoassinado no AKV
Compilar e enviar uma imagem de contêiner com as Tarefas do ACR
Assine uma imagem de contêiner com a CLI do Notation e o plug-in AKV
Valide uma imagem de contêiner em relação à assinatura com a CLI do Notation

Pré-requisitos

Criar ou usar um Registro de Contêiner do Azure para armazenar imagens de contêiner e assinaturas
Criar ou usar um Azure Key Vault para gerenciar certificados
Instalar e configurar a CLI do Azure mais recente ou executar comandos no Azure Cloud Shell

Instalar a CLI do Notation e o plug-in AKV

Instale o Notation v1.1.0 em um ambiente de amd64 do Linux. Siga o guia de instalação do Notação para baixar o pacote para outros ambientes.

# 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

Instale o plug-in de Notação do Azure Key Vault azure-kv v1.0.2 em um ambiente de amd64 do Linux.

Observação

A soma de verificação de URL e SHA256 para o plug-in de Notação do Azure Key Vault, pode ser encontrada na página de lançamento do 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
```
Liste os plug-ins disponíveis e confirme se o plug-in azure-kv com a versão 1.0.2 está incluída na lista.
```
notation plugin ls
```

Configurar variáveis de ambiente

Observação

Para facilitar a execução de comandos no tutorial, forneça valores para que os recursos do Azure correspondam aos recursos existentes do ACR e do AKV.

Configurar nomes de recursos do 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

Configurar nomes de recursos de imagem e ACR.

# 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

Para saber mais sobre a CLI do Azure e como fazer entrar com ela, confira Entrar com a CLI do Azure.

Atribuir política de acesso no AKV (CLI do Azure)

É necessário uma entidade de usuário com as permissões corretas de política de acesso para criar um certificado autoassinado e assinar artefatos. Essa entidade pode ser uma entidade de usuário, uma entidade de serviço ou uma identidade gerenciada. No mínimo, essa entidade de segurança precisa das seguintes permissões:

Permissões de Create para certificados
Permissões de Get para certificados
Permissões de Sign para chaves

Neste tutorial, a política de acesso é atribuída a um usuário conectado do Azure. Para saber mais sobre a atribuição de política a uma entidade de segurança, confira Atribuir Política de Acesso.

Definir a assinatura que contém o recurso AKV

az account set --subscription <your_subscription_id>

Definir a política de acesso no 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

Importante

Esse exemplo mostra as permissões mínimas necessárias para criar um certificado e assinar uma imagem de contêiner. Dependendo dos requisitos, talvez seja necessário conceder permissões adicionais.

Criar um certificado autoassinado no AKV (CLI do Azure)

As etapas a seguir mostram como criar um certificado autoassinado para fins de teste.

Criar um arquivo de política de certificação.

Quando o arquivo de política de certificado é executado conforme abaixo, ele cria um certificado válido compatível com os requisitos de certificado do Notary Project no AKV. O valor de ekus é para a assinatura de código, mas não é necessário para a notação para assinar artefatos. A entidade em questão é usada posteriormente como a identidade de confiança na qual o usuário irá confiar durante a verificação.

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

Criar o certificado.

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

Assine uma imagem de contêiner com a CLI do Notation e o plug-in AKV

Faça a autenticação no ACR usando sua identidade individual do Azure.
```
az acr login --name $ACR_NAME
```

Importante

Se você tiver o Docker instalado no sistema e usou az acr login ou docker login para se autenticar no ACR, suas credenciais já estarão armazenadas e disponíveis para notação. Nesse caso, você não precisa executar notation login novamente para se autenticar no ACR. Para saber mais sobre as opções de autenticação para notação, confira Autenticar com registros compatíveis com OCI.

Compilar e enviar por push uma nova imagem com Tarefas do ACR. Sempre use o valor de resumo da mensagem para identificar a imagem para assinatura, pois as marcas são mutáveis e podem ser substituídas.
```
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
```
Neste tutorial, se a imagem já foi criada e armazenada no registro, a marca servirá como um identificador para essa imagem por conveniência.
```
IMAGE=$REGISTRY/${REPO}:$TAG
```
Obtenha a ID de Chave da chave de assinatura. Um certificado no AKV pode ter várias versões; o comando a seguir obtém a ID de Chave da versão mais recente.
```
KEY_ID=$(az keyvault certificate show -n $CERT_NAME --vault-name $AKV_NAME --query 'kid' -o tsv)
```
Assine a imagem de contêiner com o formato de assinatura COSE usando a ID da chave de assinatura. Para assinar com um certificado autoassinado, você precisa definir o valor de self_signed=true da configuração do plug-in.
```
notation sign --signature-format cose --id $KEY_ID --plugin azure-kv --plugin-config self_signed=true $IMAGE
```
Veja o grafo de imagens assinadas e assinaturas associadas.
```
notation ls $IMAGE
```

Verificar uma imagem de contêiner com a CLI do Notation

Para verificar a imagem de contêiner, adicione o certificado raiz que assina o certificado folha ao armazenamento confiável e crie políticas de confiança para verificação. No caso do certificado autoassinado usado neste tutorial, o certificado raiz é o próprio certificado autoassinado.

Baixar certificado público.

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

Adicione o certificado público baixado ao repositório confiável nomeado para a verificação da assinatura.

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

Liste o certificado a ser confirmado.
```
notation cert ls
```
Configure a política de confiança antes da verificação.

As políticas de confiança permitem que os usuários especifiquem políticas de verificação com ajuste fino. O exemplo a seguir configura uma política de confiança chamada wabbit-networks-images, que se aplica a todos os artefatos em $REGISTRY/$REPO e usa o repositório confiável $STORE_NAME nomeado do tipo $STORE_TYPE. Ele também pressupõe que o usuário confia em uma identidade específica com o assunto X.509 $CERT_SUBJECT. Para obter mais detalhes, confira Especificação do repositório confiável e da política de confiança.
```
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
```
Use a notation policy para importar a configuração de política de confiança de um arquivo JSON que criamos anteriormente.
```
notation policy import ./trustpolicy.json
notation policy show
```
Use notation verify para verificar se a imagem de contêiner não foi alterada desde o momento da compilação.
```
notation verify $IMAGE
```
Após a verificação bem-sucedida da imagem usando a política de confiança, o código hash sha256 da imagem verificada será retornado em uma mensagem de saída bem-sucedida.

Próximas etapas

Confira Usar a Integridade da Imagem para validar as imagens assinadas antes de implantá-las nos seus clusters do AKS (Serviço de Kubernetes do Azure) e Ratificar no Azure para começar a verificar e auditar as imagens assinadas antes de implantá-las no AKS.