WEB3DEV

Cover image for Usando Azure Key Vault para Transações na Carteira com JavaScript - Algorand
Banana Labs
Banana Labs

Posted on • Atualizado em

Usando Azure Key Vault para Transações na Carteira com JavaScript - Algorand

A informação mais importante para cada proprietário de carteira Algorand é a chave privada. É a mais importante porque a perda dessa chave privada fará com que o proprietário não consiga acessar os tokens associados a essa carteira, e não há qualquer possibilidade de recuperação.

Com o Azure Key Vault é possível armazenar, recuperar e restaurar uma conta com sua chave privada usando a nuvem, para que você não a perca. Além disso, as carteiras iOS/Android estarão vazias se você adquirir um novo telefone ao transferir tudo do telefone antigo para um novo. Você também precisará da sua senha para restaurar a conta na nova carteira do telefone. E isso pode ser facilmente recuperado através do Azure Key Vault.

Este tutorial fornecerá as informações necessárias para assinar transações Algorand com uma chave privada armazenada no Azure Key Vault.

RECURSOS

Github
YouTube

Requisitos

Algorand JavaScript SDK
Vs Code ou qualquer IDE de sua escolha
Node Package Manager
Crie Uma Conta Azure Gratuita
Azure KeyVault Secret e Azure Identity Cliente

Pano de Fundo

O Azure Key Vault é um serviço de nuvem que fornece um armazenamento seguro para algo secreto. Você pode armazenar com segurança chaves, senhas, certificados e outras informações secretas. Os cofres de chaves do Azure podem ser criados e gerenciados por meio do portal do Azure. Neste tutorial, você cria um cofre de chaves e o usa para armazenar um segredo e recuperar o segredo para assinar transações no Algorand.

O Azure Key Vault e sua oferta de Hardware Security Modules (HSM) permitem o gerenciamento e o uso de pares de chaves criptográficas, sem que a chave privada saia do cofre, a menos que seja para operações de backup e restauração, ou seja, o risco de perda ou exposição do chave privada é reduzida.

Esse tutorial abordará a configuração da conta do Azure, a criação do Key Vault, a criação da transação de pagamento, a assinatura da transação com a chave secreta recuperada do Azure Key Vault e também a recuperação da chave privada.

Etapas

1. Instalação de pacotes e configuração do ambiente

Para começar, crie uma pasta local em sua máquina para o código, cd (mudar diretório) para a pasta criada e faça npm init e instale os seguintes pacotes

npm install algosdk

Isso instalará o Algorand JavaScript SDK. O algosdk garante interações com a blockchain da Algorand.

Fig 1-1 Instalando algosdk<br>
Fig 1-1 Instalando algosdk

npm install --save @azure/identity

Isso instalará a biblioteca de identidades do Azure. A biblioteca de identidades do Azure fornece autenticação de token do Azure Active Directory (Azure AD) por meio de um conjunto de implementações convenientes de TokenCredential.

npm install @azure/keyvault-secrets

Use a biblioteca de cliente KeyVault Secrets para obter acesso ao Azure Key Vault.

Fig 1-2 Instale Azure Identity e KeyVault Secrets
Fig 1-2 Instale Azure Identity e KeyVault Secrets

npm install dotenv --save

Dotenv é um módulo de dependência zero que carrega variáveis de ambiente de um arquivo .env para process.env. Armazenando a configuração no ambiente separada do código. Você criará um arquivo .env na raiz do seu projeto.

Fig 1-3 Instalando dotenv<br>
Fig 1-3 Instalando dotenv

No mac, faça brew update && brew install azure-cli Isso permitirá interações com o portal do Azure na linha de comando. Se você encontrar algum erro ao executar o comando acima, tente instalar a partir do código fonte com:

brew install --build-from-source [email protected]

Se você estiver tendo problemas para instalar a CLI, esse guia de instalação deve ser útil.

Fig 1-4 Fig 1-4 Instalando azure-cli
Fig 1-4 Fig 1-4 Instalando azure-cli

Estrutura de Arquivos

Sua estrutura de arquivos deve ficar assim. Seu módulo .env e módulo node deve ser adicionado ao arquivo .gitignore para que você não acabe expondo suas credenciais ao enviar para o github.

Fig 1-5 Estrutura de Arquivos<br>
Fig 1-5 Estrutura de Arquivos

