Update libsignal-service-rs

Schmiddiii · Jan 16, 2024 · 0f96270 · 0f96270
1 parent dac9b35
commit 0f96270
Show file tree

Hide file tree

Showing 6 changed files with 31 additions and 18 deletions.
diff --git a/presage-store-sled/src/lib.rs b/presage-store-sled/src/lib.rs
@@ -605,41 +605,42 @@ impl ContentsStore for SledStore {
     }
 }
 
+#[async_trait(?Send)]
 impl PreKeysStore for SledStore {
-    fn pre_keys_offset_id(&self) -> Result<u32, SignalProtocolError> {
+    async fn next_pre_key_id(&self) -> Result<u32, SignalProtocolError> {
         Ok(self
             .get(SLED_TREE_STATE, SLED_KEY_PRE_KEYS_OFFSET_ID)
             .map_err(|_| SignalProtocolError::InvalidPreKeyId)?
             .unwrap_or(0))
     }
 
-    fn set_pre_keys_offset_id(&mut self, id: u32) -> Result<(), SignalProtocolError> {
+    async fn set_next_pre_key_id(&mut self, id: u32) -> Result<(), SignalProtocolError> {
         self.insert(SLED_TREE_STATE, SLED_KEY_PRE_KEYS_OFFSET_ID, id)
             .map_err(|_| SignalProtocolError::InvalidPreKeyId)?;
         Ok(())
     }
 
-    fn next_signed_pre_key_id(&self) -> Result<u32, SignalProtocolError> {
+    async fn next_signed_pre_key_id(&self) -> Result<u32, SignalProtocolError> {
         Ok(self
             .get(SLED_TREE_STATE, SLED_KEY_NEXT_SIGNED_PRE_KEY_ID)
             .map_err(|_| SignalProtocolError::InvalidSignedPreKeyId)?
             .unwrap_or(0))
     }
 
-    fn set_next_signed_pre_key_id(&mut self, id: u32) -> Result<(), SignalProtocolError> {
+    async fn set_next_signed_pre_key_id(&mut self, id: u32) -> Result<(), SignalProtocolError> {
         self.insert(SLED_TREE_STATE, SLED_KEY_NEXT_SIGNED_PRE_KEY_ID, id)
             .map_err(|_| SignalProtocolError::InvalidSignedPreKeyId)?;
         Ok(())
     }
 
-    fn next_pq_pre_key_id(&self) -> Result<u32, SignalProtocolError> {
+    async fn next_pq_pre_key_id(&self) -> Result<u32, SignalProtocolError> {
         Ok(self
             .get(SLED_TREE_STATE, SLED_KEY_NEXT_PQ_PRE_KEY_ID)
             .map_err(|_| SignalProtocolError::InvalidKyberPreKeyId)?
             .unwrap_or(0))
     }
 
-    fn set_next_pq_pre_key_id(&mut self, id: u32) -> Result<(), SignalProtocolError> {
+    async fn set_next_pq_pre_key_id(&mut self, id: u32) -> Result<(), SignalProtocolError> {
         self.insert(SLED_TREE_STATE, SLED_KEY_NEXT_PQ_PRE_KEY_ID, id)
             .map_err(|_| SignalProtocolError::InvalidKyberPreKeyId)?;
         Ok(())
@@ -1205,6 +1206,7 @@ mod tests {
                     uuid: *g.choose(&contacts).unwrap(),
                 },
                 sender_device: Arbitrary::arbitrary(g),
+                server_guid: None,
                 timestamp,
                 needs_receipt: Arbitrary::arbitrary(g),
                 unidentified_sender: Arbitrary::arbitrary(g),

diff --git a/presage-store-sled/src/protobuf.rs b/presage-store-sled/src/protobuf.rs
@@ -4,6 +4,8 @@ mod textsecure {
     include!(concat!(env!("OUT_DIR"), "/textsecure.rs"));
 }
 
+use std::str::FromStr;
+
 use presage::libsignal_service::content::Content;
 use presage::libsignal_service::content::ContentBody;
 use presage::libsignal_service::content::Metadata;
@@ -61,6 +63,9 @@ impl TryFrom<MetadataProto> for Metadata {
                 .sender_device
                 .and_then(|m| m.try_into().ok())
                 .unwrap_or_default(),
+            server_guid: metadata
+                .server_guid
+                .and_then(|u| crate::Uuid::from_str(&u).ok()),
             timestamp: metadata
                 .timestamp
                 .and_then(|m| m.try_into().ok())

diff --git a/presage/Cargo.toml b/presage/Cargo.toml
@@ -6,8 +6,8 @@ authors = ["Gabriel Féron <[email protected]>"]
 edition = "2021"
 
 [dependencies]
-libsignal-service = { git = "https://github.com/whisperfish/libsignal-service-rs", rev = "9d55addebe010f0acbcabdfc02ab41979c1863e0" }
-libsignal-service-hyper = { git = "https://github.com/whisperfish/libsignal-service-rs", rev = "9d55addebe010f0acbcabdfc02ab41979c1863e0" }
+libsignal-service = { git = "https://github.com/whisperfish/libsignal-service-rs", rev = "54ce3c44d706ef8af6f2620734e4041602333a5e" }
+libsignal-service-hyper = { git = "https://github.com/whisperfish/libsignal-service-rs", rev = "54ce3c44d706ef8af6f2620734e4041602333a5e" }
 
 base64 = "0.21"
 futures = "0.3"

diff --git a/presage/src/manager/confirmation.rs b/presage/src/manager/confirmation.rs
@@ -51,7 +51,8 @@ impl<S: Store> Manager<S, Confirmation> {
         } = self.state;
 
         let credentials = ServiceCredentials {
-            uuid: None,
+            aci: None,
+            pni: None,
             phonenumber: phone_number.clone(),
             password: Some(password.clone()),
             signaling_key: None,

diff --git a/presage/src/manager/registered.rs b/presage/src/manager/registered.rs
@@ -23,8 +23,8 @@ use libsignal_service::protocol::SenderCertificate;
 use libsignal_service::protocol::{PrivateKey, PublicKey};
 use libsignal_service::provisioning::generate_registration_id;
 use libsignal_service::push_service::{
-    AccountAttributes, DeviceCapabilities, PushService, ServiceError, ServiceIds, WhoAmIResponse,
-    DEFAULT_DEVICE_ID,
+    AccountAttributes, DeviceCapabilities, PushService, ServiceError, ServiceIdType, ServiceIds,
+    WhoAmIResponse, DEFAULT_DEVICE_ID,
 };
 use libsignal_service::receiver::MessageReceiver;
 use libsignal_service::sender::{AttachmentSpec, AttachmentUploadError};
@@ -271,18 +271,19 @@ impl<S: Store> Manager<S, Registered> {
         let (pre_keys_offset_id, next_signed_pre_key_id, next_pq_pre_key_id) = account_manager
             .update_pre_key_bundle(
                 &mut self.store.clone(),
+                ServiceIdType::AccountIdentity, // TODO: What about PNI?
                 &mut self.rng,
-                self.store.pre_keys_offset_id()?,
-                self.store.next_signed_pre_key_id()?,
-                self.store.next_pq_pre_key_id()?,
                 true,
             )
             .await?;
 
-        self.store.set_pre_keys_offset_id(pre_keys_offset_id)?;
+        self.store.set_next_pre_key_id(pre_keys_offset_id).await?;
         self.store
-            .set_next_signed_pre_key_id(next_signed_pre_key_id)?;
-        self.store.set_next_pq_pre_key_id(next_pq_pre_key_id)?;
+            .set_next_signed_pre_key_id(next_signed_pre_key_id)
+            .await?;
+        self.store
+            .set_next_pq_pre_key_id(next_pq_pre_key_id)
+            .await?;
 
         trace!("registered pre keys");
         Ok(())
@@ -719,6 +720,7 @@ impl<S: Store> Manager<S, Registered> {
             metadata: Metadata {
                 sender: self.state.data.service_ids.aci.into(),
                 sender_device: self.state.device_id(),
+                server_guid: None, // TODO: What value should this have?
                 timestamp,
                 needs_receipt: false,
                 unidentified_sender: false,
@@ -823,6 +825,7 @@ impl<S: Store> Manager<S, Registered> {
             metadata: Metadata {
                 sender: self.state.data.service_ids.aci.into(),
                 sender_device: self.state.device_id(),
+                server_guid: None, // TODO: What value should this have?
                 timestamp,
                 needs_receipt: false, // TODO: this is just wrong
                 unidentified_sender: false,
@@ -895,7 +898,8 @@ impl<S: Store> Manager<S, Registered> {
 
     fn credentials(&self) -> Option<ServiceCredentials> {
         Some(ServiceCredentials {
-            uuid: Some(self.state.data.service_ids.aci),
+            aci: Some(self.state.data.service_ids.aci),
+            pni: Some(self.state.data.service_ids.pni),
             phonenumber: self.state.data.phone_number.clone(),
             password: Some(self.state.data.password.clone()),
             signaling_key: Some(self.state.data.signaling_key),

diff --git a/presage/src/store.rs b/presage/src/store.rs
@@ -94,6 +94,7 @@ pub trait ContentsStore {
             metadata: Metadata {
                 sender: sender.into(),
                 sender_device: 0,
+                server_guid: None,
                 timestamp: SystemTime::now()
                     .duration_since(SystemTime::UNIX_EPOCH)
                     .unwrap_or_default()