Gerenciando chaves de criptografia com o AWS KMS no Node.js

itsgoingdown.org

A segurança é muito importante no desenvolvimento de aplicativos. Como você criptografa dados e gerencia chaves de criptografia em seu aplicativo? O gerenciamento de chaves bem-sucedido é fundamental para a segurança de um sistema criptográfico. É aqui que entram os KMS. Vamos primeiro ver o que realmente é um KMS.

Sistema de Gerenciamento de Chaves (KMS)

Segundo a Wikipedia,

Um sistema de gerenciamento de chaves (KMS), também conhecido como sistema de gerenciamento de chaves criptográficas (CKMS), é uma abordagem integrada para gerar, distribuir e gerenciar chaves criptográficas para dispositivos e aplicativos. Em comparação com o termo gerenciamento de chaves, um KMS é adaptado para casos de uso específicos, como atualização de software segura ou comunicação máquina a máquina . Em uma abordagem holística, abrange todos os aspectos da segurança – desde a geração segura de chaves sobre a troca segura de chaves até o manuseio seguro de chaves e armazenamento no cliente. Assim, um KMS inclui a funcionalidade de back-end para geração , distribuição e substituição de chaves, bem como a funcionalidade do cliente para injetar chaves, armazenar e gerenciar chaves em dispositivos. Com a Internet das coisas , o KMS se torna uma parte crucial para a segurança de dispositivos conectados.

Um KMS facilita a sua vida ao lidar com o gerenciamento e a criptografia de chaves.

AWS KMS

Agora sabemos o que é um sistema de gerenciamento de chaves. Vamos falar sobre o AWS KMS brevemente.

O AWS KMS é um serviço da AWS que facilita o gerenciamento de suas chaves de criptografia. Ele usa módulos de segurança de hardware (HSMs) no back-end. O AWS KMS está integrado a outros serviços da AWS. Também é baixo em custo. O AWS KMS fornece controle de acesso às suas chaves para que você possa determinar quem pode acessar as chaves quando as chaves podem ser acessadas e muitas outras opções.

O AWS KMS usa o algoritmo Advanced Encryption Standard (AES) no Galois / Counter Mode (GCM) , conhecido como AES-GCM. O AWS KMS usa esse algoritmo com chaves secretas de 256 bits.

O preço do AWS KMS pode ser visto aqui . O nível gratuito inclui 20.000 solicitações / mês.

Usando o AWS KMS com o Node.js

Nesta seção, vou compartilhar como usar o AWS KMS em seu aplicativo Node.js. Eu cobrirei os seguintes tópicos aqui,

  • Como criar um CMK (Customer Master Key).
  • Como anexar um usuário do IAM ao CMK com uma política de restrição de IP.
  • Como criptografar dados usando o CMK.
  • Como descriptografar dados usando o CMK.
  • Criptografia de envelope usando o AWS KMS.
  • Contexto de criptografia (Intro)

Com isso dito, quero primeiro declarar que não sou um especialista em criptografia.

Como criar um CMK (Customer Master Key)

Os principais recursos no AWS KMS são chaves mestras de clientes (CMKs). Os CMKs são gerenciados pelo cliente ou gerenciados pela AWS. Vamos dar uma olhada em como criar uma chave mestra de cliente na AWS.

Faça o login no console da AWS e vá para os serviços. Em seguida, selecione "IAM". Lá, no lado esquerdo, você pode ver uma seção chamada "Chaves de criptografia". Navegue até essa seção. Em seguida, selecione "Criar chave" no canto superior esquerdo.

Digite um alias para a chave e uma descrição. Nas opções avançadas, selecione KMS. Aqui você pode importar sua própria chave externa, se quiser. Eu não vou cobrir como importar uma chave externa aqui (ela também é bem direta).

Clique em próximo. Adicione tags (opcional) se você precisar. Vá para o próximo passo novamente. Se você já tiver um usuário do IAM criado (se não ignorar a seleção de um usuário, criaremos um usuário mais tarde) e se quiser permitir que esse usuário acesse essa chave, selecione o usuário na lista e clique em Avançar. Finalmente termine o processo. Sua chave será criada agora.

