More changes for FFI

Rename KeyPair::new to KeyPair::generate and add a KeyPair::new which
just takes the respective public and private key.

Add deserialize functions for PreKey and SignedPreKey objects

src/curve.rs

@@ -209,7 +209,7 @@ pub struct KeyPair {
 }
 
 impl KeyPair {
-    pub fn new<R: Rng + CryptoRng>(csprng: &mut R) -> Self {
+    pub fn generate<R: Rng + CryptoRng>(csprng: &mut R) -> Self {
         let keypair = curve25519::KeyPair::new(csprng);
 
         let public_key = PublicKey::from(PublicKeyData::DjbPublicKey(*keypair.public_key()));
@@ -221,6 +221,13 @@ impl KeyPair {
         }
     }
 
+    pub fn new(public_key: PublicKey, private_key: PrivateKey) -> Self {
+        Self {
+            public_key,
+            private_key,
+        }
+    }
+
     pub fn from_public_and_private(public_key: &[u8], private_key: &[u8]) -> Result<Self> {
         let public_key = decode_point(public_key)?;
         let private_key = decode_private_point(private_key)?;
@@ -276,7 +283,7 @@ mod tests {
     #[test]
     fn test_large_signatures() {
         let mut csprng = OsRng;
-        let key_pair = KeyPair::new(&mut csprng);
+        let key_pair = KeyPair::generate(&mut csprng);
         let mut message = [0u8; 1024 * 1024];
         let signature = calculate_signature(&mut csprng, &key_pair.private_key, &message).unwrap();
 
@@ -288,7 +295,7 @@ mod tests {
     #[test]
     fn test_decode_size() {
         let mut csprng = OsRng;
-        let key_pair = KeyPair::new(&mut csprng);
+        let key_pair = KeyPair::generate(&mut csprng);
         let serialized_public = key_pair.public_key.serialize();
         let empty: [u8; 0] = [];
 

src/group_cipher.rs

@@ -140,7 +140,7 @@ pub fn create_sender_key_distribution_message<R: Rng + CryptoRng>(
             let sender_key_id: u32 = csprng.gen();
             let iteration = 0;
             let sender_key: [u8; 32] = csprng.gen();
-            let signing_key = curve::KeyPair::new(csprng);
+            let signing_key = curve::KeyPair::generate(csprng);
             sender_key_record.set_sender_key_state(
                 sender_key_id,
                 iteration,

src/identity_key.rs

@@ -77,7 +77,7 @@ impl IdentityKeyPair {
     }
 
     pub fn generate<R: CryptoRng + Rng>(csprng: &mut R) -> Self {
-        let keypair = curve::KeyPair::new(csprng);
+        let keypair = curve::KeyPair::generate(csprng);
 
         Self {
             identity_key: keypair.public_key.into(),
@@ -140,7 +140,7 @@ mod tests {
 
     #[test]
     fn test_identity_key_from() {
-        let key_pair = curve::KeyPair::new(&mut OsRng);
+        let key_pair = curve::KeyPair::generate(&mut OsRng);
         let key_pair_public_serialized = key_pair.public_key.serialize();
         let identity_key = IdentityKey::from(key_pair.public_key);
         assert_eq!(key_pair_public_serialized, identity_key.serialize());

src/lib.rs

@@ -36,7 +36,7 @@ pub use {
     },
     ratchet::{
         are_we_alice, initialize_alice_session, initialize_bob_session,
-        AliceSignalProtocolParameters, BobSignalProtocolParameters,
+        AliceSignalProtocolParameters, BobSignalProtocolParameters, ChainKey, MessageKeys, RootKey,
     },
     sender_keys::{SenderKeyName, SenderKeyRecord},
     session::*,

src/protocol.rs

@@ -643,9 +643,9 @@ mod tests {
         csprng.fill_bytes(&mut ciphertext);
         let ciphertext = ciphertext;
 
-        let sender_ratchet_key_pair = curve::KeyPair::new(csprng);
-        let sender_identity_key_pair = curve::KeyPair::new(csprng);
-        let receiver_identity_key_pair = curve::KeyPair::new(csprng);
+        let sender_ratchet_key_pair = curve::KeyPair::generate(csprng);
+        let sender_identity_key_pair = curve::KeyPair::generate(csprng);
+        let receiver_identity_key_pair = curve::KeyPair::generate(csprng);
 
         SignalMessage::new(
             3,
@@ -681,8 +681,8 @@ mod tests {
     #[test]
     fn test_pre_key_signal_message_serialize_deserialize() {
         let mut csprng = OsRng;
-        let identity_key_pair = curve::KeyPair::new(&mut csprng);
-        let base_key_pair = curve::KeyPair::new(&mut csprng);
+        let identity_key_pair = curve::KeyPair::generate(&mut csprng);
+        let base_key_pair = curve::KeyPair::generate(&mut csprng);
         let message = create_signal_message(&mut csprng);
         let pre_key_signal_message = PreKeySignalMessage::new(
             3,
@@ -734,7 +734,7 @@ mod tests {
     #[test]
     fn test_sender_key_message_serialize_deserialize() {
         let mut csprng = OsRng;
-        let signature_key_pair = curve::KeyPair::new(&mut csprng);
+        let signature_key_pair = curve::KeyPair::generate(&mut csprng);
         let sender_key_message = SenderKeyMessage::new(
             42,
             7,

src/ratchet.rs

@@ -27,7 +27,7 @@ pub fn initialize_alice_session<R: Rng + CryptoRng>(
 ) -> Result<SessionState> {
     let local_identity = parameters.our_identity_key_pair().identity_key();
 
-    let sending_ratchet_key = curve::KeyPair::new(&mut csprng);
+    let sending_ratchet_key = curve::KeyPair::generate(&mut csprng);
 
     let mut secrets = Vec::with_capacity(32 * 5);
 

src/session.rs

@@ -132,7 +132,7 @@ pub fn process_prekey_bundle<R: Rng + CryptoRng>(
         .load_session(&remote_address)?
         .unwrap_or_else(SessionRecord::new_fresh);
 
-    let our_base_key_pair = curve::KeyPair::new(&mut csprng);
+    let our_base_key_pair = curve::KeyPair::generate(&mut csprng);
     let their_signed_prekey = bundle.signed_pre_key_public()?;
 
     let their_one_time_prekey = bundle.pre_key_public()?;

src/session_cipher.rs

@@ -311,7 +311,7 @@ impl<'a> SessionCipher<'a> {
         let root_key = state.root_key()?;
         let our_ephemeral = state.sender_ratchet_private_key()?;
         let receiver_chain = root_key.create_chain(their_ephemeral, &our_ephemeral)?;
-        let our_new_ephemeral = curve::KeyPair::new(csprng);
+        let our_new_ephemeral = curve::KeyPair::generate(csprng);
         let sender_chain = receiver_chain
             .0
             .create_chain(their_ephemeral, &our_new_ephemeral.private_key)?;

src/state/prekey.rs

@@ -23,6 +23,12 @@ impl PreKeyRecord {
         }
     }
 
+    pub fn deserialize(data: &[u8]) -> Result<Self> {
+        Ok(Self {
+            pre_key: PreKeyRecordStructure::decode(data)?,
+        })
+    }
+
     pub fn id(&self) -> Result<PreKeyId> {
         Ok(self.pre_key.id)
     }
@@ -31,6 +37,14 @@ impl PreKeyRecord {
         curve::KeyPair::from_public_and_private(&self.pre_key.public_key, &self.pre_key.private_key)
     }
 
+    pub fn public_key(&self) -> Result<curve::PublicKey> {
+        curve::PublicKey::deserialize(&self.pre_key.public_key)
+    }
+
+    pub fn private_key(&self) -> Result<curve::PrivateKey> {
+        curve::PrivateKey::deserialize(&self.pre_key.private_key)
+    }
+
     pub fn serialize(&self) -> Result<Vec<u8>> {
         let mut buf = vec![];
         self.pre_key.encode(&mut buf)?;

src/state/signed_prekey.rs

@@ -26,6 +26,12 @@ impl SignedPreKeyRecord {
         }
     }
 
+    pub fn deserialize(data: &[u8]) -> Result<Self> {
+        Ok(Self {
+            signed_pre_key: SignedPreKeyRecordStructure::decode(data)?,
+        })
+    }
+
     pub fn id(&self) -> Result<SignedPreKeyId> {
         Ok(self.signed_pre_key.id)
     }
@@ -38,6 +44,14 @@ impl SignedPreKeyRecord {
         Ok(self.signed_pre_key.signature.clone())
     }
 
+    pub fn public_key(&self) -> Result<curve::PublicKey> {
+        curve::PublicKey::deserialize(&self.signed_pre_key.public_key)
+    }
+
+    pub fn private_key(&self) -> Result<curve::PrivateKey> {
+        curve::PrivateKey::deserialize(&self.signed_pre_key.private_key)
+    }
+
     pub fn key_pair(&self) -> Result<curve::KeyPair> {
         curve::KeyPair::from_public_and_private(
             &self.signed_pre_key.public_key,

tests/session.rs

@@ -15,8 +15,8 @@ fn test_basic_prekey_v3() -> Result<(), SignalProtocolError> {
     let mut alice_store = support::test_in_memory_protocol_store();
     let mut bob_store = support::test_in_memory_protocol_store();
 
-    let bob_pre_key_pair = KeyPair::new(&mut csprng);
-    let bob_signed_pre_key_pair = KeyPair::new(&mut csprng);
+    let bob_pre_key_pair = KeyPair::generate(&mut csprng);
+    let bob_signed_pre_key_pair = KeyPair::generate(&mut csprng);
 
     let bob_signed_pre_key_public = bob_signed_pre_key_pair.public_key.serialize();
     let bob_signed_pre_key_signature = bob_store
@@ -120,8 +120,8 @@ fn test_basic_prekey_v3() -> Result<(), SignalProtocolError> {
 
     let mut alice_store = support::test_in_memory_protocol_store();
 
-    let bob_pre_key_pair = KeyPair::new(&mut csprng);
-    let bob_signed_pre_key_pair = KeyPair::new(&mut csprng);
+    let bob_pre_key_pair = KeyPair::generate(&mut csprng);
+    let bob_signed_pre_key_pair = KeyPair::generate(&mut csprng);
 
     let bob_signed_pre_key_public = bob_signed_pre_key_pair.public_key.serialize();
     let bob_signed_pre_key_signature = bob_store
@@ -215,8 +215,8 @@ fn test_bad_signed_pre_key_signature() -> Result<(), SignalProtocolError> {
     let bob_store = support::test_in_memory_protocol_store();
 
     let mut csprng = OsRng;
-    let bob_pre_key_pair = KeyPair::new(&mut csprng);
-    let bob_signed_pre_key_pair = KeyPair::new(&mut csprng);
+    let bob_pre_key_pair = KeyPair::generate(&mut csprng);
+    let bob_signed_pre_key_pair = KeyPair::generate(&mut csprng);
 
     let bob_signed_pre_key_public = bob_signed_pre_key_pair.public_key.serialize();
     let bob_signed_pre_key_signature = bob_store
@@ -289,8 +289,8 @@ fn repeat_bundle_message_v3() -> Result<(), SignalProtocolError> {
     let mut bob_store = support::test_in_memory_protocol_store();
 
     let mut csprng = OsRng;
-    let bob_pre_key_pair = KeyPair::new(&mut csprng);
-    let bob_signed_pre_key_pair = KeyPair::new(&mut csprng);
+    let bob_pre_key_pair = KeyPair::generate(&mut csprng);
+    let bob_signed_pre_key_pair = KeyPair::generate(&mut csprng);
 
     let bob_signed_pre_key_public = bob_signed_pre_key_pair.public_key.serialize();
     let bob_signed_pre_key_signature = bob_store
@@ -396,8 +396,8 @@ fn bad_message_bundle() -> Result<(), SignalProtocolError> {
     let mut alice_store = support::test_in_memory_protocol_store();
     let mut bob_store = support::test_in_memory_protocol_store();
 
-    let bob_pre_key_pair = KeyPair::new(&mut csprng);
-    let bob_signed_pre_key_pair = KeyPair::new(&mut csprng);
+    let bob_pre_key_pair = KeyPair::generate(&mut csprng);
+    let bob_signed_pre_key_pair = KeyPair::generate(&mut csprng);
 
     let bob_signed_pre_key_public = bob_signed_pre_key_pair.public_key.serialize();
     let bob_signed_pre_key_signature = bob_store
@@ -494,7 +494,7 @@ fn optional_one_time_prekey() -> Result<(), SignalProtocolError> {
     let mut bob_store = support::test_in_memory_protocol_store();
 
     let mut csprng = OsRng;
-    let bob_signed_pre_key_pair = KeyPair::new(&mut csprng);
+    let bob_signed_pre_key_pair = KeyPair::generate(&mut csprng);
 
     let bob_signed_pre_key_public = bob_signed_pre_key_pair.public_key.serialize();
     let bob_signed_pre_key_signature = bob_store

tests/support/mod.rs

@@ -47,8 +47,8 @@ pub fn create_pre_key_bundle<R: Rng + CryptoRng>(
     store: &mut dyn ProtocolStore,
     mut csprng: &mut R,
 ) -> Result<PreKeyBundle, SignalProtocolError> {
-    let pre_key_pair = KeyPair::new(&mut csprng);
-    let signed_pre_key_pair = KeyPair::new(&mut csprng);
+    let pre_key_pair = KeyPair::generate(&mut csprng);
+    let signed_pre_key_pair = KeyPair::generate(&mut csprng);
 
     let signed_pre_key_public = signed_pre_key_pair.public_key.serialize();
     let signed_pre_key_signature = store
@@ -94,9 +94,9 @@ pub fn initialize_sessions_v3() -> Result<(SessionState, SessionState), SignalPr
     let alice_identity = IdentityKeyPair::generate(&mut csprng);
     let bob_identity = IdentityKeyPair::generate(&mut csprng);
 
-    let alice_base_key = KeyPair::new(&mut csprng);
+    let alice_base_key = KeyPair::generate(&mut csprng);
 
-    let bob_base_key = KeyPair::new(&mut csprng);
+    let bob_base_key = KeyPair::generate(&mut csprng);
     let bob_ephemeral_key = bob_base_key;
 
     let alice_params = AliceSignalProtocolParameters::new(