rpgp
diff --git a/‎src/crypto.rs
Copy file name to clipboard
+17-5Lines changed: 17 additions & 5 deletions b/‎src/crypto.rs
Copy file name to clipboard
+17-5Lines changed: 17 additions & 5 deletions
diff --git a/‎src/crypto/dsa.rs
Copy file name to clipboard
+29-14Lines changed: 29 additions & 14 deletions b/‎src/crypto/dsa.rs
Copy file name to clipboard
+29-14Lines changed: 29 additions & 14 deletions
diff --git a/‎src/crypto/ecdh.rs
Copy file name to clipboard
+88-58Lines changed: 88 additions & 58 deletions b/‎src/crypto/ecdh.rs
Copy file name to clipboard
+88-58Lines changed: 88 additions & 58 deletions
@@ -3,23 +3,26 @@
 use self::hash::HashAlgorithm;
 use crate::types::SignatureBytes;
 
+// Symmetric
+
 pub mod aead;
 pub mod aes_kw;
-pub mod checksum;
+pub mod sym;
+
+// Encryption & Signing
+
 pub mod dsa;
-pub mod ecc_curve;
 pub mod ecdh;
 pub mod ecdsa;
 pub mod ed25519;
 pub mod ed448;
 pub mod elgamal;
-pub mod hash;
-pub mod public_key;
 pub mod rsa;
-pub mod sym;
 pub mod x25519;
 pub mod x448;
 
+// PQC
+
 #[cfg(feature = "draft-pqc")]
 pub mod ml_dsa65_ed25519;
 #[cfg(feature = "draft-pqc")]
@@ -35,12 +38,21 @@ pub mod slh_dsa_shake128s;
 #[cfg(feature = "draft-pqc")]
 pub mod slh_dsa_shake256s;
 
