api!: remove key_gen_type config

This removes the ability to generate RSA keys.

src/config.rs

@@ -193,10 +193,6 @@ pub enum Config {
     #[strum(props(default = "1"))]
     FetchedExistingMsgs,
 
-    /// Type of the OpenPGP key to generate.
-    #[strum(props(default = "0"))]
-    KeyGenType,
-
     /// Timer in seconds after which the message is deleted from the
     /// server.
     ///

src/constants.rs

@@ -58,25 +58,6 @@ pub enum MediaQuality {
     Worse = 1,
 }
 
-/// Type of the key to generate.
-#[derive(
-    Debug, Default, Display, Clone, Copy, PartialEq, Eq, FromPrimitive, ToPrimitive, FromSql, ToSql,
-)]
-#[repr(u8)]
-pub enum KeyGenType {
-    #[default]
-    Default = 0,
-
-    /// 2048-bit RSA.
-    Rsa2048 = 1,
-
-    /// [Ed25519](https://ed25519.cr.yp.to/) signature and X25519 encryption.
-    Ed25519 = 2,
-
-    /// 4096-bit RSA.
-    Rsa4096 = 3,
-}
-
 /// Video chat URL type.
 #[derive(
     Debug, Default, Display, Clone, Copy, PartialEq, Eq, FromPrimitive, ToPrimitive, FromSql, ToSql,
@@ -255,16 +236,6 @@ mod tests {
         assert_eq!(Chattype::Broadcast, Chattype::from_i32(160).unwrap());
     }
 
-    #[test]
-    fn test_keygentype_values() {
-        // values may be written to disk and must not change
-        assert_eq!(KeyGenType::Default, KeyGenType::default());
-        assert_eq!(KeyGenType::Default, KeyGenType::from_i32(0).unwrap());
-        assert_eq!(KeyGenType::Rsa2048, KeyGenType::from_i32(1).unwrap());
-        assert_eq!(KeyGenType::Ed25519, KeyGenType::from_i32(2).unwrap());
-        assert_eq!(KeyGenType::Rsa4096, KeyGenType::from_i32(3).unwrap());
-    }
-
     #[test]
     fn test_showemails_values() {
         // values may be written to disk and must not change

src/context.rs

@@ -938,10 +938,6 @@ impl Context {
         res.insert("configured_trash_folder", configured_trash_folder);
         res.insert("mdns_enabled", mdns_enabled.to_string());
         res.insert("e2ee_enabled", e2ee_enabled.to_string());
-        res.insert(
-            "key_gen_type",
-            self.get_config_int(Config::KeyGenType).await?.to_string(),
-        );
         res.insert("bcc_self", bcc_self.to_string());
         res.insert("sync_msgs", sync_msgs.to_string());
         res.insert("disable_idle", disable_idle.to_string());

src/key.rs

@@ -7,7 +7,6 @@ use std::io::Cursor;
 use anyhow::{bail, ensure, Context as _, Result};
 use base64::Engine as _;
 use deltachat_contact_tools::EmailAddress;
-use num_traits::FromPrimitive;
 use pgp::composed::Deserializable;
 pub use pgp::composed::{SignedPublicKey, SignedSecretKey};
 use pgp::ser::Serialize;
@@ -15,8 +14,6 @@ use pgp::types::{PublicKeyTrait, SecretKeyTrait};
 use rand::thread_rng;
 use tokio::runtime::Handle;
 
-use crate::config::Config;
-use crate::constants::KeyGenType;
 use crate::context::Context;
 use crate::log::LogExt;
 use crate::pgp::KeyPair;
@@ -282,11 +279,9 @@ async fn generate_keypair(context: &Context) -> Result<KeyPair> {
         Some(key_pair) => Ok(key_pair),
         None => {
             let start = tools::Time::now();
-            let keytype = KeyGenType::from_i32(context.get_config_int(Config::KeyGenType).await?)
-                .unwrap_or_default();
-            info!(context, "Generating keypair with type {}", keytype);
+            info!(context, "Generating keypair.");
             let keypair = Handle::current()
-                .spawn_blocking(move || crate::pgp::create_keypair(addr, keytype))
+                .spawn_blocking(move || crate::pgp::create_keypair(addr))
                 .await??;
 
             store_self_keypair(context, &keypair).await?;
@@ -466,6 +461,7 @@ mod tests {
     use once_cell::sync::Lazy;
 
     use super::*;
+    use crate::config::Config;
     use crate::test_utils::{alice_keypair, TestContext};
 
     static KEYPAIR: Lazy<KeyPair> = Lazy::new(alice_keypair);

src/pgp.rs

@@ -18,7 +18,6 @@ use pgp::types::{CompressionAlgorithm, PublicKeyTrait, SignatureBytes, StringToK
 use rand::{thread_rng, CryptoRng, Rng};
 use tokio::runtime::Handle;
 
-use crate::constants::KeyGenType;
 use crate::key::{DcKey, Fingerprint};
 
 #[cfg(test)]
@@ -181,15 +180,9 @@ impl KeyPair {
 ///
 /// Both secret and public key consist of signing primary key and encryption subkey
 /// as [described in the Autocrypt standard](https://autocrypt.org/level1.html#openpgp-based-key-data).
-pub(crate) fn create_keypair(addr: EmailAddress, keygen_type: KeyGenType) -> Result<KeyPair> {
-    let (signing_key_type, encryption_key_type) = match keygen_type {
-        KeyGenType::Rsa2048 => (PgpKeyType::Rsa(2048), PgpKeyType::Rsa(2048)),
-        KeyGenType::Rsa4096 => (PgpKeyType::Rsa(4096), PgpKeyType::Rsa(4096)),
-        KeyGenType::Ed25519 | KeyGenType::Default => (
-            PgpKeyType::EdDSALegacy,
-            PgpKeyType::ECDH(ECCCurve::Curve25519),
-        ),
-    };
+pub(crate) fn create_keypair(addr: EmailAddress) -> Result<KeyPair> {
+    let signing_key_type = PgpKeyType::EdDSALegacy;
+    let encryption_key_type = PgpKeyType::ECDH(ECCCurve::Curve25519);
 
     let user_id = format!("<{addr}>");
     let key_params = SecretKeyParamsBuilder::default()
@@ -478,16 +471,8 @@ mod tests {
 
     #[test]
     fn test_create_keypair() {
-        let keypair0 = create_keypair(
-            EmailAddress::new("foo@bar.de").unwrap(),
-            KeyGenType::Default,
-        )
-        .unwrap();
-        let keypair1 = create_keypair(
-            EmailAddress::new("two@zwo.de").unwrap(),
-            KeyGenType::Default,
-        )
-        .unwrap();
+        let keypair0 = create_keypair(EmailAddress::new("foo@bar.de").unwrap()).unwrap();
+        let keypair1 = create_keypair(EmailAddress::new("two@zwo.de").unwrap()).unwrap();
         assert_ne!(keypair0.public, keypair1.public);
     }