Enum PrivateKeyMaterial 

pub enum PrivateKeyMaterial {
    Secp256k1(SigningKey),
    Secp256r1(SigningKey),
    Ed25519(SigningKey),
    X25519(StaticSecret),
}

Variants

Secp256k1(SigningKey)

Secp256r1(SigningKey)

Ed25519(SigningKey)

X25519(StaticSecret)

Implementations

impl PrivateKeyMaterial

pub fn public_key(&self) -> PublicKeyMaterial

Examples found in repository

examples/proof_example.rs (line 11)

fn main() {
    let secp256k1_private =
        PrivateKeyMaterial::Secp256k1(k256::ecdsa::SigningKey::random(&mut rand::rngs::OsRng));
    let secp256k1_public = secp256k1_private.public_key();
    let agent_claim = json!({
        "id": "did:wba:example.com:agents:alice",
        "type": "AgentIdentityClaim",
        "name": "Agent Alice",
        "capabilities": ["search", "booking", "payment"],
    });
    let signed_claim = generate_w3c_proof(
        &agent_claim,
        &secp256k1_private,
        "did:wba:example.com:agents:alice#key-1",
        ProofGenerationOptions::default(),
    )
    .expect("secp256k1 proof generation should succeed");
    println!(
        "secp256k1 verification: {}",
        verify_w3c_proof(
            &signed_claim,
            &secp256k1_public,
            ProofVerificationOptions::default()
        )
    );

    let ed25519_private =
        PrivateKeyMaterial::Ed25519(ed25519_dalek::SigningKey::generate(&mut rand::rngs::OsRng));
    let ed25519_public = ed25519_private.public_key();
    let credential = json!({
        "id": "did:wba:example.com:credential:bob",
        "type": ["VerifiableCredential", "AgentCapabilityCredential"],
        "issuer": "did:wba:issuer.example.com",
        "credentialSubject": {
            "id": "did:wba:example.com:agents:bob",
            "capability": "hotel-booking",
        }
    });
    let signed_credential = generate_w3c_proof(
        &credential,
        &ed25519_private,
        "did:wba:issuer.example.com#key-1",
        ProofGenerationOptions {
            proof_type: Some(PROOF_TYPE_DATA_INTEGRITY.to_string()),
            cryptosuite: Some(CRYPTOSUITE_EDDSA_JCS_2022.to_string()),
            domain: Some("example.com".to_string()),
            ..ProofGenerationOptions::default()
        },
    )
    .expect("Ed25519 proof generation should succeed");
    println!(
        "ed25519 verification: {}",
        verify_w3c_proof(
            &signed_credential,
            &ed25519_public,
            ProofVerificationOptions {
                expected_domain: Some("example.com".to_string()),
                ..ProofVerificationOptions::default()
            },
        )
    );
}

pub fn sign_message(&self, message: &[u8]) -> Result<Vec<u8>, KeyMaterialError>

Examples found in repository

examples/interop_cli.rs (line 77)

fn run_verify_key_fixture(args: &[String]) {
    let fixture_path = read_option(args, "--fixture").expect("--fixture is required");
    let content = std::fs::read_to_string(&fixture_path).expect("fixture should be readable");
    let fixture: serde_json::Value =
        serde_json::from_str(&content).expect("fixture should be valid JSON");
    let keys = fixture["keys"]
        .as_object()
        .expect("keys should be an object");
    for (fragment, key_pair) in keys {
        let private_pem = key_pair["private_key_pem"]
            .as_str()
            .expect("private_key_pem should be a string");
        let public_pem = key_pair["public_key_pem"]
            .as_str()
            .expect("public_key_pem should be a string");
        assert!(
            private_pem.starts_with("-----BEGIN PRIVATE KEY-----"),
            "{fragment} private key must be PKCS#8 PEM"
        );
        assert!(
            public_pem.starts_with("-----BEGIN PUBLIC KEY-----"),
            "{fragment} public key must be SPKI PEM"
        );
        assert!(!private_pem.contains("ANP "));
        assert!(!public_pem.contains("ANP "));

        let private_key = PrivateKeyMaterial::from_pem(private_pem)
            .expect("private key should parse as standard PEM");
        let public_key =
            PublicKeyMaterial::from_pem(public_pem).expect("public key should parse as SPKI PEM");
        if !matches!(public_key, PublicKeyMaterial::X25519(_)) {
            let signature = private_key
                .sign_message(b"cross-language standard pem")
                .expect("signature should be created");
            public_key
                .verify_message(b"cross-language standard pem", &signature)
                .expect("signature should verify");
        }
    }
    println!(
        "{}",
        serde_json::to_string(&json!({"verified": true, "key_count": keys.len()}))
            .expect("result should serialize")
    );
}

pub fn to_pem(&self) -> String

pub fn from_pem(input: &str) -> Result<Self, KeyMaterialError>

Examples found in repository

examples/interop_cli.rs (line 71)

