signstar_crypto/key/import/
mod.rs

1//! Functionality for importing of cryptographic key material.
2
3#[cfg(feature = "nethsm")]
4pub mod nethsm;
5
6use std::fmt::Debug;
7
8use rsa::{
9    RsaPrivateKey,
10    pkcs8::DecodePrivateKey as _,
11    traits::PrivateKeyParts,
12    traits::PublicKeyParts,
13};
14
15#[cfg(doc)]
16use crate::key::MIN_RSA_BIT_LENGTH;
17use crate::key::{Error, KeyType, key_type_matches_length};
18
19/// The data for private key import
20// Allow dead code here, as the variants of `PrivateKeyData` are only used with a backend, which
21// requires enabling a feature.
22pub enum PrivateKeyData {
23    /// Data for [`KeyType::Curve25519`]
24    Curve25519(Vec<u8>),
25    /// Data for [`KeyType::EcBp256`]
26    EcBp256(Vec<u8>),
27    /// Data for [`KeyType::EcBp384`]
28    EcBp384(Vec<u8>),
29    /// Data for [`KeyType::EcK256`]
30    EcK256(Vec<u8>),
31    /// Data for [`KeyType::EcP224`]
32    EcP224(Vec<u8>),
33    /// Data for [`KeyType::EcP256`]
34    EcP256(Vec<u8>),
35    /// Data for [`KeyType::EcP384`]
36    EcP384(Vec<u8>),
37    /// Data for [`KeyType::EcP521`]
38    EcP521(Vec<u8>),
39    /// Data for [`KeyType::Rsa`]
40    Rsa {
41        /// The prime number `p`.
42        prime_p: Vec<u8>,
43        /// The prime number `q`.
44        prime_q: Vec<u8>,
45        /// The public exponent `e`.
46        public_exponent: Vec<u8>,
47    },
48}
49
50impl Debug for PrivateKeyData {
51    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
52        const REDACTED: &&str = &"[REDACTED]";
53        match self {
54            Self::Curve25519(_) => f.debug_tuple("Curve25519").field(REDACTED).finish(),
55            Self::EcBp256(_) => f.debug_tuple("EcBp256").field(REDACTED).finish(),
56            Self::EcBp384(_) => f.debug_tuple("EcBp384").field(REDACTED).finish(),
57            Self::EcK256(_) => f.debug_tuple("EcK256").field(REDACTED).finish(),
58            Self::EcP224(_) => f.debug_tuple("EcP224").field(REDACTED).finish(),
59            Self::EcP256(_) => f.debug_tuple("EcP256").field(REDACTED).finish(),
60            Self::EcP384(_) => f.debug_tuple("EcP384").field(REDACTED).finish(),
61            Self::EcP521(_) => f.debug_tuple("EcP521").field(REDACTED).finish(),
62            Self::Rsa {
63                public_exponent, ..
64            } => f
65                .debug_struct("Rsa")
66                .field("prime_p", REDACTED)
67                .field("prime_q", REDACTED)
68                .field("public_exponent", public_exponent)
69                .finish(),
70        }
71    }
72}
73
74impl From<&PrivateKeyData> for KeyType {
75    fn from(value: &PrivateKeyData) -> Self {
76        match value {
77            PrivateKeyData::Curve25519(_) => Self::Curve25519,
78            PrivateKeyData::EcBp256(_) => Self::EcBp256,
79            PrivateKeyData::EcBp384(_) => Self::EcBp384,
80            PrivateKeyData::EcK256(_) => Self::EcK256,
81            PrivateKeyData::EcP224(_) => Self::EcP224,
82            PrivateKeyData::EcP256(_) => Self::EcP256,
83            PrivateKeyData::EcP384(_) => Self::EcP384,
84            PrivateKeyData::EcP521(_) => Self::EcP521,
85            PrivateKeyData::Rsa { .. } => Self::Rsa,
86        }
87    }
88}
89
90/// The key data required when importing a secret key
91#[derive(Debug)]
92pub struct PrivateKeyImport {
93    key_data: PrivateKeyData,
94}
95
96/// Creates a new vector with bytes in `buf`, left-padded with zeros so
97/// that the result is exactly `len` big.
98///
99/// # Errors
100///
101/// Returns an an error, if the input buffer `buf` is longer than the targeted `len`.
102///
103/// # Examples
104///
105/// ```no_compile
106/// let input = vec![1, 2, 3];
107/// let output = pad(&input, 4)?;
108/// assert_eq!(output, vec![0, 1, 2, 3]);
109/// ```
110fn pad(buf: &[u8], len: usize) -> Result<Vec<u8>, Error> {
111    let buffer_len = buf.len();
112    if len < buf.len() {
113        return Err(Error::PaddingInputTooLong {
114            buffer_len,
115            pad_len: len,
116        });
117    }
118    let mut v = vec![0; len];
119    v[len - buf.len()..].copy_from_slice(buf);
120    Ok(v)
121}
122
123impl PrivateKeyImport {
124    /// Creates a new [`PrivateKeyImport`]
125    ///
126    /// Accepts a [`KeyType`] (all except [`KeyType::Generic`]) and a bytes array representing a
127    /// matching PKCS#8 private key in ASN.1 DER-encoded format.
128    ///
129    /// # Errors
130    ///
131    /// Returns an error if
132    ///
133    /// - `key_data` can not be deserialized to a respective private key format.
134    /// - an RSA private key does not have prime P or prime Q.
135    /// - an RSA private key is shorter than [`MIN_RSA_BIT_LENGTH`].
136    /// - `key_type` is the unsupported [`KeyType::Generic`] or [`KeyType::EcBp512`].
137    ///
138    /// # Examples
139    ///
140    /// ```
141    /// # use testresult::TestResult;
142    /// use ed25519_dalek::{SigningKey, pkcs8::EncodePrivateKey};
143    /// use rand::{SeedableRng, rng, rngs::ChaCha20Rng};
144    /// use signstar_crypto::key::{KeyType, PrivateKeyImport};
145    /// # fn main() -> TestResult {
146    ///
147    /// let key_data = {
148    ///     let signing_key: SigningKey = SigningKey::generate(&mut ChaCha20Rng::from_rng(&mut rng()));
149    ///     signing_key.to_pkcs8_der()?.as_bytes().to_vec()
150    /// };
151    ///
152    /// assert!(PrivateKeyImport::new(KeyType::Curve25519, &key_data).is_ok());
153    /// # Ok(())
154    /// # }
155    /// ```
156    pub fn new(key_type: KeyType, key_data: &[u8]) -> Result<Self, crate::Error> {
157        Ok(match key_type {
158            KeyType::Curve25519 => {
159                let key_pair = ed25519_dalek::pkcs8::KeypairBytes::from_pkcs8_der(key_data)
160                    .map_err(Error::Pkcs8)?;
161                Self {
162                    key_data: PrivateKeyData::Curve25519(key_pair.secret_key.to_vec()),
163                }
164            }
165            KeyType::EcBp256 => {
166                let private_key =
167                    bp256::r1::SecretKey::from_pkcs8_der(key_data).map_err(Error::Pkcs8)?;
168                Self {
169                    key_data: PrivateKeyData::EcBp256(private_key.to_bytes().as_slice().to_owned()),
170                }
171            }
172            KeyType::EcBp384 => {
173                let private_key =
174                    bp384::r1::SecretKey::from_pkcs8_der(key_data).map_err(Error::Pkcs8)?;
175                Self {
176                    key_data: PrivateKeyData::EcBp384(private_key.to_bytes().as_slice().to_owned()),
177                }
178            }
179            KeyType::EcBp512 => return Err(Error::UnsupportedKeyType(key_type).into()),
180            KeyType::EcK256 => {
181                let private_key =
182                    k256::SecretKey::from_pkcs8_der(key_data).map_err(Error::Pkcs8)?;
183                Self {
184                    key_data: PrivateKeyData::EcK256(private_key.to_bytes().as_slice().to_owned()),
185                }
186            }
187            KeyType::EcP224 => {
188                let private_key =
189                    p224::SecretKey::from_pkcs8_der(key_data).map_err(Error::Pkcs8)?;
190                Self {
191                    key_data: PrivateKeyData::EcP224(private_key.to_bytes().as_slice().to_owned()),
192                }
193            }
194            KeyType::EcP256 => {
195                let private_key =
196                    p256::SecretKey::from_pkcs8_der(key_data).map_err(Error::Pkcs8)?;
197                Self {
198                    key_data: PrivateKeyData::EcP256(private_key.to_bytes().as_slice().to_owned()),
199                }
200            }
201            KeyType::EcP384 => {
202                let private_key =
203                    p384::SecretKey::from_pkcs8_der(key_data).map_err(Error::Pkcs8)?;
204                Self {
205                    key_data: PrivateKeyData::EcP384(private_key.to_bytes().as_slice().to_owned()),
206                }
207            }
208            KeyType::EcP521 => {
209                let private_key =
210                    p521::SecretKey::from_pkcs8_der(key_data).map_err(Error::Pkcs8)?;
211                Self {
212                    key_data: PrivateKeyData::EcP521(private_key.to_bytes().as_slice().to_owned()),
213                }
214            }
215            KeyType::Generic => return Err(Error::UnsupportedKeyType(KeyType::Generic).into()),
216            KeyType::Rsa => {
217                let private_key = RsaPrivateKey::from_pkcs8_der(key_data).map_err(Error::Pkcs8)?;
218                // ensure, that we have sufficient bit length
219                key_type_matches_length(key_type, Some(private_key.size() as u32 * 8))?;
220                Self {
221                    key_data: PrivateKeyData::Rsa {
222                        prime_p: private_key
223                            .primes()
224                            .first()
225                            .ok_or(Error::NoPrimes)?
226                            .to_be_bytes()
227                            .to_vec(),
228                        prime_q: private_key
229                            .primes()
230                            .get(1)
231                            .ok_or(Error::NoPrimes)?
232                            .to_be_bytes()
233                            .to_vec(),
234                        public_exponent: private_key.e().to_be_bytes().to_vec(),
235                    },
236                }
237            }
238        })
239    }
240
241    /// Creates a new [`PrivateKeyImport`]
242    ///
243    /// Accepts a [`KeyType`] (all except [`KeyType::Generic`]) and a string slice representing a
244    /// matching PKCS#8 private key in PEM-encoded format.
245    ///
246    /// # Errors
247    ///
248    /// Returns an error if
249    ///
250    /// - `key_data` can not be deserialized to a respective private key format.
251    /// - an RSA private key does not have prime P or prime Q.
252    /// - an RSA private key is shorter than [`MIN_RSA_BIT_LENGTH`].
253    /// - `key_type` is the unsupported [`KeyType::Generic`] or [`KeyType::EcBp512`].
254    ///
255    /// # Examples
256    ///
257    /// ```
258    /// # use testresult::TestResult;
259    /// use std::ops::Deref;
260    ///
261    /// use ed25519_dalek::{SigningKey, pkcs8::EncodePrivateKey, pkcs8::spki::der::pem::LineEnding};
262    /// use rand::{SeedableRng, rng, rngs::ChaCha20Rng};
263    /// use signstar_crypto::key::{KeyType, PrivateKeyImport};
264    /// # fn main() -> TestResult {
265    ///
266    /// let key_data = {
267    ///     let signing_key: SigningKey = SigningKey::generate(&mut ChaCha20Rng::from_rng(&mut rng()));
268    ///     signing_key.to_pkcs8_pem(LineEnding::default())?
269    /// };
270    ///
271    /// assert!(PrivateKeyImport::from_pkcs8_pem(KeyType::Curve25519, key_data.deref()).is_ok());
272    /// # Ok(())
273    /// # }
274    /// ```
275    pub fn from_pkcs8_pem(key_type: KeyType, key_data: &str) -> Result<Self, crate::Error> {
276        Ok(match key_type {
277            KeyType::Curve25519 => {
278                let key_pair = ed25519_dalek::pkcs8::KeypairBytes::from_pkcs8_pem(key_data)
279                    .map_err(Error::Pkcs8)?;
280                Self {
281                    key_data: PrivateKeyData::Curve25519(key_pair.secret_key.to_vec()),
282                }
283            }
284            KeyType::EcBp256 => {
285                let private_key =
286                    bp256::r1::SecretKey::from_pkcs8_pem(key_data).map_err(Error::Pkcs8)?;
287                Self {
288                    key_data: PrivateKeyData::EcBp256(private_key.to_bytes().as_slice().to_owned()),
289                }
290            }
291            KeyType::EcBp384 => {
292                let private_key =
293                    bp384::r1::SecretKey::from_pkcs8_pem(key_data).map_err(Error::Pkcs8)?;
294                Self {
295                    key_data: PrivateKeyData::EcBp384(private_key.to_bytes().as_slice().to_owned()),
296                }
297            }
298            KeyType::EcBp512 => return Err(Error::UnsupportedKeyType(key_type).into()),
299            KeyType::EcK256 => {
300                let private_key =
301                    k256::SecretKey::from_pkcs8_pem(key_data).map_err(Error::Pkcs8)?;
302                Self {
303                    key_data: PrivateKeyData::EcK256(private_key.to_bytes().as_slice().to_owned()),
304                }
305            }
306            KeyType::EcP224 => {
307                let private_key =
308                    p224::SecretKey::from_pkcs8_pem(key_data).map_err(Error::Pkcs8)?;
309                Self {
310                    key_data: PrivateKeyData::EcP224(private_key.to_bytes().as_slice().to_owned()),
311                }
312            }
313            KeyType::EcP256 => {
314                let private_key =
315                    p256::SecretKey::from_pkcs8_pem(key_data).map_err(Error::Pkcs8)?;
316                Self {
317                    key_data: PrivateKeyData::EcP256(private_key.to_bytes().as_slice().to_owned()),
318                }
319            }
320            KeyType::EcP384 => {
321                let private_key =
322                    p384::SecretKey::from_pkcs8_pem(key_data).map_err(Error::Pkcs8)?;
323                Self {
324                    key_data: PrivateKeyData::EcP384(private_key.to_bytes().as_slice().to_owned()),
325                }
326            }
327            KeyType::EcP521 => {
328                let private_key =
329                    p521::SecretKey::from_pkcs8_pem(key_data).map_err(Error::Pkcs8)?;
330                Self {
331                    key_data: PrivateKeyData::EcP521(private_key.to_bytes().as_slice().to_owned()),
332                }
333            }
334            KeyType::Generic => return Err(Error::UnsupportedKeyType(KeyType::Generic).into()),
335            KeyType::Rsa => {
336                let private_key = RsaPrivateKey::from_pkcs8_pem(key_data).map_err(Error::Pkcs8)?;
337                // ensure, that we have sufficient bit length
338                key_type_matches_length(key_type, Some(private_key.size() as u32 * 8))?;
339                Self {
340                    key_data: PrivateKeyData::Rsa {
341                        prime_p: private_key
342                            .primes()
343                            .first()
344                            .ok_or(Error::NoPrimes)?
345                            .to_be_bytes()
346                            .to_vec(),
347                        prime_q: private_key
348                            .primes()
349                            .get(1)
350                            .ok_or(Error::NoPrimes)?
351                            .to_be_bytes()
352                            .to_vec(),
353                        public_exponent: private_key.e().to_be_bytes().to_vec(),
354                    },
355                }
356            }
357        })
358    }
359
360    /// Create [`PrivateKeyImport`] object from raw, private RSA key parts.
361    ///
362    /// The function takes two primes (*p* and *q*) and the public exponent,
363    /// which usually is 65537 (`[0x01, 0x00, 0x01]`).
364    ///
365    /// # Examples
366    ///
367    /// ```rust
368    /// use signstar_crypto::key::PrivateKeyImport;
369    ///
370    /// # fn main() -> testresult::TestResult {
371    /// let prime_p = vec![7];
372    /// let prime_q = vec![11];
373    /// let public_exponent = vec![1, 0, 1];
374    ///
375    /// let _import = PrivateKeyImport::from_rsa(prime_p, prime_q, public_exponent);
376    /// # Ok(()) }
377    /// ```
378    pub fn from_rsa(prime_p: Vec<u8>, prime_q: Vec<u8>, public_exponent: Vec<u8>) -> Self {
379        Self {
380            key_data: PrivateKeyData::Rsa {
381                prime_p,
382                prime_q,
383                public_exponent,
384            },
385        }
386    }
387
388    /// Create [`PrivateKeyImport`] object from raw, private Elliptic Curve bytes.
389    ///
390    /// The function takes two parameters:
391    /// - the type of elliptic curve,
392    /// - raw bytes in a curve-specific encoding
393    ///
394    /// Elliptic curve keys require the `bytes` to be zero-padded to be of correct size.
395    /// This function automatically applies padding accordingly.
396    ///
397    /// # Examples
398    ///
399    /// ```rust
400    /// use signstar_crypto::key::{KeyType, PrivateKeyImport};
401    ///
402    /// # fn main() -> testresult::TestResult {
403    /// let bytes = vec![0x00; 32];
404    ///
405    /// let _import = PrivateKeyImport::from_raw_bytes(KeyType::Curve25519, bytes)?;
406    /// # Ok(()) }
407    /// ```
408    pub fn from_raw_bytes(ec: KeyType, bytes: impl AsRef<[u8]>) -> Result<Self, crate::Error> {
409        let bytes = bytes.as_ref();
410        Ok(Self {
411            key_data: match ec {
412                KeyType::EcP256 => PrivateKeyData::EcP256(pad(bytes, 32)?),
413                KeyType::EcP384 => PrivateKeyData::EcP384(pad(bytes, 48)?),
414                KeyType::EcP521 => PrivateKeyData::EcP521(pad(bytes, 66)?),
415                KeyType::Curve25519 => PrivateKeyData::Curve25519(pad(bytes, 32)?),
416                key_type => return Err(Error::UnsupportedKeyType(key_type).into()),
417            },
418        })
419    }
420
421    /// Get the matching [`KeyType`] for the data contained in the [`PrivateKeyImport`]
422    pub fn key_type(&self) -> KeyType {
423        KeyType::from(&self.key_data)
424    }
425}
426
427#[cfg(test)]
428mod tests {
429    use k256::elliptic_curve::Generate;
430    use rand::{SeedableRng, rng, rngs::ChaCha20Rng};
431    use rsa::RsaPrivateKey;
432    use rsa::pkcs8::EncodePrivateKey;
433    use rstest::rstest;
434    use testresult::TestResult;
435
436    use super::*;
437
438    fn ed25519_private_key() -> TestResult<Vec<u8>> {
439        let signing_key =
440            ed25519_dalek::SigningKey::generate(&mut ChaCha20Rng::from_rng(&mut rng()));
441        Ok(signing_key.to_pkcs8_der()?.as_bytes().to_vec())
442    }
443
444    fn bp256_private_key() -> TestResult<Vec<u8>> {
445        let private_key =
446            bp256::r1::SecretKey::generate_from_rng(&mut ChaCha20Rng::from_rng(&mut rng()));
447        Ok(private_key.to_pkcs8_der()?.as_bytes().to_vec())
448    }
449
450    fn bp384_private_key() -> TestResult<Vec<u8>> {
451        let private_key =
452            bp384::r1::SecretKey::generate_from_rng(&mut ChaCha20Rng::from_rng(&mut rng()));
453        Ok(private_key.to_pkcs8_der()?.as_bytes().to_vec())
454    }
455
456    fn k256_private_key() -> TestResult<Vec<u8>> {
457        let private_key =
458            k256::SecretKey::generate_from_rng(&mut ChaCha20Rng::from_rng(&mut rng()));
459        Ok(private_key.to_pkcs8_der()?.as_bytes().to_vec())
460    }
461
462    fn p224_private_key() -> TestResult<Vec<u8>> {
463        let private_key =
464            p224::SecretKey::generate_from_rng(&mut ChaCha20Rng::from_rng(&mut rng()));
465        Ok(private_key.to_pkcs8_der()?.as_bytes().to_vec())
466    }
467
468    fn p256_private_key() -> TestResult<Vec<u8>> {
469        let private_key =
470            p256::SecretKey::generate_from_rng(&mut ChaCha20Rng::from_rng(&mut rng()));
471        Ok(private_key.to_pkcs8_der()?.as_bytes().to_vec())
472    }
473
474    fn p384_private_key() -> TestResult<Vec<u8>> {
475        let private_key =
476            p384::SecretKey::generate_from_rng(&mut ChaCha20Rng::from_rng(&mut rng()));
477        Ok(private_key.to_pkcs8_der()?.as_bytes().to_vec())
478    }
479
480    fn p521_private_key() -> TestResult<Vec<u8>> {
481        let private_key =
482            p521::SecretKey::generate_from_rng(&mut ChaCha20Rng::from_rng(&mut rng()));
483        Ok(private_key.to_pkcs8_der()?.as_bytes().to_vec())
484    }
485
486    fn rsa_private_key() -> TestResult<Vec<u8>> {
487        let private_key =
488            RsaPrivateKey::new(&mut ChaCha20Rng::from_rng(&mut rng()), 2048.try_into()?)?;
489        Ok(private_key.to_pkcs8_der()?.as_bytes().to_vec())
490    }
491
492    #[rstest]
493    #[case::curve25519(KeyType::Curve25519)]
494    #[case::ecbp256(KeyType::EcBp256)]
495    #[case::ecbp384(KeyType::EcBp384)]
496    #[case::eck256(KeyType::EcK256)]
497    #[case::ecp224(KeyType::EcP224)]
498    #[case::ecp256(KeyType::EcP256)]
499    #[case::ecp384(KeyType::EcP384)]
500    #[case::ecp521(KeyType::EcP521)]
501    #[case::rsa(KeyType::Rsa)]
502    fn key_data(#[case] key_type: KeyType) -> TestResult {
503        let bp256_private_key = bp256_private_key()?;
504        let bp384_private_key = bp384_private_key()?;
505        let ed25519_private_key = ed25519_private_key()?;
506        let k256_private_key = k256_private_key()?;
507        let p224_private_key = p224_private_key()?;
508        let p256_private_key = p256_private_key()?;
509        let p384_private_key = p384_private_key()?;
510        let p521_private_key = p521_private_key()?;
511        let rsa_private_key = rsa_private_key()?;
512
513        let (ok_cases, error_cases) = match key_type {
514            KeyType::Curve25519 => (
515                [&ed25519_private_key],
516                [
517                    &bp256_private_key,
518                    &bp384_private_key,
519                    &k256_private_key,
520                    &p224_private_key,
521                    &p256_private_key,
522                    &p384_private_key,
523                    &p521_private_key,
524                    &rsa_private_key,
525                ],
526            ),
527            KeyType::EcBp256 => (
528                [&bp256_private_key],
529                [
530                    &bp384_private_key,
531                    &ed25519_private_key,
532                    &k256_private_key,
533                    &p224_private_key,
534                    &p256_private_key,
535                    &p384_private_key,
536                    &p521_private_key,
537                    &rsa_private_key,
538                ],
539            ),
540            KeyType::EcBp384 => (
541                [&bp384_private_key],
542                [
543                    &bp256_private_key,
544                    &ed25519_private_key,
545                    &k256_private_key,
546                    &p224_private_key,
547                    &p256_private_key,
548                    &p384_private_key,
549                    &p521_private_key,
550                    &rsa_private_key,
551                ],
552            ),
553            KeyType::EcK256 => (
554                [&k256_private_key],
555                [
556                    &bp256_private_key,
557                    &bp384_private_key,
558                    &ed25519_private_key,
559                    &p224_private_key,
560                    &p256_private_key,
561                    &p384_private_key,
562                    &p521_private_key,
563                    &rsa_private_key,
564                ],
565            ),
566            KeyType::EcP224 => (
567                [&p224_private_key],
568                [
569                    &bp256_private_key,
570                    &bp384_private_key,
571                    &ed25519_private_key,
572                    &k256_private_key,
573                    &p256_private_key,
574                    &p384_private_key,
575                    &p521_private_key,
576                    &rsa_private_key,
577                ],
578            ),
579            KeyType::EcP256 => (
580                [&p256_private_key],
581                [
582                    &bp256_private_key,
583                    &bp384_private_key,
584                    &ed25519_private_key,
585                    &k256_private_key,
586                    &p224_private_key,
587                    &p384_private_key,
588                    &p521_private_key,
589                    &rsa_private_key,
590                ],
591            ),
592            KeyType::EcP384 => (
593                [&p384_private_key],
594                [
595                    &bp256_private_key,
596                    &bp384_private_key,
597                    &ed25519_private_key,
598                    &k256_private_key,
599                    &p224_private_key,
600                    &p256_private_key,
601                    &p521_private_key,
602                    &rsa_private_key,
603                ],
604            ),
605            KeyType::EcP521 => (
606                [&p521_private_key],
607                [
608                    &bp256_private_key,
609                    &bp384_private_key,
610                    &ed25519_private_key,
611                    &k256_private_key,
612                    &p224_private_key,
613                    &p256_private_key,
614                    &p384_private_key,
615                    &rsa_private_key,
616                ],
617            ),
618            KeyType::Rsa => (
619                [&rsa_private_key],
620                [
621                    &bp256_private_key,
622                    &bp384_private_key,
623                    &ed25519_private_key,
624                    &k256_private_key,
625                    &p224_private_key,
626                    &p256_private_key,
627                    &p384_private_key,
628                    &p521_private_key,
629                ],
630            ),
631            KeyType::Generic => unimplemented!("generic key types are not supported"),
632            KeyType::EcBp512 => unimplemented!("there is currently no rustcrypto support"),
633        };
634
635        for ok_case in ok_cases.iter() {
636            assert!(PrivateKeyImport::new(key_type, ok_case).is_ok());
637        }
638
639        for error_case in error_cases.iter() {
640            assert!(PrivateKeyImport::new(key_type, error_case).is_err());
641        }
642
643        Ok(())
644    }
645
646    #[rstest]
647    #[case::curve_25519(PrivateKeyImport::new(KeyType::Curve25519, ed25519_private_key()?.as_slice())?, KeyType::Curve25519)]
648    #[case::ecbp256(PrivateKeyImport::new(KeyType::EcBp256, bp256_private_key()?.as_slice())?, KeyType::EcBp256)]
649    #[case::ecbp384(PrivateKeyImport::new(KeyType::EcBp384, bp384_private_key()?.as_slice())?, KeyType::EcBp384)]
650    #[case::eck256(PrivateKeyImport::new(KeyType::EcK256, k256_private_key()?.as_slice())?, KeyType::EcK256)]
651    #[case::ecp224(PrivateKeyImport::new(KeyType::EcP224, p224_private_key()?.as_slice())?, KeyType::EcP224)]
652    #[case::ecp256(PrivateKeyImport::new(KeyType::EcP256, p256_private_key()?.as_slice())?, KeyType::EcP256)]
653    #[case::ecp384(PrivateKeyImport::new(KeyType::EcP384, p384_private_key()?.as_slice())?, KeyType::EcP384)]
654    #[case::ecp521(PrivateKeyImport::new(KeyType::EcP521, p521_private_key()?.as_slice())?, KeyType::EcP521)]
655    #[case::rsa(PrivateKeyImport::new(KeyType::Rsa, rsa_private_key()?.as_slice())?, KeyType::Rsa)]
656    fn private_key_import_key_data_matches(
657        #[case] private_key_data: PrivateKeyImport,
658        #[case] key_type: KeyType,
659    ) -> TestResult {
660        assert_eq!(private_key_data.key_type(), key_type);
661
662        Ok(())
663    }
664}
signstar_crypto/key/import/mod.rs

signstar_crypto/key/import/
mod.rs
