Tutorial: Criptografar e Descriptografar Blobs no Armazenamento do Microsoft Azure usando o Azure Key VaultTutorial: Encrypt and decrypt blobs in Microsoft Azure Storage using Azure Key Vault

IntroduçãoIntroduction

Este tutorial aborda como aproveitar a criptografia de armazenamento do cliente com o Cofre da Chave do Azure.This tutorial covers how to make use of client-side storage encryption with Azure Key Vault. Ele explica como criptografar e descriptografar um blob em um aplicativo de console usando essas tecnologias.It walks you through how to encrypt and decrypt a blob in a console application using these technologies.

Tempo estimado para conclusão: 20 minutosEstimated time to complete: 20 minutes

Para obter informações gerais sobre o Cofre de Chaves do Azure, consulte O que é o Cofre de Chaves do Azure?.For overview information about Azure Key Vault, see What is Azure Key Vault?.

Para obter informações gerais sobre a criptografia de cliente do armazenamento do Azure, consulte Criptografia do lado do cliente e Cofre de Chaves do Azure para o Armazenamento do Microsoft Azure.For overview information about client-side encryption for Azure Storage, see Client-Side Encryption and Azure Key Vault for Microsoft Azure Storage.

Pré-requisitosPrerequisites

Para concluir este tutorial, você precisará do seguinte:To complete this tutorial, you must have the following:

  • Uma conta de armazenamento do AzureAn Azure Storage account
  • Visual Studio 2013 ou posterior.Visual Studio 2013 or later
  • Azure PowerShellAzure PowerShell

Visão geral da criptografia do lado do clienteOverview of client-side encryption

Para obter uma visão geral da criptografia do lado do cliente do Armazenamento do Azure, consulte Criptografia do lado do cliente e o Cofre de Chaves do Azure para o Armazenamento do Microsoft AzureFor an overview of client-side encryption for Azure Storage, see Client-Side Encryption and Azure Key Vault for Microsoft Azure Storage

Aqui está uma breve descrição de como funciona a criptografia do lado do cliente:Here is a brief description of how client side encryption works:

  1. O SDK do cliente do Armazenamento do Azure gera uma CEK (chave de criptografia de conteúdo) que é uma chave simétrica de uso único.The Azure Storage client SDK generates a content encryption key (CEK), which is a one-time-use symmetric key.
  2. Os dados do cliente são criptografados usando essa CEK.Customer data is encrypted using this CEK.
  3. O CEK é empacotada (criptografada) usando o KEK (Chave de Criptografia de Chave).The CEK is then wrapped (encrypted) using the key encryption key (KEK). A KEK é identificada por um identificador de chave e pode ser um par de chaves assimétricas ou uma chave simétrica, podendo ser gerenciada localmente ou armazenada no Cofre da Chave do Azure.The KEK is identified by a key identifier and can be an asymmetric key pair or a symmetric key and can be managed locally or stored in Azure Key Vault. O cliente de Armazenamento, por si só, nunca tem acesso à KEK.The Storage client itself never has access to the KEK. Ele simplesmente chama o algoritmo de quebra de chave fornecido pelo Cofre da Chave.It just invokes the key wrapping algorithm that is provided by Key Vault. Os clientes podem escolher usar provedores personalizados para desempacotamento/quebra da chave, se desejado.Customers can choose to use custom providers for key wrapping/unwrapping if they want.
  4. Os dados criptografados, em seguida, são carregados para o serviço de Armazenamento do Azure.The encrypted data is then uploaded to the Azure Storage service.

Configure o seu Cofre da Chave do AzureSet up your Azure Key Vault

Para continuar com este tutorial, você precisa executar as etapas a seguir, que são descritas no guia de início rápido do tutorial: Definir e recuperar um segredo de Azure Key Vault usando um aplicativoWeb .net:In order to proceed with this tutorial, you need to do the following steps, which are outlined in the tutorial Quickstart: Set and retrieve a secret from Azure Key Vault by using a .NET web app:

  • Crie um cofre da chave.Create a key vault.
  • Adicionar uma chave ou segredo ao cofre da chave.Add a key or secret to the key vault.
  • Registre um aplicativo com o Active Directory do Azure.Register an application with Azure Active Directory.
  • Autorize o aplicativo a usar a chave ou segredo.Authorize the application to use the key or secret.

