Mirrors/chatmail-core
1
0
Fork 0
mirror of https://github.com/chatmail/core.git synced 2026-05-06 16:36:59 +03:00
Code Issues Packages Projects Releases Wiki Activity

unify naming in pgp

Browse Source
This commit is contained in:
dignifiedquire
2019-10-08 22:26:16 +02:00
committed by holger krekel
parent fd69ebfd1f
commit dc2cf8ecfc
5 changed files with 27 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/e2ee.rs
View File

@@ -28,7 +28,7 @@ use crate::key::*;
use crate::keyring::*; use crate::keyring::*;
use crate::mimefactory::MimeFactory; use crate::mimefactory::MimeFactory;
use crate::peerstate::*; use crate::peerstate::*;
use crate::pgp::*; use crate::pgp;
use crate::securejoin::handle_degrade_event; use crate::securejoin::handle_degrade_event;
use crate::wrapmime; use crate::wrapmime;
use crate::wrapmime::*; use crate::wrapmime::*;
@@ -211,7 +211,7 @@ impl EncryptHelper {
"could not write/allocate" "could not write/allocate"
); );
let ctext = dc_pgp_pk_encrypt( let ctext = pgp::pk_encrypt(
std::slice::from_raw_parts((*plain).str_0 as *const u8, (*plain).len), std::slice::from_raw_parts((*plain).str_0 as *const u8, (*plain).len),
&keyring, &keyring,
sign_key.as_ref(), sign_key.as_ref(),
@@ -398,7 +398,7 @@ fn load_or_generate_self_public_key(context: &Context, self_addr: impl AsRef<str
context, context,
"Generating keypair with {} bits, e={} ...", 2048, 65537, "Generating keypair with {} bits, e={} ...", 2048, 65537,
); );
match dc_pgp_create_keypair(&self_addr) { match pgp::create_keypair(&self_addr) {
Some((public_key, private_key)) => { Some((public_key, private_key)) => {
match dc_key_save_self_keypair( match dc_key_save_self_keypair(
context, context,
@@ -581,7 +581,7 @@ fn decrypt_part(
// we should only have one decryption happening // we should only have one decryption happening
ensure!(ret_valid_signatures.is_empty(), "corrupt signatures"); ensure!(ret_valid_signatures.is_empty(), "corrupt signatures");
let plain = match dc_pgp_pk_decrypt( let plain = match pgp::pk_decrypt(
&data, &data,
&private_keyring, &private_keyring,
&public_keyring_for_validate, &public_keyring_for_validate,

9
src/imex.rs
View File

@@ -17,7 +17,7 @@ use crate::job::*;
use crate::key::*; use crate::key::*;
use crate::message::Message; use crate::message::Message;
use crate::param::*; use crate::param::*;
use crate::pgp::*; use crate::pgp;
use crate::sql::{self, Sql}; use crate::sql::{self, Sql};
use crate::stock::StockMessage; use crate::stock::StockMessage;
@@ -169,7 +169,7 @@ pub fn render_setup_file(context: &Context, passphrase: &str) -> Result<String>
true => Some(("Autocrypt-Prefer-Encrypt", "mutual")), true => Some(("Autocrypt-Prefer-Encrypt", "mutual")),
}; };
let private_key_asc = private_key.to_asc(ac_headers); let private_key_asc = private_key.to_asc(ac_headers);
let encr = dc_pgp_symm_encrypt(&passphrase, private_key_asc.as_bytes())?; let encr = pgp::symm_encrypt(&passphrase, private_key_asc.as_bytes())?;
let replacement = format!( let replacement = format!(
concat!( concat!(
@@ -323,7 +323,7 @@ fn decrypt_setup_file<T: std::io::Read + std::io::Seek>(
passphrase: &str, passphrase: &str,
file: T, file: T,
) -> Result<String> { ) -> Result<String> {
let plain_bytes = dc_pgp_symm_decrypt(passphrase, file)?; let plain_bytes = pgp::symm_decrypt(passphrase, file)?;
let plain_text = std::string::String::from_utf8(plain_bytes)?; let plain_text = std::string::String::from_utf8(plain_bytes)?;
Ok(plain_text) Ok(plain_text)
@@ -713,8 +713,9 @@ fn export_key_to_asc_file(
mod tests { mod tests {
use super::*; use super::*;
use crate::pgp::{split_armored_data, HEADER_AUTOCRYPT, HEADER_SETUPCODE};
use crate::test_utils::*; use crate::test_utils::*;
use pgp::armor::BlockType; use ::pgp::armor::BlockType;
#[test] #[test]
fn test_render_setup_file() { fn test_render_setup_file() {

4
src/key.rs
View File

@@ -381,7 +381,7 @@ i8pcjGO+IZffvyZJVRWfVooBJmWWbPB1pueo3tx8w3+fcuzpxz+RLFKaPyqXO+dD
#[test] #[test]
#[ignore] // is too expensive #[ignore] // is too expensive
fn test_from_slice_roundtrip() { fn test_from_slice_roundtrip() {
let (public_key, private_key) = crate::pgp::dc_pgp_create_keypair("hello").unwrap(); let (public_key, private_key) = crate::pgp::create_keypair("hello").unwrap();
let binary = public_key.to_bytes(); let binary = public_key.to_bytes();
let public_key2 = Key::from_slice(&binary, KeyType::Public).expect("invalid public key"); let public_key2 = Key::from_slice(&binary, KeyType::Public).expect("invalid public key");
@@ -416,7 +416,7 @@ i8pcjGO+IZffvyZJVRWfVooBJmWWbPB1pueo3tx8w3+fcuzpxz+RLFKaPyqXO+dD
#[test] #[test]
#[ignore] // is too expensive #[ignore] // is too expensive
fn test_ascii_roundtrip() { fn test_ascii_roundtrip() {
let (public_key, private_key) = crate::pgp::dc_pgp_create_keypair("hello").unwrap(); let (public_key, private_key) = crate::pgp::create_keypair("hello").unwrap();
let s = public_key.to_armored_string(None).unwrap(); let s = public_key.to_armored_string(None).unwrap();
let (public_key2, _) = let (public_key2, _) =

10
src/pgp.rs
View File

@@ -47,7 +47,7 @@ pub fn split_armored_data(
} }
/// Create a new key pair. /// Create a new key pair.
pub fn dc_pgp_create_keypair(addr: impl AsRef<str>) -> Option<(Key, Key)> { pub fn create_keypair(addr: impl AsRef<str>) -> Option<(Key, Key)> {
let user_id = format!("<{}>", addr.as_ref()); let user_id = format!("<{}>", addr.as_ref());
let key_params = SecretKeyParamsBuilder::default() let key_params = SecretKeyParamsBuilder::default()
@@ -97,7 +97,7 @@ pub fn dc_pgp_create_keypair(addr: impl AsRef<str>) -> Option<(Key, Key)> {
Some((Key::Public(public_key), Key::Secret(private_key))) Some((Key::Public(public_key), Key::Secret(private_key)))
} }
pub fn dc_pgp_pk_encrypt( pub fn pk_encrypt(
plain: &[u8], plain: &[u8],
public_keys_for_encryption: &Keyring, public_keys_for_encryption: &Keyring,
private_key_for_signing: Option<&Key>, private_key_for_signing: Option<&Key>,
@@ -134,7 +134,7 @@ pub fn dc_pgp_pk_encrypt(
Ok(encoded_msg) Ok(encoded_msg)
} }
pub fn dc_pgp_pk_decrypt( pub fn pk_decrypt(
ctext: &[u8], ctext: &[u8],
private_keys_for_decryption: &Keyring, private_keys_for_decryption: &Keyring,
public_keys_for_validation: &Keyring, public_keys_for_validation: &Keyring,
@@ -183,7 +183,7 @@ pub fn dc_pgp_pk_decrypt(
} }
/// Symmetric encryption. /// Symmetric encryption.
pub fn dc_pgp_symm_encrypt(passphrase: &str, plain: &[u8]) -> Result<String, Error> { pub fn symm_encrypt(passphrase: &str, plain: &[u8]) -> Result<String, Error> {
let mut rng = thread_rng(); let mut rng = thread_rng();
let lit_msg = Message::new_literal_bytes("", plain); let lit_msg = Message::new_literal_bytes("", plain);
@@ -197,7 +197,7 @@ pub fn dc_pgp_symm_encrypt(passphrase: &str, plain: &[u8]) -> Result<String, Err
} }
/// Symmetric decryption. /// Symmetric decryption.
pub fn dc_pgp_symm_decrypt<T: std::io::Read + std::io::Seek>( pub fn symm_decrypt<T: std::io::Read + std::io::Seek>(
passphrase: &str, passphrase: &str,
ctext: T, ctext: T,
) -> Result<Vec<u8>, Error> { ) -> Result<Vec<u8>, Error> {

23
tests/stress.rs
View File

@@ -8,7 +8,7 @@ use deltachat::contact::*;
use deltachat::context::*; use deltachat::context::*;
use deltachat::keyring::*; use deltachat::keyring::*;
use deltachat::oauth2::*; use deltachat::oauth2::*;
use deltachat::pgp::*; use deltachat::pgp;
use deltachat::Event; use deltachat::Event;
use tempfile::{tempdir, TempDir}; use tempfile::{tempdir, TempDir};
@@ -100,11 +100,11 @@ unsafe fn stress_functions(context: &Context) {
#[test] #[test]
#[ignore] // is too expensive #[ignore] // is too expensive
fn test_encryption_decryption() { fn test_encryption_decryption() {
let (public_key, private_key) = dc_pgp_create_keypair("foo@bar.de").unwrap(); let (public_key, private_key) = 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) = pgp::create_keypair("two@zwo.de").unwrap();
assert_ne!(public_key, public_key2); assert_ne!(public_key, public_key2);
@@ -113,11 +113,11 @@ fn test_encryption_decryption() {
keyring.add_owned(public_key.clone()); keyring.add_owned(public_key.clone());
keyring.add_ref(&public_key2); keyring.add_ref(&public_key2);
let ctext_signed = dc_pgp_pk_encrypt(original_text, &keyring, Some(&private_key)).unwrap(); let ctext_signed = pgp::pk_encrypt(original_text, &keyring, Some(&private_key)).unwrap();
assert!(!ctext_signed.is_empty()); assert!(!ctext_signed.is_empty());
assert!(ctext_signed.starts_with("-----BEGIN PGP MESSAGE-----")); assert!(ctext_signed.starts_with("-----BEGIN PGP MESSAGE-----"));
let ctext_unsigned = dc_pgp_pk_encrypt(original_text, &keyring, None).unwrap(); let ctext_unsigned = pgp::pk_encrypt(original_text, &keyring, None).unwrap();
assert!(!ctext_unsigned.is_empty()); assert!(!ctext_unsigned.is_empty());
assert!(ctext_unsigned.starts_with("-----BEGIN PGP MESSAGE-----")); assert!(ctext_unsigned.starts_with("-----BEGIN PGP MESSAGE-----"));
@@ -132,7 +132,7 @@ fn test_encryption_decryption() {
let mut valid_signatures: HashSet<String> = Default::default(); let mut valid_signatures: HashSet<String> = Default::default();
let plain = dc_pgp_pk_decrypt( let plain = pgp::pk_decrypt(
ctext_signed.as_bytes(), ctext_signed.as_bytes(),
&keyring, &keyring,
&public_keyring, &public_keyring,
@@ -146,7 +146,7 @@ fn test_encryption_decryption() {
valid_signatures.clear(); valid_signatures.clear();
let empty_keyring = Keyring::default(); let empty_keyring = Keyring::default();
let plain = dc_pgp_pk_decrypt( let plain = pgp::pk_decrypt(
ctext_signed.as_bytes(), ctext_signed.as_bytes(),
&keyring, &keyring,
&empty_keyring, &empty_keyring,
@@ -158,7 +158,7 @@ fn test_encryption_decryption() {
valid_signatures.clear(); valid_signatures.clear();
let plain = dc_pgp_pk_decrypt( let plain = pgp::pk_decrypt(
ctext_signed.as_bytes(), ctext_signed.as_bytes(),
&keyring, &keyring,
&public_keyring2, &public_keyring2,
@@ -172,7 +172,7 @@ fn test_encryption_decryption() {
public_keyring2.add_ref(&public_key); public_keyring2.add_ref(&public_key);
let plain = dc_pgp_pk_decrypt( let plain = pgp::pk_decrypt(
ctext_signed.as_bytes(), ctext_signed.as_bytes(),
&keyring, &keyring,
&public_keyring2, &public_keyring2,
@@ -184,7 +184,7 @@ fn test_encryption_decryption() {
valid_signatures.clear(); valid_signatures.clear();
let plain = dc_pgp_pk_decrypt( let plain = pgp::pk_decrypt(
ctext_unsigned.as_bytes(), ctext_unsigned.as_bytes(),
&keyring, &keyring,
&public_keyring, &public_keyring,
@@ -201,8 +201,7 @@ fn test_encryption_decryption() {
let mut public_keyring = Keyring::default(); let mut public_keyring = Keyring::default();
public_keyring.add_ref(&public_key); public_keyring.add_ref(&public_key);
let plain = let plain = pgp::pk_decrypt(ctext_signed.as_bytes(), &keyring, &public_keyring, None).unwrap();
dc_pgp_pk_decrypt(ctext_signed.as_bytes(), &keyring, &public_keyring, None).unwrap();
assert_eq!(plain, original_text); assert_eq!(plain, original_text);
} }