feat(keys): add ed25519legacy compatibility

* Adds support for the legacy non-standard Ed25519 variant to keep
  pre-2024 keys usable while steering new keys toward standard Ed25519
* Prevents selecting the legacy variant for subkeys under v6 primary
  keys to avoid interoperability issues
* Extends algorithm detection and key-length extraction to recognize the
  legacy variant consistently across layers

Co-authored-by: Copilot <copilot@github.com>

Author: saturneric

rust/src/types.rs

@@ -109,8 +109,14 @@ pub enum GfrKeyAlgo {
     DSA1024,
     DSA2048,
     DSA3072,
-    KYBER768X25519, // Encryption-only KEM using X25519, with 768-bit security level
-    KYBER1024X448,  // Encryption-only KEM using X448, with 1024-bit security level
+    // The original non-standard "ED25519-LEGACY" used in early versions of
+    // GpgFrontend (pre-2024), which is actually a non-compliant variant of
+    // Ed25519. Only kept for backward compatibility with keys generated by
+    // those old versions. New keys should use the standard ED25519.
+    ED25519LEGACY,
+    // Post-quantum algorithms (non-standard, for experimental use only)
+    KYBER768X25519,
+    KYBER1024X448,
 }
 
 #[repr(C)]

rust/src/utils.rs

@@ -242,6 +242,8 @@ pub fn resolve_key_type(algo: &GfrKeyAlgo, can_encrypt: bool) -> Result<KeyType,
         GfrKeyAlgo::DSA2048 => Ok(KeyType::Dsa(DsaKeySize::B2048)),
         GfrKeyAlgo::DSA3072 => Ok(KeyType::Dsa(DsaKeySize::B3072)),
 
+        GfrKeyAlgo::ED25519LEGACY => Ok(KeyType::Ed25519Legacy),
+
         GfrKeyAlgo::KYBER768X25519 => Ok(KeyType::MlKem768X25519),
         GfrKeyAlgo::KYBER1024X448 => Ok(KeyType::MlKem1024X448),
 
@@ -291,12 +293,34 @@ pub fn determine_algo(public_params: &PublicParams) -> GfrKeyAlgo {
             ECCCurve::Secp256k1 => GfrKeyAlgo::SECP256K1,
             _ => GfrKeyAlgo::Unknown,
         },
+        PublicParams::EdDSALegacy(_) => GfrKeyAlgo::ED25519LEGACY,
         PublicParams::MlKem768X25519(_) => GfrKeyAlgo::KYBER768X25519,
         PublicParams::MlKem1024X448(_) => GfrKeyAlgo::KYBER1024X448,
         _ => GfrKeyAlgo::Unknown, // Fallback
     }
 }
 
+pub fn extract_key_length(public_params: &PublicParams) -> Option<u32> {
+    match public_params {
+        PublicParams::RSA(p) => Some(p.key.n().bits() as u32),
+        PublicParams::DSA(p) => Some(p.key.components().p().bits() as u32),
+
+        PublicParams::Ed25519(_) => Some(255),
+        PublicParams::Ed448(_) => Some(448),
+        PublicParams::X448(_) => Some(448),
+
+        PublicParams::ECDH(p) => Some(p.curve().nbits() as u32),
+        PublicParams::ECDSA(p) => Some(p.curve().nbits() as u32),
+
+        PublicParams::EdDSALegacy(_) => Some(255),
+
+        PublicParams::MlKem768X25519(_) => Some(768),
+        PublicParams::MlKem1024X448(_) => Some(1024),
+
+        _ => None,
+    }
+}
+
 pub fn check_if_quantum_hybrid_algo(algo: &GfrKeyAlgo) -> bool {
     matches!(algo, GfrKeyAlgo::KYBER768X25519 | GfrKeyAlgo::KYBER1024X448)
 }
@@ -320,26 +344,6 @@ pub fn check_if_should_use_key_ver_v6(
     false
 }
 
-pub fn extract_key_length(public_params: &PublicParams) -> Option<u32> {
-    match public_params {
-        PublicParams::RSA(p) => Some(p.key.n().bits() as u32),
-        PublicParams::DSA(p) => Some(p.key.components().p().bits() as u32),
-
-        PublicParams::Ed25519(_) => Some(255),
-        PublicParams::Ed448(_) => Some(448),
-        PublicParams::X448(_) => Some(448),
-
-        PublicParams::ECDH(p) => Some(p.curve().nbits() as u32),
-
-        PublicParams::ECDSA(p) => Some(p.curve().nbits() as u32),
-
-        PublicParams::MlKem768X25519(_) => Some(768),
-        PublicParams::MlKem1024X448(_) => Some(1024),
-
-        _ => None,
-    }
-}
-
 pub fn is_self_signature_from_primary(sig: &Signature, primary_fpr_bytes: &[u8]) -> bool {
     sig.issuer_fingerprint()
         .iter()

src/core/function/rpgp/KeyGenerate.cpp

@@ -230,9 +230,12 @@ auto FilterKeyAlgoByKeyRpgpImpl(OpenPGPContext& ctx, const GpgKey& key,
     }
 
     if (key_ver == 6) {
-      // For primary keys of version 4, any subkey algorithm is allowed.
+      // ED25519-LEGACY is not allowed for subkeys of v6 primary keys, because
+      // it is a non-standard variant of Ed25519 and may cause compatibility
+      // issues. It is only kept for backward compatibility with old keys, but
+      // should not be used for new key generation.
+      if (algo_id == "ed25519legacy") continue;
       filtered_algos.append(algo);
-      continue;
     }
 
     if (algo_id == "ky768" || algo_id == "kyber768" || algo_id == "ky024" ||
@@ -241,6 +244,8 @@ auto FilterKeyAlgoByKeyRpgpImpl(OpenPGPContext& ctx, const GpgKey& key,
       continue;
     }
 
+    // For other algorithms, there is no specific limitation based on primary
+    // key version
     filtered_algos.append(algo);
   }
 

src/core/utils/RustUtils.cpp

@@ -65,6 +65,7 @@ auto KeyAlgoId2GfrKeyAlgo(const QString& algo_id) -> Rust::GfrKeyAlgo {
   if (algo_id == "dsa2048") return Rust::GfrKeyAlgo::DSA2048;
   if (algo_id == "dsa3072") return Rust::GfrKeyAlgo::DSA3072;
   if (algo_id == "dsa") return Rust::GfrKeyAlgo::DSA2048;
+  if (algo_id == "ed25519legacy") return Rust::GfrKeyAlgo::ED25519LEGACY;
   if (algo_id == "kyber768_cv25519") return Rust::GfrKeyAlgo::KYBER768X25519;
   if (algo_id == "kyber1024_x448") return Rust::GfrKeyAlgo::KYBER1024X448;
   if (algo_id == "ky768_cv25519") return Rust::GfrKeyAlgo::KYBER768X25519;
@@ -110,6 +111,8 @@ auto GF_CORE_EXPORT GfrKeyAlgo2KeyAlgoName(Rust::GfrKeyAlgo algo) -> QString {
       return "DSA 2048";
     case Rust::GfrKeyAlgo::DSA3072:
       return "DSA 3072";
+    case Rust::GfrKeyAlgo::ED25519LEGACY:
+      return "ED25519";
     case Rust::GfrKeyAlgo::KYBER768X25519:
       return "Kyber768_X25519";
     case Rust::GfrKeyAlgo::KYBER1024X448: