Refactor keypair handling and expose storing keypairs on ffi

The user-visible change here is that it allows the FFI API to save
keys in the database for a context.  This is primarily intended for
testing purposes as it allows you to get a key without having to
generate it.

Internally the most important change is to start using the
SignedPublicKey and SignedPrivateKey types from rpgp instead of
wrapping them into a single Key object.  This allows APIs to be
specific about which they want instead of having to do runtime checks
like .is_public() or so.  This means some of the functionality of the
Key impl now needs to be a trait.

A thid API change is to introduce the KeyPair struct, which binds
together the email address, public and private key for a keypair.

All these changes result in a bunch of cleanups, though more more
should be done to completely replace the Key type with the
SignedPublicKye/SignedPrivateKey + traits.  But this change is large
enough already.

Testing-wise this adds two new keys which can be loaded from disk and
and avoids a few more key-generating tests.  The encrypt/decrypt tests
are moved from the stress tests into the pgp tests and split up.

deltachat-ffi/deltachat.h

@@ -852,6 +852,27 @@ void            dc_interrupt_smtp_idle       (dc_context_t* context);
 void            dc_maybe_network             (dc_context_t* context);
 
 
+/**
+ * Save a keypair as the default keys for the user.
+ *
+ * This API is only for testing purposes and should not be used as part of a
+ * normal application, use the import-export APIs instead.
+ *
+ * This saves a public/private keypair as the default keypair in the context.
+ * It allows avoiding having to generate a secret key for unittests which need
+ * one.
+ *
+ * @memberof dc_context_t
+ * @param context The context as created by dc_context_new().
+ * @param addr The email address of the user.  This must match the
+ *    configured_addr setting of the context as well as the UID of the key.
+ * @param public_data The public key as base64.
+ * @param secret_data The secret key as base64.
+ * @return 1 on success, 0 on failure.
+ */
+int             _dc_save_self_keypair        (dc_context_t* context, const char *addr, const char *public_data, const char *secret_data);
+
+
 // handle chatlists
 
 #define         DC_GCL_ARCHIVED_ONLY         0x01

deltachat-ffi/src/lib.rs

@@ -28,6 +28,7 @@ use deltachat::chat::ChatId;
 use deltachat::constants::DC_MSG_ID_LAST_SPECIAL;
 use deltachat::contact::Contact;
 use deltachat::context::Context;
+use deltachat::key::DcKey;
 use deltachat::message::MsgId;
 use deltachat::stock::StockMessage;
 use deltachat::*;
@@ -94,6 +95,14 @@ impl ContextWrapper {
         self.translate_cb(Event::Error(msg.to_string()));
     }
 
+    /// Log a warning on the FFI context.
+    ///
+    /// Like [error] but logs as a warning which only goes to the
+    /// logfile rather than being shown directly to the user.
+    unsafe fn warning(&self, msg: &str) {
+        self.translate_cb(Event::Warning(msg.to_string()));
+    }
+
     /// Unlock the context and execute a closure with it.
     ///
     /// This unlocks the context and gets a read lock.  The Rust
@@ -123,6 +132,23 @@ impl ContextWrapper {
         }
     }
 
+    /// Unlock the context and execute a closure with it.
+    ///
+    /// This is like [ContextWrapper::with_inner] but uses
+    /// [failure::Error] as error type.  This allows you to write a
+    /// closure which could produce many errors, use the `?` operator
+    /// to return them and handle them all as the return of this call.
+    fn try_inner<T, F>(&self, ctxfn: F) -> Result<T, failure::Error>
+    where
+        F: FnOnce(&Context) -> Result<T, failure::Error>,
+    {
+        let guard = self.inner.read().unwrap();
+        match guard.as_ref() {
+            Some(ref ctx) => ctxfn(ctx),
+            None => Err(failure::err_msg("context not open")),
+        }
+    }
+
     /// Translates the callback from the rust style to the C-style version.
     unsafe fn translate_cb(&self, event: Event) {
         if let Some(ffi_cb) = self.cb {
@@ -665,6 +691,35 @@ pub unsafe extern "C" fn dc_maybe_network(context: *mut dc_context_t) {
         .unwrap_or(())
 }
 
+#[no_mangle]
+pub unsafe extern "C" fn _dc_save_self_keypair(
+    context: *mut dc_context_t,
+    addr: *const libc::c_char,
+    public_data: *const libc::c_char,
+    secret_data: *const libc::c_char,
+) -> i32 {
+    if context.is_null() {
+        eprintln!("ignoring careless call to dc_save_keypair()");
+        return 0;
+    }
+    let ffi_context = &*context;
+    ffi_context
+        .try_inner(|ctx| {
+            let addr = dc_tools::EmailAddress::new(&to_string_lossy(addr))?;
+            let public = key::SignedPublicKey::from_base64(&to_string_lossy(public_data))?;
+            let secret = key::SignedSecretKey::from_base64(&to_string_lossy(secret_data))?;
+            let keypair = key::KeyPair {
+                addr,
+                public,
+                secret,
+            };
+            key::save_self_keypair(ctx, &keypair, key::KeyPairUse::Default)?;
+            Ok(1)
+        })
+        .log_warn(ffi_context, "Failed to save keypair")
+        .unwrap_or(0)
+}
+
 #[no_mangle]
 pub unsafe extern "C" fn dc_get_chatlist(
     context: *mut dc_context_t,
@@ -3161,6 +3216,18 @@ pub unsafe extern "C" fn dc_str_unref(s: *mut libc::c_char) {
 pub trait ResultExt<T, E> {
     fn unwrap_or_log_default(self, context: &context::Context, message: &str) -> T;
     fn log_err(self, context: &context::Context, message: &str) -> Result<T, E>;
+
+    /// Log a warning to a [ContextWrapper] for an [Err] result.
+    ///
+    /// Does nothing for an [Ok].  This is usually preferable over
+    /// [ResultExt::log_err] because warnings go to the logfile and
+    /// errors are displayed directly to the user.  Usually problems
+    /// on the FFI layer are coding errors and not errors which need
+    /// to be displayed to the user.
+    ///
+    /// You can do this as soon as the wrapper exists, it does not
+    /// have to be open (which is required for teh `warn!()` macro).
+    fn log_warn(self, wrapper: &ContextWrapper, message: &str) -> Result<T, E>;
 }
 
 impl<T: Default, E: std::fmt::Display> ResultExt<T, E> for Result<T, E> {
@@ -3180,6 +3247,15 @@ impl<T: Default, E: std::fmt::Display> ResultExt<T, E> for Result<T, E> {
             err
         })
     }
+
+    fn log_warn(self, wrapper: &ContextWrapper, message: &str) -> Result<T, E> {
+        self.map_err(|err| {
+            unsafe {
+                wrapper.warning(&format!("{}: {}", message, err));
+            }
+            err
+        })
+    }
 }
 
 unsafe fn strdup_opt(s: Option<impl AsRef<str>>) -> *mut libc::c_char {