chore: rename PublicKeyAlgorithm::EdDSA to EdDSALegacy

hko-s · hko-s · commit d30ce2632f6e · 2024-07-25T15:29:16.000+02:00
diff --git a/benches/benchmarks/key.rs b/benches/benchmarks/key.rs
@@ -37,7 +37,7 @@ fn bench_key(c: &mut Criterion) {
     });
 
     g.bench_function("x25519_parse_armored", |b| {
-        let key = build_key(KeyType::EdDSA, KeyType::ECDH(ECCCurve::Curve25519))
+        let key = build_key(KeyType::EdDSALegacy, KeyType::ECDH(ECCCurve::Curve25519))
             .sign(|| "".into())
             .unwrap();
         let bytes = key.to_armored_bytes(None.into()).unwrap();
@@ -48,14 +48,14 @@ fn bench_key(c: &mut Criterion) {
     g.bench_function("x25519_generate", |b| {
         b.iter(|| {
             black_box(build_key(
-                KeyType::EdDSA,
+                KeyType::EdDSALegacy,
                 KeyType::ECDH(ECCCurve::Curve25519),
             ))
         })
     });
 
     g.bench_function("x25519_self_sign", |b| {
-        let key = build_key(KeyType::EdDSA, KeyType::ECDH(ECCCurve::Curve25519));
+        let key = build_key(KeyType::EdDSALegacy, KeyType::ECDH(ECCCurve::Curve25519));
 
         b.iter(|| black_box(key.clone().sign(|| "".into()).unwrap()))
     });
diff --git a/benches/benchmarks/message.rs b/benches/benchmarks/message.rs
@@ -2,7 +2,6 @@ use std::fs::{self, File};
 use std::io::Read;
 
 use criterion::{black_box, criterion_group, BenchmarkId, Criterion, Throughput};
-
 use pgp::composed::{Deserializable, Message, SignedSecretKey};
 use pgp::crypto::ecc_curve::ECCCurve;
 use pgp::crypto::sym::SymmetricKeyAlgorithm;
@@ -116,7 +115,7 @@ fn bench_message(c: &mut Criterion) {
 
     for (kt1, kt2, sym, asym_name, sym_name) in [
         (
-            KeyType::EdDSA,
+            KeyType::EdDSALegacy,
             KeyType::ECDH(ECCCurve::Curve25519),
             SymmetricKeyAlgorithm::AES128,
             "x25519",
diff --git a/src/composed/key/builder.rs b/src/composed/key/builder.rs
@@ -104,7 +104,7 @@ impl SecretKeyParamsBuilder {
                     return Err("Keys with less than 2048bits are considered insecure".into());
                 }
             }
-            Some(KeyType::EdDSA) => {
+            Some(KeyType::EdDSALegacy) => {
                 if let Some(can_encrypt) = self.can_encrypt {
                     if can_encrypt {
                         return Err("EdDSA can only be used for signing keys".into());
@@ -248,8 +248,8 @@ pub enum KeyType {
     Rsa(u32),
     /// Encrypting with ECDH
     ECDH(ECCCurve),
-    /// Signing with Curve25519
-    EdDSA,
+    /// Signing with Curve25519, legacy format (deprecated in RFC 9580)
+    EdDSALegacy,
     /// Signing with ECDSA
     ECDSA(ECCCurve),
     /// Signing with DSA for the given bitsize.
@@ -283,7 +283,7 @@ impl KeyType {
         match self {
             KeyType::Rsa(_) => PublicKeyAlgorithm::RSA,
             KeyType::ECDH(_) => PublicKeyAlgorithm::ECDH,
-            KeyType::EdDSA => PublicKeyAlgorithm::EdDSA,
+            KeyType::EdDSALegacy => PublicKeyAlgorithm::EdDSALegacy,
             KeyType::ECDSA(_) => PublicKeyAlgorithm::ECDSA,
             KeyType::Dsa(_) => PublicKeyAlgorithm::DSA,
         }
@@ -307,7 +307,7 @@ impl KeyType {
         let (pub_params, plain) = match self {
             KeyType::Rsa(bit_size) => rsa::generate_key(rng, *bit_size as usize)?,
             KeyType::ECDH(curve) => ecdh::generate_key(rng, curve)?,
-            KeyType::EdDSA => eddsa::generate_key(rng),
+            KeyType::EdDSALegacy => eddsa::generate_key(rng),
             KeyType::ECDSA(curve) => ecdsa::generate_key(rng, curve)?,
             KeyType::Dsa(key_size) => dsa::generate_key(rng, (*key_size).into())?,
         };
@@ -330,15 +330,14 @@ impl KeyType {
 mod tests {
     #![allow(clippy::unwrap_used)]
 
-    use super::*;
-
-    use crate::composed::{Deserializable, SignedPublicKey, SignedSecretKey};
-    use crate::types::SecretKeyTrait;
-
     use rand::SeedableRng;
     use rand_chacha::ChaCha8Rng;
     use smallvec::smallvec;
 
+    use super::*;
+    use crate::composed::{Deserializable, SignedPublicKey, SignedSecretKey};
+    use crate::types::SecretKeyTrait;
+
     #[test]
     #[ignore] // slow in debug mode
     fn test_key_gen_rsa_2048() {
@@ -478,7 +477,7 @@ mod tests {
         let _ = pretty_env_logger::try_init();
 
         let key_params = SecretKeyParamsBuilder::default()
-            .key_type(KeyType::EdDSA)
+            .key_type(KeyType::EdDSALegacy)
             .can_certify(true)
             .can_sign(true)
             .primary_user_id("Me-X <me-x25519@mail.com>".into())
diff --git a/src/crypto/ecc_curve.rs b/src/crypto/ecc_curve.rs
@@ -1,7 +1,8 @@
+use const_oid::ObjectIdentifier;
+
 use crate::crypto::hash::HashAlgorithm;
 use crate::crypto::public_key::PublicKeyAlgorithm;
 use crate::crypto::sym::SymmetricKeyAlgorithm;
-use const_oid::ObjectIdentifier;
 
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum ECCCurve {
@@ -102,7 +103,7 @@ impl ECCCurve {
     pub fn pubkey_algo(&self) -> Option<PublicKeyAlgorithm> {
         match self {
             ECCCurve::Curve25519 => Some(PublicKeyAlgorithm::ECDH),
-            ECCCurve::Ed25519 => Some(PublicKeyAlgorithm::EdDSA),
+            ECCCurve::Ed25519 => Some(PublicKeyAlgorithm::EdDSALegacy),
             ECCCurve::P256 => None,
             ECCCurve::P384 => None,
             ECCCurve::P521 => None,
diff --git a/src/crypto/eddsa.rs b/src/crypto/eddsa.rs
@@ -25,7 +25,7 @@ impl Signer for SecretKey {
         digest: &[u8],
         pub_params: &PublicParams,
     ) -> Result<Vec<Vec<u8>>> {
-        let PublicParams::EdDSA { curve, q } = pub_params else {
+        let PublicParams::EdDSALegacy { curve, q } = pub_params else {
             bail!("invalid public params");
         };
         if curve != &ECCCurve::Ed25519 {
@@ -64,11 +64,11 @@ pub fn generate_key<R: Rng + CryptoRng>(mut rng: R) -> (PublicParams, PlainSecre
     bytes.zeroize();
 
     (
-        PublicParams::EdDSA {
+        PublicParams::EdDSALegacy {
             curve: ECCCurve::Ed25519,
             q: q.into(),
         },
-        PlainSecretParams::EdDSA(p),
+        PlainSecretParams::EdDSALegacy(p),
     )
 }
 
diff --git a/src/crypto/public_key.rs b/src/crypto/public_key.rs
@@ -21,8 +21,8 @@ pub enum PublicKeyAlgorithm {
     Elgamal = 20,
     /// Reserved for Diffie-Hellman (X9.42, as defined for IETF-S/MIME)
     DiffieHellman = 21,
-    /// EdDSA (not yet assigned)
-    EdDSA = 22,
+    /// EdDSA legacy format [deprecated in RFC 9580, in favor of Ed25519 (27)]
+    EdDSALegacy = 22,
     /// Private experimental range (from OpenGPG)
     Private100 = 100,
     Private101 = 101,
diff --git a/src/packet/key/public.rs b/src/packet/key/public.rs
@@ -312,7 +312,7 @@ impl PublicKeyTrait for PubKeyInner {
                 ensure_eq!(sig.len(), 1, "invalid signature");
                 crypto::rsa::verify(n.as_bytes(), e.as_bytes(), hash, hashed, sig[0].as_bytes())
             }
-            PublicParams::EdDSA { ref curve, ref q } => {
+            PublicParams::EdDSALegacy { ref curve, ref q } => {
                 crypto::eddsa::verify(curve, q.as_bytes(), hash, hashed, sig)
             }
             PublicParams::ECDSA(ref params) => crypto::ecdsa::verify(params, hash, hashed, sig),
@@ -360,7 +360,7 @@ impl PublicKeyTrait for PubKeyInner {
             PublicParams::RSA { ref n, ref e } => {
                 crypto::rsa::encrypt(rng, n.as_bytes(), e.as_bytes(), plain)
             }
-            PublicParams::EdDSA { .. } => bail!("EdDSA is only used for signing"),
+            PublicParams::EdDSALegacy { .. } => bail!("EdDSA is only used for signing"),
             PublicParams::ECDSA { .. } => bail!("ECDSA is only used for signing"),
             PublicParams::ECDH {
                 ref curve,
diff --git a/src/packet/key/secret.rs b/src/packet/key/secret.rs
@@ -607,7 +607,7 @@ mod tests {
     #[test]
     fn secret_key_protection() {
         const DATA: &[u8] = &[0x23, 0x05];
-        let key_type = crate::KeyType::EdDSA;
+        let key_type = crate::KeyType::EdDSALegacy;
 
         let (public_params, secret_params) = key_type
             .generate_with_rng(
diff --git a/src/packet/public_key_parser.rs b/src/packet/public_key_parser.rs
@@ -35,7 +35,7 @@ fn ecdsa(i: &[u8]) -> IResult<&[u8], PublicParams> {
 }
 
 /// https://tools.ietf.org/html/draft-koch-eddsa-for-openpgp-00#section-4
-fn eddsa(i: &[u8]) -> IResult<&[u8], PublicParams> {
+fn eddsa_legacy(i: &[u8]) -> IResult<&[u8], PublicParams> {
     let (i, curve) = map_opt(
         // a one-octet size of the following field
         length_data(be_u8),
@@ -46,7 +46,7 @@ fn eddsa(i: &[u8]) -> IResult<&[u8], PublicParams> {
     let (i, q) = mpi(i)?;
     Ok((
         i,
-        PublicParams::EdDSA {
+        PublicParams::EdDSALegacy {
             curve,
             q: q.to_owned(),
         },
@@ -127,7 +127,7 @@ pub fn parse_pub_fields(typ: PublicKeyAlgorithm) -> impl Fn(&[u8]) -> IResult<&[
         PublicKeyAlgorithm::ECDSA => ecdsa(i),
         PublicKeyAlgorithm::ECDH => ecdh(i),
         PublicKeyAlgorithm::Elgamal | PublicKeyAlgorithm::ElgamalSign => elgamal(i),
-        PublicKeyAlgorithm::EdDSA => eddsa(i),
+        PublicKeyAlgorithm::EdDSALegacy => eddsa_legacy(i),
 
         PublicKeyAlgorithm::DiffieHellman
         | PublicKeyAlgorithm::Private100
diff --git a/src/packet/signature/de.rs b/src/packet/signature/de.rs
@@ -344,18 +344,18 @@ fn actual_signature(typ: &PublicKeyAlgorithm) -> impl Fn(&[u8]) -> IResult<&[u8]
         &PublicKeyAlgorithm::RSA | &PublicKeyAlgorithm::RSASign => {
             map(mpi, |v| vec![v.to_owned()])(i)
         }
-        &PublicKeyAlgorithm::DSA | &PublicKeyAlgorithm::ECDSA | &PublicKeyAlgorithm::EdDSA => {
-            fold_many_m_n(
-                2,
-                2,
-                mpi,
-                Vec::new,
-                |mut acc: Vec<Mpi>, item: MpiRef<'_>| {
-                    acc.push(item.to_owned());
-                    acc
-                },
-            )(i)
-        }
+        &PublicKeyAlgorithm::DSA
+        | &PublicKeyAlgorithm::ECDSA
+        | &PublicKeyAlgorithm::EdDSALegacy => fold_many_m_n(
+            2,
+            2,
+            mpi,
+            Vec::new,
+            |mut acc: Vec<Mpi>, item: MpiRef<'_>| {
+                acc.push(item.to_owned());
+                acc
+            },
+        )(i),
         &PublicKeyAlgorithm::Private100
         | &PublicKeyAlgorithm::Private101
         | &PublicKeyAlgorithm::Private102
diff --git a/src/packet/user_id.rs b/src/packet/user_id.rs
@@ -107,14 +107,15 @@ impl PacketTrait for UserId {
 mod tests {
     #![allow(clippy::unwrap_used)]
 
+    use rand::thread_rng;
+
     use super::*;
     use crate::types::{KeyVersion, S2kParams};
     use crate::{packet, KeyType};
-    use rand::thread_rng;
 
     #[test]
     fn test_user_id_certification() {
-        let key_type = KeyType::EdDSA;
+        let key_type = KeyType::EdDSALegacy;
 
         let (public_params, secret_params) = key_type
             .generate_with_rng(thread_rng(), None, S2kParams::Unprotected)
diff --git a/src/types/params/plain_secret.rs b/src/types/params/plain_secret.rs
@@ -31,7 +31,7 @@ pub enum PlainSecretParams {
     ECDSA(#[debug("..")] Mpi),
     ECDH(#[debug("..")] Mpi),
     Elgamal(#[debug("..")] Mpi),
-    EdDSA(#[debug("..")] Mpi),
+    EdDSALegacy(#[debug("..")] Mpi),
 }
 
 #[derive(Clone, PartialEq, Eq, derive_more::Debug)]
@@ -50,7 +50,7 @@ pub enum PlainSecretParamsRef<'a> {
     ECDSA(#[debug("..")] MpiRef<'a>),
     ECDH(#[debug("..")] MpiRef<'a>),
     Elgamal(#[debug("..")] MpiRef<'a>),
-    EdDSA(#[debug("..")] MpiRef<'a>),
+    EdDSALegacy(#[debug("..")] MpiRef<'a>),
 }
 
 impl<'a> PlainSecretParamsRef<'a> {
@@ -66,7 +66,7 @@ impl<'a> PlainSecretParamsRef<'a> {
             PlainSecretParamsRef::ECDSA(v) => PlainSecretParams::ECDSA((*v).to_owned()),
             PlainSecretParamsRef::ECDH(v) => PlainSecretParams::ECDH((*v).to_owned()),
             PlainSecretParamsRef::Elgamal(v) => PlainSecretParams::Elgamal((*v).to_owned()),
-            PlainSecretParamsRef::EdDSA(v) => PlainSecretParams::EdDSA((*v).to_owned()),
+            PlainSecretParamsRef::EdDSALegacy(v) => PlainSecretParams::EdDSALegacy((*v).to_owned()),
         }
     }
 
@@ -94,7 +94,7 @@ impl<'a> PlainSecretParamsRef<'a> {
             PlainSecretParamsRef::Elgamal(d) => {
                 (*d).to_writer(writer)?;
             }
-            PlainSecretParamsRef::EdDSA(x) => {
+            PlainSecretParamsRef::EdDSALegacy(x) => {
                 (*x).to_writer(writer)?;
             }
         }
@@ -204,8 +204,8 @@ impl<'a> PlainSecretParamsRef<'a> {
                 },
                 _ => unreachable!("inconsistent key state"),
             },
-            PlainSecretParamsRef::EdDSA(d) => match public_params {
-                PublicParams::EdDSA { ref curve, .. } => match *curve {
+            PlainSecretParamsRef::EdDSALegacy(d) => match public_params {
+                PublicParams::EdDSALegacy { ref curve, .. } => match *curve {
                     ECCCurve::Ed25519 => {
                         const SIZE: usize = ECCCurve::Ed25519.secret_key_length();
 
@@ -299,7 +299,7 @@ impl PlainSecretParams {
             PlainSecretParams::ECDSA(v) => PlainSecretParamsRef::ECDSA(v.as_ref()),
             PlainSecretParams::ECDH(v) => PlainSecretParamsRef::ECDH(v.as_ref()),
             PlainSecretParams::Elgamal(v) => PlainSecretParamsRef::Elgamal(v.as_ref()),
-            PlainSecretParams::EdDSA(v) => PlainSecretParamsRef::EdDSA(v.as_ref()),
+            PlainSecretParams::EdDSALegacy(v) => PlainSecretParamsRef::EdDSALegacy(v.as_ref()),
         }
     }
 
@@ -369,7 +369,9 @@ fn parse_secret_params(
         PublicKeyAlgorithm::Elgamal => map(mpi, |m| PlainSecretParams::Elgamal(m.to_owned()))(i),
         PublicKeyAlgorithm::ECDH => map(mpi, |m| PlainSecretParams::ECDH(m.to_owned()))(i),
         PublicKeyAlgorithm::ECDSA => map(mpi, |m| PlainSecretParams::ECDSA(m.to_owned()))(i),
-        PublicKeyAlgorithm::EdDSA => map(mpi, |m| PlainSecretParams::EdDSA(m.to_owned()))(i),
+        PublicKeyAlgorithm::EdDSALegacy => {
+            map(mpi, |m| PlainSecretParams::EdDSALegacy(m.to_owned()))(i)
+        }
         _ => Err(nom::Err::Error(crate::errors::Error::ParsingError(
             nom::error::ErrorKind::Switch,
         ))),
diff --git a/src/types/params/public.rs b/src/types/params/public.rs
@@ -32,7 +32,7 @@ pub enum PublicParams {
         g: Mpi,
         y: Mpi,
     },
-    EdDSA {
+    EdDSALegacy {
         curve: ECCCurve,
         q: Mpi,
     },
@@ -220,7 +220,7 @@ impl Serialize for PublicParams {
                 g.to_writer(writer)?;
                 y.to_writer(writer)?;
             }
-            PublicParams::EdDSA { ref curve, ref q } => {
+            PublicParams::EdDSALegacy { ref curve, ref q } => {
                 let oid = curve.oid();
                 writer.write_all(&[oid.len() as u8])?;
                 writer.write_all(&oid)?;
diff --git a/src/types/public_key.rs b/src/types/public_key.rs
@@ -2,13 +2,12 @@ use std::io;
 
 use rand::{CryptoRng, Rng};
 
+use super::{KeyId, KeyVersion, PublicParams};
 use crate::crypto::hash::HashAlgorithm;
 use crate::crypto::public_key::PublicKeyAlgorithm;
 use crate::errors::Result;
 use crate::types::Mpi;
 
-use super::{KeyId, KeyVersion, PublicParams};
-
 pub trait PublicKeyTrait: std::fmt::Debug {
     fn version(&self) -> KeyVersion;
 
@@ -39,7 +38,7 @@ pub trait PublicKeyTrait: std::fmt::Debug {
         use crate::crypto::public_key::PublicKeyAlgorithm::*;
         matches!(
             self.algorithm(),
-            RSA | RSASign | ElgamalSign | DSA | ECDSA | EdDSA
+            RSA | RSASign | ElgamalSign | DSA | ECDSA | EdDSALegacy
         )
     }
 
diff --git a/tests/hsm-test.rs b/tests/hsm-test.rs
@@ -1,7 +1,7 @@
-use chrono::{DateTime, Utc};
 use std::fmt::Debug;
 use std::fs::File;
 
+use chrono::{DateTime, Utc};
 use pgp::crypto::checksum;
 use pgp::crypto::ecc_curve::ECCCurve;
 use pgp::crypto::hash::HashAlgorithm;
@@ -143,7 +143,7 @@ impl SecretKeyTrait for FakeHsm {
                     Mpi::from_raw_slice(&sig[mid..]),
                 ]
             }
-            PublicKeyAlgorithm::EdDSA => {
+            PublicKeyAlgorithm::EdDSALegacy => {
                 assert_eq!(sig.len(), 64); // FIXME: check curve; add error handling
 
                 vec![

Original file line number	Diff line number	Diff line change
`@@ -312,7 +312,7 @@ impl PublicKeyTrait for PubKeyInner {`
`312`	`312`	`ensure_eq!(sig.len(), 1, "invalid signature");`
`313`	`313`	`crypto::rsa::verify(n.as_bytes(), e.as_bytes(), hash, hashed, sig[0].as_bytes())`
`314`	`314`	`}`
`315`		`- PublicParams::EdDSA { ref curve, ref q } => {`
	`315`	`+ PublicParams::EdDSALegacy { ref curve, ref q } => {`
`316`	`316`	`crypto::eddsa::verify(curve, q.as_bytes(), hash, hashed, sig)`
`317`	`317`	`}`
`318`	`318`	`PublicParams::ECDSA(ref params) => crypto::ecdsa::verify(params, hash, hashed, sig),`
`@@ -360,7 +360,7 @@ impl PublicKeyTrait for PubKeyInner {`
`360`	`360`	`PublicParams::RSA { ref n, ref e } => {`
`361`	`361`	`crypto::rsa::encrypt(rng, n.as_bytes(), e.as_bytes(), plain)`
`362`	`362`	`}`
`363`		`- PublicParams::EdDSA { .. } => bail!("EdDSA is only used for signing"),`
	`363`	`+ PublicParams::EdDSALegacy { .. } => bail!("EdDSA is only used for signing"),`
`364`	`364`	`PublicParams::ECDSA { .. } => bail!("ECDSA is only used for signing"),`
`365`	`365`	`PublicParams::ECDH {`
`366`	`366`	`ref curve,`