aws-lc-rs

Fakten und die Prüfungen dahinter

Nichts im Folgenden ist aus einer Dokumentation abgeschrieben. Das Prüfskript content/libraries/verify/aws-lc-rs/run.sh hat aws-lc-rs 1.18.2 am 20. Oktober 2026 im Container-Image rust:1.99.1-trixie ausgeführt; die Seite muss mit seiner Ausgabe übereinstimmen, und jeder Fakt führt die zugehörigen Zeilen auf.

• Kodierung von ECDSA-Signaturen

  der-or-raw

  Die Konstanten *_FIXED signieren als 64 Byte rohes r‖s, die Konstanten *_ASN1 als DER; eine rohe Signatur bestand die Prüfung mit der ASN1-Konstante nicht.

  Von der Prüfung aufgezeichnet

  fact ecdsa-signature-encoding = der-or-raw
  evidence ecdsa-signature-encoding: FIXED signs 64 bytes; the same bytes verify under the ASN1 constant: false

• ECDSA-Nonce

  random

  Zufällige Nonce: Zwei Signaturen derselben Nachricht unterscheiden sich.

  Von der Prüfung aufgezeichnet

  fact ecdsa-nonce = random

• Low-S beim Signieren

  either

  s wird nicht normalisiert: Unter 64 Signaturen traten High-S-Werte auf.

  Von der Prüfung aufgezeichnet

  fact ecdsa-low-s-sign = either

• High-S bei der Prüfung

  accepts-high-s

  Der FIXED-Verifizierer akzeptierte die Signatur, in der s durch n − s ersetzt war.

  Von der Prüfung aufgezeichnet

  fact ecdsa-low-s-verify = accepts-high-s

• Was der Signaturaufruf hasht

  hashes-message

  Die Nachricht wird mit dem Algorithmus gehasht, den die Konstante nennt (Varianten mit SHA-2 oder SHA-3).

  Von der Prüfung aufgezeichnet

  fact ecdsa-prehash = hashes-message

• Fehlerhafte ECDSA-Signatur

  returns-error

  Die Prüfung gibt bei fehlerhaften oder falschen Signaturen einen Fehlerwert zurück.

  Von der Prüfung aufgezeichnet

  fact ecdsa-malformed-signature = returns-error

• ECDSA-Kurven

  P-256P-384P-521secp256k1

  Signieren und Prüfen funktionierten mit P-256, P-384, P-521 und secp256k1.

  Von der Prüfung aufgezeichnet

  fact ecdsa-curves = P-256, P-384, P-521, secp256k1

• EdDSA

  Ed25519

  Ed25519.

  Von der Prüfung aufgezeichnet

  fact eddsa = Ed25519

• Ed25519-Schlüssel in PKCS #8 v1

  accepted

  Ed25519KeyPair::from_pkcs8 akzeptierte einen 48 Byte langen Ed25519-Schlüssel in PKCS#8 v1, den ring ablehnt.

  Von der Prüfung aufgezeichnet

  fact ed25519-pkcs8-v1 = accepted
  evidence ed25519-pkcs8-v1: 48-byte PKCS#8 v1 Ed25519 key with from_pkcs8: Ok("ok")

• Post-Quanten-Algorithmen

  ML-KEMML-DSA

  Kapselung und Entkapselung mit ML-KEM-512/768/1024 sowie Signieren und Prüfen mit ML-DSA-44/65/87 funktionierten, gebaut ohne das Feature unstable.

  Von der Prüfung aufgezeichnet

  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

• Formate öffentlicher Schlüssel

  spki-dersec1-uncompressedsec1-compressed

  SPKI als DER über ParsedPublicKey sowie SEC1-Punkte, komprimiert oder unkomprimiert.

  Von der Prüfung aufgezeichnet

  fact public-key-formats = spki-der, sec1-uncompressed, sec1-compressed

• Formate privater Schlüssel

  pkcs8-dersec1-derraw-scalar

  PKCS#8 als DER, SEC1 (RFC 5915) als DER und ein roher Skalar zusammen mit seinem öffentlichen Schlüssel.

  Von der Prüfung aufgezeichnet

  fact private-key-formats = pkcs8-der, sec1-der, raw-scalar

Verwendung

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());
}