From 69f89733392a5278e262f897ec48c3346902aeb6 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 10 Sep 2019 16:23:38 +0300 Subject: [PATCH 1/4] test_encryption_decryption: use safe from_slice instead of from_binary --- tests/stress.rs | 23 ++++++++--------------- 1 file changed, 8 insertions(+), 15 deletions(-) diff --git a/tests/stress.rs b/tests/stress.rs index bf60a1961..e7a4ac460 100644 --- a/tests/stress.rs +++ b/tests/stress.rs @@ -461,28 +461,22 @@ unsafe fn stress_functions(context: &Context) { #[test] #[ignore] // is too expensive fn test_encryption_decryption() { - unsafe { - 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; + let mut bad_data: [u8; 4096] = [0; 4096]; - while j < 4096 / 40 { - let bad_key = Key::from_binary( - &mut *bad_data.as_mut_ptr().offset(j as isize) as *const u8, - 4096 / 2 + j, + 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()); - j += 1 } let (public_key, private_key) = dc_pgp_create_keypair("foo@bar.de").unwrap(); @@ -590,7 +584,6 @@ fn test_encryption_decryption() { dc_pgp_pk_decrypt(ctext_signed.as_bytes(), &keyring, &public_keyring, None).unwrap(); assert_eq!(plain, original_text); - } } unsafe extern "C" fn cb( From 971960a2421b1a4e7cb0c1e443bbbf7b89fdc470 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 10 Sep 2019 16:23:56 +0300 Subject: [PATCH 2/4] key.rs: remove unsafe Key.from_binary --- src/key.rs | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/src/key.rs b/src/key.rs index bb7ac3115..434a3b039 100644 --- a/src/key.rs +++ b/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 { - 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, From 22c1ee1f552a86d7fed91e99f00ee04132dbc710 Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Tue, 10 Sep 2019 16:29:41 +0300 Subject: [PATCH 3/4] cargo fmt --- tests/stress.rs | 188 ++++++++++++++++++++++++------------------------ 1 file changed, 94 insertions(+), 94 deletions(-) diff --git a/tests/stress.rs b/tests/stress.rs index e7a4ac460..d993c1334 100644 --- a/tests/stress.rs +++ b/tests/stress.rs @@ -461,129 +461,129 @@ unsafe fn stress_functions(context: &Context) { #[test] #[ignore] // is too expensive fn test_encryption_decryption() { - let mut bad_data: [u8; 4096] = [0; 4096]; + let mut bad_data: [u8; 4096] = [0; 4096]; - for i in 0..4096 { - bad_data[i] = (i & 0xff) as u8; - } + 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()); - } + 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()); + } - let (public_key, private_key) = dc_pgp_create_keypair("foo@bar.de").unwrap(); + let (public_key, private_key) = dc_pgp_create_keypair("foo@bar.de").unwrap(); - private_key.split_key().unwrap(); + private_key.split_key().unwrap(); - let (public_key2, private_key2) = dc_pgp_create_keypair("two@zwo.de").unwrap(); + let (public_key2, private_key2) = dc_pgp_create_keypair("two@zwo.de").unwrap(); - assert_ne!(public_key, public_key2); + assert_ne!(public_key, public_key2); - 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 original_text = b"This is a test"; + let mut keyring = Keyring::default(); + 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(); - assert!(!ctext_signed.is_empty()); - assert!(ctext_signed.starts_with("-----BEGIN PGP MESSAGE-----")); + 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-----")); - 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 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 mut keyring = Keyring::default(); - keyring.add_owned(private_key); + let mut keyring = Keyring::default(); + keyring.add_owned(private_key); - let mut public_keyring = Keyring::default(); - public_keyring.add_ref(&public_key); + let mut public_keyring = Keyring::default(); + public_keyring.add_ref(&public_key); - let mut public_keyring2 = Keyring::default(); - public_keyring2.add_owned(public_key2.clone()); + let mut public_keyring2 = Keyring::default(); + public_keyring2.add_owned(public_key2.clone()); - let mut valid_signatures: HashSet = Default::default(); + let mut valid_signatures: HashSet = Default::default(); - let plain = dc_pgp_pk_decrypt( - ctext_signed.as_bytes(), - &keyring, - &public_keyring, - Some(&mut valid_signatures), - ) - .unwrap(); + let plain = dc_pgp_pk_decrypt( + ctext_signed.as_bytes(), + &keyring, + &public_keyring, + Some(&mut valid_signatures), + ) + .unwrap(); - assert_eq!(plain, original_text,); - assert_eq!(valid_signatures.len(), 1); + assert_eq!(plain, original_text,); + assert_eq!(valid_signatures.len(), 1); - valid_signatures.clear(); + valid_signatures.clear(); - let empty_keyring = Keyring::default(); - 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); + let empty_keyring = Keyring::default(); + 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(); + 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 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); - valid_signatures.clear(); + valid_signatures.clear(); - public_keyring2.add_ref(&public_key); + public_keyring2.add_ref(&public_key); - 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(), 1); + 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(), 1); - valid_signatures.clear(); + valid_signatures.clear(); - let plain = dc_pgp_pk_decrypt( - ctext_unsigned.as_bytes(), - &keyring, - &public_keyring, - Some(&mut valid_signatures), - ) - .unwrap(); + let plain = dc_pgp_pk_decrypt( + ctext_unsigned.as_bytes(), + &keyring, + &public_keyring, + Some(&mut valid_signatures), + ) + .unwrap(); - assert_eq!(plain, original_text); + assert_eq!(plain, original_text); - valid_signatures.clear(); + valid_signatures.clear(); - let mut keyring = Keyring::default(); - keyring.add_ref(&private_key2); - let mut public_keyring = Keyring::default(); - public_keyring.add_ref(&public_key); + 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(); + let plain = + dc_pgp_pk_decrypt(ctext_signed.as_bytes(), &keyring, &public_keyring, None).unwrap(); - assert_eq!(plain, original_text); + assert_eq!(plain, original_text); } unsafe extern "C" fn cb( From 706a97b0138101b6311bd8f484eee519b0efc46e Mon Sep 17 00:00:00 2001 From: Alexander Krotov Date: Wed, 11 Sep 2019 00:40:40 +0300 Subject: [PATCH 4/4] Move part of test_encryption_decryption to key.rs --- src/key.rs | 21 +++++++++++++++++++++ tests/stress.rs | 19 ------------------- 2 files changed, 21 insertions(+), 19 deletions(-) diff --git a/src/key.rs b/src/key.rs index 434a3b039..2c5d6566e 100644 --- a/src/key.rs +++ b/src/key.rs @@ -439,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() { diff --git a/tests/stress.rs b/tests/stress.rs index d993c1334..1202392ab 100644 --- a/tests/stress.rs +++ b/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,24 +460,6 @@ unsafe fn stress_functions(context: &Context) { #[test] #[ignore] // is too expensive fn test_encryption_decryption() { - 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()); - } - let (public_key, private_key) = dc_pgp_create_keypair("foo@bar.de").unwrap(); private_key.split_key().unwrap();