Rust

aws-lc-rs

aws-lc-rs de AWS, una API de Rust compatible con ring sobre la biblioteca C AWS-LC: las mismas constantes de codificación FIXED/ASN1 que ring, además de P-521, secp256k1, ML-KEM y ML-DSA en la API estable, y una compilación FIPS 140-3 opcional.

Licencia: ISC AND (Apache-2.0 OR ISC)
Versión comprobada: 1.18.2 · 20 de octubre de 2026
Código fuente: github.com/aws/aws-lc-rs
Documentación: docs.rs/aws-lc-rs/1.18.2/aws_lc_rs/

Compatibilidad de un vistazo

ECDSAEdDSACriptografía poscuántica

Curvas ECDSA: P-256P-384P-521secp256k1
EdDSA: Ed25519
Algoritmos poscuánticos: ML-KEMML-DSA
Codificación de la firma ECDSA: der-or-raw
Formatos de clave pública: spki-dersec1-uncompressedsec1-compressed
Formatos de clave privada: pkcs8-dersec1-derraw-scalar

aws-lc-rs expone AWS-LC —el fork de BoringSSL de Amazon— a través de una API inspirada en la de ring, de modo que la mayor parte del código de ring compila tras cambiar el nombre del crate. Es el proveedor criptográfico predeterminado de rustls y la opción de los servicios en Rust que necesitan validación FIPS 140-3 (la característica fips) o algoritmos poscuánticos. La biblioteca C se compila al compilar el crate; la comprobación compiló la 1.18.2 con las características predeterminadas en la imagen rust estándar.

Las codificaciones de firma funcionan exactamente igual que en ring: las constantes *_FIXED producen y aceptan r‖s en bruto de 64 bytes, y las constantes *_ASN1, DER; una firma en bruto falló con la constante de verificación ASN1. Los nonces son aleatorios, s no se normaliza y la verificación acepta s en cualquiera de las dos mitades. Además de las curvas P-256 y P-384 de ring, firma y verifica en P-521 y secp256k1, con variantes SHA-2 y SHA-3.

Los algoritmos poscuánticos forman parte de la API estable en la 1.18.2 —la comprobación se compiló sin la característica unstable—: ML-KEM-512, ML-KEM-768 y ML-KEM-1024 en aws_lc_rs::kem, y ML-DSA-44, ML-DSA-65 y ML-DSA-87 en aws_lc_rs::signature, que es lo que usa el ejemplo. Los tamaños que imprime —una clave pública de 1952 bytes y una firma de 3309 bytes para ML-DSA-65, y un texto cifrado de 1088 bytes para ML-KEM-768— son lo que tienen que transportar los certificados, los tokens y los handshakes; la herramienta de firmas poscuánticas y la herramienta de KEM los comparan con los de los algoritmos clásicos.

La carga de claves es más amplia que en ring: las claves ECDSA se cargan desde PKCS#8, DER SEC1 (RFC 5915) y un escalar en bruto junto con su clave pública, y las claves públicas, desde DER SPKI y puntos SEC1, comprimidos o no. A diferencia de ring, Ed25519KeyPair::from_pkcs8 aceptó la forma PKCS#8 v1 de 48 bytes que escribe OpenSSL.

Usa el conversor DER ⇄ en bruto cuando sospeches de una discrepancia entre FIXED y ASN1, y el generador de configuración TLS para los ajustes del intercambio de claves híbrido poscuántico.

Datos y las comprobaciones que los respaldan

Nada de lo que sigue está copiado de la documentación. La comprobación content/libraries/verify/aws-lc-rs/run.sh ejecutó aws-lc-rs 1.18.2 en la imagen de contenedor rust:1.99.1-trixie el 20 de octubre de 2026; la página debe coincidir con lo que imprimió, y cada dato cita esas líneas.

