Biblioteca criptográfica soberana com algoritmos aprovados apenas
Implementação pura em Rust sem dependências externas. Controle total sobre algoritmos criptográficos.
Otimizado para AVX2/AVX-512 com suporte para aceleração de hardware.
Apenas algoritmos aprovados e auditados. Implementações certificadas.
Features opcionais para curvas elípticas, assinaturas, cifras e MACs.
| Tipo | Descrição | Feature |
|---|---|---|
CryptoRuntime |
Runtime criptográfico principal | crypto-runtime |
Secp256k1 |
Curva elíptica secp256k1 | curves |
Ed25519 |
Curva Edwards25519 para assinaturas | signatures |
ECDSA |
Assinaturas digitais ECDSA | signatures |
AES |
Cifra de bloco AES-128/192/256 | cipher |
ChaCha20 |
Cifra de fluxo ChaCha20 | cipher |
HMAC |
Código de autenticação de mensagem | mac |
BigInt |
Aritmética de inteiros grandes | default |
use avx_crypto::signatures::ecdsa::Ecdsa;
use avx_crypto::curves::secp256k1::Secp256k1;
fn main() {
// Gerar par de chaves
let mut rng = avx_crypto::rand::thread_rng();
let private_key = Secp256k1::generate_private_key(&mut rng);
let public_key = Secp256k1::derive_public_key(&private_key);
// Assinar mensagem
let message = b"AVX Crypto Security";
let signature = Ecdsa::sign(&private_key, message, &mut rng)
.expect("Falha ao assinar");
// Verificar assinatura
let is_valid = Ecdsa::verify(&public_key, message, &signature);
assert!(is_valid);
println!("✅ Assinatura verificada com sucesso!");
}use avx_crypto::signatures::ed25519::Ed25519;
fn main() {
// Gerar par de chaves Ed25519
let keypair = Ed25519::generate_keypair();
// Assinar mensagem
let message = b"Mensagem confidencial";
let signature = Ed25519::sign(&keypair.secret, message);
// Verificar assinatura
let is_valid = Ed25519::verify(&keypair.public, message, &signature);
assert!(is_valid);
println!("✅ Ed25519 verificado!");
}use avx_crypto::bigint::BigInt;
fn main() {
// Criar inteiros grandes
let a = BigInt::from_hex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
let b = BigInt::from_hex("1234567890ABCDEF");
// Operações aritméticas
let sum = a.add(&b);
let product = a.mul(&b);
let modulus = BigInt::from_hex("FFFFFFFFFFFFFFFFFFFFFFFFFFFF");
let result = product.mod_exp(&b, &modulus);
println!("Resultado: {}", result.to_hex());
}pub fn new() -> Self
Cria uma nova instância do runtime criptográfico.
pub fn initialize(&mut self) -> Result<(), CryptoError>
Inicializa o runtime com gerador de números aleatórios seguro.
pub fn generate_private_key<R: RngCore>(rng: &mut R) -> PrivateKey
Gera uma chave privada aleatória para a curva secp256k1.
pub fn derive_public_key(private_key: &PrivateKey) -> PublicKey
Deriva a chave pública correspondente de uma chave privada.
pub fn sign<R: RngCore>(key: &PrivateKey, msg: &[u8], rng: &mut R) -> Result<Signature, CryptoError>
Assina uma mensagem usando ECDSA.
pub fn verify(key: &PublicKey, msg: &[u8], sig: &Signature) -> bool
Verifica uma assinatura ECDSA.
pub fn generate_keypair() -> Keypair
Gera um par de chaves Ed25519.
pub fn sign(secret: &SecretKey, message: &[u8]) -> Signature
Assina uma mensagem usando Ed25519.
pub fn verify(public: &PublicKey, message: &[u8], signature: &Signature) -> bool
Verifica uma assinatura Ed25519.
Assinaturas digitais, carteiras criptográficas, contratos inteligentes e validação de transações.
Autenticação forte, assinaturas de transações e proteção de dados financeiros sensíveis.
PKI corporativa, certificados digitais, HSM e gerenciamento de chaves criptográficas.
Criptografia end-to-end, autenticação de dispositivos IoT e comunicação segura.
AVX Crypto é software proprietário desenvolvido pela Ávila Inc. Todos os direitos reservados.
Para licenciamento comercial, entre em contato: nicolas@avila.inc