Struct osshkeys::keys::KeyPair

pub struct KeyPair { /* fields omitted */ }

General key pair type

This is a type to make it easy to store different types of key pair in the container. Each can contain one of the types supported in this crate.

Key pair is the so-called "private key" which contains both public and private parts of an asymmetry key.

Methods

impl KeyPair

pub fn from_keystr(pem: &str, passphrase: Option<&[u8]>) -> OsshResult<Self>

Parse a keypair from supporting file types

The passphrase is required if the keypair is encrypted.

OpenSSL PEM

• Begin with -----BEGIN DSA PRIVATE KEY----- for dsa key.
• Begin with -----BEGIN RSA PRIVATE KEY----- for rsa key.
• Begin with -----BEGIN EC PRIVATE KEY----- for ecdsa key.
• This file type doesn't support Ed25519

PKCS#8 Format

• Begin with -----BEGIN PRIVATE KEY-----

Openssh

• Begin with -----BEGIN OPENSSH PRIVATE KEY-----

This is the new format which is supported since OpenSSH 6.5, and it became the default format in OpenSSH 7.8. The Ed25519 key can only be stored in this type.

pub fn generate(keytype: KeyType, bits: usize) -> OsshResult<Self>

Generate a key of the specified type and size

Key Size

There are some limitations to the key size:

• RSA: the size should >= 1024 and <= 16384 bits.
• DSA: the size should be 1024 bits.
• EcDSA: the size should be 256, 384, or 521 bits.
• Ed25519: the size should be 256 bits.

If the key size parameter is zero, then it will use the default size to generate the key

• RSA: 2048 bits
• DSA: 1024 bits
• EcDSA: 256 bits
• Ed25519: 256 bits

pub fn keytype(&self) -> KeyType

Indicate the key type being stored

pub fn serialize_pem(&self, passphrase: Option<&[u8]>) -> OsshResult<String>

Serialize the keypair to the OpenSSL PEM format

If the passphrase is given (set to Some(...)), then the generated PEM key will be encrypted.

pub fn serialize_pkcs8(&self, passphrase: Option<&[u8]>) -> OsshResult<String>

Serialize the keypair to the OpenSSL PKCS#8 PEM format

If the passphrase is given (set to Some(...)), then the generated PKCS#8 key will be encrypted.

pub fn serialize_openssh(
    &self,
    passphrase: Option<&[u8]>,
    cipher: Cipher
) -> OsshResult<String>

Serialize the keypair to the OpenSSH private key format

If the passphrase is given (set to Some(...)) and cipher is not null, then the generated private key will be encrypted.

pub fn comment(&self) -> &str

Get the comment of the key

pub fn comment_mut(&mut self) -> &mut String

Get the mutable comment of the key

pub fn serialize_publickey(&self) -> OsshResult<String>

Get the string presentation of the public parts

pub fn clone_public_key(&self) -> Result<PublicKey, Error>

Clone the public parts of the key pair

Trait Implementations

impl From<DsaKeyPair> for KeyPair

fn from(inner: DsaKeyPair) -> KeyPair

Performs the conversion.

impl From<EcDsaKeyPair> for KeyPair

fn from(inner: EcDsaKeyPair) -> KeyPair

Performs the conversion.

impl From<Ed25519KeyPair> for KeyPair

fn from(inner: Ed25519KeyPair) -> KeyPair

Performs the conversion.

impl From<RsaKeyPair> for KeyPair

fn from(inner: RsaKeyPair) -> KeyPair

Performs the conversion.

impl Key for KeyPair

fn size(&self) -> usize

The size in bits of the key

fn keyname(&self) -> &'static str

The key name of the key

impl PrivateParts for KeyPair

fn sign(&self, data: &[u8]) -> Result<Vec<u8>, Error>

Sign the data with the key, returning the "detached" signature

impl PublicParts for KeyPair

fn verify(&self, data: &[u8], sig: &[u8]) -> Result<bool, Error>

Verify the data with a detached signature, returning true if the signature is not malformed

fn blob(&self) -> Result<Vec<u8>, Error>

Return the binary representation of the public key

fn fingerprint(&self, hash: FingerprintHash) -> OsshResult<Vec<u8>>

Hash the blob of the public key to generate the fingerprint