2. Configuração da Conta do Azure

Crie uma conta gratuita do Azure e faça login no portal. Crie uma conta aqui. Existem dois tipos de conta: a conta gratuita e a conta PayAsYouGo. A conta gratuita dá acesso ao portal do Azure para acessar os recursos do Azure por um período de avaliação de 30 dias.

Crie Uma Conta Azure

Fig 2-1 Criar conta
Fig 2-1 Criar conta

Entrar no Portal do Azure

Após a criação bem-sucedida da conta, você pode fazer o login.

Fig 2-2 Login

3. Criar Grupo de Recursos

Um grupo de recursos é um contêiner que contém recursos relacionados para uma solução do Azure. Para criar recursos, clique em Grupos de Recursos no painel esquerdo para exibir grupos de recursos.

Fig 3-1 Selecionar grupo de recursos<br>
Fig 3-1 Selecionar grupo de recursos

Clique no botão criar para criar um novo grupo de recursos chamado azure-vault-rg

Fig 3-2 Criar Grupo de Recursos
Fig 3-2 Criar Grupo de Recursos

Ao criar um recurso no Azure, a convenção de nomenclatura é terminar o nome do recurso com
-rg, desta forma é possível identificá-lo facilmente como grupo de recursos. Mesmo com outros nomes -vault, -secret, -vm, etc

A marcação de recursos do Azure permite atribuir um tipo de metadados a um recurso. Então, você pode encontrar todos os recursos que têm a mesma tag!

Uma tag é um par Key/Value. Ele pode ser aplicado aos grupos de recursos ou diretamente nos recursos. É pesquisável para que possa ser usado para localizar recursos ou grupos de recursos usando o Powershell ou o Portal do Azure.

Fig 3-3 Tag do Grupo de Recursos<br>
Fig 3-3 Tag do Grupo de Recursos

4. Criar Cofre de Chaves (Key Vault)

O Azure Key Vault é um serviço de nuvem que fornece um armazenamento seguro para segredos. Você pode armazenar com segurança chaves, senhas, certificados e outros segredos. Os cofres de chaves do Azure podem ser criados e gerenciados por meio do portal do Azure.

Existem várias maneiras de criar o cofre de chaves do portal do Azure. No seu grupo de recursos, você pode clicar no botão + para criar um novo recurso ou pesquisar por Key Vault usando a barra de pesquisa.

Fig 4-1 Pesquisar Key Vault<br>
Fig 4-1 Pesquisar Key Vault

Selecione o nome do grupo de recursos, insira o nome do cofre de chaves, selecione a região e o tipo de preço. Em seguida, clique no botão revisar e criar.

Fig 4-2 Criar Key Vault
Fig 4-2 Criar Key Vault

A proteção contra limpeza é um comportamento opcional do Key Vault e não está habilitada por padrão. A proteção contra limpeza só pode ser habilitada quando a exclusão reversível estiver habilitada. Ela pode ser ativada via CLI ou PowerShell. A proteção contra limpeza é recomendada ao usar chaves para criptografia para evitar a perda de dados.

Fig 4-3 Vá para Recurso
Fig 4-3 Vá para Recurso

Quando terminar de criar o cofre de chaves, clique no botão Ir para o recurso. Isso o levará à página de visão geral do cofre de chaves. Anote a URI do cofre, ela será usada posteriormente no aplicativo cliente. O valor URI do cofre será usado posteriormente na etapa 6.

Fig 4-4 Visão geral do Key Vault
Fig 4-4 Visão geral do Key Vault

Para verificar os detalhes ou propriedades do cofre de chaves. Clique em propriedades no painel esquerdo.

Fig 4-5 Propriedades do Key Vault
Fig 4-5 Propriedades do Key Vault

5. Criar Segredo

Para acompanhar este tutorial, você armazenará seu mnemônico em segredo. Este segredo será recuperado posteriormente para assinar a transação.

Para criar segredo, clique no segredo e no botão + para gerar/importar segredo.

Fig 5-1 Criar Segredo
Fig 5-1 Criar Segredo

Insira o nome e o valor do segredo. Defina a data de ativação e expiração e a tag em seguida pressione o botão criar.

Fig 5-2 Criar Formulário do Segredo
Fig 5-2 Criar Formulário do Segredo

