Try #255:

Author: bors[bot]

Cargo.lock

@@ -27,8 +27,8 @@ byteorder = "1.0.0"
 yasna = { version = "0.2", optional = true, features = ["num-bigint", "bit-vec"] }
 num-bigint = { version = "0.2", optional = true }
 bit-vec = { version = "0.5", optional = true }
-block-modes = { version = "0.3", optional = true }
-rc2 = { version = "0.3", optional = true }
+cbc = { version = "0.1.2", optional = true }
+rc2 = { version = "0.8.1", optional = true }
 cfg-if = "1.0.0"
 
 [target.x86_64-fortanix-unknown-sgx.dependencies]
@@ -67,7 +67,7 @@ time = ["mbedtls-sys-auto/time"]
 padlock = ["mbedtls-sys-auto/padlock"]
 dsa = ["std", "yasna", "num-bigint", "bit-vec"]
 pkcs12 = ["std", "yasna"]
-pkcs12_rc2 = ["pkcs12", "rc2", "block-modes"]
+pkcs12_rc2 = ["pkcs12", "rc2", "cbc"]
 
 [[example]]
 name = "client"

mbedtls/Cargo.toml

@@ -58,8 +58,10 @@ impl<T> Drop for Box<T> {
     }
 }
 
+unsafe impl<T: Send> Send for Box<T> {}
+unsafe impl<T: Sync> Sync for Box<T> {}
+
 #[repr(transparent)]
 pub struct List<T> {
     pub(crate) inner: Option<Box<T>>
 }
-

mbedtls/src/alloc.rs