Anote o ClientID e ClientSecret que foram gerados ao registrar um aplicativo com o Active Directory do Azure.Make note of the ClientID and ClientSecret that were generated when registering an application with Azure Active Directory.

Crie ambas as chaves no cofre da chave.Create both keys in the key vault. Vamos supor pelo restante do tutorial que você tenha usado os seguintes nomes: ContosoKeyVault e TestRSAKey1.We assume for the rest of the tutorial that you have used the following names: ContosoKeyVault and TestRSAKey1.

Criar um aplicativo de console com pacotes e AppSettingsCreate a console application with packages and AppSettings

No Visual Studio, crie um novo aplicativo de console.In Visual Studio, create a new console application.

Adicione pacotes nuget necessários no Console do Gerenciador de Pacotes.Add necessary nuget packages in the Package Manager Console.

Install-Package Microsoft.Azure.ConfigurationManager
Install-Package Microsoft.Azure.Storage.Common
Install-Package Microsoft.Azure.Storage.Blob
Install-Package Microsoft.IdentityModel.Clients.ActiveDirectory

Install-Package Microsoft.Azure.KeyVault
Install-Package Microsoft.Azure.KeyVault.Extensions

Adicione AppSettings a App.Config.Add AppSettings to the App.Config.

<appSettings>
    <add key="accountName" value="myaccount"/>
    <add key="accountKey" value="theaccountkey"/>
    <add key="clientId" value="theclientid"/>
    <add key="clientSecret" value="theclientsecret"/>
    <add key="container" value="stuff"/>
</appSettings>

Adicione as seguintes diretivas do using e adicione uma referência a System.Configuration ao projeto.Add the following using directives and make sure to add a reference to System.Configuration to the project.

using Microsoft.IdentityModel.Clients.ActiveDirectory;
using System.Configuration;
using Microsoft.Azure;
using Microsoft.Azure.Storage;
using Microsoft.Azure.Storage.Auth;
using Microsoft.Azure.Storage.Blob;
using Microsoft.Azure.KeyVault;
using System.Threading;
using System.IO;

Adicione um método para obter um token para o aplicativo de consoleAdd a method to get a token to your console application

O método a seguir é usado pelas classes do Cofre da Chave que precisam ser autenticadas para acessar seu cofre da chave.The following method is used by Key Vault classes that need to authenticate for access to your key vault.

private async static Task<string> GetToken(string authority, string resource, string scope)
{
    var authContext = new AuthenticationContext(authority);
    ClientCredential clientCred = new ClientCredential(
        CloudConfigurationManager.GetSetting("clientId"),
        CloudConfigurationManager.GetSetting("clientSecret"));
    AuthenticationResult result = await authContext.AcquireTokenAsync(resource, clientCred);

    if (result == null)
        throw new InvalidOperationException("Failed to obtain the JWT token");

    return result.AccessToken;
}

Acessar o Armazenamento e o Cofre da Chave em seu programaAccess Storage and Key Vault in your program

No método Main (), adicione o código a seguir.In the Main() method, add the following code.

