Struct openssl::crypto::pkey::PKey [−] [src]

pub struct PKey {
    // some fields omitted
}

Methods

`impl PKey`

Represents a public key, optionally with a private key attached.

`fn new() -> PKey`

`fn from_handle(handle: *mut EVP_PKEY, parts: Parts) -> PKey`

`fn private_key_from_pem<R>(reader: &mut R) -> Result<PKey, SslError> where R: Read`

Reads private key from PEM, takes ownership of handle

`fn public_key_from_pem<R>(reader: &mut R) -> Result<PKey, SslError> where R: Read`

Reads public key from PEM, takes ownership of handle

`fn gen(&mut self, keysz: usize)`

`fn save_pub(&self) -> Vec<u8>`

Returns a DER serialized form of the public key, suitable for load_pub().

`fn load_pub(&mut self, s: &[u8])`

Loads a DER serialized form of the public key, as produced by save_pub().

`fn save_priv(&self) -> Vec<u8>`

Returns a serialized form of the public and private keys, suitable for load_priv().

`fn load_priv(&mut self, s: &[u8])`

Loads a serialized form of the public and private keys, as produced by save_priv().

`fn write_pem<W: Write>(&self, writer: &mut W) -> Result<(), SslError>`

Stores private key as a PEM

`fn write_pub_pem<W: Write>(&self, writer: &mut W) -> Result<(), SslError>`

Stores public key as a PEM

`fn size(&self) -> usize`

Returns the size of the public key modulus.

`fn can(&self, r: Role) -> bool`

Returns whether this pkey object can perform the specified role.

`fn max_data(&self) -> usize`

Returns the maximum amount of data that can be encrypted by an encrypt() call.

`fn encrypt_with_padding(&self, s: &[u8], padding: EncryptionPadding) -> Vec<u8>`

`fn decrypt_with_padding(&self, s: &[u8], padding: EncryptionPadding) -> Vec<u8>`

`fn encrypt(&self, s: &[u8]) -> Vec<u8>`

Encrypts data using OAEP padding, returning the encrypted data. The supplied data must not be larger than max_data().

`fn decrypt(&self, s: &[u8]) -> Vec<u8>`

Decrypts data, expecting OAEP padding, returning the decrypted data.

`fn sign(&self, s: &[u8]) -> Vec<u8>`

Signs data, using OpenSSL's default scheme and adding sha256 ASN.1 information to the signature. The bytes to sign must be the result of a sha256 hashing; returns the signature.

`fn verify(&self, h: &[u8], s: &[u8]) -> bool`

Verifies a signature s (using OpenSSL's default scheme and sha256) on the SHA256 hash of a message. Returns true if the signature is valid, and false otherwise.

`fn sign_with_hash(&self, s: &[u8], hash: Type) -> Vec<u8>`

Signs data, using OpenSSL's default scheme and add ASN.1 information for the given hash type to the signature. The bytes to sign must be the result of this type of hashing; returns the signature.