Merge pull request #484 from link2xt/safe_test_encryption_decryption

Safe test encryption decryption

src/key.rs

@@ -1,7 +1,6 @@
 use std::collections::BTreeMap;
 use std::ffi::{CStr, CString};
 use std::io::Cursor;
-use std::slice;
 
 use libc;
 use pgp::composed::{Deserializable, SignedPublicKey, SignedSecretKey};
@@ -106,15 +105,6 @@ impl Key {
         }
     }
 
-    pub fn from_binary(data: *const u8, len: libc::c_int, key_type: KeyType) -> Option<Self> {
-        if data.is_null() || len == 0 {
-            return None;
-        }
-
-        let bytes = unsafe { slice::from_raw_parts(data, len as usize) };
-        Self::from_slice(bytes, key_type)
-    }
-
     pub fn from_armored_string(
         data: &str,
         key_type: KeyType,
@@ -449,6 +439,27 @@ i8pcjGO+IZffvyZJVRWfVooBJmWWbPB1pueo3tx8w3+fcuzpxz+RLFKaPyqXO+dD
         assert_eq!(private_key, private_key2);
     }
 
+    #[test]
+    fn test_from_slice_bad_data() {
+        let mut bad_data: [u8; 4096] = [0; 4096];
+
+        for i in 0..4096 {
+            bad_data[i] = (i & 0xff) as u8;
+        }
+
+        for j in 0..(4096 / 40) {
+            let bad_key = Key::from_slice(
+                &bad_data[j..j + 4096 / 2 + j],
+                if 0 != j & 1 {
+                    KeyType::Public
+                } else {
+                    KeyType::Private
+                },
+            );
+            assert!(bad_key.is_none());
+        }
+    }
+
     #[test]
     #[ignore] // is too expensive
     fn test_ascii_roundtrip() {

tests/stress.rs

@@ -12,7 +12,6 @@ use deltachat::contact::*;
 use deltachat::context::*;
 use deltachat::dc_imex::*;
 use deltachat::dc_tools::*;
-use deltachat::key::*;
 use deltachat::keyring::*;
 use deltachat::oauth2::*;
 use deltachat::pgp::*;
@@ -461,136 +460,111 @@ unsafe fn stress_functions(context: &Context) {
 #[test]
 #[ignore] // is too expensive
 fn test_encryption_decryption() {
-    unsafe {
+    let (public_key, private_key) = dc_pgp_create_keypair("foo@bar.de").unwrap();
-        let mut bad_data: [libc::c_uchar; 4096] = [0; 4096];
-        let mut i_0: libc::c_int = 0i32;
-        while i_0 < 4096i32 {
-            bad_data[i_0 as usize] = (i_0 & 0xffi32) as libc::c_uchar;
-            i_0 += 1
-        }
-        let mut j: libc::c_int = 0i32;
 
-        while j < 4096 / 40 {
+    private_key.split_key().unwrap();
-            let bad_key = Key::from_binary(
-                &mut *bad_data.as_mut_ptr().offset(j as isize) as *const u8,
-                4096 / 2 + j,
-                if 0 != j & 1 {
-                    KeyType::Public
-                } else {
-                    KeyType::Private
-                },
-            );
 
-            assert!(bad_key.is_none());
+    let (public_key2, private_key2) = dc_pgp_create_keypair("two@zwo.de").unwrap();
-            j += 1
-        }
 
-        let (public_key, private_key) = dc_pgp_create_keypair("foo@bar.de").unwrap();
+    assert_ne!(public_key, public_key2);
 
-        private_key.split_key().unwrap();
+    let original_text = b"This is a test";
+    let mut keyring = Keyring::default();
+    keyring.add_owned(public_key.clone());
+    keyring.add_ref(&public_key2);
 
-        let (public_key2, private_key2) = dc_pgp_create_keypair("two@zwo.de").unwrap();
+    let ctext_signed = dc_pgp_pk_encrypt(original_text, &keyring, Some(&private_key)).unwrap();
+    assert!(!ctext_signed.is_empty());
+    assert!(ctext_signed.starts_with("-----BEGIN PGP MESSAGE-----"));
 
-        assert_ne!(public_key, public_key2);
+    let ctext_unsigned = dc_pgp_pk_encrypt(original_text, &keyring, None).unwrap();
+    assert!(!ctext_unsigned.is_empty());
+    assert!(ctext_unsigned.starts_with("-----BEGIN PGP MESSAGE-----"));
 
-        let original_text = b"This is a test";
+    let mut keyring = Keyring::default();
-        let mut keyring = Keyring::default();
+    keyring.add_owned(private_key);
-        keyring.add_owned(public_key.clone());
-        keyring.add_ref(&public_key2);
 
-        let ctext_signed = dc_pgp_pk_encrypt(original_text, &keyring, Some(&private_key)).unwrap();
+    let mut public_keyring = Keyring::default();
-        assert!(!ctext_signed.is_empty());
+    public_keyring.add_ref(&public_key);
-        assert!(ctext_signed.starts_with("-----BEGIN PGP MESSAGE-----"));
 
-        let ctext_unsigned = dc_pgp_pk_encrypt(original_text, &keyring, None).unwrap();
+    let mut public_keyring2 = Keyring::default();
-        assert!(!ctext_unsigned.is_empty());
+    public_keyring2.add_owned(public_key2.clone());
-        assert!(ctext_unsigned.starts_with("-----BEGIN PGP MESSAGE-----"));
 
-        let mut keyring = Keyring::default();
+    let mut valid_signatures: HashSet<String> = Default::default();
-        keyring.add_owned(private_key);
 
-        let mut public_keyring = Keyring::default();
+    let plain = dc_pgp_pk_decrypt(
-        public_keyring.add_ref(&public_key);
+        ctext_signed.as_bytes(),
+        &keyring,
+        &public_keyring,
+        Some(&mut valid_signatures),
+    )
+    .unwrap();
 
-        let mut public_keyring2 = Keyring::default();
+    assert_eq!(plain, original_text,);
-        public_keyring2.add_owned(public_key2.clone());
+    assert_eq!(valid_signatures.len(), 1);
 
-        let mut valid_signatures: HashSet<String> = Default::default();
+    valid_signatures.clear();
 
-        let plain = dc_pgp_pk_decrypt(
+    let empty_keyring = Keyring::default();
-            ctext_signed.as_bytes(),
+    let plain = dc_pgp_pk_decrypt(
-            &keyring,
+        ctext_signed.as_bytes(),
-            &public_keyring,
+        &keyring,
-            Some(&mut valid_signatures),
+        &empty_keyring,
-        )
+        Some(&mut valid_signatures),
-        .unwrap();
+    )
+    .unwrap();
+    assert_eq!(plain, original_text);
+    assert_eq!(valid_signatures.len(), 0);
 
-        assert_eq!(plain, original_text,);
+    valid_signatures.clear();
-        assert_eq!(valid_signatures.len(), 1);
 
-        valid_signatures.clear();
+    let plain = dc_pgp_pk_decrypt(
+        ctext_signed.as_bytes(),
+        &keyring,
+        &public_keyring2,
+        Some(&mut valid_signatures),
+    )
+    .unwrap();
+    assert_eq!(plain, original_text);
+    assert_eq!(valid_signatures.len(), 0);
 
-        let empty_keyring = Keyring::default();
+    valid_signatures.clear();
-        let plain = dc_pgp_pk_decrypt(
-            ctext_signed.as_bytes(),
-            &keyring,
-            &empty_keyring,
-            Some(&mut valid_signatures),
-        )
-        .unwrap();
-        assert_eq!(plain, original_text);
-        assert_eq!(valid_signatures.len(), 0);
 
-        valid_signatures.clear();
+    public_keyring2.add_ref(&public_key);
 
-        let plain = dc_pgp_pk_decrypt(
+    let plain = dc_pgp_pk_decrypt(
-            ctext_signed.as_bytes(),
+        ctext_signed.as_bytes(),
-            &keyring,
+        &keyring,
-            &public_keyring2,
+        &public_keyring2,
-            Some(&mut valid_signatures),
+        Some(&mut valid_signatures),
-        )
+    )
-        .unwrap();
+    .unwrap();
-        assert_eq!(plain, original_text);
+    assert_eq!(plain, original_text);
-        assert_eq!(valid_signatures.len(), 0);
+    assert_eq!(valid_signatures.len(), 1);
 
-        valid_signatures.clear();
+    valid_signatures.clear();
 
-        public_keyring2.add_ref(&public_key);
+    let plain = dc_pgp_pk_decrypt(
+        ctext_unsigned.as_bytes(),
+        &keyring,
+        &public_keyring,
+        Some(&mut valid_signatures),
+    )
+    .unwrap();
 
-        let plain = dc_pgp_pk_decrypt(
+    assert_eq!(plain, original_text);
-            ctext_signed.as_bytes(),
-            &keyring,
-            &public_keyring2,
-            Some(&mut valid_signatures),
-        )
-        .unwrap();
-        assert_eq!(plain, original_text);
-        assert_eq!(valid_signatures.len(), 1);
 
-        valid_signatures.clear();
+    valid_signatures.clear();
 
-        let plain = dc_pgp_pk_decrypt(
+    let mut keyring = Keyring::default();
-            ctext_unsigned.as_bytes(),
+    keyring.add_ref(&private_key2);
-            &keyring,
+    let mut public_keyring = Keyring::default();
-            &public_keyring,
+    public_keyring.add_ref(&public_key);
-            Some(&mut valid_signatures),
-        )
-        .unwrap();
 
-        assert_eq!(plain, original_text);
+    let plain =
+        dc_pgp_pk_decrypt(ctext_signed.as_bytes(), &keyring, &public_keyring, None).unwrap();
 
-        valid_signatures.clear();
+    assert_eq!(plain, original_text);
-
-        let mut keyring = Keyring::default();
-        keyring.add_ref(&private_key2);
-        let mut public_keyring = Keyring::default();
-        public_keyring.add_ref(&public_key);
-
-        let plain =
-            dc_pgp_pk_decrypt(ctext_signed.as_bytes(), &keyring, &public_keyring, None).unwrap();
-
-        assert_eq!(plain, original_text);
-    }
 }
 
 unsafe extern "C" fn cb(