21.11.2024

Aula 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

1. Funções de Hash: Funções irreversíveis que recebem uma entrada e produzem uma string de bytes de tamanho fixo.
2. Assinaturas Digitais: Usadas para atestar a autenticidade de uma mensagem ou transação.
3. 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!

Navigation