rustls/crypto/aws_lc_rs/
sign.rs

1#![allow(clippy::duplicate_mod)]
2
3use alloc::boxed::Box;
4use alloc::string::ToString;
5use alloc::vec::Vec;
6use alloc::{format, vec};
7use core::fmt::{self, Debug, Formatter};
8
9use pki_types::{PrivateKeyDer, PrivatePkcs8KeyDer, SubjectPublicKeyInfoDer, alg_id};
10
11use super::ring_like::rand::SystemRandom;
12use super::ring_like::signature::{self, EcdsaKeyPair, Ed25519KeyPair, KeyPair, RsaKeyPair};
13#[cfg(any(test, bench))]
14use crate::crypto::CryptoProvider;
15use crate::crypto::signer::{Signer, SigningKey, public_key_to_spki};
16use crate::enums::{SignatureAlgorithm, SignatureScheme};
17use crate::error::Error;
18use crate::sync::Arc;
19
20/// A `SigningKey` for RSA-PKCS1 or RSA-PSS.
21pub(super) struct RsaSigningKey {
22    key: Arc<RsaKeyPair>,
23}
24
25impl RsaSigningKey {
26    fn to_signer(&self, scheme: SignatureScheme) -> RsaSigner {
27        let encoding: &dyn signature::RsaEncoding = match scheme {
28            SignatureScheme::RSA_PKCS1_SHA256 => &signature::RSA_PKCS1_SHA256,
29            SignatureScheme::RSA_PKCS1_SHA384 => &signature::RSA_PKCS1_SHA384,
30            SignatureScheme::RSA_PKCS1_SHA512 => &signature::RSA_PKCS1_SHA512,
31            SignatureScheme::RSA_PSS_SHA256 => &signature::RSA_PSS_SHA256,
32            SignatureScheme::RSA_PSS_SHA384 => &signature::RSA_PSS_SHA384,
33            SignatureScheme::RSA_PSS_SHA512 => &signature::RSA_PSS_SHA512,
34            _ => unreachable!(),
35        };
36
37        RsaSigner {
38            key: self.key.clone(),
39            scheme,
40            encoding,
41        }
42    }
43
44    const SCHEMES: &[SignatureScheme] = &[
45        SignatureScheme::RSA_PSS_SHA512,
46        SignatureScheme::RSA_PSS_SHA384,
47        SignatureScheme::RSA_PSS_SHA256,
48        SignatureScheme::RSA_PKCS1_SHA512,
49        SignatureScheme::RSA_PKCS1_SHA384,
50        SignatureScheme::RSA_PKCS1_SHA256,
51    ];
52}
53
54impl SigningKey for RsaSigningKey {
55    fn choose_scheme(&self, offered: &[SignatureScheme]) -> Option<Box<dyn Signer>> {
56        Self::SCHEMES
57            .iter()
58            .find(|scheme| offered.contains(scheme))
59            .map(|&scheme| Box::new(self.to_signer(scheme)) as Box<dyn Signer>)
60    }
61
62    fn public_key(&self) -> Option<SubjectPublicKeyInfoDer<'_>> {
63        Some(public_key_to_spki(
64            &alg_id::RSA_ENCRYPTION,
65            self.key.public_key(),
66        ))
67    }
68
69    fn algorithm(&self) -> SignatureAlgorithm {
70        SignatureAlgorithm::RSA
71    }
72}
73
74impl TryFrom<&PrivateKeyDer<'_>> for RsaSigningKey {
75    type Error = Error;
76
77    /// Make a new `RsaSigningKey` from a DER encoding, in either
78    /// PKCS#1 or PKCS#8 format.
79    fn try_from(der: &PrivateKeyDer<'_>) -> Result<Self, Self::Error> {
80        let key_pair = match der {
81            PrivateKeyDer::Pkcs1(pkcs1) => RsaKeyPair::from_der(pkcs1.secret_pkcs1_der()),
82            PrivateKeyDer::Pkcs8(pkcs8) => RsaKeyPair::from_pkcs8(pkcs8.secret_pkcs8_der()),
83            _ => {
84                return Err(Error::General(
85                    "failed to parse RSA private key as either PKCS#1 or PKCS#8".into(),
86                ));
87            }
88        }
89        .map_err(|key_rejected| {
90            Error::General(format!("failed to parse RSA private key: {key_rejected}"))
91        })?;
92
93        Ok(Self {
94            key: Arc::new(key_pair),
95        })
96    }
97}
98
99impl Debug for RsaSigningKey {
100    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
101        f.debug_struct("RsaSigningKey")
102            .field("algorithm", &self.algorithm())
103            .finish()
104    }
105}
106
107struct RsaSigner {
108    key: Arc<RsaKeyPair>,
109    scheme: SignatureScheme,
110    encoding: &'static dyn signature::RsaEncoding,
111}
112
113impl RsaSigner {
114    fn sign(&self, message: &[u8]) -> Result<Vec<u8>, Error> {
115        let mut sig = vec![0; self.key.public_modulus_len()];
116
117        let rng = SystemRandom::new();
118        self.key
119            .sign(self.encoding, &rng, message, &mut sig)
120            .map(|_| sig)
121            .map_err(|_| Error::General("signing failed".to_string()))
122    }
123}
124
125impl Signer for RsaSigner {
126    fn sign(self: Box<Self>, message: &[u8]) -> Result<Vec<u8>, Error> {
127        (*self).sign(message)
128    }
129
130    fn scheme(&self) -> SignatureScheme {
131        self.scheme
132    }
133}
134
135impl Debug for RsaSigner {
136    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
137        f.debug_struct("RsaSigner")
138            .field("scheme", &self.scheme)
139            .finish()
140    }
141}
142
143/// A [`SigningKey`] and [`Signer`] implementation for ECDSA.
144///
145/// Unlike [`RsaSigningKey`]/[`RsaSigner`], where we have one key that supports
146/// multiple signature schemes, we can use the same type for both traits here.
147#[derive(Clone)]
148pub(super) struct EcdsaSigner {
149    key: Arc<EcdsaKeyPair>,
150    scheme: SignatureScheme,
151}
152
153impl EcdsaSigner {
154    /// Make a new [`EcdsaSigner`] from a DER encoding in PKCS#8 or SEC1
155    /// format, expecting a key usable with precisely the given signature scheme.
156    fn new(
157        der: &PrivateKeyDer<'_>,
158        scheme: SignatureScheme,
159        sigalg: &'static signature::EcdsaSigningAlgorithm,
160    ) -> Result<Self, ()> {
161        let key_pair = match der {
162            PrivateKeyDer::Sec1(sec1) => {
163                EcdsaKeyPair::from_private_key_der(sigalg, sec1.secret_sec1_der())
164                    .map_err(|_| ())?
165            }
166            PrivateKeyDer::Pkcs8(pkcs8) => {
167                EcdsaKeyPair::from_pkcs8(sigalg, pkcs8.secret_pkcs8_der()).map_err(|_| ())?
168            }
169            _ => return Err(()),
170        };
171
172        Ok(Self {
173            key: Arc::new(key_pair),
174            scheme,
175        })
176    }
177
178    fn sign(&self, message: &[u8]) -> Result<Vec<u8>, Error> {
179        let rng = SystemRandom::new();
180        self.key
181            .sign(&rng, message)
182            .map_err(|_| Error::General("signing failed".into()))
183            .map(|sig| sig.as_ref().into())
184    }
185}
186
187impl SigningKey for EcdsaSigner {
188    fn choose_scheme(&self, offered: &[SignatureScheme]) -> Option<Box<dyn Signer>> {
189        if offered.contains(&self.scheme) {
190            Some(Box::new(self.clone()))
191        } else {
192            None
193        }
194    }
195
196    fn public_key(&self) -> Option<SubjectPublicKeyInfoDer<'_>> {
197        let id = match self.scheme {
198            SignatureScheme::ECDSA_NISTP256_SHA256 => alg_id::ECDSA_P256,
199            SignatureScheme::ECDSA_NISTP384_SHA384 => alg_id::ECDSA_P384,
200            SignatureScheme::ECDSA_NISTP521_SHA512 => alg_id::ECDSA_P521,
201            _ => unreachable!(),
202        };
203
204        Some(public_key_to_spki(&id, self.key.public_key()))
205    }
206
207    fn algorithm(&self) -> SignatureAlgorithm {
208        self.scheme.algorithm()
209    }
210}
211
212impl Signer for EcdsaSigner {
213    fn sign(self: Box<Self>, message: &[u8]) -> Result<Vec<u8>, Error> {
214        (*self).sign(message)
215    }
216
217    fn scheme(&self) -> SignatureScheme {
218        self.scheme
219    }
220}
221
222impl TryFrom<&PrivateKeyDer<'_>> for EcdsaSigner {
223    type Error = Error;
224
225    /// Parse `der` as any ECDSA key type, returning the first which works.
226    ///
227    /// Both SEC1 (PEM section starting with 'BEGIN EC PRIVATE KEY') and PKCS8
228    /// (PEM section starting with 'BEGIN PRIVATE KEY') encodings are supported.
229    fn try_from(der: &PrivateKeyDer<'_>) -> Result<Self, Error> {
230        if let Ok(ecdsa_p256) = Self::new(
231            der,
232            SignatureScheme::ECDSA_NISTP256_SHA256,
233            &signature::ECDSA_P256_SHA256_ASN1_SIGNING,
234        ) {
235            return Ok(ecdsa_p256);
236        }
237
238        if let Ok(ecdsa_p384) = Self::new(
239            der,
240            SignatureScheme::ECDSA_NISTP384_SHA384,
241            &signature::ECDSA_P384_SHA384_ASN1_SIGNING,
242        ) {
243            return Ok(ecdsa_p384);
244        }
245
246        if let Ok(ecdsa_p521) = Self::new(
247            der,
248            SignatureScheme::ECDSA_NISTP521_SHA512,
249            &signature::ECDSA_P521_SHA512_ASN1_SIGNING,
250        ) {
251            return Ok(ecdsa_p521);
252        }
253
254        Err(Error::General(
255            "failed to parse ECDSA private key as PKCS#8 or SEC1".into(),
256        ))
257    }
258}
259
260impl Debug for EcdsaSigner {
261    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
262        f.debug_struct("EcdsaSigner")
263            .field("scheme", &self.scheme)
264            .finish()
265    }
266}
267
268/// A [`SigningKey`] and [`Signer`] implementation for ED25519.
269///
270/// Unlike [`RsaSigningKey`]/[`RsaSigner`], where we have one key that supports
271/// multiple signature schemes, we can use the same type for both traits here.
272#[derive(Clone)]
273pub(super) struct Ed25519Signer {
274    key: Arc<Ed25519KeyPair>,
275    scheme: SignatureScheme,
276}
277
278impl Ed25519Signer {
279    fn sign(&self, message: &[u8]) -> Result<Vec<u8>, Error> {
280        Ok(self.key.sign(message).as_ref().into())
281    }
282}
283
284impl SigningKey for Ed25519Signer {
285    fn choose_scheme(&self, offered: &[SignatureScheme]) -> Option<Box<dyn Signer>> {
286        if offered.contains(&self.scheme) {
287            Some(Box::new(self.clone()))
288        } else {
289            None
290        }
291    }
292
293    fn public_key(&self) -> Option<SubjectPublicKeyInfoDer<'_>> {
294        Some(public_key_to_spki(&alg_id::ED25519, self.key.public_key()))
295    }
296
297    fn algorithm(&self) -> SignatureAlgorithm {
298        self.scheme.algorithm()
299    }
300}
301
302impl Signer for Ed25519Signer {
303    fn sign(self: Box<Self>, message: &[u8]) -> Result<Vec<u8>, Error> {
304        (*self).sign(message)
305    }
306
307    fn scheme(&self) -> SignatureScheme {
308        self.scheme
309    }
310}
311
312impl TryFrom<&PrivatePkcs8KeyDer<'_>> for Ed25519Signer {
313    type Error = Error;
314
315    /// Parse `der` as an Ed25519 key.
316    ///
317    /// Note that, at the time of writing, Ed25519 does not have wide support
318    /// in browsers.  It is also not supported by the WebPKI, because the
319    /// CA/Browser Forum Baseline Requirements do not support it for publicly
320    /// trusted certificates.
321    fn try_from(der: &PrivatePkcs8KeyDer<'_>) -> Result<Self, Error> {
322        match Ed25519KeyPair::from_pkcs8_maybe_unchecked(der.secret_pkcs8_der()) {
323            Ok(key_pair) => Ok(Self {
324                key: Arc::new(key_pair),
325                scheme: SignatureScheme::ED25519,
326            }),
327            Err(e) => Err(Error::General(format!(
328                "failed to parse Ed25519 private key: {e}"
329            ))),
330        }
331    }
332}
333
334impl Debug for Ed25519Signer {
335    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
336        f.debug_struct("Ed25519Signer")
337            .field("scheme", &self.scheme)
338            .finish()
339    }
340}
341
342#[cfg(any(test, bench))]
343fn load_key(
344    provider: &CryptoProvider,
345    der: PrivateKeyDer<'static>,
346) -> Result<Box<dyn SigningKey>, Error> {
347    provider
348        .key_provider
349        .load_private_key(der)
350}
351
352#[cfg(test)]
353mod tests {
354    use alloc::format;
355
356    use pki_types::{PrivatePkcs1KeyDer, PrivateSec1KeyDer};
357
358    use super::*;
359    use crate::crypto::aws_lc_rs::DEFAULT_PROVIDER;
360
361    #[test]
362    fn can_load_ecdsa_nistp256_pkcs8() {
363        let key =
364            PrivatePkcs8KeyDer::from(&include_bytes!("../../testdata/nistp256key.pkcs8.der")[..]);
365        assert!(Ed25519Signer::try_from(&key).is_err());
366        let key = PrivateKeyDer::Pkcs8(key);
367        assert!(load_key(&DEFAULT_PROVIDER, key.clone_key()).is_ok());
368        assert!(EcdsaSigner::try_from(&key).is_ok());
369    }
370
371    #[test]
372    fn can_load_ecdsa_nistp256_sec1() {
373        let key = PrivateKeyDer::Sec1(PrivateSec1KeyDer::from(
374            &include_bytes!("../../testdata/nistp256key.der")[..],
375        ));
376        assert!(load_key(&DEFAULT_PROVIDER, key.clone_key()).is_ok());
377        assert!(EcdsaSigner::try_from(&key).is_ok());
378    }
379
380    #[test]
381    fn can_sign_ecdsa_nistp256() {
382        let key = PrivateKeyDer::Sec1(PrivateSec1KeyDer::from(
383            &include_bytes!("../../testdata/nistp256key.der")[..],
384        ));
385
386        let k = load_key(&DEFAULT_PROVIDER, key.clone_key()).unwrap();
387        assert_eq!(
388            format!("{k:?}"),
389            "EcdsaSigner { scheme: ECDSA_NISTP256_SHA256 }"
390        );
391        assert_eq!(k.algorithm(), SignatureAlgorithm::ECDSA);
392
393        assert!(
394            k.choose_scheme(&[SignatureScheme::RSA_PKCS1_SHA256])
395                .is_none()
396        );
397        assert!(
398            k.choose_scheme(&[SignatureScheme::ECDSA_NISTP384_SHA384])
399                .is_none()
400        );
401        let s = k
402            .choose_scheme(&[SignatureScheme::ECDSA_NISTP256_SHA256])
403            .unwrap();
404        assert_eq!(
405            format!("{s:?}"),
406            "EcdsaSigner { scheme: ECDSA_NISTP256_SHA256 }"
407        );
408        assert_eq!(s.scheme(), SignatureScheme::ECDSA_NISTP256_SHA256);
409        // nb. signature is variable length and asn.1-encoded
410        assert!(
411            s.sign(b"hello")
412                .unwrap()
413                .starts_with(&[0x30])
414        );
415    }
416
417    #[test]
418    fn can_load_ecdsa_nistp384_pkcs8() {
419        let key =
420            PrivatePkcs8KeyDer::from(&include_bytes!("../../testdata/nistp384key.pkcs8.der")[..]);
421        assert!(Ed25519Signer::try_from(&key).is_err());
422        let key = PrivateKeyDer::Pkcs8(key);
423        assert!(load_key(&DEFAULT_PROVIDER, key.clone_key()).is_ok());
424        assert!(EcdsaSigner::try_from(&key).is_ok());
425    }
426
427    #[test]
428    fn can_load_ecdsa_nistp384_sec1() {
429        let key = PrivateKeyDer::Sec1(PrivateSec1KeyDer::from(
430            &include_bytes!("../../testdata/nistp384key.der")[..],
431        ));
432        assert!(load_key(&DEFAULT_PROVIDER, key.clone_key()).is_ok());
433        assert!(EcdsaSigner::try_from(&key).is_ok());
434    }
435
436    #[test]
437    fn can_sign_ecdsa_nistp384() {
438        let key = PrivateKeyDer::Sec1(PrivateSec1KeyDer::from(
439            &include_bytes!("../../testdata/nistp384key.der")[..],
440        ));
441
442        let k = load_key(&DEFAULT_PROVIDER, key.clone_key()).unwrap();
443        assert_eq!(
444            format!("{k:?}"),
445            "EcdsaSigner { scheme: ECDSA_NISTP384_SHA384 }"
446        );
447        assert_eq!(k.algorithm(), SignatureAlgorithm::ECDSA);
448
449        assert!(
450            k.choose_scheme(&[SignatureScheme::RSA_PKCS1_SHA256])
451                .is_none()
452        );
453        assert!(
454            k.choose_scheme(&[SignatureScheme::ECDSA_NISTP256_SHA256])
455                .is_none()
456        );
457        let s = k
458            .choose_scheme(&[SignatureScheme::ECDSA_NISTP384_SHA384])
459            .unwrap();
460        assert_eq!(
461            format!("{s:?}"),
462            "EcdsaSigner { scheme: ECDSA_NISTP384_SHA384 }"
463        );
464        assert_eq!(s.scheme(), SignatureScheme::ECDSA_NISTP384_SHA384);
465        // nb. signature is variable length and asn.1-encoded
466        assert!(
467            s.sign(b"hello")
468                .unwrap()
469                .starts_with(&[0x30])
470        );
471    }
472
473    #[test]
474    fn can_load_ecdsa_nistp521_pkcs8() {
475        let key =
476            PrivatePkcs8KeyDer::from(&include_bytes!("../../testdata/nistp521key.pkcs8.der")[..]);
477        assert!(Ed25519Signer::try_from(&key).is_err());
478        let key = PrivateKeyDer::Pkcs8(key);
479        assert!(load_key(&DEFAULT_PROVIDER, key.clone_key()).is_ok());
480        assert!(EcdsaSigner::try_from(&key).is_ok());
481    }
482
483    #[test]
484    fn can_load_ecdsa_nistp521_sec1() {
485        let key = PrivateKeyDer::Sec1(PrivateSec1KeyDer::from(
486            &include_bytes!("../../testdata/nistp521key.der")[..],
487        ));
488        assert!(load_key(&DEFAULT_PROVIDER, key.clone_key()).is_ok());
489        assert!(EcdsaSigner::try_from(&key).is_ok());
490    }
491
492    #[test]
493    fn can_sign_ecdsa_nistp521() {
494        let key = PrivateKeyDer::Sec1(PrivateSec1KeyDer::from(
495            &include_bytes!("../../testdata/nistp521key.der")[..],
496        ));
497
498        let k = load_key(&DEFAULT_PROVIDER, key.clone_key()).unwrap();
499        assert_eq!(
500            format!("{k:?}"),
501            "EcdsaSigner { scheme: ECDSA_NISTP521_SHA512 }"
502        );
503        assert_eq!(k.algorithm(), SignatureAlgorithm::ECDSA);
504
505        assert!(
506            k.choose_scheme(&[SignatureScheme::RSA_PKCS1_SHA256])
507                .is_none()
508        );
509        assert!(
510            k.choose_scheme(&[SignatureScheme::ECDSA_NISTP256_SHA256])
511                .is_none()
512        );
513        assert!(
514            k.choose_scheme(&[SignatureScheme::ECDSA_NISTP384_SHA384])
515                .is_none()
516        );
517        let s = k
518            .choose_scheme(&[SignatureScheme::ECDSA_NISTP521_SHA512])
519            .unwrap();
520        assert_eq!(
521            format!("{s:?}"),
522            "EcdsaSigner { scheme: ECDSA_NISTP521_SHA512 }"
523        );
524        assert_eq!(s.scheme(), SignatureScheme::ECDSA_NISTP521_SHA512);
525        // nb. signature is variable length and asn.1-encoded
526        assert!(
527            s.sign(b"hello")
528                .unwrap()
529                .starts_with(&[0x30])
530        );
531    }
532
533    #[test]
534    fn can_load_eddsa_pkcs8() {
535        let key = PrivatePkcs8KeyDer::from(&include_bytes!("../../testdata/eddsakey.der")[..]);
536        assert!(Ed25519Signer::try_from(&key).is_ok());
537        let key = PrivateKeyDer::Pkcs8(key);
538        assert!(load_key(&DEFAULT_PROVIDER, key.clone_key()).is_ok());
539        assert!(EcdsaSigner::try_from(&key).is_err());
540    }
541
542    #[test]
543    fn can_sign_eddsa() {
544        let key = PrivatePkcs8KeyDer::from(&include_bytes!("../../testdata/eddsakey.der")[..]);
545
546        let k = Ed25519Signer::try_from(&key).unwrap();
547        assert_eq!(format!("{k:?}"), "Ed25519Signer { scheme: ED25519 }");
548        assert_eq!(k.algorithm(), SignatureAlgorithm::ED25519);
549
550        assert!(
551            k.choose_scheme(&[SignatureScheme::RSA_PKCS1_SHA256])
552                .is_none()
553        );
554        assert!(
555            k.choose_scheme(&[SignatureScheme::ECDSA_NISTP256_SHA256])
556                .is_none()
557        );
558        let s = k
559            .choose_scheme(&[SignatureScheme::ED25519])
560            .unwrap();
561        assert_eq!(format!("{s:?}"), "Ed25519Signer { scheme: ED25519 }");
562        assert_eq!(s.scheme(), SignatureScheme::ED25519);
563        assert_eq!(s.sign(b"hello").unwrap().len(), 64);
564    }
565
566    #[test]
567    fn can_load_rsa2048_pkcs8() {
568        let key =
569            PrivatePkcs8KeyDer::from(&include_bytes!("../../testdata/rsa2048key.pkcs8.der")[..]);
570        assert!(Ed25519Signer::try_from(&key).is_err());
571        let key = PrivateKeyDer::Pkcs8(key);
572        assert!(load_key(&DEFAULT_PROVIDER, key.clone_key()).is_ok());
573        assert!(EcdsaSigner::try_from(&key).is_err());
574    }
575
576    #[test]
577    fn can_load_rsa2048_pkcs1() {
578        let key = PrivateKeyDer::Pkcs1(PrivatePkcs1KeyDer::from(
579            &include_bytes!("../../testdata/rsa2048key.pkcs1.der")[..],
580        ));
581        assert!(load_key(&DEFAULT_PROVIDER, key.clone_key()).is_ok());
582        assert!(EcdsaSigner::try_from(&key).is_err());
583    }
584
585    #[test]
586    fn can_sign_rsa2048() {
587        let key = PrivateKeyDer::Pkcs8(PrivatePkcs8KeyDer::from(
588            &include_bytes!("../../testdata/rsa2048key.pkcs8.der")[..],
589        ));
590
591        let k = load_key(&DEFAULT_PROVIDER, key.clone_key()).unwrap();
592        assert_eq!(format!("{k:?}"), "RsaSigningKey { algorithm: RSA }");
593        assert_eq!(k.algorithm(), SignatureAlgorithm::RSA);
594
595        assert!(
596            k.choose_scheme(&[SignatureScheme::ECDSA_NISTP256_SHA256])
597                .is_none()
598        );
599        assert!(
600            k.choose_scheme(&[SignatureScheme::ED25519])
601                .is_none()
602        );
603
604        let s = k
605            .choose_scheme(&[SignatureScheme::RSA_PSS_SHA256])
606            .unwrap();
607        assert_eq!(format!("{s:?}"), "RsaSigner { scheme: RSA_PSS_SHA256 }");
608        assert_eq!(s.scheme(), SignatureScheme::RSA_PSS_SHA256);
609        assert_eq!(s.sign(b"hello").unwrap().len(), 256);
610
611        for scheme in &[
612            SignatureScheme::RSA_PKCS1_SHA256,
613            SignatureScheme::RSA_PKCS1_SHA384,
614            SignatureScheme::RSA_PKCS1_SHA512,
615            SignatureScheme::RSA_PSS_SHA256,
616            SignatureScheme::RSA_PSS_SHA384,
617            SignatureScheme::RSA_PSS_SHA512,
618        ] {
619            k.choose_scheme(&[*scheme]).unwrap();
620        }
621    }
622
623    #[test]
624    fn cannot_load_invalid_pkcs8_encoding() {
625        let key = PrivateKeyDer::Pkcs8(PrivatePkcs8KeyDer::from(&b"invalid"[..]));
626        assert_eq!(
627            load_key(&DEFAULT_PROVIDER, key.clone_key()).err(),
628            Some(Error::General(
629                "failed to parse private key as RSA, ECDSA, or EdDSA".into()
630            ))
631        );
632        assert_eq!(
633            EcdsaSigner::try_from(&key).err(),
634            Some(Error::General(
635                "failed to parse ECDSA private key as PKCS#8 or SEC1".into()
636            ))
637        );
638        assert_eq!(
639            RsaSigningKey::try_from(&key).err(),
640            Some(Error::General(
641                "failed to parse RSA private key: InvalidEncoding".into()
642            ))
643        );
644    }
645}
646
647#[cfg(bench)]
648mod benchmarks {
649    use super::*;
650    use crate::crypto::aws_lc_rs::DEFAULT_PROVIDER;
651
652    #[bench]
653    fn bench_rsa2048_pkcs1_sha256(b: &mut test::Bencher) {
654        let key = PrivateKeyDer::Pkcs8(PrivatePkcs8KeyDer::from(
655            &include_bytes!("../../testdata/rsa2048key.pkcs8.der")[..],
656        ));
657
658        let signer = RsaSigningKey::try_from(&key)
659            .unwrap()
660            .to_signer(SignatureScheme::RSA_PKCS1_SHA256);
661
662        b.iter(|| {
663            test::black_box(
664                signer
665                    .sign(SAMPLE_TLS13_MESSAGE)
666                    .unwrap(),
667            );
668        });
669    }
670
671    #[bench]
672    fn bench_rsa2048_pss_sha256(b: &mut test::Bencher) {
673        let key = PrivateKeyDer::Pkcs8(PrivatePkcs8KeyDer::from(
674            &include_bytes!("../../testdata/rsa2048key.pkcs8.der")[..],
675        ));
676
677        let signer = RsaSigningKey::try_from(&key)
678            .unwrap()
679            .to_signer(SignatureScheme::RSA_PSS_SHA256);
680
681        b.iter(|| {
682            test::black_box(
683                signer
684                    .sign(SAMPLE_TLS13_MESSAGE)
685                    .unwrap(),
686            );
687        });
688    }
689
690    #[bench]
691    fn bench_eddsa(b: &mut test::Bencher) {
692        let key = PrivatePkcs8KeyDer::from(&include_bytes!("../../testdata/eddsakey.der")[..]);
693        let signer = Ed25519Signer::try_from(&key).unwrap();
694
695        b.iter(|| {
696            test::black_box(
697                signer
698                    .sign(SAMPLE_TLS13_MESSAGE)
699                    .unwrap(),
700            );
701        });
702    }
703
704    #[bench]
705    fn bench_ecdsa_p256_sha256(b: &mut test::Bencher) {
706        let key = PrivateKeyDer::Pkcs8(PrivatePkcs8KeyDer::from(
707            &include_bytes!("../../testdata/nistp256key.pkcs8.der")[..],
708        ));
709
710        let signer = EcdsaSigner::try_from(&key).unwrap();
711        b.iter(|| {
712            test::black_box(
713                signer
714                    .sign(SAMPLE_TLS13_MESSAGE)
715                    .unwrap(),
716            );
717        });
718    }
719
720    #[bench]
721    fn bench_ecdsa_p384_sha384(b: &mut test::Bencher) {
722        let key = PrivateKeyDer::Pkcs8(PrivatePkcs8KeyDer::from(
723            &include_bytes!("../../testdata/nistp384key.pkcs8.der")[..],
724        ));
725
726        let signer = EcdsaSigner::try_from(&key).unwrap();
727        b.iter(|| {
728            test::black_box(
729                signer
730                    .sign(SAMPLE_TLS13_MESSAGE)
731                    .unwrap(),
732            );
733        });
734    }
735
736    #[bench]
737    fn bench_ecdsa_p521_sha512(b: &mut test::Bencher) {
738        let key = PrivateKeyDer::Pkcs8(PrivatePkcs8KeyDer::from(
739            &include_bytes!("../../testdata/nistp521key.pkcs8.der")[..],
740        ));
741
742        let signer = EcdsaSigner::try_from(&key).unwrap();
743        b.iter(|| {
744            test::black_box(
745                signer
746                    .sign(SAMPLE_TLS13_MESSAGE)
747                    .unwrap(),
748            );
749        });
750    }
751
752    #[bench]
753    fn bench_load_and_validate_rsa2048(b: &mut test::Bencher) {
754        let key = PrivateKeyDer::Pkcs8(PrivatePkcs8KeyDer::from(
755            &include_bytes!("../../testdata/rsa2048key.pkcs8.der")[..],
756        ));
757
758        b.iter(|| {
759            test::black_box(load_key(&DEFAULT_PROVIDER, key.clone_key()).unwrap());
760        });
761    }
762
763    #[bench]
764    fn bench_load_and_validate_rsa4096(b: &mut test::Bencher) {
765        let key = PrivateKeyDer::Pkcs8(PrivatePkcs8KeyDer::from(
766            &include_bytes!("../../testdata/rsa4096key.pkcs8.der")[..],
767        ));
768
769        b.iter(|| {
770            test::black_box(load_key(&DEFAULT_PROVIDER, key.clone_key()).unwrap());
771        });
772    }
773
774    #[bench]
775    fn bench_load_and_validate_p256(b: &mut test::Bencher) {
776        let key = PrivateKeyDer::Pkcs8(PrivatePkcs8KeyDer::from(
777            &include_bytes!("../../testdata/nistp256key.pkcs8.der")[..],
778        ));
779
780        b.iter(|| {
781            test::black_box(EcdsaSigner::try_from(&key).unwrap());
782        });
783    }
784
785    #[bench]
786    fn bench_load_and_validate_p384(b: &mut test::Bencher) {
787        let key = PrivateKeyDer::Pkcs8(PrivatePkcs8KeyDer::from(
788            &include_bytes!("../../testdata/nistp384key.pkcs8.der")[..],
789        ));
790
791        b.iter(|| {
792            test::black_box(EcdsaSigner::try_from(&key).unwrap());
793        });
794    }
795
796    #[bench]
797    fn bench_load_and_validate_p521(b: &mut test::Bencher) {
798        let key = PrivateKeyDer::Pkcs8(PrivatePkcs8KeyDer::from(
799            &include_bytes!("../../testdata/nistp521key.pkcs8.der")[..],
800        ));
801
802        b.iter(|| {
803            test::black_box(EcdsaSigner::try_from(&key).unwrap());
804        });
805    }
806
807    #[bench]
808    fn bench_load_and_validate_eddsa(b: &mut test::Bencher) {
809        let key = PrivatePkcs8KeyDer::from(&include_bytes!("../../testdata/eddsakey.der")[..]);
810
811        b.iter(|| {
812            test::black_box(Ed25519Signer::try_from(&key).unwrap());
813        });
814    }
815
816    const SAMPLE_TLS13_MESSAGE: &[u8] = &[
817        0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
818        0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
819        0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
820        0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
821        0x20, 0x20, 0x20, 0x20, 0x54, 0x4c, 0x53, 0x20, 0x31, 0x2e, 0x33, 0x2c, 0x20, 0x73, 0x65,
822        0x72, 0x76, 0x65, 0x72, 0x20, 0x43, 0x65, 0x72, 0x74, 0x69, 0x66, 0x69, 0x63, 0x61, 0x74,
823        0x65, 0x56, 0x65, 0x72, 0x69, 0x66, 0x79, 0x00, 0x04, 0xca, 0xc4, 0x48, 0x0e, 0x70, 0xf2,
824        0x1b, 0xa9, 0x1c, 0x16, 0xca, 0x90, 0x48, 0xbe, 0x28, 0x2f, 0xc7, 0xf8, 0x9b, 0x87, 0x72,
825        0x93, 0xda, 0x4d, 0x2f, 0x80, 0x80, 0x60, 0x1a, 0xd3, 0x08, 0xe2, 0xb7, 0x86, 0x14, 0x1b,
826        0x54, 0xda, 0x9a, 0xc9, 0x6d, 0xe9, 0x66, 0xb4, 0x9f, 0xe2, 0x2c,
827    ];
828}
rustls/crypto/aws_lc_rs/sign.rs

rustls/crypto/aws_lc_rs/
sign.rs
