diff --git a/mbedtls/src/alloc.rs b/mbedtls/src/alloc.rs
index 12883277e..bd28023e2 100644
--- a/mbedtls/src/alloc.rs
+++ b/mbedtls/src/alloc.rs
@@ -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>>
 }
-
diff --git a/mbedtls/src/lib.rs b/mbedtls/src/lib.rs
index a98f6f40b..07b18e9d1 100644
--- a/mbedtls/src/lib.rs
+++ b/mbedtls/src/lib.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 {}
+}
diff --git a/mbedtls/src/wrapper_macros.rs b/mbedtls/src/wrapper_macros.rs
index 6c2d20156..8a3d916ff 100644
--- a/mbedtls/src/wrapper_macros.rs
+++ b/mbedtls/src/wrapper_macros.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 {}
diff --git a/mbedtls/src/x509/certificate.rs b/mbedtls/src/x509/certificate.rs
index 56f2c3cb2..6a698e961 100644
--- a/mbedtls/src/x509/certificate.rs
+++ b/mbedtls/src/x509/certificate.rs
@@ -67,6 +67,8 @@ define!(
     impl<'a> UnsafeFrom<ptr> {}
 );
 
+unsafe impl Sync for Certificate {}
+
 fn x509_buf_to_vec(buf: &x509_buf) -> Vec<u8> {
     if buf.p.is_null() || buf.len == 0 {
         return vec![];
@@ -494,10 +496,6 @@ impl<'a> Builder<'a> {
 // x509write_crt_set_subject_key_identifier
 //
 
-unsafe impl Send for MbedtlsBox<Certificate> {}
-
-unsafe impl Sync for MbedtlsBox<Certificate> {}
-
 impl MbedtlsBox<Certificate> {
     fn init() -> Result<Self> {
         unsafe {
@@ -556,10 +554,6 @@ impl<'a> UnsafeFrom<*mut *mut x509_crt> for &'a mut Option<MbedtlsBox<Certificat
     }
 }
 
-unsafe impl Send for MbedtlsList<Certificate> {}
-
-unsafe impl Sync for MbedtlsList<Certificate> {}
-
 impl MbedtlsList<Certificate> {
     pub fn new() -> Self {
         Self { inner: None }
@@ -1439,4 +1433,14 @@ cYp0bH/RcPTC0Z+ZaqSWMtfxRrk63MJQF9EXpDCdvQRcTMD9D85DJrMKn8aumq0M
         let cert : &mut Certificate = unsafe { UnsafeFrom::from(ptr).unwrap() };
         assert_eq!(c1_info, format!("{:?}", cert));
     }
+
+    #[test]
+    fn cert_send_sync() {
+        assert!(crate::tests::TestTrait::<dyn Send, Certificate>::new().impls_trait(), "Certificate should be Send");
+        assert!(crate::tests::TestTrait::<dyn Send, MbedtlsBox<Certificate>>::new().impls_trait(), "MbedtlsBox<Certificate> should be Send");
+        assert!(crate::tests::TestTrait::<dyn Send, MbedtlsList<Certificate>>::new().impls_trait(), "MbedtlsList<Certificate> should be Send");
+        assert!(crate::tests::TestTrait::<dyn Sync, Certificate>::new().impls_trait(), "Certificate should be Sync");
+        assert!(crate::tests::TestTrait::<dyn Sync, MbedtlsBox<Certificate>>::new().impls_trait(), "MbedtlsBox<Certificate> should be Sync");
+        assert!(crate::tests::TestTrait::<dyn Sync, MbedtlsList<Certificate>>::new().impls_trait(), "MbedtlsList<Certificate> should be Sync");
+    }
 }