O segredo destacado é o nome do segredo que você usará posteriormente no aplicativo cliente. Este será o valor para o nome do segredo nas variáveis de ambiente na etapa 6.

Fig 5-3 Segredos
Fig 5-3 Segredos

6. Configuração das Variáveis de Ambiente

Crie um arquivo .env na raiz do seu projeto para armazenar informações confidenciais. Seu arquivo .env deve ficar assim. Os valores não devem ser citados.

O cliente Purestake será usado para conectar. A API_KEY é obtida da API Purestake. Depois de criar a conta, você terá acesso à chave da API.

O nome secreto é destacado na fig. 5-3 e a URI do Vault é destacado na fig. 4-4.

API_KEY = YOUR PURESTAKE API KEY
KEY_VAULT_URI = https://algo-vault.vault.azure.net/
SECRET_NAME =   mnemonic-secret
ALGOD_SERVER = https://testnet-algorand.api.purestake.io/ps2/
PORT = 
Enter fullscreen mode Exit fullscreen mode

7. Obtenha o segredo do cliente do Azure Key Vault

Estes handlers conectam à identidade do Azure e cliente do segredo fazendo uma solicitação para obter o segredo. // src/VaultSecret.js

// Azure authentication library to access Azure Key Vault
const { DefaultAzureCredential} = require("@azure/identity")
const { SecretClient } = require("@azure/keyvault-secrets")
require('dotenv').config({path: '../.env'})

const getSecret =  async () =>{
  try{
    // Azure SDK clients accept the credential as a parameter
    const credential = new DefaultAzureCredential();
    const client = new SecretClient(process.env.KEY_VAULT_URI, credential)
    const secret =  await  client.getSecret(process.env.SECRET_NAME)
    const value = secret.value
    console.log(value)
    return value
  }catch(err){
    console.log(err)
  }
}
getSecret()
module.exports ={
  getSecret
}
Enter fullscreen mode Exit fullscreen mode

8. Recuperar Conta

Estes handlers recuperam a carteira Algorand usando o segredo do Azure Key Vault. // src/RecoverAccount.js

const vault = require('./VaultSecret') 
  const algosdk = require('algosdk')

  const recoverAccount = async () =>{
  const mnomenic = await vault.getSecret()
  const recover =  algosdk.mnemonicToSecretKey(mnomenic)
  console.log(recover.sk)
}

recoverAccount()
Enter fullscreen mode Exit fullscreen mode

9. Crie uma transação de pagamento e assine com o segredo recuperado do Key Vault

Conecte seu cliente
//src/Transaction.js

const algodToken = {"X-API-Key": process.env.API_KEY}
const algodServer = process.env.ALGOD_SERVER;
const algodPort = process.env.PORT;
let algodClient = new algosdk.Algodv2(algodToken, algodServer, algodPort);
Enter fullscreen mode Exit fullscreen mode

O código aqui é um handler para conexão com o cliente da API Algorand Purestake, criando uma transação de pagamento, assinando a transação com segredo do Azure Key Vault.

const vault = require('./VaultSecret') 
const algosdk = require('algosdk')
require('dotenv').config({path: '../.env'})

  async function paymentTransaction() {
    const mnomenic = await vault.getSecret()
    const account = algosdk.mnemonicToSecretKey(mnomenic)
    const senderAddress = account.addr

    try {

        //Check your balance
        let accountInfo = await algodClient.accountInformation(senderAddress).do();
        console.log("Account balance: %d microAlgos", accountInfo.amount);

        // Construct the transaction
        let params = await algodClient.getTransactionParams().do();
        // comment out the next two lines to use suggested fee
        params.fee = algosdk.ALGORAND_MIN_TX_FEE;
        params.flatFee = true;

        // receiver defined as TestNet faucet address 
        const receiver = "HZ57J3K46JIJXILONBBZOHX6BKPXEM2VVXNRFSUED6DKFD5ZD24PMJ3MVA";
        const enc = new TextEncoder();
        const note = enc.encode("Hello World");
        let amount = 1000000;
        let sender = senderAddress;
        let txn = algosdk.makePaymentTxnWithSuggestedParamsFromObject({
            from: sender, 
            to: receiver, 
            amount: amount, 
            note: note, 
            suggestedParams: params
        });


        // Sign the transaction
        let signedTxn = txn.signTxn(account.sk);
        let txId = txn.txID().toString();
        console.log("Signed transaction with txID: %s", txId);

        // Submit the transaction
        await algodClient.sendRawTransaction(signedTxn).do();

        // Wait for confirmation
        let confirmedTxn = await algosdk.waitForConfirmation(algodClient, txId, 4);
        //Get the completed Transaction
        console.log("Transaction " + txId + " confirmed in round " + confirmedTxn["confirmed-round"]);
        let string = new TextDecoder().decode(confirmedTxn.txn.txn.note);
        console.log("Note field: ", string);
        accountInfo = await algodClient.accountInformation(senderAddress).do();
        console.log("Transaction Amount: %d microAlgos", confirmedTxn.txn.txn.amt);        
        console.log("Transaction Fee: %d microAlgos", confirmedTxn.txn.txn.fee);
        console.log("Account balance: %d microAlgos", accountInfo.amount);
    }
    catch (err) {
        console.log("err", err);
    }  
  };
  paymentTransaction()
