jwt_simple_legacy/algorithms/
rsa.rs

1use std::mem;
2
3use ct_codecs::{Base64UrlSafeNoPadding, Encoder};
4use hmac_sha1_compact::Hash as SHA1;
5use hmac_sha256::Hash as SHA256;
6use hmac_sha512::sha384::Hash as SHA384;
7use hmac_sha512::Hash as SHA512;
8use rsa::pkcs1::{DecodeRsaPrivateKey as _, DecodeRsaPublicKey};
9use rsa::pkcs8::{DecodePrivateKey as _, DecodePublicKey as _, EncodePrivateKey as _};
10use rsa::{BigUint, PublicKey as _, PublicKeyParts as _};
11use serde::{de::DeserializeOwned, Serialize};
12#[allow(unused_imports)]
13use spki::{DecodePublicKey as _, EncodePublicKey as _};
14
15use crate::claims::*;
16use crate::common::*;
17#[cfg(feature = "cwt")]
18use crate::cwt_token::*;
19use crate::error::*;
20use crate::jwt_header::*;
21use crate::token::*;
22
23#[doc(hidden)]
24#[derive(Debug, Clone)]
25pub struct RSAPublicKey(rsa::RsaPublicKey);
26
27impl AsRef<rsa::RsaPublicKey> for RSAPublicKey {
28    fn as_ref(&self) -> &rsa::RsaPublicKey {
29        &self.0
30    }
31}
32
33pub struct RSAPublicKeyComponents {
34    pub n: Vec<u8>,
35    pub e: Vec<u8>,
36}
37
38impl RSAPublicKey {
39    pub fn from_der(der: &[u8]) -> Result<Self, Error> {
40        let rsa_pk = rsa::RsaPublicKey::from_public_key_der(der)
41            .or_else(|_| rsa::RsaPublicKey::from_pkcs1_der(der))?;
42        Ok(RSAPublicKey(rsa_pk))
43    }
44
45    pub fn from_pem(pem: &str) -> Result<Self, Error> {
46        let pem = pem.trim();
47        let rsa_pk = rsa::RsaPublicKey::from_public_key_pem(pem)
48            .or_else(|_| rsa::RsaPublicKey::from_pkcs1_pem(pem))?;
49        Ok(RSAPublicKey(rsa_pk))
50    }
51
52    pub fn from_components(n: &[u8], e: &[u8]) -> Result<Self, Error> {
53        let n = BigUint::from_bytes_be(n);
54        let e = BigUint::from_bytes_be(e);
55        let rsa_pk = rsa::RsaPublicKey::new_with_max_size(n, e, 8192)?;
56        Ok(RSAPublicKey(rsa_pk))
57    }
58
59    pub fn to_der(&self) -> Result<Vec<u8>, Error> {
60        self.0
61            .to_public_key_der()
62            .map_err(Into::into)
63            .map(|x| x.as_ref().to_vec())
64    }
65
66    pub fn to_pem(&self) -> Result<String, Error> {
67        self.0
68            .to_public_key_pem(Default::default())
69            .map_err(Into::into)
70    }
71
72    pub fn to_components(&self) -> RSAPublicKeyComponents {
73        let n = self.0.n().to_bytes_be();
74        let e = self.0.e().to_bytes_be();
75        RSAPublicKeyComponents { n, e }
76    }
77}
78
79#[doc(hidden)]
80#[derive(Debug, Clone)]
81pub struct RSAKeyPair {
82    rsa_sk: rsa::RsaPrivateKey,
83    metadata: Option<KeyMetadata>,
84}
85
86impl AsRef<rsa::RsaPrivateKey> for RSAKeyPair {
87    fn as_ref(&self) -> &rsa::RsaPrivateKey {
88        &self.rsa_sk
89    }
90}
91
92impl RSAKeyPair {
93    pub fn from_der(der: &[u8]) -> Result<Self, Error> {
94        let mut rsa_sk = rsa::RsaPrivateKey::from_pkcs8_der(der)
95            .or_else(|_| rsa::RsaPrivateKey::from_pkcs1_der(der))?;
96        rsa_sk.validate()?;
97        rsa_sk.precompute()?;
98        Ok(RSAKeyPair {
99            rsa_sk,
100            metadata: None,
101        })
102    }
103
104    pub fn from_pem(pem: &str) -> Result<Self, Error> {
105        let pem = pem.trim();
106        let mut rsa_sk = rsa::RsaPrivateKey::from_pkcs8_pem(pem)
107            .or_else(|_| rsa::RsaPrivateKey::from_pkcs1_pem(pem))?;
108        rsa_sk.validate()?;
109        rsa_sk.precompute()?;
110        Ok(RSAKeyPair {
111            rsa_sk,
112            metadata: None,
113        })
114    }
115
116    pub fn to_der(&self) -> Result<Vec<u8>, Error> {
117        self.rsa_sk
118            .to_pkcs8_der()
119            .map_err(Into::into)
120            .map(|x| mem::take(x.to_bytes().as_mut()))
121    }
122
123    pub fn to_pem(&self) -> Result<String, Error> {
124        self.rsa_sk
125            .to_pkcs8_pem(Default::default())
126            .map_err(Into::into)
127            .map(|x| x.to_string())
128    }
129
130    pub fn public_key(&self) -> RSAPublicKey {
131        let rsa_pk = self.rsa_sk.to_public_key();
132        RSAPublicKey(rsa_pk)
133    }
134
135    pub fn generate(modulus_bits: usize) -> Result<Self, Error> {
136        match modulus_bits {
137            2048 | 3072 | 4096 => {}
138            _ => bail!(JWTError::UnsupportedRSAModulus),
139        };
140        let mut rng = rand::thread_rng();
141        let rsa_sk = rsa::RsaPrivateKey::new(&mut rng, modulus_bits)?;
142        Ok(RSAKeyPair {
143            rsa_sk,
144            metadata: None,
145        })
146    }
147}
148
149pub trait RSAKeyPairLike {
150    fn jwt_alg_name() -> &'static str;
151    fn key_pair(&self) -> &RSAKeyPair;
152    fn key_id(&self) -> &Option<String>;
153    fn metadata(&self) -> &Option<KeyMetadata>;
154    fn attach_metadata(&mut self, metadata: KeyMetadata) -> Result<(), Error>;
155    fn hash(message: &[u8]) -> Vec<u8>;
156    fn padding_scheme(&self) -> rsa::PaddingScheme;
157
158    fn sign<CustomClaims: Serialize + DeserializeOwned>(
159        &self,
160        claims: JWTClaims<CustomClaims>,
161    ) -> Result<String, Error> {
162        let jwt_header = JWTHeader::new(Self::jwt_alg_name().to_string(), self.key_id().clone())
163            .with_metadata(self.metadata());
164        Token::build(&jwt_header, claims, |authenticated| {
165            let digest = Self::hash(authenticated.as_bytes());
166            let mut rng = rand::thread_rng();
167            let token =
168                self.key_pair()
169                    .as_ref()
170                    .sign_blinded(&mut rng, self.padding_scheme(), &digest)?;
171            Ok(token)
172        })
173    }
174}
175
176pub trait RSAPublicKeyLike {
177    fn jwt_alg_name() -> &'static str;
178    fn public_key(&self) -> &RSAPublicKey;
179    fn key_id(&self) -> &Option<String>;
180    fn set_key_id(&mut self, key_id: String);
181    fn hash(message: &[u8]) -> Vec<u8>;
182    fn padding_scheme(&self) -> rsa::PaddingScheme;
183
184    fn verify_token<CustomClaims: Serialize + DeserializeOwned>(
185        &self,
186        token: &str,
187        options: Option<VerificationOptions>,
188    ) -> Result<JWTClaims<CustomClaims>, Error> {
189        Token::verify(
190            Self::jwt_alg_name(),
191            token,
192            options,
193            |authenticated, signature| {
194                let digest = Self::hash(authenticated.as_bytes());
195                self.public_key()
196                    .as_ref()
197                    .verify(self.padding_scheme(), &digest, signature)
198                    .map_err(|_| JWTError::InvalidSignature)?;
199                Ok(())
200            },
201        )
202    }
203
204    #[cfg(feature = "cwt")]
205    fn verify_cwt_token<CustomClaims: Serialize + DeserializeOwned>(
206        &self,
207        token: &[u8],
208        options: Option<VerificationOptions>,
209    ) -> Result<JWTClaims<NoCustomClaims>, Error> {
210        CWTToken::verify(
211            Self::jwt_alg_name(),
212            token,
213            options,
214            |authenticated, signature| {
215                let digest = Self::hash(authenticated.as_bytes());
216                self.public_key()
217                    .as_ref()
218                    .verify(self.padding_scheme(), &digest, signature)
219                    .map_err(|_| JWTError::InvalidSignature)?;
220                Ok(())
221            },
222        )
223    }
224}
225
226#[derive(Debug, Clone)]
227pub struct RS256KeyPair {
228    key_pair: RSAKeyPair,
229    key_id: Option<String>,
230}
231
232#[derive(Debug, Clone)]
233pub struct RS256PublicKey {
234    pk: RSAPublicKey,
235    key_id: Option<String>,
236}
237
238impl RSAKeyPairLike for RS256KeyPair {
239    fn jwt_alg_name() -> &'static str {
240        "RS256"
241    }
242
243    fn key_pair(&self) -> &RSAKeyPair {
244        &self.key_pair
245    }
246
247    fn key_id(&self) -> &Option<String> {
248        &self.key_id
249    }
250
251    fn metadata(&self) -> &Option<KeyMetadata> {
252        &self.key_pair.metadata
253    }
254
255    fn attach_metadata(&mut self, metadata: KeyMetadata) -> Result<(), Error> {
256        self.key_pair.metadata = Some(metadata);
257        Ok(())
258    }
259
260    fn hash(message: &[u8]) -> Vec<u8> {
261        SHA256::hash(message).to_vec()
262    }
263
264    fn padding_scheme(&self) -> rsa::PaddingScheme {
265        rsa::PaddingScheme::new_pkcs1v15_sign::<SHA256>()
266    }
267}
268
269impl RS256KeyPair {
270    pub fn from_der(der: &[u8]) -> Result<Self, Error> {
271        Ok(RS256KeyPair {
272            key_pair: RSAKeyPair::from_der(der)?,
273            key_id: None,
274        })
275    }
276
277    pub fn from_pem(pem: &str) -> Result<Self, Error> {
278        Ok(RS256KeyPair {
279            key_pair: RSAKeyPair::from_pem(pem)?,
280            key_id: None,
281        })
282    }
283
284    pub fn to_der(&self) -> Result<Vec<u8>, Error> {
285        self.key_pair.to_der()
286    }
287
288    pub fn to_pem(&self) -> Result<String, Error> {
289        self.key_pair.to_pem()
290    }
291
292    pub fn public_key(&self) -> RS256PublicKey {
293        RS256PublicKey {
294            pk: self.key_pair.public_key(),
295            key_id: self.key_id.clone(),
296        }
297    }
298
299    pub fn generate(modulus_bits: usize) -> Result<Self, Error> {
300        Ok(RS256KeyPair {
301            key_pair: RSAKeyPair::generate(modulus_bits)?,
302            key_id: None,
303        })
304    }
305
306    pub fn with_key_id(mut self, key_id: &str) -> Self {
307        self.key_id = Some(key_id.to_string());
308        self
309    }
310}
311
312impl RSAPublicKeyLike for RS256PublicKey {
313    fn jwt_alg_name() -> &'static str {
314        "RS256"
315    }
316
317    fn hash(message: &[u8]) -> Vec<u8> {
318        SHA256::hash(message).to_vec()
319    }
320
321    fn padding_scheme(&self) -> rsa::PaddingScheme {
322        rsa::PaddingScheme::new_pkcs1v15_sign::<SHA256>()
323    }
324
325    fn public_key(&self) -> &RSAPublicKey {
326        &self.pk
327    }
328
329    fn key_id(&self) -> &Option<String> {
330        &self.key_id
331    }
332
333    fn set_key_id(&mut self, key_id: String) {
334        self.key_id = Some(key_id);
335    }
336}
337
338impl RS256PublicKey {
339    pub fn from_der(der: &[u8]) -> Result<Self, Error> {
340        Ok(RS256PublicKey {
341            pk: RSAPublicKey::from_der(der)?,
342            key_id: None,
343        })
344    }
345
346    pub fn from_pem(pem: &str) -> Result<Self, Error> {
347        Ok(RS256PublicKey {
348            pk: RSAPublicKey::from_pem(pem)?,
349            key_id: None,
350        })
351    }
352
353    pub fn from_components(n: &[u8], e: &[u8]) -> Result<Self, Error> {
354        Ok(RS256PublicKey {
355            pk: RSAPublicKey::from_components(n, e)?,
356            key_id: None,
357        })
358    }
359
360    pub fn to_der(&self) -> Result<Vec<u8>, Error> {
361        self.pk.to_der()
362    }
363
364    pub fn to_pem(&self) -> Result<String, Error> {
365        self.pk.to_pem()
366    }
367
368    pub fn to_components(&self) -> RSAPublicKeyComponents {
369        self.pk.to_components()
370    }
371
372    pub fn with_key_id(mut self, key_id: &str) -> Self {
373        self.key_id = Some(key_id.to_string());
374        self
375    }
376
377    pub fn sha1_thumbprint(&self) -> String {
378        Base64UrlSafeNoPadding::encode_to_string(SHA1::hash(&self.pk.to_der().unwrap())).unwrap()
379    }
380
381    pub fn sha256_thumbprint(&self) -> String {
382        Base64UrlSafeNoPadding::encode_to_string(SHA256::hash(&self.pk.to_der().unwrap())).unwrap()
383    }
384}
385
386//
387
388#[derive(Debug, Clone)]
389pub struct RS512KeyPair {
390    key_pair: RSAKeyPair,
391    key_id: Option<String>,
392}
393
394#[derive(Debug, Clone)]
395pub struct RS512PublicKey {
396    pk: RSAPublicKey,
397    key_id: Option<String>,
398}
399
400impl RSAKeyPairLike for RS512KeyPair {
401    fn jwt_alg_name() -> &'static str {
402        "RS512"
403    }
404
405    fn key_pair(&self) -> &RSAKeyPair {
406        &self.key_pair
407    }
408
409    fn key_id(&self) -> &Option<String> {
410        &self.key_id
411    }
412
413    fn metadata(&self) -> &Option<KeyMetadata> {
414        &self.key_pair.metadata
415    }
416
417    fn attach_metadata(&mut self, metadata: KeyMetadata) -> Result<(), Error> {
418        self.key_pair.metadata = Some(metadata);
419        Ok(())
420    }
421
422    fn hash(message: &[u8]) -> Vec<u8> {
423        SHA512::hash(message).to_vec()
424    }
425
426    fn padding_scheme(&self) -> rsa::PaddingScheme {
427        rsa::PaddingScheme::new_pkcs1v15_sign::<SHA512>()
428    }
429}
430
431impl RS512KeyPair {
432    pub fn from_der(der: &[u8]) -> Result<Self, Error> {
433        Ok(RS512KeyPair {
434            key_pair: RSAKeyPair::from_der(der)?,
435            key_id: None,
436        })
437    }
438
439    pub fn from_pem(pem: &str) -> Result<Self, Error> {
440        Ok(RS512KeyPair {
441            key_pair: RSAKeyPair::from_pem(pem)?,
442            key_id: None,
443        })
444    }
445
446    pub fn to_der(&self) -> Result<Vec<u8>, Error> {
447        self.key_pair.to_der()
448    }
449
450    pub fn to_pem(&self) -> Result<String, Error> {
451        self.key_pair.to_pem()
452    }
453
454    pub fn public_key(&self) -> RS512PublicKey {
455        RS512PublicKey {
456            pk: self.key_pair.public_key(),
457            key_id: self.key_id.clone(),
458        }
459    }
460
461    pub fn generate(modulus_bits: usize) -> Result<Self, Error> {
462        Ok(RS512KeyPair {
463            key_pair: RSAKeyPair::generate(modulus_bits)?,
464            key_id: None,
465        })
466    }
467
468    pub fn with_key_id(mut self, key_id: &str) -> Self {
469        self.key_id = Some(key_id.to_string());
470        self
471    }
472}
473
474impl RSAPublicKeyLike for RS512PublicKey {
475    fn jwt_alg_name() -> &'static str {
476        "RS512"
477    }
478
479    fn hash(message: &[u8]) -> Vec<u8> {
480        SHA512::hash(message).to_vec()
481    }
482
483    fn padding_scheme(&self) -> rsa::PaddingScheme {
484        rsa::PaddingScheme::new_pkcs1v15_sign::<SHA512>()
485    }
486
487    fn public_key(&self) -> &RSAPublicKey {
488        &self.pk
489    }
490
491    fn key_id(&self) -> &Option<String> {
492        &self.key_id
493    }
494
495    fn set_key_id(&mut self, key_id: String) {
496        self.key_id = Some(key_id);
497    }
498}
499
500impl RS512PublicKey {
501    pub fn from_der(der: &[u8]) -> Result<Self, Error> {
502        Ok(RS512PublicKey {
503            pk: RSAPublicKey::from_der(der)?,
504            key_id: None,
505        })
506    }
507
508    pub fn from_pem(pem: &str) -> Result<Self, Error> {
509        Ok(RS512PublicKey {
510            pk: RSAPublicKey::from_pem(pem)?,
511            key_id: None,
512        })
513    }
514
515    pub fn from_components(n: &[u8], e: &[u8]) -> Result<Self, Error> {
516        Ok(RS512PublicKey {
517            pk: RSAPublicKey::from_components(n, e)?,
518            key_id: None,
519        })
520    }
521
522    pub fn to_der(&self) -> Result<Vec<u8>, Error> {
523        self.pk.to_der()
524    }
525
526    pub fn to_pem(&self) -> Result<String, Error> {
527        self.pk.to_pem()
528    }
529
530    pub fn to_components(&self) -> RSAPublicKeyComponents {
531        self.pk.to_components()
532    }
533
534    pub fn with_key_id(mut self, key_id: &str) -> Self {
535        self.key_id = Some(key_id.to_string());
536        self
537    }
538
539    pub fn sha1_thumbprint(&self) -> String {
540        Base64UrlSafeNoPadding::encode_to_string(SHA1::hash(&self.pk.to_der().unwrap())).unwrap()
541    }
542
543    pub fn sha256_thumbprint(&self) -> String {
544        Base64UrlSafeNoPadding::encode_to_string(SHA256::hash(&self.pk.to_der().unwrap())).unwrap()
545    }
546}
547
548//
549
550#[derive(Debug, Clone)]
551pub struct RS384KeyPair {
552    key_pair: RSAKeyPair,
553    key_id: Option<String>,
554}
555
556#[derive(Debug, Clone)]
557pub struct RS384PublicKey {
558    pk: RSAPublicKey,
559    key_id: Option<String>,
560}
561
562impl RSAKeyPairLike for RS384KeyPair {
563    fn jwt_alg_name() -> &'static str {
564        "RS384"
565    }
566
567    fn key_pair(&self) -> &RSAKeyPair {
568        &self.key_pair
569    }
570
571    fn key_id(&self) -> &Option<String> {
572        &self.key_id
573    }
574
575    fn metadata(&self) -> &Option<KeyMetadata> {
576        &self.key_pair.metadata
577    }
578
579    fn attach_metadata(&mut self, metadata: KeyMetadata) -> Result<(), Error> {
580        self.key_pair.metadata = Some(metadata);
581        Ok(())
582    }
583
584    fn hash(message: &[u8]) -> Vec<u8> {
585        SHA384::hash(message).to_vec()
586    }
587
588    fn padding_scheme(&self) -> rsa::PaddingScheme {
589        rsa::PaddingScheme::new_pkcs1v15_sign::<SHA384>()
590    }
591}
592
593impl RS384KeyPair {
594    pub fn from_der(der: &[u8]) -> Result<Self, Error> {
595        Ok(RS384KeyPair {
596            key_pair: RSAKeyPair::from_der(der)?,
597            key_id: None,
598        })
599    }
600
601    pub fn from_pem(pem: &str) -> Result<Self, Error> {
602        Ok(RS384KeyPair {
603            key_pair: RSAKeyPair::from_pem(pem)?,
604            key_id: None,
605        })
606    }
607
608    pub fn to_der(&self) -> Result<Vec<u8>, Error> {
609        self.key_pair.to_der()
610    }
611
612    pub fn to_pem(&self) -> Result<String, Error> {
613        self.key_pair.to_pem()
614    }
615
616    pub fn public_key(&self) -> RS384PublicKey {
617        RS384PublicKey {
618            pk: self.key_pair.public_key(),
619            key_id: self.key_id.clone(),
620        }
621    }
622
623    pub fn generate(modulus_bits: usize) -> Result<Self, Error> {
624        Ok(RS384KeyPair {
625            key_pair: RSAKeyPair::generate(modulus_bits)?,
626            key_id: None,
627        })
628    }
629
630    pub fn with_key_id(mut self, key_id: &str) -> Self {
631        self.key_id = Some(key_id.to_string());
632        self
633    }
634}
635
636impl RSAPublicKeyLike for RS384PublicKey {
637    fn jwt_alg_name() -> &'static str {
638        "RS384"
639    }
640
641    fn hash(message: &[u8]) -> Vec<u8> {
642        SHA384::hash(message).to_vec()
643    }
644
645    fn padding_scheme(&self) -> rsa::PaddingScheme {
646        rsa::PaddingScheme::new_pkcs1v15_sign::<SHA384>()
647    }
648
649    fn public_key(&self) -> &RSAPublicKey {
650        &self.pk
651    }
652
653    fn key_id(&self) -> &Option<String> {
654        &self.key_id
655    }
656
657    fn set_key_id(&mut self, key_id: String) {
658        self.key_id = Some(key_id);
659    }
660}
661
662impl RS384PublicKey {
663    pub fn from_der(der: &[u8]) -> Result<Self, Error> {
664        Ok(RS384PublicKey {
665            pk: RSAPublicKey::from_der(der)?,
666            key_id: None,
667        })
668    }
669
670    pub fn from_pem(pem: &str) -> Result<Self, Error> {
671        Ok(RS384PublicKey {
672            pk: RSAPublicKey::from_pem(pem)?,
673            key_id: None,
674        })
675    }
676
677    pub fn from_components(n: &[u8], e: &[u8]) -> Result<Self, Error> {
678        Ok(RS384PublicKey {
679            pk: RSAPublicKey::from_components(n, e)?,
680            key_id: None,
681        })
682    }
683
684    pub fn to_der(&self) -> Result<Vec<u8>, Error> {
685        self.pk.to_der()
686    }
687
688    pub fn to_pem(&self) -> Result<String, Error> {
689        self.pk.to_pem()
690    }
691
692    pub fn to_components(&self) -> RSAPublicKeyComponents {
693        self.pk.to_components()
694    }
695
696    pub fn with_key_id(mut self, key_id: &str) -> Self {
697        self.key_id = Some(key_id.to_string());
698        self
699    }
700
701    pub fn sha1_thumbprint(&self) -> String {
702        Base64UrlSafeNoPadding::encode_to_string(SHA1::hash(&self.pk.to_der().unwrap())).unwrap()
703    }
704
705    pub fn sha256_thumbprint(&self) -> String {
706        Base64UrlSafeNoPadding::encode_to_string(SHA256::hash(&self.pk.to_der().unwrap())).unwrap()
707    }
708}
709
710//
711
712#[derive(Debug, Clone)]
713pub struct PS256KeyPair {
714    key_pair: RSAKeyPair,
715    key_id: Option<String>,
716}
717
718#[derive(Debug, Clone)]
719pub struct PS256PublicKey {
720    pk: RSAPublicKey,
721    key_id: Option<String>,
722}
723
724impl RSAKeyPairLike for PS256KeyPair {
725    fn jwt_alg_name() -> &'static str {
726        "PS256"
727    }
728
729    fn key_pair(&self) -> &RSAKeyPair {
730        &self.key_pair
731    }
732
733    fn key_id(&self) -> &Option<String> {
734        &self.key_id
735    }
736
737    fn metadata(&self) -> &Option<KeyMetadata> {
738        &self.key_pair.metadata
739    }
740
741    fn attach_metadata(&mut self, metadata: KeyMetadata) -> Result<(), Error> {
742        self.key_pair.metadata = Some(metadata);
743        Ok(())
744    }
745
746    fn hash(message: &[u8]) -> Vec<u8> {
747        SHA256::hash(message).to_vec()
748    }
749
750    fn padding_scheme(&self) -> rsa::PaddingScheme {
751        rsa::PaddingScheme::new_pss::<SHA256>()
752    }
753}
754
755impl PS256KeyPair {
756    pub fn from_der(der: &[u8]) -> Result<Self, Error> {
757        Ok(PS256KeyPair {
758            key_pair: RSAKeyPair::from_der(der)?,
759            key_id: None,
760        })
761    }
762
763    pub fn from_pem(pem: &str) -> Result<Self, Error> {
764        Ok(PS256KeyPair {
765            key_pair: RSAKeyPair::from_pem(pem)?,
766            key_id: None,
767        })
768    }
769
770    pub fn to_der(&self) -> Result<Vec<u8>, Error> {
771        self.key_pair.to_der()
772    }
773
774    pub fn to_pem(&self) -> Result<String, Error> {
775        self.key_pair.to_pem()
776    }
777
778    pub fn public_key(&self) -> PS256PublicKey {
779        PS256PublicKey {
780            pk: self.key_pair.public_key(),
781            key_id: self.key_id.clone(),
782        }
783    }
784
785    pub fn generate(modulus_bits: usize) -> Result<Self, Error> {
786        Ok(PS256KeyPair {
787            key_pair: RSAKeyPair::generate(modulus_bits)?,
788            key_id: None,
789        })
790    }
791
792    pub fn with_key_id(mut self, key_id: &str) -> Self {
793        self.key_id = Some(key_id.to_string());
794        self
795    }
796}
797
798impl RSAPublicKeyLike for PS256PublicKey {
799    fn jwt_alg_name() -> &'static str {
800        "PS256"
801    }
802
803    fn hash(message: &[u8]) -> Vec<u8> {
804        SHA256::hash(message).to_vec()
805    }
806
807    fn padding_scheme(&self) -> rsa::PaddingScheme {
808        rsa::PaddingScheme::new_pss::<SHA256>()
809    }
810
811    fn public_key(&self) -> &RSAPublicKey {
812        &self.pk
813    }
814
815    fn key_id(&self) -> &Option<String> {
816        &self.key_id
817    }
818
819    fn set_key_id(&mut self, key_id: String) {
820        self.key_id = Some(key_id);
821    }
822}
823
824impl PS256PublicKey {
825    pub fn from_der(der: &[u8]) -> Result<Self, Error> {
826        Ok(PS256PublicKey {
827            pk: RSAPublicKey::from_der(der)?,
828            key_id: None,
829        })
830    }
831
832    pub fn from_pem(pem: &str) -> Result<Self, Error> {
833        Ok(PS256PublicKey {
834            pk: RSAPublicKey::from_pem(pem)?,
835            key_id: None,
836        })
837    }
838
839    pub fn from_components(n: &[u8], e: &[u8]) -> Result<Self, Error> {
840        Ok(PS256PublicKey {
841            pk: RSAPublicKey::from_components(n, e)?,
842            key_id: None,
843        })
844    }
845
846    pub fn to_der(&self) -> Result<Vec<u8>, Error> {
847        self.pk.to_der()
848    }
849
850    pub fn to_pem(&self) -> Result<String, Error> {
851        self.pk.to_pem()
852    }
853
854    pub fn to_components(&self) -> RSAPublicKeyComponents {
855        self.pk.to_components()
856    }
857
858    pub fn with_key_id(mut self, key_id: &str) -> Self {
859        self.key_id = Some(key_id.to_string());
860        self
861    }
862}
863
864//
865
866#[derive(Debug, Clone)]
867pub struct PS512KeyPair {
868    key_pair: RSAKeyPair,
869    key_id: Option<String>,
870}
871
872#[derive(Debug, Clone)]
873pub struct PS512PublicKey {
874    pk: RSAPublicKey,
875    key_id: Option<String>,
876}
877
878impl RSAKeyPairLike for PS512KeyPair {
879    fn jwt_alg_name() -> &'static str {
880        "PS512"
881    }
882
883    fn key_pair(&self) -> &RSAKeyPair {
884        &self.key_pair
885    }
886
887    fn key_id(&self) -> &Option<String> {
888        &self.key_id
889    }
890
891    fn metadata(&self) -> &Option<KeyMetadata> {
892        &self.key_pair.metadata
893    }
894
895    fn attach_metadata(&mut self, metadata: KeyMetadata) -> Result<(), Error> {
896        self.key_pair.metadata = Some(metadata);
897        Ok(())
898    }
899
900    fn hash(message: &[u8]) -> Vec<u8> {
901        SHA512::hash(message).to_vec()
902    }
903
904    fn padding_scheme(&self) -> rsa::PaddingScheme {
905        rsa::PaddingScheme::new_pss::<SHA512>()
906    }
907}
908
909impl PS512KeyPair {
910    pub fn from_der(der: &[u8]) -> Result<Self, Error> {
911        Ok(PS512KeyPair {
912            key_pair: RSAKeyPair::from_der(der)?,
913            key_id: None,
914        })
915    }
916
917    pub fn from_pem(pem: &str) -> Result<Self, Error> {
918        Ok(PS512KeyPair {
919            key_pair: RSAKeyPair::from_pem(pem)?,
920            key_id: None,
921        })
922    }
923
924    pub fn to_der(&self) -> Result<Vec<u8>, Error> {
925        self.key_pair.to_der()
926    }
927
928    pub fn to_pem(&self) -> Result<String, Error> {
929        self.key_pair.to_pem()
930    }
931
932    pub fn public_key(&self) -> PS512PublicKey {
933        PS512PublicKey {
934            pk: self.key_pair.public_key(),
935            key_id: self.key_id.clone(),
936        }
937    }
938
939    pub fn generate(modulus_bits: usize) -> Result<Self, Error> {
940        Ok(PS512KeyPair {
941            key_pair: RSAKeyPair::generate(modulus_bits)?,
942            key_id: None,
943        })
944    }
945
946    pub fn with_key_id(mut self, key_id: &str) -> Self {
947        self.key_id = Some(key_id.to_string());
948        self
949    }
950}
951
952impl RSAPublicKeyLike for PS512PublicKey {
953    fn jwt_alg_name() -> &'static str {
954        "PS512"
955    }
956
957    fn hash(message: &[u8]) -> Vec<u8> {
958        SHA512::hash(message).to_vec()
959    }
960
961    fn padding_scheme(&self) -> rsa::PaddingScheme {
962        rsa::PaddingScheme::new_pss::<SHA512>()
963    }
964
965    fn public_key(&self) -> &RSAPublicKey {
966        &self.pk
967    }
968
969    fn key_id(&self) -> &Option<String> {
970        &self.key_id
971    }
972
973    fn set_key_id(&mut self, key_id: String) {
974        self.key_id = Some(key_id);
975    }
976}
977
978impl PS512PublicKey {
979    pub fn from_der(der: &[u8]) -> Result<Self, Error> {
980        Ok(PS512PublicKey {
981            pk: RSAPublicKey::from_der(der)?,
982            key_id: None,
983        })
984    }
985
986    pub fn from_pem(pem: &str) -> Result<Self, Error> {
987        Ok(PS512PublicKey {
988            pk: RSAPublicKey::from_pem(pem)?,
989            key_id: None,
990        })
991    }
992
993    pub fn from_components(n: &[u8], e: &[u8]) -> Result<Self, Error> {
994        Ok(PS512PublicKey {
995            pk: RSAPublicKey::from_components(n, e)?,
996            key_id: None,
997        })
998    }
999
1000    pub fn to_der(&self) -> Result<Vec<u8>, Error> {
1001        self.pk.to_der()
1002    }
1003
1004    pub fn to_pem(&self) -> Result<String, Error> {
1005        self.pk.to_pem()
1006    }
1007
1008    pub fn to_components(&self) -> RSAPublicKeyComponents {
1009        self.pk.to_components()
1010    }
1011
1012    pub fn with_key_id(mut self, key_id: &str) -> Self {
1013        self.key_id = Some(key_id.to_string());
1014        self
1015    }
1016
1017    pub fn sha1_thumbprint(&self) -> String {
1018        Base64UrlSafeNoPadding::encode_to_string(SHA1::hash(&self.pk.to_der().unwrap())).unwrap()
1019    }
1020
1021    pub fn sha256_thumbprint(&self) -> String {
1022        Base64UrlSafeNoPadding::encode_to_string(SHA256::hash(&self.pk.to_der().unwrap())).unwrap()
1023    }
1024}
1025
1026//
1027
1028#[derive(Debug, Clone)]
1029pub struct PS384KeyPair {
1030    key_pair: RSAKeyPair,
1031    key_id: Option<String>,
1032}
1033
1034#[derive(Debug, Clone)]
1035pub struct PS384PublicKey {
1036    pk: RSAPublicKey,
1037    key_id: Option<String>,
1038}
1039
1040impl RSAKeyPairLike for PS384KeyPair {
1041    fn jwt_alg_name() -> &'static str {
1042        "PS384"
1043    }
1044
1045    fn key_pair(&self) -> &RSAKeyPair {
1046        &self.key_pair
1047    }
1048
1049    fn key_id(&self) -> &Option<String> {
1050        &self.key_id
1051    }
1052
1053    fn metadata(&self) -> &Option<KeyMetadata> {
1054        &self.key_pair.metadata
1055    }
1056
1057    fn attach_metadata(&mut self, metadata: KeyMetadata) -> Result<(), Error> {
1058        self.key_pair.metadata = Some(metadata);
1059        Ok(())
1060    }
1061
1062    fn hash(message: &[u8]) -> Vec<u8> {
1063        SHA384::hash(message).to_vec()
1064    }
1065
1066    fn padding_scheme(&self) -> rsa::PaddingScheme {
1067        rsa::PaddingScheme::new_pss::<SHA384>()
1068    }
1069}
1070
1071impl PS384KeyPair {
1072    pub fn from_der(der: &[u8]) -> Result<Self, Error> {
1073        Ok(PS384KeyPair {
1074            key_pair: RSAKeyPair::from_der(der)?,
1075            key_id: None,
1076        })
1077    }
1078
1079    pub fn from_pem(pem: &str) -> Result<Self, Error> {
1080        Ok(PS384KeyPair {
1081            key_pair: RSAKeyPair::from_pem(pem)?,
1082            key_id: None,
1083        })
1084    }
1085
1086    pub fn to_der(&self) -> Result<Vec<u8>, Error> {
1087        self.key_pair.to_der()
1088    }
1089
1090    pub fn to_pem(&self) -> Result<String, Error> {
1091        self.key_pair.to_pem()
1092    }
1093
1094    pub fn public_key(&self) -> PS384PublicKey {
1095        PS384PublicKey {
1096            pk: self.key_pair.public_key(),
1097            key_id: self.key_id.clone(),
1098        }
1099    }
1100
1101    pub fn generate(modulus_bits: usize) -> Result<Self, Error> {
1102        Ok(PS384KeyPair {
1103            key_pair: RSAKeyPair::generate(modulus_bits)?,
1104            key_id: None,
1105        })
1106    }
1107
1108    pub fn with_key_id(mut self, key_id: &str) -> Self {
1109        self.key_id = Some(key_id.to_string());
1110        self
1111    }
1112}
1113
1114impl RSAPublicKeyLike for PS384PublicKey {
1115    fn jwt_alg_name() -> &'static str {
1116        "PS384"
1117    }
1118
1119    fn hash(message: &[u8]) -> Vec<u8> {
1120        SHA384::hash(message).to_vec()
1121    }
1122
1123    fn padding_scheme(&self) -> rsa::PaddingScheme {
1124        rsa::PaddingScheme::new_pss::<SHA384>()
1125    }
1126
1127    fn public_key(&self) -> &RSAPublicKey {
1128        &self.pk
1129    }
1130
1131    fn key_id(&self) -> &Option<String> {
1132        &self.key_id
1133    }
1134
1135    fn set_key_id(&mut self, key_id: String) {
1136        self.key_id = Some(key_id);
1137    }
1138}
1139
1140impl PS384PublicKey {
1141    pub fn from_der(der: &[u8]) -> Result<Self, Error> {
1142        Ok(PS384PublicKey {
1143            pk: RSAPublicKey::from_der(der)?,
1144            key_id: None,
1145        })
1146    }
1147
1148    pub fn from_pem(pem: &str) -> Result<Self, Error> {
1149        Ok(PS384PublicKey {
1150            pk: RSAPublicKey::from_pem(pem)?,
1151            key_id: None,
1152        })
1153    }
1154
1155    pub fn from_components(n: &[u8], e: &[u8]) -> Result<Self, Error> {
1156        Ok(PS384PublicKey {
1157            pk: RSAPublicKey::from_components(n, e)?,
1158            key_id: None,
1159        })
1160    }
1161
1162    pub fn to_der(&self) -> Result<Vec<u8>, Error> {
1163        self.pk.to_der()
1164    }
1165
1166    pub fn to_pem(&self) -> Result<String, Error> {
1167        self.pk.to_pem()
1168    }
1169
1170    pub fn to_components(&self) -> RSAPublicKeyComponents {
1171        self.pk.to_components()
1172    }
1173
1174    pub fn with_key_id(mut self, key_id: &str) -> Self {
1175        self.key_id = Some(key_id.to_string());
1176        self
1177    }
1178
1179    pub fn sha1_thumbprint(&self) -> String {
1180        Base64UrlSafeNoPadding::encode_to_string(SHA1::hash(&self.pk.to_der().unwrap())).unwrap()
1181    }
1182
1183    pub fn sha256_thumbprint(&self) -> String {
1184        Base64UrlSafeNoPadding::encode_to_string(SHA256::hash(&self.pk.to_der().unwrap())).unwrap()
1185    }
1186}
jwt_simple_legacy/algorithms/rsa.rs

jwt_simple_legacy/algorithms/
rsa.rs
