paysec_crypto_rustcrypto/
rsa.rs1use 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 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 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 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 let plaintext = vec![0u8; 191];
329
330 let result = provider.encrypt_oaep_sha256(&public_key, &plaintext);
331
332 assert!(result.is_err());
333 }
334}