Criptografia de imagens para garantir a confidencialidade em {{site.data.keyword.registryshort_notm}}

Proteja a confidencialidade das suas imagens do {{site.data.keyword.registryshort_notm}} criptografando-as com um par de chaves pública e privada RSA, de modo que apenas servidores confiáveis possam executá-las.

Crie uma imagem criptografada para que pessoas sem a chave privada não possam acessar o conteúdo. Crie a imagem criptografada usando um par de chaves RSA pública/privada para criptografar e decriptografar a imagem. Uma chave pública não é um segredo e qualquer um pode usá-la para criptografar uma imagem. Uma chave privada é um segredo e apenas os usuários que as possuem podem usá-la para decriptografar a imagem.

A criptografia é suportada no {{site.data.keyword.registrylong_notm}} e obedece as normas a seguir:

Para obter mais informações sobre como criptografar imagens, consulte Imagens de contêiner criptografadas para segurança de imagem de contêiner em repouso e Avançar a segurança de imagem e a conformidade por meio da Criptografia de imagem de contêiner.

Antes de Iniciar

Conclua as instruções em Introdução ao {{site.data.keyword.registrylong_notm}}.
Certifique-se de ter a versão mais recente do plug-in da interface de linha de comando (CLI) do container-registry para a CLI do {{site.data.keyword.cloud_notm}}; consulte Atualização do plug-in da CLI do container-registry.
Assegure-se de que você tenha um namespace privado para o qual enviar por push sua imagem criptografada. Consulte Configurar um namespace.
Instale a versão do Buildah 1.15 ou posterior, para que você possa criar imagens criptografadas. O Buildah funciona somente no ambiente Linux®. Como alternativa ao Linux®, é possível usar uma máquina virtual ou imagem do Docker para executar o Buildah para construir imagens.
Instale o Podman.

Criar o par de chaves pública/privada

Crie um par de chaves pública/privada usando comandos OpenSSL.

Crie um diretório de trabalho, por exemplo, USER_KEYS, para armazenar as chaves e alterar para esse diretório:
```
mkdir USER_KEYS; cd USER_KEYS
```
Use o OpenSSL para criar uma chave privada, em que USER_KEY é o nome para a identidade da sua chave:
```
openssl genrsa --out USER_KEYPrivate.pem
```
Crie uma chave pública:
```
openssl rsa -in USER_KEYPrivate.pem -pubout -out USER_KEYPub.pem
```
Para usar a chave privada na produção, ela deve ser armazenada e protegida com segurança em um armazenamento adequado. Também é possível que você queira gerenciar a chave pública da mesma maneira. Para obter mais informações, consulte Armazenando chaves.
Liste as chaves para assegurar que elas sejam criadas:
```
ls -l
```

Para usar esse par de chaves para criptografar imagens, exiba a chave pública executando o comando cat a seguir:

cat USER_KEYPub.pem

Você obtém uma resposta semelhante à saída a seguir:

Criptografar a imagem

Criptografe a imagem usando a chave pública e, em seguida, crie uma imagem de contêiner usando um Dockerfile.

Vá até o diretório onde você armazena seus aplicativos, por exemplo, MY_APP.
```
cd MY_APP
```

Crie o Dockerfile executando o comando a seguir:

cat << EOF >> Dockerfile
FROM nginx:latest
RUN echo "some secret" > /secret-file
EOF

Use o Buildah para criar uma imagem não criptografada executando o seguinte comando, em que NAMESPACE é o seu namespace:
```
buildah bud -t us.icr.io/NAMESPACE/MY_APP .
```
O us.icr.io/NAMESPACE/MY_APP está comprometido com o armazenamento de imagens local.
Criptografe a imagem usando a chave pública e faça upload da imagem para o registro, executando os comandos a seguir e especificando o protocolo JSON Web Encryption (jwe) para criptografar a imagem, em que USER_KEYS/USER_KEYPub.pem é a chave de criptografia.
```
buildah push --encryption-key jwe:..USER_KEYS/USER_KEYPub.pem us.icr.io/NAMESPACE/MY_APP
```
Buildah A versão 1.15 ou posterior utiliza as credenciais de login do site Docker para autenticação. Se essas credenciais não funcionarem ou se você quiser usar uma chave de API, é possível especificar a opção —-creds <username>, em que <username> é o nome de usuário. Se você utilizar a opção “ —-creds <username> ”, quando solicitado, digite a senha da credencial do Registro.