Como anexar um usuário do IAM ao CMK com uma política de restrição de IP

Agora, se você não tiver um usuário do IAM criado anteriormente, siga estas etapas para criar um.

Vá para "IAM" (como acima). Selecione "Usuários" no lado esquerdo. Selecione "Adicionar usuário" no canto superior esquerdo. Preencha os detalhes necessários. Um exemplo é dado abaixo.

Selecione o próximo. Selecione a opção "Anexar políticas existentes diretamente". Em seguida, selecione "Criar política". Você pode editar visualmente a política ou editar o json da política. Eu vou editar o json aqui. Selecione a aba “json”. Eu vou estar usando a política abaixo simples que só permitirá o acesso ao CMK de um IP selecionado. Você pode selecionar um intervalo de IP ou personalizar a política da maneira que desejar.

política

Depois disso, siga as instruções para salvar a política criada. Em seguida, termine de criar o usuário. Na última página, o ID da chave de acesso e a chave de acesso secreta do novo usuário serão exibidos. Baixe essas informações. Você não poderá visualizá-lo depois (mas você pode criar novas credenciais novamente).

Agora vá para as chaves de criptografia e selecione a chave que você acabou de criar. Vá para a seção "Key Users" e selecione "Add". Selecione o usuário que você criou. Então esse usuário será adicionado à lista permitida para o CMK que você criou.

Usuários chave

Como criptografar dados usando o CMK

Chega de configurar as coisas, vamos ver como usar o AWS KMS!

Estou usando o AWS SDK for Node.js aqui. Vamos instalar o pacote do AWS SDK a partir do npm.

 npm instala o aws-sdk 

A função seguinte criptografa um determinado buffer e gera o blob do texto cifrado.

 função criptografar (buffer) { 
const kms = novo aws.KMS ({
accessKeyId: 'AKCVBTRNOSMLTIA7RPQQ', // credenciais para seu usuário do IAM
secretAccessKey: 'lJQtdIfH / Cup9AyaaHV8h2NnR / eKFIsZea5Vn0k', // credenciais para seu usuário do IAM
região: 'ap-southeast-1'
});
return new Promise ((resolver, rejeitar) => {
const params = {
KeyId: '965d2884-b2cd-4d79-8773-6b1f57133300', // O identificador do CMK a ser usado para criptografia. Você pode usar o ID de chave ou o Nome de Recurso da Amazon (ARN) do CMK, ou o nome ou ARN de um alias que se refere ao CMK.
Plaintext: buffer // Os dados para criptografar.
};
kms.encrypt (params, (err, data) => {
if (err) {
rejeitar (err);
} mais {
resolver (data.CiphertextBlob);
}
});
});
}

Como descriptografar dados usando o CMK

A função a seguir descriptografa um blob de texto cifrado que foi criptografado antes e retorna o buffer de texto simples.

 função descriptografar (buffer) { 
const kms = novo aws.KMS ({
accessKeyId: 'AKCVBTRNOSMLTIB7ROQQ',
secretAccessKey: 'lJQtdIfH / Cup9AyabHV9h2NnR / eKFIsZea2Vn0k',
região: 'ap-southeast-1'
});
return new Promise ((resolver, rejeitar) => {
const params = {
CiphertextBlob: buffer // Os dados a serem descriptografados.
};
kms.decrypt (params, (err, data) => {
if (err) {
rejeitar (err);
} mais {
resolve (data.Plaintext);
}
});
});
}

O código a seguir criptografa o texto “abc”, depois descriptografa e imprime o valor no console

 criptografar ( novo Buffer ('abc', 'utf-8')). então (descriptografar). then (plaintext => { 
console.log (plaintext.toString ('utf-8'));
});

Criptografia de envelope usando o AWS KMS

O AWS KMS tem um limite de tamanho para criptografar dados diretamente usando o CMK. Você só pode criptografar até 4 kilobytes de dados por solicitação. Se você quiser criptografar dados de tamanho maior, por exemplo, um vídeo, você precisa usar criptografia de envelope.

