Assinar imagens de contêiner com Notação e Cofre de Chaves do Azure usando um certificado autoassinado

Artigo
04/27/2024

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

Neste tutorial:

Instale o plugin Notation CLI e AKV
Criar um certificado auto-assinado no AKV
Criar e enviar por push uma imagem de contêiner com tarefas ACR
Assinar uma imagem de contentor com a CLI de Notação e o plug-in do AKV
Validar uma imagem de contêiner em relação à assinatura com a CLI de notação

Pré-requisitos

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

Instale o plugin Notation CLI e AKV

Instale o Notation v1.1.0 em um ambiente Linux amd64. Siga o guia de instalação do Notation 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 azure-kv Notation Azure Key Vault v1.1.0 em um ambiente Linux amd64.

Nota

A URL e a soma de verificação SHA256 para o plug-in Notation Azure Key Vault podem ser encontradas na página de lançamento do plug-in.
```
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
```
Liste os plugins disponíveis e confirme se o plugin com versão azure-kv1.1.0 está incluído na lista.
```
notation plugin ls
```

Configurar variáveis de ambiente

Nota

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

Configure nomes de recursos 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

Configure nomes de recursos ACR e de imagem.

# 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 entrar com ela, consulte Entrar com a CLI do Azure.

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

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

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

Neste tutorial, a política de acesso é atribuída a um usuário conectado do Azure. Para saber mais sobre como atribuir política a uma entidade de segurança, consulte Atribuir política de acesso.

Definir a subscrição 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

Este exemplo mostra as permissões mínimas necessárias para criar um certificado e assinar uma imagem de contêiner. Dependendo dos seus requisitos, poderá ter de conceder permissões adicionais.

Criar um certificado autoassinado em AKV (CLI do Azure)

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

Crie um arquivo de política de certificado.

Uma vez que o arquivo de política de certificado é executado como abaixo, ele cria um certificado válido compatível com o requisito de certificado do Projeto Notarial no AKV. O valor for ekus é para assinatura de código, mas não é necessário para notação para assinar artefatos. O assunto é usado posteriormente como identidade de confiança na qual o usuário confia 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

Crie o certificado.

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

Assinar uma imagem de contentor com a CLI de Notação e o plug-in do AKV

Autentique-se em seu ACR usando sua identidade individual do Azure.
```
az acr login --name $ACR_NAME
```

Importante

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

Crie e envie uma nova imagem com as Tarefas ACR. Use sempre o valor digest para identificar a imagem para assinatura, pois as tags 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á tiver sido criada e estiver armazenada no Registro, a tag servirá como um identificador para essa imagem por conveniência.
```
IMAGE=$REGISTRY/${REPO}:$TAG
```
Obtenha o ID da chave de assinatura. Um certificado no AKV pode ter várias versões, o comando a seguir obtém o ID da 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 do contêiner com o formato de assinatura COSE usando o ID da chave de assinatura. Para assinar com um certificado autoassinado, você precisa definir o valor self_signed=truede configuração do plug-in.

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

Para autenticar com AKV, por padrão, os seguintes tipos de credenciais, se ativados, serão testados na ordem:

Se você quiser especificar um tipo de credencial, use uma configuração de plug-in adicional chamada credential_type. Por exemplo, você pode definir credential_type explicitamente para azurecli usar a credencial da CLI do Azure, conforme demonstrado abaixo:

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

Consulte a tabela abaixo para obter os valores de para vários tipos de credential_type credenciais.

Tipo de credencial	Valor para `credential_type`
Credencial de ambiente	`environment`
Credencial de identidade da carga de trabalho	`workloadid`
Credencial de identidade gerenciada	`managedid`
Credencial da CLI do Azure	`azurecli`

Veja o gráfico de imagens assinadas e assinaturas associadas.
```
notation ls $IMAGE
```

Verificar uma imagem de contentor com a CLI de Notação

Para verificar a imagem do 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. Para o certificado autoassinado usado neste tutorial, o certificado raiz é o próprio certificado autoassinado.

Faça o download do certificado público.

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

Adicione o certificado público baixado ao armazenamento confiável nomeado para verificação de assinatura.

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

Liste o certificado a confirmar.
```
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 ajustadas. O exemplo a seguir configura uma política de confiança chamada wabbit-networks-images, que se aplica a todos os artefatos e $REGISTRY/$REPO usa o armazenamento $STORE_NAME de confiança nomeado do tipo $STORE_TYPE. Ele também assume que o usuário confia em uma identidade específica com o assunto $CERT_SUBJECTX.509. Para obter mais detalhes, consulte Armazenamento confiável e especificação de 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 notation policy para importar a configuração da 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 do contêiner não foi alterada desde o tempo de compilação.
```
notation verify $IMAGE
```
Após a verificação bem-sucedida da imagem usando a política de confiança, o resumo sha256 da imagem verificada é retornado em uma mensagem de saída bem-sucedida.

Próximos passos

Consulte Usar a integridade da imagem para validar imagens assinadas antes de implantá-las em seus clusters do Serviço Kubernetes do Azure (AKS) (Visualização) e Ratificar no Azure para começar a verificar e auditar imagens assinadas antes de implantá-las no AKS.