@@ -158,3 +158,69 @@ cfg_if::cfg_if! {
 pub unsafe fn set_global_debug_threshold(threshold: i32) {
     mbedtls_sys::debug_set_threshold(threshold);
 }
+
+#[cfg(test)]
+mod tests {
+    #[allow(dead_code)]
+    /// Utilities for testing whether types implement certain traits.
+    ///
+    /// For each trait `Trait` that you want to be able to test, you should
+    /// implement:
+    /// ```ignore
+    /// impl<T: “Trait”> Testable<dyn “Trait”> for T {}
+    /// ```
+    ///
+    /// Then, to test whether a type `Type` implements `Trait`, call:
+    /// ```ignore
+    /// TestTrait::<dyn “Trait”, “Type”>::new().impls_trait()
+    /// ```
+    /// This returns a `bool` indicating whether the trait is implemented.
+    // This relies on auto-deref to distinguish between types that do and don't
+    // implement the trait.
+    mod testtrait {
+        use core::marker::PhantomData;
+
+        pub struct NonImplTrait<T> {
+            inner: PhantomData<T>
+        }
+
+        pub struct TestTrait<TraitObj: ?Sized, Type> {
+            non_impl: NonImplTrait<Type>,
+            phantom: PhantomData<*const TraitObj>,
+        }
+
+        pub trait Testable<T: ?Sized> {}
+
+        impl<TraitObj: ?Sized, Type> TestTrait<TraitObj, Type> {
+            pub fn new() -> Self {
+                TestTrait { non_impl: NonImplTrait { inner: PhantomData }, phantom: PhantomData }
+            }
+        }
+
+        impl<TraitObj: ?Sized, Type: Testable<TraitObj>> TestTrait<TraitObj, Type> {
+            pub fn impls_trait(&self) -> bool {
+                true
+            }
+        }
+
+        impl<T> NonImplTrait<T> {
+            pub fn impls_trait(&self) -> bool {
+                false
+            }
+        }
+
+        impl<TraitObj: ?Sized, Type> core::ops::Deref for TestTrait<TraitObj, Type> {
+            type Target = NonImplTrait<Type>;
+
+            fn deref(&self) -> &NonImplTrait<Type> {
+                &self.non_impl
+            }
+        }
+    }
+
+    pub use testtrait::{TestTrait, Testable};
+
+    impl<T: Send> Testable<dyn Send> for T {}
+    impl<T: Sync> Testable<dyn Sync> for T {}
+    impl<T: Send + Sync> Testable<dyn Send + Sync> for T {}
+}

mbedtls/src/lib.rs

@@ -113,7 +113,7 @@ extern "C" fn alloc_custom_pk_ctx() -> *mut c_void {
 }
 
 unsafe extern "C" fn free_custom_pk_ctx(p: *mut c_void) {
-    Box::from_raw(p as *mut CustomPkContext);
+    let _ = Box::from_raw(p as *mut CustomPkContext);
 }
 
 extern "C" fn custom_pk_can_do(_t: u32) -> i32 {

mbedtls/src/pk/mod.rs

@@ -601,17 +601,17 @@ fn decrypt_3des(ciphertext: &[u8], key: &[u8], iv: &[u8]) -> Pkcs12Result<Vec<u8
 
 #[cfg(feature = "pkcs12_rc2")]
 fn decrypt_rc2(ciphertext: &[u8], key: &[u8], iv: &[u8]) -> Pkcs12Result<Vec<u8>> {
-    use block_modes::BlockMode;
+    use rc2::cipher::{block_padding::Pkcs7, BlockDecryptMut, KeyIvInit};
 
     let cipher =
-        block_modes::Cbc::<rc2::Rc2, block_modes::block_padding::Pkcs7>::new_var(&key, &iv)
+        cbc::Decryptor::<rc2::Rc2>::new_from_slices(key, iv)
             .map_err(|e| Pkcs12Error::Custom(format!("{:?}", e)))?;
 
     let mut pt = ciphertext.to_vec();
     let pt = cipher
-        .decrypt(&mut pt)
+        .decrypt_padded_mut::<Pkcs7>(&mut pt)
         .map_err(|e| Pkcs12Error::Custom(format!("{:?}", e)))?;
-    return Ok(pt.to_owned());
+    Ok(pt.to_owned())
 }
 
 #[cfg(not(feature = "pkcs12_rc2"))]

mbedtls/src/pkcs12/mod.rs

@@ -301,69 +301,11 @@ macro_rules! getter {
 
 #[cfg(test)]
 mod tests {
-    #[allow(dead_code)]
-    /// Utilities for testing whether types implement certain traits.
-    ///
-    /// For each trait `Trait` that you want to be able to test, you should
-    /// implement:
-    /// ```ignore
-    /// impl<T: “Trait”> Testable<dyn “Trait”> for T {}
-    /// ```
-    ///
-    /// Then, to test whether a type `Type` implements `Trait`, call:
-    /// ```ignore
-    /// TestTrait::<dyn “Trait”, “Type”>::new().impls_trait()
-    /// ```
-    /// This returns a `bool` indicating whether the trait is implemented. 
-    // This relies on auto-deref to distinguish between types that do and don't
-    // implement the trait.
-    mod testtrait {
-        use core::marker::PhantomData;
-
-        pub struct NonImplTrait<T> {
-            inner: PhantomData<T>
-        }
-
-        pub struct TestTrait<TraitObj: ?Sized, Type> {
-            non_impl: NonImplTrait<Type>,
-            phantom: PhantomData<*const TraitObj>,
-        }
-
-        pub trait Testable<T: ?Sized> {}
-
-        impl<TraitObj: ?Sized, Type> TestTrait<TraitObj, Type> {
-            pub fn new() -> Self {
-                TestTrait { non_impl: NonImplTrait { inner: PhantomData }, phantom: PhantomData }
-            }
-        }
-        
-        impl<TraitObj: ?Sized, Type: Testable<TraitObj>> TestTrait<TraitObj, Type> {
-            pub fn impls_trait(&self) -> bool {
-                true
-            }
-        }
-
-        impl<T> NonImplTrait<T> {
-            pub fn impls_trait(&self) -> bool {
-                false
-            }
-        }
-
-        impl<TraitObj: ?Sized, Type> core::ops::Deref for TestTrait<TraitObj, Type> {
-            type Target = NonImplTrait<Type>;
-            
-            fn deref(&self) -> &NonImplTrait<Type> {
-                &self.non_impl
-            }
-        }
-    }
-    
-    use testtrait::{TestTrait, Testable};
+    use crate::tests::{TestTrait, Testable};
 
     callback!(RustTest: Fn() -> ());
     callback!(NativeTestMut,NativeTest() -> ());
 
-    impl<T: Send + Sync> Testable<dyn Send + Sync> for T {}
     impl<T: RustTest> Testable<dyn RustTest> for T {}
     impl<T: NativeTest> Testable<dyn NativeTest> for T {}
     impl<T: NativeTestMut> Testable<dyn NativeTestMut> for T {}