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

rustls/crypto/aws_lc_rs/
sign.rs
