Merge #125

125: Add support for RSA OAEP encryption/decryption with custom labels r=AdrianCX a=Pagten

This exposes the `mbedtls_rsa_rsaes_oaep_encrypt()` and `mbedtls_rsa_rsaes_oaep_decrypt()` functions in rust-mbedtls.

Co-authored-by: Pieter Agten <[email protected]>

Author: bors[bot]

mbedtls/src/pk/mod.rs

@@ -539,6 +539,42 @@ impl Pk {
         Ok(ret)
     }
 
+    /// Decrypt using a custom label.
+    ///
+    /// This function may only be called on an RSA key with its padding set to RSA_PKCS_V21.
+    pub fn decrypt_with_label<F: Random>(
+        &mut self,
+        cipher: &[u8],
+        plain: &mut [u8],
+        rng: &mut F,
+        label: &[u8],
+    ) -> Result<usize> {
+        if self.pk_type() != Type::Rsa {
+            return Err(Error::PkTypeMismatch);
+        }
+        let ctx = self.inner.pk_ctx as *mut rsa_context;
+        if unsafe { (*ctx).padding != RSA_PKCS_V21 } {
+            return Err(Error::RsaInvalidPadding);
+        }
+
+        let mut ret = 0usize;
+        unsafe {
+            rsa_rsaes_oaep_decrypt(
+                ctx,
+                Some(F::call),
+                rng.data_ptr(),
+                RSA_PRIVATE,
+                label.as_ptr(),
+                label.len(),
+                &mut ret,
+                cipher.as_ptr(),
+                plain.as_mut_ptr(),
+                plain.len(),
+            ).into_result()?;
+        }
+        Ok(ret)
+    }
+
     pub fn encrypt<F: Random>(
         &mut self,
         plain: &[u8],
@@ -562,6 +598,44 @@ impl Pk {
         Ok(ret)
     }
 
+    /// Encrypt using a custom label.
+    ///
+    /// This function may only be called on an RSA key with its padding set to RSA_PKCS_V21.
+    pub fn encrypt_with_label<F: Random>(
+        &mut self,
+        plain: &[u8],
+        cipher: &mut [u8],
+        rng: &mut F,
+        label: &[u8],
+    ) -> Result<usize> {
+        if self.pk_type() != Type::Rsa {
+            return Err(Error::PkTypeMismatch);
+        }
+        let ctx = self.inner.pk_ctx as *mut rsa_context;
+        if unsafe { (*ctx).padding != RSA_PKCS_V21 } {
+            return Err(Error::RsaInvalidPadding);
+        }
+        let olen = self.len() / 8;
+        if cipher.len() < olen {
+            return Err(Error::RsaOutputTooLarge);
+        }
+
+        unsafe {
+            rsa_rsaes_oaep_encrypt(
+                ctx,
+                Some(F::call),
+                rng.data_ptr(),
+                RSA_PUBLIC,
+                label.as_ptr(),
+                label.len(),
+                plain.len(),
+                plain.as_ptr(),
+                cipher.as_mut_ptr()
+            ).into_result()?;
+        }
+        Ok(olen)
+    }
+
     /// Sign the hash `hash` of type `md`, placing the signature in `sig`. `rng` must be a
     /// cryptographically secure RNG.
     ///
@@ -1129,6 +1203,34 @@ iy6KC991zzvaWY/Ys+q/84Afqa+0qJKQnPuy/7F5GkVdQA/lfbhi
         );
     }
 
+    #[test]
+    fn rsa_encrypt_decrypt_with_label() {
+        let mut pk = Pk::from_private_key(TEST_DER, None).unwrap();
+        let mut cipher = [0u8; 2048 / 8];
+        // set raw decryption padding mode
+        pk.set_options(Options::Rsa {
+            padding: RsaPadding::Pkcs1V21 { mgf: MdType::Sha256 }
+        });
+
+        let plain = b"testing123";
+        let cipher_len = pk.encrypt_with_label(plain, &mut cipher,
+                                         &mut crate::test_support::rand::test_rng(),
+                                         b"MY_LABEL").unwrap();
+        assert_eq!(cipher_len, cipher.len());
+
+        let mut plain_decrypted = [0u8; 10];
+        let plain_len = pk.decrypt_with_label(&cipher, &mut plain_decrypted,
+                                              &mut crate::test_support::rand::test_rng(),
+                                              b"MY_LABEL").unwrap();
+        assert_eq!(plain_len, plain.len());
+        assert_eq!(&plain_decrypted, plain);
+
+        assert_eq!(pk.decrypt_with_label(&cipher, &mut plain_decrypted,
+                                              &mut crate::test_support::rand::test_rng(),
+                                              b"WRONG_LABEL").unwrap_err(),
+                   Error::RsaInvalidPadding);
+    }
+
     #[test]
     fn rsa_sign_with_none_padding() {
         let mut pk =