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
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
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
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
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
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
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
Entrar no Portal do Azure
Após a criação bem-sucedida da conta, você pode fazer o 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
Clique no botão criar para criar um novo grupo de recursos chamado azure-vault-rg
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
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
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
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
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
Para verificar os detalhes ou propriedades do cofre de chaves. Clique em propriedades no painel esquerdo.
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
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
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
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 =
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
}
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()
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);
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()
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
}
// 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()
// 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()
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
Após o login bem-sucedido, sua resposta deve se parecer com a figura 10-2 abaixo
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
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
Execute o Código Transaction
Execute o código usando node Transaction.js.
Fig 10-5 Resultado
AlgoExplorer
Id da transação VMCTXSOCX3DSQUHMGGVMZOSYT4C6H4CXPN3SYSJ5FI2MO47HUBDA você pode verificar os detalhes da transação no explorer.
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
Top comments (0)