add rsa_ext

src/algorithms/pad.rs

@@ -8,7 +8,7 @@ use crate::errors::{Error, Result};
 
 /// Returns a new vector of the given length, with 0s left padded.
 #[inline]
-fn left_pad(input: &[u8], padded_len: usize) -> Result<Vec<u8>> {
+pub(crate) fn left_pad(input: &[u8], padded_len: usize) -> Result<Vec<u8>> {
  if input.len() > padded_len {
  return Err(Error::InvalidPadLen);
  }

src/lib.rs

@@ -228,11 +228,13 @@ pub mod oaep;
 pub mod pkcs1v15;
 pub mod pss;
 pub mod traits;
+pub mod rsa_ext;
 
 mod dummy_rng;
 mod encoding;
 mod key;
 
+
 pub use pkcs1;
 pub use pkcs8;
 #[cfg(feature = "sha2")]

src/rsa_ext.rs

@@ -0,0 +1,112 @@
+//! RSA-ext trait definitions.
+
+use alloc::vec::Vec;
+
+use num_bigint::BigUint;
+use rand_core::{CryptoRng, RngCore};
+
+use zeroize::{Zeroize, Zeroizing};
+
+use crate::algorithms::pad::left_pad;
+use crate::algorithms::rsa::rsa_decrypt;
+use crate::errors::{Error, Result};
+use crate::key;
+
+use crate::traits::PublicKeyParts;
+use crate::{RsaPrivateKey, RsaPublicKey};
+
+/// RsaPrivateKey Ext
+pub trait RsaPrivateKeyExt {
+ /// private_key encrypt
+ fn encrypt_ext<R: RngCore + CryptoRng>(&self, rng: &mut R, msg: &[u8]) -> Result<Vec<u8>>;
+ /// RsaPublicKey decrypt
+ fn pub_decrypt(&self, data: &[u8]) -> Result<Vec<u8>>;
+}
+/// RsaPrivateKey Ext
+pub trait RsaPublicKeyExt {
+ /// RsaPublicKey decrypt
+ fn decrypt_ext(&self, data: &[u8]) -> Result<Vec<u8>>;
+}
+impl RsaPublicKeyExt for RsaPublicKey {
+ fn decrypt_ext(&self, data: &[u8]) -> Result<Vec<u8>> {
+ let e = self.e();
+ let n = self.n();
+
+ let k: usize = self.size();
+ let mut ret = vec![];
+ for v in data.chunks(k) {
+ let m = BigUint::from_bytes_be(v);
+ let m = m.modpow(e, n);
+ let m = Zeroizing::new(m);
+ let m = Zeroizing::new(m.to_bytes_be());
+ let mut out = vec![0u8; k];
+ out[k - m.len()..].copy_from_slice(&m);
+
+ if out[0] != 0 {
+ break;
+ }
+ if out[1] != 0 && out[1] != 1 {
+ break;
+ }
+ let mut i = 2;
+ while i < out.len() {
+ if out[i] == 0 {
+ break;
+ }
+ i += 1;
+ }
+
+ i += 1;
+ if i == out.len() {
+ break;
+ }
+ ret.extend(&out[i..]);
+ }
+ Ok(ret)
+ }
+}
+
+impl RsaPrivateKeyExt for RsaPrivateKey {
+ fn encrypt_ext<R: RngCore + CryptoRng>(&self, rng: &mut R, msg: &[u8]) -> Result<Vec<u8>> {
+ let pub_key: RsaPublicKey = self.into();
+ key::check_public(&pub_key)?;
+ let k = pub_key.size();
+ let max = k - 11;
+ let chunks = msg.chunks(max);
+ let mut ret = vec![];
+ for sub in chunks {
+ let msg = sub;
+ let t_len = msg.len();
+ // EM = 0x00 || 0x02 || PS || 0x00 || M
+ let mut em = Zeroizing::new(vec![0u8; k]);
+ em[1] = 1;
+ for i in 2..(k - t_len - 1) {
+ em[i] = 0xff;
+ }
+ // non_zero_random_bytes(rng, &mut em[2..k - msg.len() - 1]);
+ // em[k - msg.len() - 1] = 0;
+ em[k - msg.len()..].copy_from_slice(msg);
+
+ let mut m = BigUint::from_bytes_be(&em);
+ let mut c = rsa_decrypt(Some(rng), self, &m)?;
+ let mut c_bytes = c.to_bytes_be();
+ let ciphertext = left_pad(&c_bytes, k)?;
+ if k < ciphertext.len() {
+ return Err(Error::Verification);
+ }
+ // clear out tmp values
+ m.zeroize();
+ c.zeroize();
+ c_bytes.zeroize();
+
+ ret.extend(ciphertext);
+ }
+ Ok(ret)
+ }
+
+ /// RsaPublicKey decrypt
+ fn pub_decrypt(&self, data: &[u8]) -> Result<Vec<u8>> {
+ let public_key = self.to_public_key();
+ public_key.decrypt_ext(data)
+ }
+}