Skip to main content

paysec_crypto_rustcrypto/
rsa.rs

1use paysec_crypto::{RsaOaepSha256Encrypt, RsaPkcs1v15Sha256Sign, RsaPkcs1v15Sha256Verify};
2
3use rand_core::{CryptoRng, OsRng, RngCore};
4
5use ::rsa::{Oaep, Pkcs1v15Sign, RsaPrivateKey, RsaPublicKey};
6
7use sha2::{Digest, Sha256};
8
9use crate::{RustCryptoError, RustCryptoProvider, RustCryptoProviderWithRng};
10
11fn encrypt_oaep_sha256_with_rng<R>(
12    rng: &mut R,
13    key: &RsaPublicKey,
14    plaintext: &[u8],
15) -> Result<Vec<u8>, RustCryptoError>
16where
17    R: RngCore + CryptoRng,
18{
19    key.encrypt(rng, Oaep::new::<Sha256>(), plaintext)
20        .map_err(|_| RustCryptoError::rsa_oaep_encryption_failed())
21}
22
23fn sign_pkcs1v15_sha256(key: &RsaPrivateKey, message: &[u8]) -> Result<Vec<u8>, RustCryptoError> {
24    let digest = Sha256::digest(message);
25    let padding = Pkcs1v15Sign::new::<Sha256>();
26
27    // PKCS#1 v1.5 signatures are deterministic. The RNG is used only for
28    // RSA blinding of the private-key operation.
29    let mut rng = OsRng;
30
31    key.sign_with_rng(&mut rng, padding, digest.as_slice())
32        .map_err(|_| RustCryptoError::rsa_signing_failed())
33}
34
35fn verify_pkcs1v15_sha256(
36    key: &RsaPublicKey,
37    message: &[u8],
38    signature: &[u8],
39) -> Result<(), RustCryptoError> {
40    let digest = Sha256::digest(message);
41    let padding = Pkcs1v15Sign::new::<Sha256>();
42
43    key.verify(padding, digest.as_slice(), signature)
44        .map_err(|_| RustCryptoError::rsa_verification_failed())
45}
46
47impl RsaOaepSha256Encrypt<RsaPublicKey> for RustCryptoProvider {
48    fn encrypt_oaep_sha256(
49        &mut self,
50        key: &RsaPublicKey,
51        plaintext: &[u8],
52    ) -> Result<Vec<u8>, Self::Error> {
53        let mut rng = OsRng;
54
55        encrypt_oaep_sha256_with_rng(&mut rng, key, plaintext)
56    }
57}
58
59impl<R> RsaOaepSha256Encrypt<RsaPublicKey> for RustCryptoProviderWithRng<R>
60where
61    R: RngCore + CryptoRng,
62{
63    fn encrypt_oaep_sha256(
64        &mut self,
65        key: &RsaPublicKey,
66        plaintext: &[u8],
67    ) -> Result<Vec<u8>, Self::Error> {
68        encrypt_oaep_sha256_with_rng(self.rng_mut(), key, plaintext)
69    }
70}
71
72impl RsaPkcs1v15Sha256Sign<RsaPrivateKey> for RustCryptoProvider {
73    fn sign_pkcs1v15_sha256(
74        &self,
75        key: &RsaPrivateKey,
76        message: &[u8],
77    ) -> Result<Vec<u8>, Self::Error> {
78        sign_pkcs1v15_sha256(key, message)
79    }
80}
81
82impl<R> RsaPkcs1v15Sha256Sign<RsaPrivateKey> for RustCryptoProviderWithRng<R> {
83    fn sign_pkcs1v15_sha256(
84        &self,
85        key: &RsaPrivateKey,
86        message: &[u8],
87    ) -> Result<Vec<u8>, Self::Error> {
88        sign_pkcs1v15_sha256(key, message)
89    }
90}
91
92impl RsaPkcs1v15Sha256Verify<RsaPublicKey> for RustCryptoProvider {
93    fn verify_pkcs1v15_sha256(
94        &self,
95        key: &RsaPublicKey,
96        message: &[u8],
97        signature: &[u8],
98    ) -> Result<(), Self::Error> {
99        verify_pkcs1v15_sha256(key, message, signature)
100    }
101}
102
103impl<R> RsaPkcs1v15Sha256Verify<RsaPublicKey> for RustCryptoProviderWithRng<R> {
104    fn verify_pkcs1v15_sha256(
105        &self,
106        key: &RsaPublicKey,
107        message: &[u8],
108        signature: &[u8],
109    ) -> Result<(), Self::Error> {
110        verify_pkcs1v15_sha256(key, message, signature)
111    }
112}
113
114#[cfg(test)]
115mod tests {
116    use super::*;
117
118    struct FixedRng {
119        bytes: Vec<u8>,
120        offset: usize,
121    }
122
123    impl FixedRng {
124        fn new(bytes: impl Into<Vec<u8>>) -> Self {
125            Self {
126                bytes: bytes.into(),
127                offset: 0,
128            }
129        }
130
131        fn consumed(&self) -> usize {
132            self.offset
133        }
134    }
135
136    impl RngCore for FixedRng {
137        fn next_u32(&mut self) -> u32 {
138            let mut bytes = [0u8; 4];
139            self.fill_bytes(&mut bytes);
140            u32::from_le_bytes(bytes)
141        }
142
143        fn next_u64(&mut self) -> u64 {
144            let mut bytes = [0u8; 8];
145            self.fill_bytes(&mut bytes);
146            u64::from_le_bytes(bytes)
147        }
148
149        fn fill_bytes(&mut self, dest: &mut [u8]) {
150            let end = self.offset + dest.len();
151
152            assert!(end <= self.bytes.len(), "fixed RNG exhausted");
153
154            dest.copy_from_slice(&self.bytes[self.offset..end]);
155            self.offset = end;
156        }
157
158        fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand_core::Error> {
159            self.fill_bytes(dest);
160            Ok(())
161        }
162    }
163
164    impl CryptoRng for FixedRng {}
165
166    fn rsa_key_pair() -> (RsaPrivateKey, RsaPublicKey) {
167        let mut rng = OsRng;
168
169        let private_key = RsaPrivateKey::new(&mut rng, 2048).unwrap();
170
171        let public_key = RsaPublicKey::from(&private_key);
172
173        (private_key, public_key)
174    }
175
176    #[test]
177    fn oaep_sha256_round_trip() {
178        let (private_key, public_key) = rsa_key_pair();
179
180        let mut provider = RustCryptoProvider::new();
181
182        let plaintext = b"0123456789ABCDEF";
183
184        let ciphertext = provider
185            .encrypt_oaep_sha256(&public_key, plaintext)
186            .unwrap();
187
188        let decrypted = private_key
189            .decrypt(Oaep::new::<Sha256>(), &ciphertext)
190            .unwrap();
191
192        assert_eq!(decrypted, plaintext);
193    }
194
195    #[test]
196    fn oaep_sha256_is_deterministic_with_fixed_seed() {
197        let (_private_key, public_key) = rsa_key_pair();
198
199        // OAEP with SHA-256 uses a 32-byte seed.
200        let seed = [
201            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
202            0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b,
203            0x1c, 0x1d, 0x1e, 0x1f,
204        ];
205
206        let mut provider_a = RustCryptoProvider::with_rng(FixedRng::new(seed));
207
208        let mut provider_b = RustCryptoProvider::with_rng(FixedRng::new(seed));
209
210        let plaintext = b"0123456789ABCDEF";
211
212        let ciphertext_a = provider_a
213            .encrypt_oaep_sha256(&public_key, plaintext)
214            .unwrap();
215
216        let ciphertext_b = provider_b
217            .encrypt_oaep_sha256(&public_key, plaintext)
218            .unwrap();
219
220        assert_eq!(ciphertext_a, ciphertext_b);
221
222        // This also proves RustCrypto consumed exactly the SHA-256-sized
223        // OAEP seed and no additional protocol-visible randomness.
224        assert_eq!(provider_a.into_rng().consumed(), 32);
225        assert_eq!(provider_b.into_rng().consumed(), 32);
226    }
227
228    #[test]
229    fn different_oaep_seeds_produce_different_ciphertexts() {
230        let (_private_key, public_key) = rsa_key_pair();
231
232        let mut provider_a = RustCryptoProvider::with_rng(FixedRng::new([0x11; 32]));
233
234        let mut provider_b = RustCryptoProvider::with_rng(FixedRng::new([0x22; 32]));
235
236        let plaintext = b"0123456789ABCDEF";
237
238        let ciphertext_a = provider_a
239            .encrypt_oaep_sha256(&public_key, plaintext)
240            .unwrap();
241
242        let ciphertext_b = provider_b
243            .encrypt_oaep_sha256(&public_key, plaintext)
244            .unwrap();
245
246        assert_ne!(ciphertext_a, ciphertext_b);
247    }
248
249    #[test]
250    fn pkcs1v15_sha256_sign_and_verify() {
251        let (private_key, public_key) = rsa_key_pair();
252
253        let provider = RustCryptoProvider::new();
254
255        let message = b"TR-34 test message";
256
257        let signature = provider
258            .sign_pkcs1v15_sha256(&private_key, message)
259            .unwrap();
260
261        provider
262            .verify_pkcs1v15_sha256(&public_key, message, &signature)
263            .unwrap();
264    }
265
266    #[test]
267    fn pkcs1v15_sha256_signature_is_deterministic() {
268        let (private_key, _public_key) = rsa_key_pair();
269
270        let provider = RustCryptoProvider::new();
271
272        let message = b"TR-34 test message";
273
274        let signature_a = provider
275            .sign_pkcs1v15_sha256(&private_key, message)
276            .unwrap();
277
278        let signature_b = provider
279            .sign_pkcs1v15_sha256(&private_key, message)
280            .unwrap();
281
282        assert_eq!(signature_a, signature_b);
283    }
284
285    #[test]
286    fn pkcs1v15_sha256_rejects_modified_message() {
287        let (private_key, public_key) = rsa_key_pair();
288
289        let provider = RustCryptoProvider::new();
290
291        let signature = provider
292            .sign_pkcs1v15_sha256(&private_key, b"original")
293            .unwrap();
294
295        let result = provider.verify_pkcs1v15_sha256(&public_key, b"modified", &signature);
296
297        assert!(result.is_err());
298    }
299
300    #[test]
301    fn pkcs1v15_sha256_rejects_modified_signature() {
302        let (private_key, public_key) = rsa_key_pair();
303
304        let provider = RustCryptoProvider::new();
305
306        let message = b"TR-34 test message";
307
308        let mut signature = provider
309            .sign_pkcs1v15_sha256(&private_key, message)
310            .unwrap();
311
312        signature[0] ^= 0x01;
313
314        let result = provider.verify_pkcs1v15_sha256(&public_key, message, &signature);
315
316        assert!(result.is_err());
317    }
318
319    #[test]
320    fn oaep_sha256_rejects_oversized_plaintext() {
321        let (_private_key, public_key) = rsa_key_pair();
322
323        let mut provider = RustCryptoProvider::new();
324
325        // RSA-2048 + SHA-256 OAEP supports at most:
326        //
327        // 256 - 2 * 32 - 2 = 190 bytes.
328        let plaintext = vec![0u8; 191];
329
330        let result = provider.encrypt_oaep_sha256(&public_key, &plaintext);
331
332        assert!(result.is_err());
333    }
334}