Struct kanidm_proto::internal::SshPublicKey

pub struct SshPublicKey {
    pub key_type: KeyType,
    pub kind: PublicKeyKind,
    pub comment: Option<String>,
}

A type which represents an OpenSSH public key.

Fields

key_type: KeyType

Key type.

kind: PublicKeyKind

The kind of public key.

comment: Option<String>

Associated comment, if any.

Implementations

impl PublicKey

pub fn from_path<P>(path: P) -> Result<PublicKey, Error>

where P: AsRef<Path>,

Reads an OpenSSH public key from a given path.

Examples

let key = sshkeys::PublicKey::from_path("/path/to/id_ed25519.pub")?;

pub fn from_string(contents: &str) -> Result<PublicKey, Error>

Reads an OpenSSH public key from a given string.

Examples

let key = sshkeys::PublicKey::from_string("ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIHkbe7gwx7s0dlApEEzpUyOAPrzPLy4czEZw/sh8m8rd me@home").unwrap();
let fp = key.fingerprint();
assert_eq!(fp.hash, "ciQkdxjFUhk2E2vRkWJD9kB8pi+EneOkaCJJHNWzPC4");

pub fn from_bytes<T>(data: &T) -> Result<PublicKey, Error>

where T: AsRef<[u8]> + ?Sized,

Reads a public key from a given byte sequence.

The byte sequence is expected to be the base64 decoded body of the public key.

Example

let data = vec![0, 0, 0, 11, 115, 115, 104, 45,
                101, 100, 50, 53, 53, 49, 57,
                0, 0, 0, 32, 121, 27, 123, 184,
                48, 199, 187, 52, 118, 80, 41, 16,
                76, 233, 83, 35, 128, 62, 188,
                207, 47, 46, 28, 204, 70, 112,
                254, 200, 124, 155, 202, 221];

let key = sshkeys::PublicKey::from_bytes(&data).unwrap();
let fp = key.fingerprint();
assert_eq!(fp.hash, "ciQkdxjFUhk2E2vRkWJD9kB8pi+EneOkaCJJHNWzPC4");

pub fn bits(&self) -> usize

Returns the number of bits of the public key.

Example

let key = sshkeys::PublicKey::from_string("ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIHkbe7gwx7s0dlApEEzpUyOAPrzPLy4czEZw/sh8m8rd me@home").unwrap();
assert_eq!(key.bits(), 256);

pub fn encode(&self) -> Vec<u8>

Encodes the public key in an OpenSSH compatible format.

Example

let key = sshkeys::PublicKey::from_string("ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIHkbe7gwx7s0dlApEEzpUyOAPrzPLy4czEZw/sh8m8rd me@home").unwrap();
assert_eq!(key.encode(), vec![0, 0, 0, 11, 115, 115, 104, 45, 101, 100, 50, 53, 53, 49, 57, 0, 0, 0, 32, 121, 27, 123, 184, 48, 199, 187, 52, 118, 80, 41, 16, 76, 233, 83, 35, 128, 62, 188, 207, 47, 46, 28, 204, 70, 112, 254, 200, 124, 155, 202, 221]);

pub fn fingerprint(&self) -> Fingerprint

Computes the fingerprint of the public key using the default OpenSSH fingerprint representation with SHA256.

Example

let key = sshkeys::PublicKey::from_path("/path/to/id_ed25519.pub")?;
let fp = key.fingerprint();
println!("{}", fp.hash);

pub fn fingerprint_with(&self, kind: FingerprintKind) -> Fingerprint

Computes the fingerprint of the public key using a given fingerprint representation.

Example

let key = sshkeys::PublicKey::from_path("/path/to/id_ed25519.pub").unwrap();
let sha512fp = key.fingerprint_with(sshkeys::FingerprintKind::Sha512);
println!("{}", sha512fp.hash);

pub fn write<W>(&self, w: &mut W) -> Result<(), Error>

where W: Write,

Writes the public key to a given writer.

Example

use std::fs::File;
let key = sshkeys::PublicKey::from_string("ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAA...")?;
let mut file = File::create("/path/to/id_ed25519.pub")?;
key.write(&mut file).unwrap();

Trait Implementations

impl Clone for PublicKey

fn clone(&self) -> PublicKey

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PublicKey

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for PublicKey

fn deserialize<D>( deserializer: D, ) -> Result<PublicKey, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for PublicKey

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

Formats the value using the given formatter.

impl PartialEq for PublicKey

fn eq(&self, other: &PublicKey) -> 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 Serialize for PublicKey

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for PublicKey