Struct PrivateKey 

pub struct PrivateKey { /* private fields */ }

SSH private key.

Implementations

impl PrivateKey

pub fn new(key_data: KeypairData, comment: impl Into<String>) -> Result<Self>

Available on crate feature alloc only.

Create a new unencrypted private key with the given keypair data and comment.

On no_std platforms, use PrivateKey::from(key_data) instead.

pub fn from_openssh(pem: impl AsRef<[u8]>) -> Result<Self>

Parse an OpenSSH-formatted PEM private key.

OpenSSH-formatted private keys begin with the following:

-----BEGIN OPENSSH PRIVATE KEY-----

pub fn from_bytes(bytes: &[u8]) -> Result<Self>

Parse a raw binary SSH private key.

pub fn encode_openssh<'o>( &self, line_ending: LineEnding, out: &'o mut [u8], ) -> Result<&'o str>

Encode OpenSSH-formatted (PEM) private key.

pub fn to_openssh(&self, line_ending: LineEnding) -> Result<Zeroizing<String>>

Available on crate feature alloc only.

Encode an OpenSSH-formatted PEM private key, allocating a self-zeroizing String for the result.

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

Available on crate feature alloc only.

Serialize SSH private key as raw bytes.

pub fn sign( &self, namespace: &str, hash_alg: HashAlg, msg: &[u8], ) -> Result<SshSig>

Available on crate feature alloc only.

Sign the given message using this private key, returning an SshSig.

These signatures can be produced using ssh-keygen -Y sign. They’re encoded as PEM and begin with the following:

-----BEGIN SSH SIGNATURE-----

See PROTOCOL.sshsig for more information.

Usage

See also: PublicKey::verify.

use ssh_key::{PrivateKey, HashAlg, SshSig};

// Message to be signed.
let message = b"testing";

// Example domain/namespace used for the message.
let namespace = "example";

// Private key to use when computing the signature.
// WARNING: don't actually hardcode private keys in source code!!!
let encoded_private_key = r#"
-----BEGIN OPENSSH PRIVATE KEY-----
b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW
QyNTUxOQAAACCzPq7zfqLffKoBDe/eo04kH2XxtSmk9D7RQyf1xUqrYgAAAJgAIAxdACAM
XQAAAAtzc2gtZWQyNTUxOQAAACCzPq7zfqLffKoBDe/eo04kH2XxtSmk9D7RQyf1xUqrYg
AAAEC2BsIi0QwW2uFscKTUUXNHLsYX4FxlaSDSblbAj7WR7bM+rvN+ot98qgEN796jTiQf
ZfG1KaT0PtFDJ/XFSqtiAAAAEHVzZXJAZXhhbXBsZS5jb20BAgMEBQ==
-----END OPENSSH PRIVATE KEY-----
"#;

let private_key = encoded_private_key.parse::<PrivateKey>()?;
let signature = private_key.sign(namespace, HashAlg::default(), message)?;
// assert!(private_key.public_key().verify(namespace, message, &signature).is_ok());

pub fn read_openssh_file(path: &Path) -> Result<Self>

Available on crate feature std only.

Read private key from an OpenSSH-formatted PEM file.

pub fn write_openssh_file( &self, path: &Path, line_ending: LineEnding, ) -> Result<()>

Available on crate feature std only.

Write private key as an OpenSSH-formatted PEM file.

pub fn algorithm(&self) -> Algorithm

Get the digital signature Algorithm used by this key.

pub fn comment(&self) -> &str

Comment on the key (e.g. email address).

pub fn cipher(&self) -> Cipher

Cipher algorithm (a.k.a. ciphername).

pub fn fingerprint(&self, hash_alg: HashAlg) -> Fingerprint

Compute key fingerprint.

Use Default::default() to use the default hash function (SHA-256).

pub fn is_encrypted(&self) -> bool

Is this key encrypted?

pub fn kdf(&self) -> &Kdf

Key Derivation Function (KDF) used to encrypt this key.

Returns Kdf::None if this key is not encrypted.

pub fn key_data(&self) -> &KeypairData

Keypair data.

pub fn public_key(&self) -> &PublicKey

Get the PublicKey which corresponds to this private key.

pub fn random( rng: &mut impl CryptoRngCore, algorithm: Algorithm, ) -> Result<Self>

Available on crate feature rand_core only.

Generate a random key which uses the given algorithm.

Returns

• Error::AlgorithmUnknown if the algorithm is unsupported.

pub fn set_comment(&mut self, comment: impl Into<String>)

Available on crate feature alloc only.

Set the comment on the key.

Trait Implementations

impl Clone for PrivateKey

fn clone(&self) -> PrivateKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ConstantTimeEq for PrivateKey

fn ct_eq(&self, other: &Self) -> Choice

Determine if two items are equal.

fn ct_ne(&self, other: &Self) -> Choice

Determine if two items are NOT equal.

impl Debug for PrivateKey

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

Formats the value using the given formatter.

impl Decode for PrivateKey

type Error = Error

Type returned in the event of a decoding error.

fn decode(reader: &mut impl Reader) -> Result<Self>

Attempt to decode a value of this type using the provided Reader.

impl Encode for PrivateKey

fn encoded_len(&self) -> Result<usize>

Get the length of this type encoded in bytes, prior to Base64 encoding.

fn encode(&self, writer: &mut impl Writer) -> Result<()>

Encode this value using the provided Writer.

fn encoded_len_prefixed(&self) -> Result<usize, Error>

Return the length of this type after encoding when prepended with a uint32 length prefix.

fn encode_prefixed(&self, writer: &mut impl Writer) -> Result<(), Error>

Encode this value, first prepending a uint32 length prefix set to Encode::encoded_len.

impl From<&PrivateKey> for KeyData

fn from(private_key: &PrivateKey) -> KeyData

Converts to this type from the input type.

impl From<&PrivateKey> for PublicKey

fn from(private_key: &PrivateKey) -> PublicKey

Converts to this type from the input type.

impl From<DsaKeypair> for PrivateKey

Available on crate feature alloc only.

fn from(keypair: DsaKeypair) -> PrivateKey

Converts to this type from the input type.

impl From<EcdsaKeypair> for PrivateKey

Available on crate feature ecdsa only.

fn from(keypair: EcdsaKeypair) -> PrivateKey

Converts to this type from the input type.

impl From<Ed25519Keypair> for PrivateKey

fn from(keypair: Ed25519Keypair) -> PrivateKey

Converts to this type from the input type.

impl From<PrivateKey> for KeyData

fn from(private_key: PrivateKey) -> KeyData

Converts to this type from the input type.

impl From<PrivateKey> for PublicKey

fn from(private_key: PrivateKey) -> PublicKey

Converts to this type from the input type.

impl From<RsaKeypair> for PrivateKey

Available on crate feature alloc only.

fn from(keypair: RsaKeypair) -> PrivateKey

Converts to this type from the input type.

impl From<SkEcdsaSha2NistP256> for PrivateKey

Available on crate features alloc and ecdsa only.

fn from(keypair: SkEcdsaSha2NistP256) -> PrivateKey

Converts to this type from the input type.

impl From<SkEd25519> for PrivateKey

Available on crate feature alloc only.

fn from(keypair: SkEd25519) -> PrivateKey

Converts to this type from the input type.

impl FromStr for PrivateKey

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self>

Parses a string s to return a value of this type.

impl PartialEq for PrivateKey

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PemLabel for PrivateKey

const PEM_LABEL: &'static str = "OPENSSH PRIVATE KEY"

Expected PEM type label for a given document, e.g. "PRIVATE KEY"

fn validate_pem_label(actual: &str) -> Result<(), Error>

Validate that a given label matches the expected label.

impl Signer<Signature> for PrivateKey

Available on crate feature alloc only.

fn try_sign(&self, message: &[u8]) -> Result<Signature>

Attempt to sign the given message, returning a digital signature on success, or an error if something went wrong.

fn sign(&self, msg: &[u8]) -> S

Sign the given message and return a digital signature

impl TryFrom<KeypairData> for PrivateKey

type Error = Error

The type returned in the event of a conversion error.

fn try_from(key_data: KeypairData) -> Result<PrivateKey>

Performs the conversion.

impl Eq for PrivateKey

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 424 bytes