Na criptografia de envelope, geramos uma chave de dados usando nosso CMK no KMS. Ao gerar a chave de dados, a AWS nos envia a chave de texto simples e a chave criptografada (usando nosso CMK). Em seguida, usamos a chave de dados em texto simples gerada para criptografar nossos dados. Depois de criptografar os dados, destruímos a chave de texto simples e mantemos a chave criptografada conosco. Quando queremos descriptografar os dados, enviamos a chave criptografada para o AWS KMS, recuperamos a chave em texto simples e continuamos com a descriptografia.

Primeiro, precisamos gerar uma chave de dados no AWS KMS. O diagrama a seguir descreve esse procedimento.

http://docs.aws.amazon.com

A função a seguir gera uma chave de dados no AWS KMS.

 function generateDataKey () { 
const kms = novo aws.KMS ({
accessKeyId: 'AKCVBTRNOSMLTIB7ROQQ',
secretAccessKey: 'lJQtdIfH / Cup9AyabHV9h2NnR / eKFIsZea2Vn0k',
região: 'ap-southeast-1'
});
return new Promise ((resolver, rejeitar) => {
const params = {
KeyId: '965d2884-b2ab-4e78-8773-6b1f57133300', // O identificador do CMK a ser usado para criptografar a chave de dados. Você pode usar o ID de chave ou o Nome de Recurso da Amazon (ARN) do CMK, ou o nome ou ARN de um alias que se refere ao CMK.
KeySpec: 'AES_256' // Especifica o tipo de chave de dados a ser retornada.
};
kms.generateDataKey (params, (err, data) => {
if (err) {
rejeitar (err);
} mais {
resolver (dados);
}
});
});
}

“Data” tem chave de dados criptografados e chave de dados de texto sem formatação como buffers.

O próximo passo é criptografar dados com chave de dados de texto simples.

http://docs.aws.amazon.com

A seguir, um código de exemplo que usa o AES-CBC para criptografar dados usando a chave de dados. Isso usa o pacote de criptografia. Aqui eu usei um iv fixo (vetor de inicialização) para a simplicidade.

 function encryptAES (chave, buffer) { 
algoritmo const = 'AES-256-CBC';

const iv = novo Buffer ('00000000000000000000000000000000', 'hex');

encryptor = crypto.createCipheriv (algoritmo, chave, iv);
encryptor.write (strBuffer);
encryptor.end ();

return encryptor.read ();
}

Vamos ver como descriptografar os dados criptografados. Primeiro de tudo precisamos descriptografar a nossa chave ecrypted usando o CMK. O diagrama a seguir ilustra isso. O snippet de código que eu postei anteriormente pode ser usado para fazer isso (da mesma forma que a descriptografia de dados regular).

http://docs.aws.amazon.com

O último passo é descriptografar os dados. O diagrama a seguir ilustra isso.

http://docs.aws.amazon.com

Um exemplo de código para descriptografar os dados criptografados acima usando AES-CBC é mostrado abaixo.

 função decryptAES (chave, buffer) { 
algoritmo const = 'AES-256-CBC';

const iv = novo Buffer ('00000000000000000000000000000000', 'hex');

encryptor = crypto.createDecipheriv (algoritmo, chave, iv);
encryptor.write (buffer);
encryptor.end ();

return encryptor.read ();
}

A seguir está um trecho de código para criptografar e descriptografar uma string usando criptografia de envelope.

 generateDataKey () 
.then (dados => {
const cipherTextBlob = encryptAES (data.Plaintext, novo Buffer ('abc', 'utf-8'));
para ( let i = 0; i <data.Plaintext.length; i ++) {
data.Plaintext [i] = nulo ;
}
descriptografar (data.CiphertextBlob)
.then (key => {
const dataBuffer = decryptAES (chave, cipherTextBlob);
console.log (dataBuffer.toString ('utf-8'));
});
});

Contexto de criptografia

Além de todos esses AWS KMS, há suporte para o contexto de criptografia para aumentar ainda mais a segurança. Existem alguns problemas de segurança que podem ser atenuados usando um contexto de criptografia. Para saber mais sobre o contexto de criptografia e como usá-lo, por favor, dirija-se aqui .

OK estamos no final. Este foi um artigo bastante longo. Mas espero que você tenha aprendido algo com isso. Agora é sua vez de verificar o AWS KMS fora !!!

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *