ssh_key/private/
sk.rs

1//! Security Key (FIDO/U2F) private keys as described in [PROTOCOL.u2f].
2//!
3//! [PROTOCOL.u2f]: https://cvsweb.openbsd.org/src/usr.bin/ssh/PROTOCOL.u2f?annotate=HEAD
4
5use crate::{
6    checked::CheckedSum, decode::Decode, encode::Encode, public, reader::Reader, writer::Writer,
7    Result,
8};
9use alloc::vec::Vec;
10
11/// Security Key (FIDO/U2F) ECDSA/NIST P-256 private key as specified in
12/// [PROTOCOL.u2f](https://cvsweb.openbsd.org/src/usr.bin/ssh/PROTOCOL.u2f?annotate=HEAD).
13#[cfg(all(feature = "alloc", feature = "ecdsa"))]
14#[cfg_attr(docsrs, doc(cfg(all(feature = "alloc", feature = "ecdsa"))))]
15#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
16pub struct SkEcdsaSha2NistP256 {
17    /// Public key.
18    public: public::SkEcdsaSha2NistP256,
19
20    /// Flags.
21    flags: u8,
22
23    /// FIDO/U2F key handle.
24    key_handle: Vec<u8>,
25
26    /// Reserved data.
27    reserved: Vec<u8>,
28}
29
30#[cfg(feature = "ecdsa")]
31impl SkEcdsaSha2NistP256 {
32    /// Get the ECDSA/NIST P-256 public key.
33    pub fn public(&self) -> &public::SkEcdsaSha2NistP256 {
34        &self.public
35    }
36
37    /// Get flags.
38    pub fn flags(&self) -> u8 {
39        self.flags
40    }
41
42    /// Get FIDO/U2F key handle.
43    pub fn key_handle(&self) -> &[u8] {
44        &self.key_handle
45    }
46}
47
48#[cfg(feature = "ecdsa")]
49impl Decode for SkEcdsaSha2NistP256 {
50    fn decode(reader: &mut impl Reader) -> Result<Self> {
51        Ok(Self {
52            public: public::SkEcdsaSha2NistP256::decode(reader)?,
53            flags: u8::decode(reader)?,
54            key_handle: Vec::decode(reader)?,
55            reserved: Vec::decode(reader)?,
56        })
57    }
58}
59
60#[cfg(feature = "ecdsa")]
61impl Encode for SkEcdsaSha2NistP256 {
62    fn encoded_len(&self) -> Result<usize> {
63        [
64            self.public.encoded_len()?,
65            self.flags.encoded_len()?,
66            self.key_handle.encoded_len()?,
67            self.reserved.encoded_len()?,
68        ]
69        .checked_sum()
70    }
71
72    fn encode(&self, writer: &mut impl Writer) -> Result<()> {
73        self.public.encode(writer)?;
74        self.flags.encode(writer)?;
75        self.key_handle.encode(writer)?;
76        self.reserved.encode(writer)
77    }
78}
79
80/// Security Key (FIDO/U2F) Ed25519 private key as specified in
81/// [PROTOCOL.u2f](https://cvsweb.openbsd.org/src/usr.bin/ssh/PROTOCOL.u2f?annotate=HEAD).
82#[cfg(feature = "alloc")]
83#[cfg_attr(docsrs, doc(cfg(feature = "alloc")))]
84#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Ord)]
85pub struct SkEd25519 {
86    /// Public key.
87    public: public::SkEd25519,
88
89    /// Flags.
90    flags: u8,
91
92    /// FIDO/U2F key handle.
93    key_handle: Vec<u8>,
94
95    /// Reserved data.
96    reserved: Vec<u8>,
97}
98
99impl SkEd25519 {
100    /// Get the Ed25519 public key.
101    pub fn public(&self) -> &public::SkEd25519 {
102        &self.public
103    }
104
105    /// Get flags.
106    pub fn flags(&self) -> u8 {
107        self.flags
108    }
109
110    /// Get FIDO/U2F key handle.
111    pub fn key_handle(&self) -> &[u8] {
112        &self.key_handle
113    }
114}
115
116impl Decode for SkEd25519 {
117    fn decode(reader: &mut impl Reader) -> Result<Self> {
118        Ok(Self {
119            public: public::SkEd25519::decode(reader)?,
120            flags: u8::decode(reader)?,
121            key_handle: Vec::decode(reader)?,
122            reserved: Vec::decode(reader)?,
123        })
124    }
125}
126
127impl Encode for SkEd25519 {
128    fn encoded_len(&self) -> Result<usize> {
129        [
130            self.public.encoded_len()?,
131            self.flags.encoded_len()?,
132            self.key_handle.encoded_len()?,
133            self.reserved.encoded_len()?,
134        ]
135        .checked_sum()
136    }
137
138    fn encode(&self, writer: &mut impl Writer) -> Result<()> {
139        self.public.encode(writer)?;
140        self.flags.encode(writer)?;
141        self.key_handle.encode(writer)?;
142        self.reserved.encode(writer)
143    }
144}