Enter fullscreen mode Exit fullscreen mode

10. Código Completo

//src/VaultSecret.js

// Azure authentication library to access Azure Key Vault
const { DefaultAzureCredential} = require("@azure/identity")
const { SecretClient } = require("@azure/keyvault-secrets")
require('dotenv').config({path: '../.env'})

const getSecret =  async () =>{
  try{
    // Azure SDK clients accept the credential as a parameter
    const credential = new DefaultAzureCredential();
    const client = new SecretClient(process.env.KEY_VAULT_URI, credential)
    const secret =  await  client.getSecret(process.env.SECRET_NAME)
    const value = secret.value
    console.log(value)
    return value
  }catch(err){
    console.log(err)
  }
}
getSecret()
module.exports ={
  getSecret
}
Enter fullscreen mode Exit fullscreen mode

// src/RecoverAccount.js

const vault = require('./VaultSecret') 
const algosdk = require('algosdk')

const recoverAccount = async () =>{
const mnomenic = await vault.getSecret()
const recover =  algosdk.mnemonicToSecretKey(mnomenic)
console.log(recover.sk)
}

recoverAccount()
Enter fullscreen mode Exit fullscreen mode

// src/Transaction.js

const vault = require('./VaultSecret') 
const algosdk = require('algosdk')
require('dotenv').config({path: '../.env'})

  async function paymentTransaction() {
    const mnomenic = await vault.getSecret()
    const account = algosdk.mnemonicToSecretKey(mnomenic)
    const senderAddress = account.addr

    try {
        // Connect your client
        const algodToken = {"X-API-Key": process.env.API_KEY}
        const algodServer = 'https://testnet-algorand.api.purestake.io/ps2/';
        const algodPort = "";
        let algodClient = new algosdk.Algodv2(algodToken, algodServer, algodPort);

        //Check your balance
        let accountInfo = await algodClient.accountInformation(senderAddress).do();
        console.log("Account balance: %d microAlgos", accountInfo.amount);

        // Construct the transaction
        let params = await algodClient.getTransactionParams().do();
        // comment out the next two lines to use suggested fee
        params.fee = algosdk.ALGORAND_MIN_TX_FEE;
        params.flatFee = true;

        // receiver defined as TestNet faucet address 
        const receiver = "HZ57J3K46JIJXILONBBZOHX6BKPXEM2VVXNRFSUED6DKFD5ZD24PMJ3MVA";
        const enc = new TextEncoder();
        const note = enc.encode("Hello World");
        let amount = 1000000;
        let sender = senderAddress;
        let txn = algosdk.makePaymentTxnWithSuggestedParamsFromObject({
            from: sender, 
            to: receiver, 
            amount: amount, 
            note: note, 
            suggestedParams: params
        });


        // Sign the transaction
        let signedTxn = txn.signTxn(account.sk);
        let txId = txn.txID().toString();
        console.log("Signed transaction with txID: %s", txId);

        // Submit the transaction
        await algodClient.sendRawTransaction(signedTxn).do();

        // Wait for confirmation
        let confirmedTxn = await algosdk.waitForConfirmation(algodClient, txId, 4);
        //Get the completed Transaction
        console.log("Transaction " + txId + " confirmed in round " + confirmedTxn["confirmed-round"]);
        let string = new TextDecoder().decode(confirmedTxn.txn.txn.note);
        console.log("Note field: ", string);
        accountInfo = await algodClient.accountInformation(senderAddress).do();
        console.log("Transaction Amount: %d microAlgos", confirmedTxn.txn.txn.amt);        
        console.log("Transaction Fee: %d microAlgos", confirmedTxn.txn.txn.fee);
        console.log("Account balance: %d microAlgos", accountInfo.amount);
    }
    catch (err) {
        console.log("err", err);
    }  
  };
  paymentTransaction()
