Bump libsignal-service with adjustments (#291)

Author: gferon

presage-cli/src/main.rs

@@ -21,9 +21,9 @@ use presage::libsignal_service::prelude::ProfileKey;
 use presage::libsignal_service::prelude::Uuid;
 use presage::libsignal_service::proto::data_message::Quote;
 use presage::libsignal_service::proto::sync_message::Sent;
+use presage::libsignal_service::protocol::ServiceId;
 use presage::libsignal_service::sender::AttachmentSpec;
 use presage::libsignal_service::zkgroup::GroupMasterKeyBytes;
-use presage::libsignal_service::ServiceAddress;
 use presage::manager::ReceivingMode;
 use presage::model::contacts::Contact;
 use presage::model::groups::Group;
@@ -264,7 +264,7 @@ async fn send<S: Store>(
                 Recipient::Contact(uuid) => {
                     info!(recipient =% uuid, "sending message to contact");
                     manager
-                        .send_message(ServiceAddress::from_aci(uuid), content_body, timestamp)
+                        .send_message(ServiceId::Aci(uuid.into()), content_body, timestamp)
                         .await
                         .expect("failed to send message");
                 }
@@ -292,7 +292,7 @@ async fn process_incoming_message<S: Store>(
 ) {
     print_message(manager, notifications, content).await;
 
-    let sender = content.metadata.sender.uuid;
+    let sender = content.metadata.sender.raw_uuid();
     if let ContentBody::DataMessage(DataMessage { attachments, .. }) = &content.body {
         for attachment_pointer in attachments {
             let Ok(attachment_data) = manager.get_attachment(attachment_pointer).await else {
@@ -481,7 +481,7 @@ async fn print_message<S: Store>(
                 (format!("To {contact} @ {ts}"), body)
             }
             Msg::Received(Thread::Group(key), body) => {
-                let sender = format_contact(&content.metadata.sender.uuid, manager).await;
+                let sender = format_contact(&content.metadata.sender.raw_uuid(), manager).await;
                 let group = format_group(*key, manager).await;
                 (format!("From {sender} to group {group} @ {ts}: "), body)
             }
@@ -559,8 +559,8 @@ async fn run<S: Store>(subcommand: Cmd, config_store: S) -> anyhow::Result<()> {
                 let registered_manager =
                     manager.confirm_verification_code(confirmation_code).await?;
                 println!(
-                    "Account identifier: {}",
-                    registered_manager.registration_data().aci()
+                    "Account identifiers: {}",
+                    registered_manager.registration_data().service_ids
                 );
             }
         }
@@ -591,16 +591,16 @@ async fn run<S: Store>(subcommand: Cmd, config_store: S) -> anyhow::Result<()> {
 
             match manager {
                 (Ok(manager), _) => {
-                    let uuid = manager.whoami().await.unwrap().uuid;
-                    println!("{uuid:?}");
+                    let whoami = manager.whoami().await.unwrap();
+                    println!("{whoami:?}");
                 }
                 (Err(err), _) => {
                     println!("{err:?}");
                 }
             }
         }
         Cmd::AddDevice { url } => {
-            let manager = Manager::load_registered(config_store).await?;
+            let mut manager = Manager::load_registered(config_store).await?;
             manager.link_secondary(url).await?;
             println!("Added new secondary device");
         }

presage-store-sled/src/lib.rs

@@ -540,8 +540,7 @@ mod tests {
         content::{ContentBody, Metadata},
         prelude::Uuid,
         proto::DataMessage,
-        protocol::PreKeyId,
-        ServiceAddress, ServiceIdType,
+        protocol::{PreKeyId, ServiceId},
     };
     use presage::store::ContentsStore;
     use protocol::SledPreKeyId;
@@ -581,15 +580,11 @@ mod tests {
                 Uuid::from_u128(Arbitrary::arbitrary(g)),
                 Uuid::from_u128(Arbitrary::arbitrary(g)),
             ];
+            let sender_uuid: Uuid = *g.choose(&contacts).unwrap();
+            let destination_uuid: Uuid = *g.choose(&contacts).unwrap();
             let metadata = Metadata {
-                sender: ServiceAddress {
-                    uuid: *g.choose(&contacts).unwrap(),
-                    identity: ServiceIdType::AccountIdentity,
-                },
-                destination: ServiceAddress {
-                    uuid: *g.choose(&contacts).unwrap(),
-                    identity: ServiceIdType::AccountIdentity,
-                },
+                sender: ServiceId::Aci(sender_uuid.into()),
+                destination: ServiceId::Aci(destination_uuid.into()),
                 sender_device: Arbitrary::arbitrary(g),
                 server_guid: None,
                 timestamp,

presage-store-sled/src/protobuf.rs

@@ -11,30 +11,30 @@ use presage::libsignal_service::content::ContentBody;
 use presage::libsignal_service::content::Metadata;
 use presage::libsignal_service::prelude::Uuid;
 use presage::libsignal_service::proto;
-use presage::libsignal_service::ServiceAddress;
+use presage::libsignal_service::protocol::ServiceId;
 
 use crate::SledStoreError;
 
 use self::textsecure::AddressProto;
 use self::textsecure::MetadataProto;
 
-impl From<ServiceAddress> for AddressProto {
-    fn from(s: ServiceAddress) -> Self {
+impl From<ServiceId> for AddressProto {
+    fn from(s: ServiceId) -> Self {
         AddressProto {
-            uuid: Some(s.uuid.as_bytes().to_vec()),
+            uuid: Some(s.raw_uuid().as_bytes().to_vec()),
         }
     }
 }
 
-impl TryFrom<AddressProto> for ServiceAddress {
+impl TryFrom<AddressProto> for ServiceId {
     type Error = SledStoreError;
 
     fn try_from(address: AddressProto) -> Result<Self, Self::Error> {
         address
             .uuid
             .and_then(|bytes| Some(Uuid::from_bytes(bytes.try_into().ok()?)))
             .ok_or_else(|| SledStoreError::NoUuid)
-            .map(Self::from_aci)
+            .map(|u| ServiceId::Aci(u.into()))
     }
 }
 
@@ -49,7 +49,7 @@ impl From<Metadata> for MetadataProto {
             needs_receipt: Some(m.needs_receipt),
             server_guid: None,
             group_id: None,
-            destination_uuid: Some(m.destination.uuid.to_string()),
+            destination_uuid: Some(m.destination.raw_uuid().to_string()),
         }
     }
 }
@@ -60,10 +60,13 @@ impl TryFrom<MetadataProto> for Metadata {
     fn try_from(metadata: MetadataProto) -> Result<Self, Self::Error> {
         Ok(Metadata {
             sender: metadata.address.ok_or(SledStoreError::NoUuid)?.try_into()?,
-            destination: ServiceAddress::from_aci(match metadata.destination_uuid.as_deref() {
-                Some(value) => value.parse().map_err(|_| SledStoreError::NoUuid),
-                None => Ok(Uuid::nil()),
-            }?),
+            destination: ServiceId::Aci(
+                match metadata.destination_uuid.as_deref() {
+                    Some(value) => value.parse().map_err(|_| SledStoreError::NoUuid),
+                    None => Ok(Uuid::nil()),
+                }?
+                .into(),
+            ),
             sender_device: metadata
                 .sender_device
                 .and_then(|m| m.try_into().ok())

presage-store-sled/src/protocol.rs

@@ -9,12 +9,11 @@ use presage::{
             Direction, GenericSignedPreKey, IdentityKey, IdentityKeyPair, IdentityKeyStore,
             KyberPreKeyId, KyberPreKeyRecord, KyberPreKeyStore, PreKeyId, PreKeyRecord,
             PreKeyStore, ProtocolAddress, ProtocolStore, SenderKeyRecord, SenderKeyStore,
-            SessionRecord, SessionStore, SignalProtocolError, SignedPreKeyId, SignedPreKeyRecord,
-            SignedPreKeyStore,
+            ServiceId, SessionRecord, SessionStore, SignalProtocolError, SignedPreKeyId,
+            SignedPreKeyRecord, SignedPreKeyStore,
         },
         push_service::DEFAULT_DEVICE_ID,
         session_store::SessionStoreExt,
-        ServiceAddress,
     },
     proto::verified,
     store::{save_trusted_identity_message, StateStore},
@@ -464,9 +463,9 @@ impl<T: SledTrees> SessionStore for SledProtocolStore<T> {
 impl<T: SledTrees> SessionStoreExt for SledProtocolStore<T> {
     async fn get_sub_device_sessions(
         &self,
-        address: &ServiceAddress,
+        address: &ServiceId,
     ) -> Result<Vec<u32>, SignalProtocolError> {
-        let session_prefix = format!("{}.", address.uuid);
+        let session_prefix = format!("{}.", address.raw_uuid());
         trace!(session_prefix, "get_sub_device_sessions");
         let session_ids: Vec<u32> = self
             .store
@@ -496,16 +495,13 @@ impl<T: SledTrees> SessionStoreExt for SledProtocolStore<T> {
         Ok(())
     }
 
-    async fn delete_all_sessions(
-        &self,
-        address: &ServiceAddress,
-    ) -> Result<usize, SignalProtocolError> {
+    async fn delete_all_sessions(&self, address: &ServiceId) -> Result<usize, SignalProtocolError> {
         let db = self.store.write();
         let sessions_tree = db.open_tree(T::sessions()).map_err(SledStoreError::Db)?;
 
         let mut batch = Batch::default();
         sessions_tree
-            .scan_prefix(address.uuid.to_string())
+            .scan_prefix(address.raw_uuid().to_string())
             .filter_map(|r| {
                 let (key, _) = r.ok()?;
                 Some(key)

presage-store-sqlite/src/protocol.rs

@@ -6,11 +6,10 @@ use presage::libsignal_service::{
     protocol::{
         Direction, IdentityKey, IdentityKeyPair, KyberPreKeyId, KyberPreKeyRecord,
         KyberPreKeyStore, PreKeyId, PreKeyRecord, PreKeyStore, ProtocolAddress, ProtocolStore,
-        SenderKeyRecord, SenderKeyStore, SessionRecord, SessionStore,
+        SenderKeyRecord, SenderKeyStore, ServiceId, SessionRecord, SessionStore,
         SignalProtocolError as ProtocolError, SignedPreKeyId, SignedPreKeyRecord,
         SignedPreKeyStore,
     },
-    ServiceAddress,
 };
 
 use crate::SqliteStore;
@@ -47,10 +46,7 @@ impl SessionStoreExt for SqliteProtocolStore {
     /// Get the IDs of all known sub devices with active sessions for a recipient.
     ///
     /// This should return every device except for the main device [DEFAULT_DEVICE_ID].
-    async fn get_sub_device_sessions(
-        &self,
-        name: &ServiceAddress,
-    ) -> Result<Vec<u32>, ProtocolError> {
+    async fn get_sub_device_sessions(&self, name: &ServiceId) -> Result<Vec<u32>, ProtocolError> {
         todo!()
     }
 
@@ -63,7 +59,7 @@ impl SessionStoreExt for SqliteProtocolStore {
     /// ID.
     ///
     /// Returns the number of deleted sessions.
-    async fn delete_all_sessions(&self, address: &ServiceAddress) -> Result<usize, ProtocolError> {
+    async fn delete_all_sessions(&self, address: &ServiceId) -> Result<usize, ProtocolError> {
         todo!()
     }
 }

presage/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2021"
 license = "AGPL-3.0-only"
 
 [dependencies]
-libsignal-service = { git = "https://github.com/whisperfish/libsignal-service-rs", rev = "468fa6f84cce0db3bdf11609d165758291da99df" }
+libsignal-service = { git = "https://github.com/whisperfish/libsignal-service-rs", rev = "6401dc34872a5f0c2fba32c1f136d98ccf3dd418" }
 
 base64 = "0.22"
 futures = "0.3"

presage/src/manager/confirmation.rs

@@ -40,8 +40,8 @@ impl<S: Store> Manager<S, Confirmation> {
     ) -> Result<Manager<S, Registered>, Error<S::Error>> {
         trace!("confirming verification code");
 
-        let registration_id = generate_registration_id(&mut self.rng);
-        let pni_registration_id = generate_registration_id(&mut self.rng);
+        let registration_id = generate_registration_id(&mut self.csprng);
+        let pni_registration_id = generate_registration_id(&mut self.csprng);
 
         let Confirmation {
             signal_servers,
@@ -75,19 +75,19 @@ impl<S: Store> Manager<S, Confirmation> {
 
         // generate a 52 bytes signaling key
         let mut signaling_key = [0u8; 52];
-        self.rng.fill_bytes(&mut signaling_key);
+        self.csprng.fill_bytes(&mut signaling_key);
 
         // generate a 32 bytes profile key
         let mut profile_key = [0u8; 32];
-        self.rng.fill_bytes(&mut profile_key);
+        self.csprng.fill_bytes(&mut profile_key);
         let profile_key = ProfileKey::generate(profile_key);
 
         // generate new identity keys used in `register_account` and below
         self.store
-            .set_aci_identity_key_pair(IdentityKeyPair::generate(&mut self.rng))
+            .set_aci_identity_key_pair(IdentityKeyPair::generate(&mut self.csprng))
             .await?;
         self.store
-            .set_pni_identity_key_pair(IdentityKeyPair::generate(&mut self.rng))
+            .set_pni_identity_key_pair(IdentityKeyPair::generate(&mut self.csprng))
             .await?;
 
         let skip_device_transfer = true;
@@ -100,7 +100,7 @@ impl<S: Store> Manager<S, Confirmation> {
             number: _,
         } = account_manager
             .register_account(
-                &mut self.rng,
+                &mut self.csprng,
                 RegistrationMethod::SessionId(&session.id),
                 AccountAttributes {
                     signaling_key: Some(signaling_key.to_vec()),
@@ -126,7 +126,7 @@ impl<S: Store> Manager<S, Confirmation> {
         trace!("confirmed! (and registered)");
 
         let mut manager = Manager {
-            rng: self.rng,
+            csprng: self.csprng,
             store: self.store,
             state: Registered::with_data(RegistrationData {
                 signal_servers: self.state.signal_servers,

presage/src/manager/linking.rs

@@ -158,7 +158,7 @@ impl<S: Store> Manager<S, Linking> {
                 );
 
                 let mut manager = Manager {
-                    rng,
+                    csprng: rng,
                     store: store.clone(),
                     state: Registered::with_data(registration_data),
                 };

presage/src/manager/mod.rs

@@ -28,7 +28,7 @@ pub struct Manager<Store, State> {
     /// Part of the manager which is persisted in the store.
     state: State,
     /// Random number generator
-    rng: StdRng,
+    csprng: StdRng,
 }
 
 impl<Store, State: fmt::Debug> fmt::Debug for Manager<Store, State> {