Você recebe uma resposta que informa que o manifest está gravado no destino da imagem, que é o registro.
Confira seu registro para certificar-se de que a imagem está lá.

Puxar e decriptografar a imagem

Puxe a imagem do registro e decriptografe-a usando a chave privada.

Para assegurar que você esteja puxando do registro e que não esteja usando o cache local, remova a imagem localmente:
```
buildah rmi -f us.icr.io/NAMESPACE/MY_APP
```

(Opcional) É possível tentar puxar a imagem sem fornecer a chave de decriptografia para confirmar que não é possível decriptografá-la:

buildah pull us.icr.io/NAMESPACE/MY_APP

A saída contém uma mensagem semelhante à seguinte:

...<truncated>...
Error decrypting layer sha256:ab4ea03582e08a8e8fc35b778cc6f1a1fa797469fa9cc61cee85f703b316bb12: missing private key needed for decryption
ERRO exit status 125

Use o Buildah para fazer pull da imagem com a chave de decriptografia, em que USER_KEYS/USER_KEYPrivate.pem é a chave de decriptografia e us.icr.io/NAMESPACE/MY_APP é o registro:
```
buildah pull --decryption-key ../USER_KEYS/USER_KEYPrivate.pem us.icr.io/NAMESPACE/MY_APP
```
A imagem criptografada é recuperada do registro, decriptografada e armazenada no armazenamento de imagem local.
Confirme se a imagem está armazenada executando o Podman:
```
podman run -it us.icr.io/NAMESPACE/MY_APP /bin/bash
```

Armazenando chaves

Para usar a chave privada na produção, ela deve ser armazenada e protegida com segurança. Também é possível que você queira gerenciar a chave pública da mesma maneira para controlar quem pode construir imagens. É possível usar o {{site.data.keyword.keymanagementservicelong_notm}} para armazenar e proteger suas chaves.

O {{site.data.keyword.keymanagementservicelong_notm}} armazena chaves simétricas, em vez das chaves PKI assimétricas usadas para a criptografia de imagem. É possível incluir suas chaves separadamente como duas chaves padrão do {{site.data.keyword.keymanagementservicelong_notm}} usando o painel, a CLI ou a API. O {{site.data.keyword.keymanagementservicelong_notm}} exige que apenas os dados Base64 sejam importados. Para obter dados de Base64 puros, é possível codificar os arquivos PEM executando "openssl enc -base64 -A -in USER_KEYPrivate.pem -out USER_KEYPrivate.b64" antes de carregar o conteúdo Base64 e reverter esta ação para obter a chave utilizável novamente, executando "openssl enc -base64 -A -d -in USER_KEYPrivate..b64 -out USER_KEYPrivate.pem".

Para obter mais informações sobre como usar o {{site.data.keyword.keymanagementservicelong_notm}} para armazenar e proteger as suas chaves, consulte Trazendo as suas chaves de criptografia para a nuvem e Importando as suas próprias chaves.

Como uma alternativa, é possível proteger as suas chaves em seu próprio armazenamento usando uma chave raiz do {{site.data.keyword.keymanagementservicelong_notm}} para agrupá-las. Essa ação significa que elas devem ser desagrupadas novamente usando o {{site.data.keyword.keymanagementservicelong_notm}} e a chave raiz válida.

Por exemplo, para agrupar chaves usando a CLI, execute o comando "ibmcloud kp key wrap ROOT_KEY_ID -p <base64 encoded image key>", e para desagrupar chaves, execute o comando "ibmcloud kp key unwrap ROOT_KEY_ID -p <base64 cyphertext>, em que ROOT_KEY_ID é o ID da chave raiz que você está usando.

Para obter mais informações sobre como é possível proteger as suas chaves em seu próprio armazenamento usando uma chave raiz do {{site.data.keyword.keymanagementservicelong_notm}} para agrupá-las, consulte Agrupando chaves.

As imagens criptografadas não são digitalizadas pelo Vulnerability Advisor.

Próximas etapas

Execute sua imagem criptografada em um cluster do {{site.data.keyword.openshiftlong}} usando o Complemento de cluster do sincronizador de Chave de imagem.