Struct PublicKey 

pub struct PublicKey { /* private fields */ }

Wraps a public SecKeyRef.

Implementations

impl PublicKey

pub fn type_id() -> usize

Wraps the corresponding public SecKeyRef operation.

pub fn attributes(&self) -> Result<Value>

Wraps the corresponding public SecKeyRef operation.

pub fn block_size(&self) -> usize

Wraps the corresponding public SecKeyRef operation.

Examples found in repository

examples/15_key_encrypt_export.rs (line 35)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let private_key = PrivateKey::from_data(
        &std::fs::read("tests/fixtures/test-key-rsa.pkcs1.der")?,
        KeyType::Rsa,
        2048,
    )?;
    let public_key = private_key.public_key()?;

    let ciphertext = public_key.encrypt(
        EncryptionAlgorithm::RsaEncryptionOaepSha256,
        b"security-rs example",
    )?;
    let plaintext =
        private_key.decrypt(EncryptionAlgorithm::RsaEncryptionOaepSha256, &ciphertext)?;
    assert_eq!(plaintext, b"security-rs example");

    let signature = private_key.sign(
        SignatureAlgorithm::RsaSignatureMessagePkcs1v15Sha256,
        b"security-rs example",
    )?;
    let certificate = Certificate::from_pem(&std::fs::read("tests/fixtures/test-cert.pem")?)?;
    assert!(certificate.public_key()?.verify_signature(
        SignatureAlgorithm::RsaSignatureMessagePkcs1v15Sha256,
        b"security-rs example",
        &signature,
    )?);

    println!(
        "key_type_id={} block_size={} exported_private={} exported_public={}",
        PrivateKey::type_id(),
        public_key.block_size(),
        private_key.external_representation()?.len(),
        public_key.external_representation()?.len(),
    );

    Ok(())
}

pub fn external_representation(&self) -> Result<Vec<u8>>

Wraps the corresponding public SecKeyRef operation.

Examples found in repository

examples/15_key_encrypt_export.rs (line 37)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let private_key = PrivateKey::from_data(
        &std::fs::read("tests/fixtures/test-key-rsa.pkcs1.der")?,
        KeyType::Rsa,
        2048,
    )?;
    let public_key = private_key.public_key()?;

    let ciphertext = public_key.encrypt(
        EncryptionAlgorithm::RsaEncryptionOaepSha256,
        b"security-rs example",
    )?;
    let plaintext =
        private_key.decrypt(EncryptionAlgorithm::RsaEncryptionOaepSha256, &ciphertext)?;
    assert_eq!(plaintext, b"security-rs example");

    let signature = private_key.sign(
        SignatureAlgorithm::RsaSignatureMessagePkcs1v15Sha256,
        b"security-rs example",
    )?;
    let certificate = Certificate::from_pem(&std::fs::read("tests/fixtures/test-cert.pem")?)?;
    assert!(certificate.public_key()?.verify_signature(
        SignatureAlgorithm::RsaSignatureMessagePkcs1v15Sha256,
        b"security-rs example",
        &signature,
    )?);

    println!(
        "key_type_id={} block_size={} exported_private={} exported_public={}",
        PrivateKey::type_id(),
        public_key.block_size(),
        private_key.external_representation()?.len(),
        public_key.external_representation()?.len(),
    );

    Ok(())
}

pub fn encrypt( &self, algorithm: EncryptionAlgorithm, plaintext: &[u8], ) -> Result<Vec<u8>>

Wraps the corresponding public SecKeyRef operation.

Examples found in repository

examples/15_key_encrypt_export.rs (lines 13-16)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let private_key = PrivateKey::from_data(
        &std::fs::read("tests/fixtures/test-key-rsa.pkcs1.der")?,
        KeyType::Rsa,
        2048,
    )?;
    let public_key = private_key.public_key()?;

    let ciphertext = public_key.encrypt(
        EncryptionAlgorithm::RsaEncryptionOaepSha256,
        b"security-rs example",
    )?;
    let plaintext =
        private_key.decrypt(EncryptionAlgorithm::RsaEncryptionOaepSha256, &ciphertext)?;
    assert_eq!(plaintext, b"security-rs example");

    let signature = private_key.sign(
        SignatureAlgorithm::RsaSignatureMessagePkcs1v15Sha256,
        b"security-rs example",
    )?;
    let certificate = Certificate::from_pem(&std::fs::read("tests/fixtures/test-cert.pem")?)?;
    assert!(certificate.public_key()?.verify_signature(
        SignatureAlgorithm::RsaSignatureMessagePkcs1v15Sha256,
        b"security-rs example",
        &signature,
    )?);

    println!(
        "key_type_id={} block_size={} exported_private={} exported_public={}",
        PrivateKey::type_id(),
        public_key.block_size(),
        private_key.external_representation()?.len(),
        public_key.external_representation()?.len(),
    );

    Ok(())
}

pub fn verify_signature( &self, algorithm: SignatureAlgorithm, signed_data: &[u8], signature: &[u8], ) -> Result<bool>

Wraps the corresponding public SecKeyRef operation.

Examples found in repository

examples/14_key_import_sign_verify.rs (lines 17-21)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let raw_key = PrivateKey::from_data(
        &support::fixture("test-key-rsa.pkcs1.der"),
        KeyType::Rsa,
        2048,
    )?;
    let signature = raw_key.sign(
        SignatureAlgorithm::RsaSignatureMessagePkcs1v15Sha256,
        b"security-rs",
    )?;
    let certificate = Certificate::from_pem(&support::fixture("test-cert.pem"))?;
    let verified = certificate.public_key()?.verify_signature(
        SignatureAlgorithm::RsaSignatureMessagePkcs1v15Sha256,
        b"security-rs",
        &signature,
    )?;
    println!("signature_len={} verified={verified}", signature.len());
    Ok(())
}

examples/15_key_encrypt_export.rs (lines 26-30)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let private_key = PrivateKey::from_data(
        &std::fs::read("tests/fixtures/test-key-rsa.pkcs1.der")?,
        KeyType::Rsa,
        2048,
    )?;
    let public_key = private_key.public_key()?;

    let ciphertext = public_key.encrypt(
        EncryptionAlgorithm::RsaEncryptionOaepSha256,
        b"security-rs example",
    )?;
    let plaintext =
        private_key.decrypt(EncryptionAlgorithm::RsaEncryptionOaepSha256, &ciphertext)?;
    assert_eq!(plaintext, b"security-rs example");

    let signature = private_key.sign(
        SignatureAlgorithm::RsaSignatureMessagePkcs1v15Sha256,
        b"security-rs example",
    )?;
    let certificate = Certificate::from_pem(&std::fs::read("tests/fixtures/test-cert.pem")?)?;
    assert!(certificate.public_key()?.verify_signature(
        SignatureAlgorithm::RsaSignatureMessagePkcs1v15Sha256,
        b"security-rs example",
        &signature,
    )?);

    println!(
        "key_type_id={} block_size={} exported_private={} exported_public={}",
        PrivateKey::type_id(),
        public_key.block_size(),
        private_key.external_representation()?.len(),
        public_key.external_representation()?.len(),
    );

    Ok(())
}

Trait Implementations

impl Debug for PublicKey

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

Formats the value using the given formatter.