// This is standard code to interact with Blob storage.
StorageCredentials creds = new StorageCredentials(
    CloudConfigurationManager.GetSetting("accountName"),
    CloudConfigurationManager.GetSetting("accountKey");
CloudStorageAccount account = new CloudStorageAccount(creds, useHttps: true);
CloudBlobClient client = account.CreateCloudBlobClient();
CloudBlobContainer contain = client.GetContainerReference(CloudConfigurationManager.GetSetting("container"));
contain.CreateIfNotExists();

// The Resolver object is used to interact with Key Vault for Azure Storage.
// This is where the GetToken method from above is used.
KeyVaultKeyResolver cloudResolver = new KeyVaultKeyResolver(GetToken);

Observação

Modelos de Objetos de Chave de CofreKey Vault Object Models

É importante entender que há realmente dois Chave de Cofre modelos de objeto estar atento: uma baseada na API REST (namespace KeyVault) e a outra é uma extensão para criptografia do lado do cliente.It is important to understand that there are actually two Key Vault object models to be aware of: one is based on the REST API (KeyVault namespace) and the other is an extension for client-side encryption.

O Cliente do Cofre da Chave interage com a API REST e compreende JSON Web chaves e segredos para os dois tipos de coisas que estão contidos no Cofre da Chave.The Key Vault Client interacts with the REST API and understands JSON Web Keys and secrets for the two kinds of things that are contained in Key Vault.

As Extensões de Chave de Cofre são classes que parecem criados especificamente para a criptografia de cliente no Armazenamento do Azure.The Key Vault Extensions are classes that seem specifically created for client-side encryption in Azure Storage. Eles contêm uma interface para chaves (IKey) e classes com base no conceito de um Resolvedor de Chave.They contain an interface for keys (IKey) and classes based on the concept of a Key Resolver. Há duas implementações de IKey que você precisa conhecer: RSAKey e SymmetricKey.There are two implementations of IKey that you need to know: RSAKey and SymmetricKey. Agora que eles aconteçam coincidir com as coisas que estão contidas em um Cofre da Chave, mas agora são classes independentes (para a chave e o segredo recuperada pelo cliente Cofre da Chave não implementam IKey).Now they happen to coincide with the things that are contained in a Key Vault, but at this point they are independent classes (so the Key and Secret retrieved by the Key Vault Client do not implement IKey).

Criptografar o blob e carregarEncrypt blob and upload

Adicione o seguinte código para criptografar um blob e carregá-lo à sua conta de armazenamento do Azure.Add the following code to encrypt a blob and upload it to your Azure storage account. O método ResolveKeyAsync usado retorna uma IKey.The ResolveKeyAsync method that is used returns an IKey.

// Retrieve the key that you created previously.
// The IKey that is returned here is an RsaKey.
var rsa = cloudResolver.ResolveKeyAsync(
            "https://contosokeyvault.vault.azure.net/keys/TestRSAKey1", 
            CancellationToken.None).GetAwaiter().GetResult();

// Now you simply use the RSA key to encrypt by setting it in the BlobEncryptionPolicy.
BlobEncryptionPolicy policy = new BlobEncryptionPolicy(rsa, null);
BlobRequestOptions options = new BlobRequestOptions() { EncryptionPolicy = policy };

// Reference a block blob.
CloudBlockBlob blob = contain.GetBlockBlobReference("MyFile.txt");

// Upload using the UploadFromStream method.
using (var stream = System.IO.File.OpenRead(@"C:\Temp\MyFile.txt"))
    blob.UploadFromStream(stream, stream.Length, null, options, null);

Observação

Se você examinar o construtor BlobEncryptionPolicy, você verá que ele pode aceitar uma chave e/ou um resolvedor.If you look at the BlobEncryptionPolicy constructor, you will see that it can accept a key and/or a resolver. Lembre-se de que agora, você não pode usar um resolvedor para criptografia porque atualmente não dá suporte a uma chave padrão.Be aware that right now you cannot use a resolver for encryption because it does not currently support a default key.

Descriptografar o blob e baixarDecrypt blob and download

Descriptografia é quando o uso das classes de resolvedor realmente fazem sentido.Decryption is really when using the Resolver classes make sense. A ID da chave usada para criptografia é associada ao blob em seus metadados, portanto, não há motivo para recuperar a chave e lembre-se a associação entre a chave e o blob.The ID of the key used for encryption is associated with the blob in its metadata, so there is no reason for you to retrieve the key and remember the association between key and blob. Você precisa certificar-se de que a chave permanece no Cofre da Chave.You just have to make sure that the key remains in Key Vault.

A chave privada de uma Chave RSA permanece no Cofre da Chave de modo que, para a descriptografia ocorrer, a Chave Criptografada dos metadados do blob que contêm a CEK é enviada ao Cofre da Chave para descriptografia.The private key of an RSA Key remains in Key Vault, so for decryption to occur, the Encrypted Key from the blob metadata that contains the CEK is sent to Key Vault for decryption.

Adicione o seguinte para descriptografar o blob que você acabou de carregar.Add the following to decrypt the blob that you just uploaded.

// In this case, we will not pass a key and only pass the resolver because
// this policy will only be used for downloading / decrypting.
BlobEncryptionPolicy policy = new BlobEncryptionPolicy(null, cloudResolver);
BlobRequestOptions options = new BlobRequestOptions() { EncryptionPolicy = policy };

using (var np = File.Open(@"C:\data\MyFileDecrypted.txt", FileMode.Create))
    blob.DownloadToStream(np, null, options, null);

Observação

Existem alguns outros tipos de resolvedores para facilitar o gerenciamento de chaves, incluindo: AggregateKeyResolver e CachingKeyResolver.There are a couple of other kinds of resolvers to make key management easier, including: AggregateKeyResolver and CachingKeyResolver.

Usar os segredos do Cofre da ChaveUse Key Vault secrets

A maneira de usar um segredo com criptografia do lado do cliente é por meio da classe SymmetricKey, dado que um segredo é essencialmente uma chave simétrica.The way to use a secret with client-side encryption is via the SymmetricKey class because a secret is essentially a symmetric key. Mas, conforme observado anteriormente, um segredo no Cofre da Chave não é mapeado com exatidão para uma SymmetricKey.But, as noted above, a secret in Key Vault does not map exactly to a SymmetricKey. Há algumas coisas que deve compreender:There are a few things to understand:

  • A chave em uma SymmetricKey deve ter um comprimento fixo: 192, 128, 256, 384 ou 512 bits.The key in a SymmetricKey has to be a fixed length: 128, 192, 256, 384, or 512 bits.
  • A chave em uma SymmetricKey deve ser codificado em Base64.The key in a SymmetricKey should be Base64 encoded.
  • Um segredo do Cofre da Chave que será usado como uma SymmetricKey deve ter um tipo de conteúdo de "application/octet-stream" no Cofre da Chave.A Key Vault secret that will be used as a SymmetricKey needs to have a Content Type of "application/octet-stream" in Key Vault.

Aqui está um exemplo no PowerShell sobre a criação de um segredo no Cofre da Chave que pode ser usado como uma SymmetricKey.Here is an example in PowerShell of creating a secret in Key Vault that can be used as a SymmetricKey. Observe que o valor codificado, $key, serve apenas para demonstração.Please note that the hard coded value, $key, is for demonstration purpose only. Em seu próprio código, você desejará gerar essa chave.In your own code you'll want to generate this key.

// Here we are making a 128-bit key so we have 16 characters.
//     The characters are in the ASCII range of UTF8 so they are
//    each 1 byte. 16 x 8 = 128.
$key = "qwertyuiopasdfgh"
$b = [System.Text.Encoding]::UTF8.GetBytes($key)
$enc = [System.Convert]::ToBase64String($b)
$secretvalue = ConvertTo-SecureString $enc -AsPlainText -Force

// Substitute the VaultName and Name in this command.
$secret = Set-AzureKeyVaultSecret -VaultName 'ContosoKeyVault' -Name 'TestSecret2' -SecretValue $secretvalue -ContentType "application/octet-stream"

Em seu aplicativo de console, você pode usar a mesma chamada como antes, para recuperar esse segredo como uma SymmetricKey.In your console application, you can use the same call as before to retrieve this secret as a SymmetricKey.

SymmetricKey sec = (SymmetricKey) cloudResolver.ResolveKeyAsync(
    "https://contosokeyvault.vault.azure.net/secrets/TestSecret2/",
    CancellationToken.None).GetAwaiter().GetResult();

É isso.That's it. Aproveite!Enjoy!

Próximas etapasNext steps

Para obter mais informações sobre como usar o Armazenamento do Microsoft Azure com C#, consulte Biblioteca de cliente de Armazenamento do Microsoft Azure para .NET.For more information about using Microsoft Azure Storage with C#, see Microsoft Azure Storage Client Library for .NET.

Para obter mais informações sobre a API REST do Blob, consulte API REST do Serviço Blob.For more information about the Blob REST API, see Blob Service REST API.

Para obter as informações mais recentes sobre o Armazenamento do Microsoft Azure, vá para o Blog da equipe de Armazenamento do Microsoft Azure.For the latest information on Microsoft Azure Storage, go to the Microsoft Azure Storage Team Blog.