+// Misc
+
+pub mod checksum;
+pub mod ecc_curve;
+pub mod hash;
+pub mod public_key;
+
+/// Describes keys that can decrypt data.
 pub trait Decryptor {
     type EncryptionFields<'a>;
 
     fn decrypt(&self, data: Self::EncryptionFields<'_>) -> crate::errors::Result<Vec<u8>>;
 }
 
+/// Describes keys that can sign data.
 pub trait Signer {
     fn sign(&self, hash: HashAlgorithm, digest: &[u8]) -> crate::errors::Result<SignatureBytes>;
 }
@@ -1,5 +1,3 @@
-use std::ops::Deref;
-
 pub use dsa::KeySize;
 use dsa::{Components, Signature, SigningKey};
 use num_bigint::BigUint;
@@ -10,6 +8,7 @@ use zeroize::Zeroize;
 use crate::{
     crypto::{hash::HashAlgorithm, Signer},
     errors::{unimplemented_err, Result},
+    ser::Serialize,
     types::{DsaPublicParams, Mpi, SignatureBytes},
 };
 
@@ -45,28 +44,44 @@ impl Drop for SecretKey {
 
 impl zeroize::ZeroizeOnDrop for SecretKey {}
 
-impl Deref for SecretKey {
-    type Target = dsa::SigningKey;
-    fn deref(&self) -> &Self::Target {
-        &self.key
-    }
-}
-
 impl Eq for SecretKey {}
 
 impl SecretKey {
-    pub(crate) fn try_from_mpi(pub_params: &DsaPublicParams, x: Mpi) -> Result<Self> {
-        let secret = dsa::SigningKey::from_components(pub_params.key.clone(), x.into())?;
-        Ok(Self { key: secret })
-    }
-
     /// Generate a DSA `SecretKey`.
     pub fn generate<R: Rng + CryptoRng>(mut rng: R, key_size: KeySize) -> Self {
         let components = Components::generate(&mut rng, key_size);
         let signing_key = SigningKey::generate(&mut rng, components);
 
         SecretKey { key: signing_key }
     }
+
+    /// Create from the given MPI and matching public params.
+    pub(crate) fn try_from_mpi(pub_params: &DsaPublicParams, x: Mpi) -> Result<Self> {
+        let secret = dsa::SigningKey::from_components(pub_params.key.clone(), x.into())?;
+        Ok(Self { key: secret })
+    }
+
+    /// Returns the secret point `x` as MPI.
+    fn to_mpi(&self) -> Mpi {
+        Mpi::from(self.key.x())
+    }
+
+    /// Returns the secret point `x` as big endian bytes.
+    pub fn to_bytes(&self) -> Vec<u8> {
+        self.key.x().to_bytes_be()
+    }
+}
+
+impl Serialize for SecretKey {
+    fn to_writer<W: std::io::Write>(&self, writer: &mut W) -> Result<()> {
+        self.to_mpi().to_writer(writer)?;
+
+        Ok(())
+    }
+
+    fn write_len(&self) -> usize {
+        self.to_mpi().write_len()
+    }
 }
 
 impl Signer for SecretKey {
 
@@ -1,5 +1,3 @@
-use std::ops::Deref;
-
 use log::debug;
 use rand::{CryptoRng, Rng};
 use x25519_dalek::{PublicKey, StaticSecret};
@@ -12,6 +10,7 @@ use crate::{
         Decryptor,
     },
     errors::{ensure, ensure_eq, unsupported_err, Error, Result},
+    ser::Serialize,
     types::{pad_key, EcdhPublicParams, Mpi, PkeskBytes},
 };
 
@@ -21,28 +20,56 @@ const ANON_SENDER: [u8; 20] = [
     0x20, 0x20, 0x20, 0x20,
 ];
 
-/// Hack around `StaticSecret` not implementing debug.
+/// ECDH Curve25519 secret key
 #[derive(Clone, ZeroizeOnDrop, derive_more::Debug)]
-pub struct Curve25519Wrapper(#[debug("..")] StaticSecret);
+pub struct Curve25519(#[debug("..")] StaticSecret);
 
-impl From<StaticSecret> for Curve25519Wrapper {
+impl From<StaticSecret> for Curve25519 {
     fn from(value: StaticSecret) -> Self {
         Self(value)
     }
 }
 
-impl PartialEq for Curve25519Wrapper {
+impl PartialEq for Curve25519 {
     fn eq(&self, other: &Self) -> bool {
         self.0.as_bytes().eq(other.0.as_bytes())
     }
 }
 
-impl Eq for Curve25519Wrapper {}
+impl Eq for Curve25519 {}
+
+impl Curve25519 {
+    pub fn generate<R: Rng + CryptoRng>(mut rng: R) -> Self {
+        let mut secret_key_bytes = Zeroizing::new([0u8; ECCCurve::Curve25519.secret_key_length()]);
+        rng.fill_bytes(&mut *secret_key_bytes);
+
+        // Clamp, as `to_bytes` does not clamp.
+        let q_raw = curve25519_dalek::scalar::clamp_integer(*secret_key_bytes);
+        let secret = StaticSecret::from(q_raw);
+
+        Self(secret)
+    }
+
+    /// Reads the value in the reverse order (little endian), because..PGP screwed up
+    pub fn try_from_bytes_rev(bytes: &[u8]) -> Result<Self> {
+        let rev: Vec<u8> = bytes.iter().rev().copied().collect();
+        let secret_raw = pad_key::<32>(&rev)?;
+        let secret = x25519_dalek::StaticSecret::from(secret_raw);
+        Ok(Self(secret))
+    }
+
+    /// Returns the raw key in reverse order (little endian)
+    pub fn to_bytes_rev(&self) -> [u8; 32] {
+        let mut out = [0u8; 32];
+        for (byte, o) in self.0.as_bytes().iter().rev().zip(out.iter_mut()) {
+            *o = *byte;
+        }
+        out
+    }
 
-impl Deref for Curve25519Wrapper {
-    type Target = StaticSecret;
-    fn deref(&self) -> &Self::Target {
-        &self.0
+    /// Returns the raw key in big endian
+    pub fn as_bytes(&self) -> &[u8; 32] {
+        self.0.as_bytes()
     }
 }
 
@@ -51,13 +78,7 @@ impl Deref for Curve25519Wrapper {
 #[cfg_attr(test, derive(proptest_derive::Arbitrary))]
 pub enum SecretKey {
     /// ECDH with Curve25519
-    Curve25519 {
-        /// The secret point.
-        #[debug("..")]
-        #[cfg_attr(test, proptest(strategy = "tests::key_curve25519_gen()"))]
-        secret: Curve25519Wrapper,
-    },
-
+    Curve25519(Curve25519),
     /// ECDH with Nist P256
     P256 {
         /// The secret point.
@@ -89,14 +110,11 @@ impl From<&SecretKey> for EcdhPublicParams {
         let hash = curve.hash_algo().expect("known algo");
         let alg_sym = curve.sym_algo().expect("known algo");
         match value {
-            SecretKey::Curve25519 { secret } => {
-                let secret: &StaticSecret = secret;
-                Self::Curve25519 {
-                    p: PublicKey::from(secret),
-                    hash,
-                    alg_sym,
-                }
-            }
+            SecretKey::Curve25519(key) => Self::Curve25519 {
+                p: PublicKey::from(&key.0),
+                hash,
+                alg_sym,
+            },
             SecretKey::P256 { ref secret } => Self::P256 {
                 p: secret.public_key(),
                 hash,
@@ -121,17 +139,8 @@ impl SecretKey {
     pub fn generate<R: Rng + CryptoRng>(mut rng: R, curve: &ECCCurve) -> Result<Self> {
         match curve {
             ECCCurve::Curve25519 => {
-                let mut secret_key_bytes =
-                    Zeroizing::new([0u8; ECCCurve::Curve25519.secret_key_length()]);
-                rng.fill_bytes(&mut *secret_key_bytes);
-
-                // Clamp, as `to_bytes` does not clamp.
-                let q_raw = curve25519_dalek::scalar::clamp_integer(*secret_key_bytes);
-                let secret = StaticSecret::from(q_raw);
-
-                Ok(SecretKey::Curve25519 {
-                    secret: Curve25519Wrapper(secret),
-                })
+                let key = Curve25519::generate(rng);
+                Ok(Self::Curve25519(key))
             }
             ECCCurve::P256 => {
                 let secret = p256::SecretKey::random(&mut rng);
@@ -152,14 +161,8 @@ impl SecretKey {
     pub(crate) fn try_from_mpi(pub_params: &EcdhPublicParams, d: Mpi) -> Result<Self> {
         match pub_params {
             EcdhPublicParams::Curve25519 { .. } => {
-                const SIZE: usize = ECCCurve::Curve25519.secret_key_length();
-                let rev: Vec<u8> = d.as_ref().iter().rev().copied().collect();
-                let secret_raw = pad_key::<SIZE>(&rev)?;
-                let secret = x25519_dalek::StaticSecret::from(secret_raw);
-
-                Ok(SecretKey::Curve25519 {
-                    secret: secret.into(),
-                })
+                let key = Curve25519::try_from_bytes_rev(d.as_ref())?;
+                Ok(SecretKey::Curve25519(key))
             }
             EcdhPublicParams::P256 { .. } => {
                 const SIZE: usize = ECCCurve::P256.secret_key_length();
@@ -197,31 +200,51 @@ impl SecretKey {
         }
     }
 
-    pub(crate) fn as_mpi(&self) -> Mpi {
+    fn to_mpi(&self) -> Mpi {
         match self {
-            Self::Curve25519 { secret, .. } => {
-                let bytes = secret.to_bytes();
+            Self::Curve25519(key) => {
+                let bytes = key.to_bytes_rev();
 
                 // create scalar and reverse to little endian
                 // https://www.rfc-editor.org/rfc/rfc9580.html#name-curve25519legacy-ecdh-secre
-                let reversed = bytes.iter().rev().copied().collect::<Vec<u8>>();
-
-                Mpi::from_raw(reversed.into())
+                Mpi::from_raw(bytes.to_vec().into())
             }
             Self::P256 { secret, .. } => Mpi::from_slice(&secret.to_bytes()),
             Self::P384 { secret, .. } => Mpi::from_slice(&secret.to_bytes()),
             Self::P521 { secret, .. } => Mpi::from_slice(&secret.to_bytes()),
         }
     }
 
-    fn curve(&self) -> ECCCurve {
+    pub fn curve(&self) -> ECCCurve {
         match self {
             Self::Curve25519 { .. } => ECCCurve::Curve25519,
             Self::P256 { .. } => ECCCurve::P256,
             Self::P384 { .. } => ECCCurve::P384,
             Self::P521 { .. } => ECCCurve::P521,
         }
     }
+
+    /// Returns the secret material as raw bytes.
+    pub fn to_bytes(&self) -> Vec<u8> {
+        match self {
+            Self::Curve25519(key) => key.as_bytes().to_vec(),
+            Self::P256 { secret, .. } => secret.to_bytes().to_vec(),
+            Self::P384 { secret, .. } => secret.to_bytes().to_vec(),
+            Self::P521 { secret, .. } => secret.to_bytes().to_vec(),
+        }
+    }
+}
+
+impl Serialize for SecretKey {
+    fn to_writer<W: std::io::Write>(&self, writer: &mut W) -> Result<()> {
+        let x = self.to_mpi();
+        x.to_writer(writer)
+    }
+
+    fn write_len(&self) -> usize {
+        let x = self.to_mpi();
+        x.write_len()
+    }
 }
 
 pub struct EncryptionFields<'a> {
@@ -250,7 +273,7 @@ impl Decryptor for SecretKey {
         let hash = data.hash;
 
         let shared_secret = match self {
-            SecretKey::Curve25519 { secret, .. } => {
+            SecretKey::Curve25519(key) => {
                 ensure_eq!(data.public_point.len(), 33, "invalid public point"); // prefix "0x40" + 32 bytes = 33 bytes
 
                 let their_public = {
@@ -265,7 +288,7 @@ impl Decryptor for SecretKey {
                 };
 
                 // derive shared secret
-                let shared_secret = secret.diffie_hellman(&their_public);
+                let shared_secret = key.0.diffie_hellman(&their_public);
 
                 shared_secret.to_bytes().to_vec()
             }
@@ -686,10 +709,17 @@ mod tests {
         }
     }
 
-    prop_compose! {
-        pub fn key_curve25519_gen()(bytes: [u8; 32]) -> Curve25519Wrapper {
-            let q_raw = curve25519_dalek::scalar::clamp_integer(bytes);
-            Curve25519Wrapper(StaticSecret::from(q_raw))
+    impl Arbitrary for Curve25519 {
+        type Parameters = ();
+        type Strategy = BoxedStrategy<Self>;
+
+        fn arbitrary_with(_args: Self::Parameters) -> Self::Strategy {
+            any::<u64>()
+                .prop_map(|seed| {
+                    let mut rng = rand_chacha::ChaCha8Rng::seed_from_u64(seed);
+                    Curve25519::generate(&mut rng)
+                })
+                .boxed()
         }
     }
 }