Lição: 096: Criptografia Avançada em Programas Solana
Nesta aula, vamos nos aprofundar em conceitos avançados de criptografia e como utilizá-los em contratos inteligentes (programas) da Solana. Vamos explorar alguns primitivos criptográficos e suas aplicações dentro do ecossistema Solana, fornecendo exemplos de código utilizando Rust.
Entendendo os Fundamentos da Criptografia
A criptografia é fundamental para garantir a comunicação segura e a integridade dos dados. Nos programas Solana, funções criptográficas podem ser usadas para assinatura de dados, verificação e hashing seguro.
Primitivos Criptográficos Comuns
- Funções de Hash: Funções irreversíveis que recebem uma entrada e produzem uma string de bytes de tamanho fixo.
- Assinaturas Digitais: Usadas para atestar a autenticidade de uma mensagem ou transação.
- Geração de Chaves: Criando chaves criptográficas para uso em criptografia assimétrica ou simétrica.
Configurando Seu Projeto
Antes de começarmos, você precisará criar um novo programa Solana. Use os seguintes comandos para iniciar seu projeto:
cargo new --lib meu_programa_solana
cd meu_programa_solana
Certifique-se de adicionar as dependências necessárias no seu Cargo.toml
:
[dependencies]
solana-program = "1.10"
bincode = "1.3"
rand = "0.8"
ed25519-dalek = "1.0"
sha2 = "0.10"
Hashing de Dados
A Solana usa SHA-256 para fins de hashing. Vamos ver como hash dados utilizando o crate sha2
.
use sha2::{Sha256, Digest};
fn hash_data(input: &[u8]) -> Vec<u8> {
let mut hasher = Sha256::new();
hasher.update(input);
hasher.finalize().to_vec()
}
fn main() {
let data = b"Olá, Solana!";
let hash = hash_data(data);
println!("Hash SHA256: {:?}", hash);
}
Assinaturas Digitais
Em muitos cenários, você precisará assinar mensagens ou transações. Vamos usar o crate ed25519-dalek
para assinar e verificar.
Geração de Par de Chaves
use ed25519_dalek::{Keypair, Signature, Signer, Verifier};
fn generate_keypair() -> Keypair {
Keypair::generate(&mut rand::thread_rng())
}
fn main() {
let keypair = generate_keypair();
println!("Chave Pública: {:?}", keypair.public);
}
Assinando uma Mensagem
fn sign_message(keypair: &Keypair, message: &[u8]) -> Signature {
keypair.sign(message)
}
fn main() {
let keypair = generate_keypair();
let message = b"Mensagem assinada";
let signature = sign_message(&keypair, message);
println!("Assinatura: {:?}", signature);
}
Verificando uma Assinatura
fn verify_signature(public_key: &PublicKey, message: &[u8], signature: &Signature) -> bool {
public_key.verify(message, signature).is_ok()
}
fn main() {
let keypair = generate_keypair();
let message = b"Mensagem assinada";
let signature = sign_message(&keypair, message);
let valid = verify_signature(&keypair.public, message, &signature);
println!("Assinatura válida: {}", valid);
}
Aplicação em Programas Solana
Agora que entendemos como hash dados e empregar assinaturas digitais, vamos ver como esses conceitos se aplicam dentro do ambiente de programas Solana.
Exemplo: Criando um Programa Solana com Assinatura
Aqui está um exemplo de uso de criptografia em um programa simples da Solana que verifica uma mensagem assinada.
use anchor_lang::prelude::*;
use ed25519_dalek::{Keypair, Signature};
use sha2::{Sha256, Digest};
declare_id!("SeuIDdoPrograma");
#[program]
pub mod meu_programa_solana {
use super::*;
pub fn verify_signed_message(ctx: Context<Verify>, message: Vec<u8>, signature: [u8; 64]) -> Result<()> {
let public_key = ctx.accounts.user.key;
// Verifica a assinatura
let signature = Signature::from_bytes(&signature).map_err(|_| ErrorCode::SignatureError)?;
let is_valid = public_key.verify(&message, &signature).is_ok();
if is_valid {
msg!("Assinatura é válida!");
} else {
return Err(ErrorCode::InvalidSignature.into());
}
Ok(())
}
}
#[derive(Accounts)]
pub struct Verify<'info> {
#[account(mut)]
pub user: Signer<'info>,
}
#[error_code]
pub enum ErrorCode {
#[msg("Assinatura inválida.")]
InvalidSignature,
#[msg("Falha na verificação da assinatura.")]
SignatureError,
}
Conclusão
Nesta aula, exploramos técnicas avançadas de criptografia e suas aplicações dentro de programas Solana usando Rust. Aprendemos sobre hashing, assinaturas digitais e como implementar esses conceitos para verificar a integridade e autenticidade dos dados.
À medida que você desenvolver aplicações mais complexas, entender esses fundamentos criptográficos será crucial para garantir a segurança e construir confiança em seus projetos Solana. Boa codificação!