Update PrivateKey -> X25519PrivateKey

Author: jazzz

conversations/src/conversation/privatev1.rs

@@ -221,14 +221,14 @@ impl Debug for PrivateV1Convo {
 
 #[cfg(test)]
 mod tests {
-    use x25519_dalek::StaticSecret;
+    use crypto::X25519PrivateKey;
 
     use super::*;
 
     #[test]
     fn test_encrypt_roundtrip() {
-        let saro = StaticSecret::random();
-        let raya = StaticSecret::random();
+        let saro = X25519PrivateKey::random();
+        let raya = X25519PrivateKey::random();
 
         let pub_raya = X25519PublicKey::from(&raya);
 

conversations/src/crypto.rs

@@ -1,5 +1,4 @@
-pub use crypto::X25519PublicKey;
-pub use x25519_dalek::StaticSecret;
+pub use crypto::{X25519PrivateKey, X25519PublicKey};
 
 use prost::bytes::Bytes;
 

conversations/src/identity.rs

@@ -1,9 +1,9 @@
 use std::fmt;
 
-use crate::crypto::{StaticSecret, X25519PublicKey};
+use crate::crypto::{X25519PrivateKey, X25519PublicKey};
 
 pub struct Identity {
-    secret: StaticSecret,
+    secret: X25519PrivateKey,
 }
 
 impl fmt::Debug for Identity {
@@ -18,15 +18,15 @@ impl fmt::Debug for Identity {
 impl Identity {
     pub fn new() -> Self {
         Self {
-            secret: StaticSecret::random(),
+            secret: X25519PrivateKey::random(),
         }
     }
 
     pub fn public_key(&self) -> X25519PublicKey {
         X25519PublicKey::from(&self.secret)
     }
 
-    pub fn secret(&self) -> &StaticSecret {
+    pub fn secret(&self) -> &X25519PrivateKey {
         &self.secret
     }
 }

conversations/src/inbox/handler.rs

@@ -10,7 +10,7 @@ use crypto::{PrekeyBundle, SymmetricKey32};
 
 use crate::context::Introduction;
 use crate::conversation::{ChatError, ConversationId, Convo, Id, PrivateV1Convo};
-use crate::crypto::{CopyBytes, StaticSecret, X25519PublicKey};
+use crate::crypto::{CopyBytes, X25519PrivateKey, X25519PublicKey};
 use crate::identity::Identity;
 use crate::inbox::handshake::InboxHandshake;
 use crate::proto;
@@ -25,7 +25,7 @@ fn delivery_address_for_installation(_: X25519PublicKey) -> String {
 pub struct Inbox {
     ident: Rc<Identity>,
     local_convo_id: String,
-    ephemeral_keys: HashMap<String, StaticSecret>,
+    ephemeral_keys: HashMap<String, X25519PrivateKey>,
 }
 
 impl std::fmt::Debug for Inbox {
@@ -47,12 +47,12 @@ impl Inbox {
         Self {
             ident,
             local_convo_id,
-            ephemeral_keys: HashMap::<String, StaticSecret>::new(),
+            ephemeral_keys: HashMap::<String, X25519PrivateKey>::new(),
         }
     }
 
     pub fn create_intro_bundle(&mut self) -> Introduction {
-        let ephemeral = StaticSecret::random();
+        let ephemeral = X25519PrivateKey::random();
 
         let ephemeral_key: X25519PublicKey = (&ephemeral).into();
         self.ephemeral_keys
@@ -169,7 +169,7 @@ impl Inbox {
 
     fn perform_handshake(
         &self,
-        ephemeral_key: &StaticSecret,
+        ephemeral_key: &X25519PrivateKey,
         header: proto::InboxHeaderV1,
         bytes: Bytes,
     ) -> Result<(SymmetricKey32, proto::InboxV1Frame), ChatError> {
@@ -215,7 +215,7 @@ impl Inbox {
         Ok(frame)
     }
 
-    fn lookup_ephemeral_key(&self, key: &str) -> Result<&StaticSecret, ChatError> {
+    fn lookup_ephemeral_key(&self, key: &str) -> Result<&X25519PrivateKey, ChatError> {
         self.ephemeral_keys
             .get(key)
             .ok_or(ChatError::UnknownEphemeralKey())

conversations/src/inbox/handshake.rs

@@ -5,7 +5,7 @@ use blake2::{
 use crypto::{DomainSeparator, PrekeyBundle, SymmetricKey32, X3Handshake};
 use rand_core::{CryptoRng, RngCore};
 
-use crate::crypto::{StaticSecret, X25519PublicKey};
+use crate::crypto::{X25519PrivateKey, X25519PublicKey};
 
 type Blake2bMac256 = Blake2bMac<U32>;
 
@@ -21,7 +21,7 @@ pub struct InboxHandshake {}
 impl InboxHandshake {
     /// Performs
     pub fn perform_as_initiator<R: RngCore + CryptoRng>(
-        identity_keypair: &StaticSecret,
+        identity_keypair: &X25519PrivateKey,
         recipient_bundle: &PrekeyBundle,
         rng: &mut R,
     ) -> (SymmetricKey32, X25519PublicKey) {
@@ -42,9 +42,9 @@ impl InboxHandshake {
     /// * `initiator_identity` - Initiator's identity public key
     /// * `initiator_ephemeral` - Initiator's ephemeral public key
     pub fn perform_as_responder(
-        identity_keypair: &StaticSecret,
-        signed_prekey: &StaticSecret,
-        onetime_prekey: Option<&StaticSecret>,
+        identity_keypair: &X25519PrivateKey,
+        signed_prekey: &X25519PrivateKey,
+        onetime_prekey: Option<&X25519PrivateKey>,
         initiator_identity: &X25519PublicKey,
         initiator_ephemeral: &X25519PublicKey,
     ) -> SymmetricKey32 {
@@ -85,12 +85,12 @@ mod tests {
         let mut rng = OsRng;
 
         // Alice (initiator) generates her identity key
-        let alice_identity = StaticSecret::random_from_rng(rng);
+        let alice_identity = X25519PrivateKey::random_from_rng(rng);
         let alice_identity_pub = X25519PublicKey::from(&alice_identity);
 
         // Bob (responder) generates his keys
-        let bob_identity = StaticSecret::random_from_rng(rng);
-        let bob_signed_prekey = StaticSecret::random_from_rng(rng);
+        let bob_identity = X25519PrivateKey::random_from_rng(rng);
+        let bob_signed_prekey = X25519PrivateKey::random_from_rng(rng);
         let bob_signed_prekey_pub = X25519PublicKey::from(&bob_signed_prekey);
 
         // Create Bob's prekey bundle

conversations/src/inbox/introduction.rs

@@ -1,9 +1,8 @@
 use base64::{Engine, engine::general_purpose::URL_SAFE_NO_PAD};
 use chat_proto::logoschat::intro::IntroBundle;
-use crypto::{Ed25519Signature, X25519PublicKey};
+use crypto::{Ed25519Signature, X25519PrivateKey, X25519PublicKey};
 use prost::Message;
 use rand_core::{CryptoRng, RngCore};
-use x25519_dalek::StaticSecret;
 
 use crate::errors::ChatError;
 
@@ -17,7 +16,7 @@ fn intro_binding_message(ephemeral: &X25519PublicKey) -> Vec<u8> {
 }
 
 pub(crate) fn sign_intro_binding<R: RngCore + CryptoRng>(
-    secret: &StaticSecret,
+    secret: &X25519PrivateKey,
     ephemeral: &X25519PublicKey,
     rng: R,
 ) -> Ed25519Signature {
@@ -44,7 +43,7 @@ pub struct Introduction {
 impl Introduction {
     /// Create a new `Introduction` by signing the ephemeral key with the installation secret.
     pub(crate) fn new<R: RngCore + CryptoRng>(
-        installation_secret: &StaticSecret,
+        installation_secret: &X25519PrivateKey,
         ephemeral_key: X25519PublicKey,
         rng: R,
     ) -> Self {
@@ -147,9 +146,9 @@ mod tests {
     use rand_core::OsRng;
 
     fn create_test_introduction() -> Introduction {
-        let install_secret = StaticSecret::random_from_rng(OsRng);
+        let install_secret = X25519PrivateKey::random_from_rng(OsRng);
 
-        let ephemeral_secret = StaticSecret::random_from_rng(OsRng);
+        let ephemeral_secret = X25519PrivateKey::random_from_rng(OsRng);
         let ephemeral_pub: X25519PublicKey = (&ephemeral_secret).into();
 
         Introduction::new(&install_secret, ephemeral_pub, OsRng)

crypto/src/keys.rs

@@ -2,7 +2,7 @@ pub use generic_array::{GenericArray, typenum::U32};
 
 use rand_core::{CryptoRng, OsRng, RngCore};
 use std::{fmt::Debug, ops::Deref};
-use x25519_dalek::{PublicKey, SharedSecret, StaticSecret};
+use x25519_dalek;
 use xeddsa::xed25519;
 use zeroize::{Zeroize, ZeroizeOnDrop};
 
@@ -15,9 +15,9 @@ impl From<x25519_dalek::PublicKey> for X25519PublicKey {
     }
 }
 
-impl From<&StaticSecret> for X25519PublicKey {
-    fn from(value: &StaticSecret) -> Self {
-        Self(x25519_dalek::PublicKey::from(value))
+impl From<&X25519PrivateKey> for X25519PublicKey {
+    fn from(value: &X25519PrivateKey) -> Self {
+        Self(x25519_dalek::PublicKey::from(&value.0))
     }
 }
 
@@ -28,7 +28,7 @@ impl From<[u8; 32]> for X25519PublicKey {
 }
 
 impl Deref for X25519PublicKey {
-    type Target = PublicKey;
+    type Target = x25519_dalek::PublicKey;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
@@ -60,13 +60,25 @@ impl X25519PrivateKey {
     }
 }
 
+impl From<[u8; 32]> for X25519PrivateKey {
+    fn from(value: [u8; 32]) -> Self {
+        Self(x25519_dalek::StaticSecret::from(value))
+    }
+}
+
 impl Deref for X25519PrivateKey {
     type Target = x25519_dalek::StaticSecret;
     fn deref(&self) -> &Self::Target {
         &self.0
     }
 }
 
+impl From<&X25519PrivateKey> for xed25519::PrivateKey {
+    fn from(value: &X25519PrivateKey) -> Self {
+        Self::from(&value.0)
+    }
+}
+
 /// A Generic secret key container for symmetric keys.
 /// SymmetricKey retains ownership of bytes to ensure they are Zeroized on drop.
 #[derive(Clone, Zeroize, ZeroizeOnDrop, PartialEq)]
@@ -107,10 +119,10 @@ impl From<GenericArray<u8, U32>> for SymmetricKey32 {
     }
 }
 
-impl From<&SharedSecret> for SymmetricKey32 {
+impl From<&x25519_dalek::SharedSecret> for SymmetricKey32 {
     // This relies on the feature 'zeroize' being set for x25519-dalek.
     // If not the SharedSecret will need to manually zeroized
-    fn from(value: &SharedSecret) -> Self {
+    fn from(value: &x25519_dalek::SharedSecret) -> Self {
         value.to_bytes().into()
     }
 }

crypto/src/lib.rs

@@ -2,6 +2,6 @@ mod keys;
 mod x3dh;
 mod xeddsa_sign;
 
-pub use keys::{GenericArray, SymmetricKey32, X25519PublicKey};
+pub use keys::{GenericArray, SymmetricKey32, X25519PrivateKey, X25519PublicKey};
 pub use x3dh::{DomainSeparator, PrekeyBundle, X3Handshake};
 pub use xeddsa_sign::{Ed25519Signature, SignatureError, xeddsa_sign, xeddsa_verify};

crypto/src/x3dh.rs

@@ -3,9 +3,9 @@ use std::marker::PhantomData;
 use hkdf::Hkdf;
 use rand_core::{CryptoRng, RngCore};
 use sha2::Sha256;
-use x25519_dalek::{SharedSecret, StaticSecret};
+use x25519_dalek::SharedSecret;
 
-use crate::keys::{SymmetricKey32, X25519PublicKey};
+use crate::keys::{SymmetricKey32, X25519PrivateKey, X25519PublicKey};
 use crate::xeddsa_sign::Ed25519Signature;
 
 /// A prekey bundle containing the public keys needed to initiate an X3DH key exchange.
@@ -67,12 +67,12 @@ impl<D: DomainSeparator> X3Handshake<D> {
     /// # Returns
     /// A tuple of (shared secret bytes, ephemeral public key)
     pub fn initator<R: RngCore + CryptoRng>(
-        identity_keypair: &StaticSecret,
+        identity_keypair: &X25519PrivateKey,
         recipient_bundle: &PrekeyBundle,
         rng: &mut R,
     ) -> (SymmetricKey32, X25519PublicKey) {
-        // Generate ephemeral key for this handshake (using StaticSecret for multiple DH operations)
-        let ephemeral_secret = StaticSecret::random_from_rng(rng);
+        // Generate ephemeral key for this handshake (using X25519PrivateKey for multiple DH operations)
+        let ephemeral_secret = X25519PrivateKey::random_from_rng(rng);
         let ephemeral_public = X25519PublicKey::from(&ephemeral_secret);
 
         // Perform the 4 Diffie-Hellman operations
@@ -102,9 +102,9 @@ impl<D: DomainSeparator> X3Handshake<D> {
     /// # Returns
     /// The derived shared secret bytes
     pub fn responder(
-        identity_keypair: &StaticSecret,
-        signed_prekey: &StaticSecret,
-        onetime_prekey: Option<&StaticSecret>,
+        identity_keypair: &X25519PrivateKey,
+        signed_prekey: &X25519PrivateKey,
+        onetime_prekey: Option<&X25519PrivateKey>,
         initiator_identity: &X25519PublicKey,
         initiator_ephemeral: &X25519PublicKey,
     ) -> SymmetricKey32 {
@@ -135,17 +135,17 @@ mod tests {
         let mut rng = OsRng;
 
         // Alice (initiator) generates her identity key
-        let alice_identity = StaticSecret::random_from_rng(rng);
+        let alice_identity = X25519PrivateKey::random_from_rng(rng);
         let alice_identity_pub = X25519PublicKey::from(&alice_identity);
 
         // Bob (responder) generates his keys
-        let bob_identity = StaticSecret::random_from_rng(rng);
+        let bob_identity = X25519PrivateKey::random_from_rng(rng);
         let bob_identity_pub = X25519PublicKey::from(&bob_identity);
 
-        let bob_signed_prekey = StaticSecret::random_from_rng(rng);
+        let bob_signed_prekey = X25519PrivateKey::random_from_rng(rng);
         let bob_signed_prekey_pub = X25519PublicKey::from(&bob_signed_prekey);
 
-        let bob_onetime_prekey = StaticSecret::random_from_rng(rng);
+        let bob_onetime_prekey = X25519PrivateKey::random_from_rng(rng);
         let bob_onetime_prekey_pub = X25519PublicKey::from(&bob_onetime_prekey);
 
         // Create Bob's prekey bundle (with one-time prekey)
@@ -178,14 +178,14 @@ mod tests {
         let mut rng = OsRng;
 
         // Alice (initiator) generates her identity key
-        let alice_identity = StaticSecret::random_from_rng(rng);
+        let alice_identity = X25519PrivateKey::random_from_rng(rng);
         let alice_identity_pub = X25519PublicKey::from(&alice_identity);
 
         // Bob (responder) generates his keys
-        let bob_identity = StaticSecret::random_from_rng(rng);
+        let bob_identity = X25519PrivateKey::random_from_rng(rng);
         let bob_identity_pub = X25519PublicKey::from(&bob_identity);
 
-        let bob_signed_prekey = StaticSecret::random_from_rng(rng);
+        let bob_signed_prekey = X25519PrivateKey::random_from_rng(rng);
         let bob_signed_prekey_pub = X25519PublicKey::from(&bob_signed_prekey);
 
         // Create Bob's prekey bundle (without one-time prekey)