fn run_verify_key_fixture(args: &[String]) {
    let fixture_path = read_option(args, "--fixture").expect("--fixture is required");
    let content = std::fs::read_to_string(&fixture_path).expect("fixture should be readable");
    let fixture: serde_json::Value =
        serde_json::from_str(&content).expect("fixture should be valid JSON");
    let keys = fixture["keys"]
        .as_object()
        .expect("keys should be an object");
    for (fragment, key_pair) in keys {
        let private_pem = key_pair["private_key_pem"]
            .as_str()
            .expect("private_key_pem should be a string");
        let public_pem = key_pair["public_key_pem"]
            .as_str()
            .expect("public_key_pem should be a string");
        assert!(
            private_pem.starts_with("-----BEGIN PRIVATE KEY-----"),
            "{fragment} private key must be PKCS#8 PEM"
        );
        assert!(
            public_pem.starts_with("-----BEGIN PUBLIC KEY-----"),
            "{fragment} public key must be SPKI PEM"
        );
        assert!(!private_pem.contains("ANP "));
        assert!(!public_pem.contains("ANP "));

        let private_key = PrivateKeyMaterial::from_pem(private_pem)
            .expect("private key should parse as standard PEM");
        let public_key =
            PublicKeyMaterial::from_pem(public_pem).expect("public key should parse as SPKI PEM");
        if !matches!(public_key, PublicKeyMaterial::X25519(_)) {
            let signature = private_key
                .sign_message(b"cross-language standard pem")
                .expect("signature should be created");
            public_key
                .verify_message(b"cross-language standard pem", &signature)
                .expect("signature should verify");
        }
    }
    println!(
        "{}",
        serde_json::to_string(&json!({"verified": true, "key_count": keys.len()}))
            .expect("result should serialize")
    );
}

examples/direct_e2ee_interop_cli.rs (line 41)

fn main() {
    let args = std::env::args().skip(1).collect::<Vec<String>>();
    if args.first().map(String::as_str) != Some("fixture") {
        eprintln!("Usage: cargo run --example direct_e2ee_interop_cli -- fixture");
        std::process::exit(1);
    }

    let alice = create_did_wba_document(
        "a.example",
        DidDocumentOptions::default()
            .with_profile(DidProfile::E1)
            .with_path_segments(["agents", "alice"]),
    )
    .expect("alice did");
    let bob = create_did_wba_document(
        "b.example",
        DidDocumentOptions::default()
            .with_profile(DidProfile::E1)
            .with_path_segments(["agents", "bob"]),
    )
    .expect("bob did");

    let alice_did = alice.did_document["id"].as_str().unwrap().to_string();
    let bob_did = bob.did_document["id"].as_str().unwrap().to_string();

    let alice_static = load_x25519_secret(&alice.keys["key-3"].private_key_pem);
    let bob_static = load_x25519_secret(&bob.keys["key-3"].private_key_pem);
    let bob_spk = X25519StaticSecret::from([55u8; 32]);

    let bob_signing_key =
        PrivateKeyMaterial::from_pem(&bob.keys["key-1"].private_key_pem).expect("bob signing key");
    let bundle = build_prekey_bundle(
        "bundle-001",
        &bob_did,
        &format!("{bob_did}#key-3"),
        signed_prekey_from_private_key("spk-001", &bob_spk, "2026-04-07T00:00:00Z"),
        &bob_signing_key,
        &format!("{bob_did}#key-1"),
        Some("2026-03-31T09:58:58Z"),
    )
    .expect("bundle");

    let init_metadata = metadata(&alice_did, &bob_did, "msg-init");
    let (mut alice_session, _pending, init_body) = DirectE2eeSession::initiate_session(
        &init_metadata,
        "op-init",
        &format!("{alice_did}#key-3"),
        &alice_static,
        &bundle,
        &X25519PublicKey::from(&bob_static).to_bytes(),
        &X25519PublicKey::from(&bob_spk).to_bytes(),
        &ApplicationPlaintext::new_text("text/plain", "hello bob"),
    )
    .expect("initiate");

    let follow_up_metadata = metadata(&alice_did, &bob_did, "msg-2");
    let (_pending, cipher_body) = DirectE2eeSession::encrypt_follow_up(
        &mut alice_session,
        &follow_up_metadata,
        "op-2",
        &ApplicationPlaintext::new_json("application/json", json!({"event": "wave"})),
    )
    .expect("follow up");

    println!(
        "{}",
        serde_json::to_string(&json!({
            "alice_did_document": alice.did_document,
            "bob_did_document": bob.did_document,
            "bundle": serde_json::to_value(&bundle).expect("bundle json"),
            "bob_static_private_key_b64u": encode_secret(&bob_static),
            "bob_signed_prekey_private_key_b64u": encode_secret(&bob_spk),
            "init_metadata": serde_json::to_value(&init_metadata).expect("metadata json"),
            "follow_up_metadata": serde_json::to_value(&follow_up_metadata).expect("metadata json"),
            "init_body": serde_json::to_value(&init_body).expect("init json"),
            "cipher_body": serde_json::to_value(&cipher_body).expect("cipher json"),
            "init_plaintext": json!({"application_content_type": "text/plain", "text": "hello bob"}),
            "follow_up_plaintext": json!({"application_content_type": "application/json", "payload": {"event": "wave"}}),
        }))
        .expect("fixture json")
    );
}

fn metadata(sender: &str, recipient: &str, message_id: &str) -> DirectEnvelopeMetadata {
    DirectEnvelopeMetadata {
        sender_did: sender.to_owned(),
        recipient_did: recipient.to_owned(),
        message_id: message_id.to_owned(),
        profile: "anp.direct.e2ee.v1".to_owned(),
        security_profile: "direct-e2ee".to_owned(),
    }
}

fn load_x25519_secret(pem: &str) -> X25519StaticSecret {
    match PrivateKeyMaterial::from_pem(pem).expect("private key") {
        PrivateKeyMaterial::X25519(secret) => secret,
        _ => panic!("expected X25519 private key"),
    }
}

pub fn from_compatible_private_pem( input: &str, ) -> Result<Self, KeyMaterialError>

Trait Implementations

impl Debug for PrivateKeyMaterial

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.