Enum PublicKeyMaterial 

pub enum PublicKeyMaterial {
    Secp256k1(VerifyingKey),
    Secp256r1(VerifyingKey),
    Ed25519(VerifyingKey),
    X25519([u8; 32]),
}

Variants

Secp256k1(VerifyingKey)

Secp256r1(VerifyingKey)

Ed25519(VerifyingKey)

X25519([u8; 32])

Implementations

impl PublicKeyMaterial

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

Examples found in repository

examples/interop_cli.rs (line 80)

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 74)

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

Trait Implementations

impl Clone for PublicKeyMaterial

fn clone(&self) -> PublicKeyMaterial

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PublicKeyMaterial

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

Formats the value using the given formatter.

impl Display for PublicKeyMaterial

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

Formats the value using the given formatter.