Codificación de la firma ECDSA
der-or-raw
Las constantes *_FIXED producen firmas r‖s en bruto de 64 bytes, y las *_ASN1, DER; una firma en bruto no se verificó con la constante ASN1.
Registrado por la comprobación
```
fact ecdsa-signature-encoding = der-or-raw
evidence ecdsa-signature-encoding: FIXED signs 64 bytes; the same bytes verify under the ASN1 constant: false
```
Nonce de ECDSA
random
Nonce aleatorio: dos firmas del mismo mensaje son distintas.
Registrado por la comprobación
```
fact ecdsa-nonce = random
```
Low-S al firmar
either
s no se normaliza: aparecieron valores high-S entre 64 firmas.
Registrado por la comprobación
```
fact ecdsa-low-s-sign = either
```
High-S al verificar
accepts-high-s
El verificador FIXED aceptó la firma con s sustituido por n − s.
Registrado por la comprobación
```
fact ecdsa-low-s-verify = accepts-high-s
```
De qué calcula el hash la llamada de firma
hashes-message
El hash del mensaje se calcula con el algoritmo que indica la constante (variantes SHA-2 o SHA-3).
Registrado por la comprobación
```
fact ecdsa-prehash = hashes-message
```
Firma ECDSA mal formada
returns-error
La verificación devuelve un valor de error con firmas mal formadas o incorrectas.
Registrado por la comprobación
```
fact ecdsa-malformed-signature = returns-error
```
Curvas ECDSA
P-256P-384P-521secp256k1
Con P-256, P-384, P-521 y secp256k1 se firmó y se verificó.
Registrado por la comprobación
```
fact ecdsa-curves = P-256, P-384, P-521, secp256k1
```
EdDSA
Ed25519
Ed25519.
Registrado por la comprobación
```
fact eddsa = Ed25519
```
Claves Ed25519 en PKCS #8 v1
accepted
Ed25519KeyPair::from_pkcs8 aceptó una clave Ed25519 PKCS#8 v1 de 48 bytes, que ring rechaza.
Registrado por la comprobación
```
fact ed25519-pkcs8-v1 = accepted
evidence ed25519-pkcs8-v1: 48-byte PKCS#8 v1 Ed25519 key with from_pkcs8: Ok("ok")
```
Algoritmos poscuánticos
ML-KEMML-DSA
Con ML-KEM-512/768/1024 se encapsuló y desencapsuló, y con ML-DSA-44/65/87 se firmó y verificó, en una compilación sin la característica unstable.
Registrado por la comprobación
```
fact pqc = ML-KEM, ML-DSA
evidence pqc: ML-KEM-512/768/1024 via aws_lc_rs::kem; ML-DSA-44/65/87 via aws_lc_rs::signature
```
Formatos de clave pública
spki-dersec1-uncompressedsec1-compressed
DER SPKI mediante ParsedPublicKey, y puntos SEC1 comprimidos o sin comprimir.
Registrado por la comprobación
```
fact public-key-formats = spki-der, sec1-uncompressed, sec1-compressed
```
Formatos de clave privada
pkcs8-dersec1-derraw-scalar
DER PKCS#8, DER SEC1 (RFC 5915) y un escalar en bruto junto con su clave pública.
Registrado por la comprobación
```
fact private-key-formats = pkcs8-der, sec1-der, raw-scalar
```

Uso

Firma y verifica con ML-DSA-65, ejecuta una encapsulación ML-KEM-768 e imprime los tamaños de la clave, la firma y el texto cifrado.

use aws_lc_rs::kem::{DecapsulationKey, ML_KEM_768};
use aws_lc_rs::signature::{self, KeyPair, PqdsaKeyPair, UnparsedPublicKey};

fn main() {
    // ML-DSA-65 (FIPS 204) through the stable signature API.
    let key = PqdsaKeyPair::generate(&signature::ML_DSA_65_SIGNING).unwrap();
    let message = b"release v2.0 manifest";
    let mut sig = vec![0u8; signature::ML_DSA_65_SIGNING.signature_len()];
    let len = key.sign(message, &mut sig).unwrap();
    let ok = UnparsedPublicKey::new(&signature::ML_DSA_65, key.public_key().as_ref()).verify(message, &sig[..len]);
    println!("ML-DSA-65: public key {} bytes, signature {len} bytes, verified {}", key.public_key().as_ref().len(), ok.is_ok());

    // ML-KEM-768 (FIPS 203): the receiver publishes the encapsulation key.
    let receiver = DecapsulationKey::generate(&ML_KEM_768).unwrap();
    let (ciphertext, sender_secret) = receiver.encapsulation_key().unwrap().encapsulate().unwrap();
    let receiver_secret = receiver.decapsulate(ciphertext.as_ref().into()).unwrap();
    println!("ML-KEM-768: ciphertext {} bytes, shared secrets match {}", ciphertext.as_ref().len(), sender_secret.as_ref() == receiver_secret.as_ref());
}

El arnés de pruebas de fragmentos de código ejecuta cada ejemplo tal cual en la imagen de contenedor rust:1.99.1-trixie, y la ejecución falla si la salida no coincide.

Comando: cargo run --quiet --release
La salida debe coincidir (expresión regular): ML-DSA-65: public key 1952 bytes, signature 3309 bytes, verified true\nML-KEM-768: ciphertext 1088 bytes, shared secrets match true

Herramientas

Términos

Bibliotecas

Artículos

Formatos de firma ECDSA: DER frente a raw (P1363), high-S y trampas entre bibliotecas

Bibliotecas

Compatibilidad de un vistazo

Datos y las comprobaciones que los respaldan

Codificación de la firma ECDSA

Nonce de ECDSA

Low-S al firmar

High-S al verificar

De qué calcula el hash la llamada de firma

Firma ECDSA mal formada

Curvas ECDSA

EdDSA

Claves Ed25519 en PKCS #8 v1

Algoritmos poscuánticos

Formatos de clave pública

Formatos de clave privada

Uso

Contenido relacionado

Herramientas

Términos

Bibliotecas

Artículos