Enter fullscreen mode Exit fullscreen mode

11. Executar o Código

Para acessar o segredo, certifique-se de estar conectado usando o azure cli. Digite az login. Se você não estiver logado e tentar recuperar o segredo, verá algo como na figura 10-1 abaixo.

Fig 10-1 Unauthorized Error
Fig 10-1 Unauthorized Error

Após o login bem-sucedido, sua resposta deve se parecer com a figura 10-2 abaixo

Fig 10-2 Login bem-sucedido
Fig 10-2 Login bem-sucedido

Para executar os códigos abaixo, verifique se você está na pasta src

Execute o Código VaultSecret

Execute o código usando node VaultSecret.js Isso exibirá o valor do segredo do seu cofre.

Fig 10-3 Vault Secret<br>
Fig 10-3 Vault Secret

Execute o Código RecoverAccount

Execute o código usando node RecoverAccount.js. A saída será o valor mnemônico que você armazenou no Azure Key Vault Secret.

Fig 10-4 Recover Account Output
Fig 10-4 Recover Account Output

Execute o Código Transaction

Execute o código usando node Transaction.js.

Fig 10-5 Resultado
Fig 10-5 Resultado

AlgoExplorer

Id da transação VMCTXSOCX3DSQUHMGGVMZOSYT4C6H4CXPN3SYSJ5FI2MO47HUBDA você pode verificar os detalhes da transação no explorer.

Fig 10-6 AlgoExplorer<br>
Fig 10-6 AlgoExplorer

12. Limpar Recurso

Quando não for mais necessário, exclua o grupo de recursos, que exclui o Key Vault e os recursos relacionados. Para excluir o grupo de recursos por meio do portal:

Insira o nome do seu grupo de recursos na caixa Pesquisar na parte superior do portal. Quando você ver o grupo de recursos usado neste tutorial nos resultados da pesquisa, selecione-o. Selecione Excluir grupo de recursos. Na caixa DIGITE O NOME DO GRUPO DE RECURSOS: você digita o nome do grupo de recursos e selecione Excluir.

É importante observar que, depois que um segredo, chave, certificado ou cofre de chaves for excluído, ele permanecerá recuperável por um período configurável de 7 a 90 dias corridos. Se nenhuma configuração for especificada, o período de recuperação padrão será definido para 90 dias. Isso fornece aos usuários tempo suficiente para perceber uma exclusão acidental de segredo e solucionar o erro. Para obter mais informações sobre como excluir e recuperar cofres de chaves e objetos de cofre de chaves, confira Visão geral de exclusão reversível do Azure Key Vault.

13. Próxima Etapa

Para saber mais sobre Azure Key Vault e Transações em Algorand. Confira os links abaixo;

Definir e recuperar um segredo do Azure Key Vault usando o portal do Azure
Biblioteca JavaScript do Azure Key Vault
Biblioteca de cliente de identidade do Azure
Acesso seguro ao Key Vault
Usar o Key Vault com o aplicativo Web do serviço de aplicativo
Guia do desenvolvedor do Azure Key Vault
Visão geral da segurança do Key Vault
Implantando Sandbox em uma VM Linux no Azure
Criando sua primeira transação na Algorand

14. Conclusão

Este tutorial aborda os conceitos básicos sobre como criar o Key Vault, assinar transações com o valor secreto recuperado e recuperar a chave privada.

Aviso!

Este tutorial destina-se apenas para fins de aprendizado. Ele não cobre a verificação de erros e outros casos extremos. Portanto, não deve ser usado para uma aplicação em produção.

Esse artigo é uma tradução de Glory Agatevure feita por @bananlabs. Você pode encontrar o artigo original aqui

Latest comments (0)