Fix DeviceInfo::created

Schmiddiii · rubdos · commit aebf60700d36 · 2026-01-28T09:47:02.000+01:00
This somewhat recently changed, which lead to errors deserializing device
IDs. This field now needs to be decrypted. This commit adds that
decryption, and also replaces primitive types by DeviceId in many places
if appropriate.
diff --git a/Cargo.toml b/Cargo.toml
@@ -9,6 +9,7 @@ readme = "README.md"
 [dependencies]
 libsignal-protocol = { git = "https://github.com/signalapp/libsignal", tag = "v0.86.6" }
 libsignal-core = { git = "https://github.com/signalapp/libsignal", tag = "v0.86.6" }
+signal-crypto = { git = "https://github.com/signalapp/libsignal", tag = "v0.86.6" }
 zkgroup = { git = "https://github.com/signalapp/libsignal", tag = "v0.86.6" }
 
 aes = "0.8"
diff --git a/src/account_manager.rs b/src/account_manager.rs
@@ -1,4 +1,5 @@
 use base64::prelude::*;
+use libsignal_core::DeviceId;
 use phonenumber::PhoneNumber;
 use rand::{CryptoRng, Rng};
 use reqwest::Method;
@@ -457,8 +458,14 @@ impl AccountManager {
                             },
                         }
                     }),
-                    created: i.created,
+                    registration_id: i.registration_id,
                     last_seen: i.last_seen,
+                    created_at: decrypt_device_created_at_from_device_info(
+                        i.id,
+                        i.registration_id,
+                        &i.created_at_ciphertext,
+                        &aci_identity_keypair,
+                    )?,
                 })
             })
             .collect()
@@ -991,6 +998,33 @@ fn decrypt_device_name_from_device_info(
     crate::decrypt_device_name(aci.private_key(), &name)
 }
 
+// Analogous to https://github.com/signalapp/Signal-Android/blob/d88a862e0985cc2bbc463c5f504f5bb4e91ad4fc/app/src/main/java/org/thoughtcrime/securesms/linkdevice/LinkDeviceRepository.kt#L121.
+fn decrypt_device_created_at_from_device_info(
+    id: DeviceId,
+    registration_id: i32,
+    string: &str,
+    aci: &IdentityKeyPair,
+) -> Result<chrono::DateTime<chrono::Utc>, ServiceError> {
+    use signal_crypto::SimpleHpkeReceiver;
+
+    let mut associated_data = [0; 5];
+    associated_data[0] = id.into();
+    associated_data[1..].copy_from_slice(&registration_id.to_be_bytes());
+
+    let data = BASE64_RELAXED.decode(string)?;
+
+    let result =
+        aci.private_key()
+            .open(b"deviceCreatedAt", &associated_data, &data)?;
+
+    let timestamp = i64::from_be_bytes(result.try_into().map_err(|_| {
+        ServiceError::DecryptDeviceInfoFieldError("created-at")
+    })?);
+
+    chrono::DateTime::<chrono::Utc>::from_timestamp_millis(timestamp)
+        .ok_or(ServiceError::DecryptDeviceInfoFieldError("created-at"))
+}
+
 pub fn decrypt_device_name(
     private_key: &PrivateKey,
     device_name: &DeviceName,
@@ -1001,7 +1035,7 @@ pub fn decrypt_device_name(
         ciphertext: Some(ciphertext),
     } = device_name
     else {
-        return Err(ServiceError::InvalidDeviceName);
+        return Err(ServiceError::DecryptDeviceInfoFieldError("name"));
     };
 
     let synthetic_iv: [u8; 16] = synthetic_iv[..synthetic_iv.len().min(16)]
diff --git a/src/cipher.rs b/src/cipher.rs
@@ -418,7 +418,7 @@ where
             use crate::proto::envelope::Type;
             Ok(OutgoingPushMessage {
                 r#type: Type::UnidentifiedSender as u32,
-                destination_device_id: address.device_id().into(),
+                destination_device_id: address.device_id(),
                 destination_registration_id,
                 content: BASE64_RELAXED.encode(message),
             })
@@ -446,7 +446,7 @@ where
             } as u32;
             Ok(OutgoingPushMessage {
                 r#type: message_type,
-                destination_device_id: address.device_id().into(),
+                destination_device_id: address.device_id(),
                 destination_registration_id,
                 content: body,
             })
diff --git a/src/provisioning/mod.rs b/src/provisioning/mod.rs
@@ -332,7 +332,7 @@ pub async fn link_device<
             NewDeviceRegistration {
                 phone_number,
                 service_ids: ServiceIds { aci, pni },
-                device_id: device_id.try_into()?,
+                device_id,
                 registration_id,
                 pni_registration_id,
                 aci_private_key,
diff --git a/src/push_service/error.rs b/src/push_service/error.rs
@@ -100,8 +100,8 @@ pub enum ServiceError {
     #[error("Not found.")]
     NotFoundError,
 
-    #[error("invalid device name")]
-    InvalidDeviceName,
+    #[error("failed to decrypt field from device info: {0}")]
+    DecryptDeviceInfoFieldError(&'static str),
 
     #[error("Unknown CDN version {0}")]
     UnknownCdnVersion(u32),
@@ -112,12 +112,23 @@ pub enum ServiceError {
     #[error(transparent)]
     Curve(#[from] CurveError),
 
+    // HpkeError does not implement StdError, so we need a manual display,
+    // and manual From impl.
+    #[error("Cryptographic error: {0}")]
+    Hpke(signal_crypto::HpkeError),
+
     // FingerprintError does not implement StdError, so we need a manual display,
     // and manual From impl.
     #[error("Fingerprint error: {0}")]
     Fingerprint(FingerprintError),
 }
 
+impl From<signal_crypto::HpkeError> for ServiceError {
+    fn from(value: signal_crypto::HpkeError) -> Self {
+        ServiceError::Hpke(value)
+    }
+}
+
 impl From<FingerprintError> for ServiceError {
     fn from(value: FingerprintError) -> Self {
         ServiceError::Fingerprint(value)
diff --git a/src/push_service/linking.rs b/src/push_service/linking.rs
@@ -1,9 +1,11 @@
+use libsignal_core::DeviceId;
 use reqwest::Method;
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
 use crate::{
-    configuration::Endpoint, websocket::registration::DeviceActivationRequest,
+    configuration::Endpoint, utils::serde_device_id,
+    websocket::registration::DeviceActivationRequest,
 };
 
 use super::{
@@ -50,7 +52,8 @@ pub struct LinkResponse {
     #[serde(rename = "uuid")]
     pub aci: Uuid,
     pub pni: Uuid,
-    pub device_id: u32,
+    #[serde(with = "serde_device_id")]
+    pub device_id: DeviceId,
 }
 
 #[derive(Debug, Serialize)]
diff --git a/src/push_service/mod.rs b/src/push_service/mod.rs
@@ -3,9 +3,11 @@ use std::{sync::LazyLock, time::Duration};
 use crate::{
     configuration::{Endpoint, ServiceCredentials},
     prelude::ServiceConfiguration,
+    utils::serde_device_id_vec,
     websocket::{SignalWebSocket, WebSocketType},
 };
 
+use libsignal_core::DeviceId;
 use protobuf::ProtobufResponseExt;
 use reqwest::{Method, RequestBuilder};
 use reqwest_websocket::RequestBuilderExt;
@@ -57,14 +59,17 @@ pub enum AvatarWrite<C> {
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct MismatchedDevices {
-    pub missing_devices: Vec<u32>,
-    pub extra_devices: Vec<u32>,
+    #[serde(with = "serde_device_id_vec")]
+    pub missing_devices: Vec<DeviceId>,
+    #[serde(with = "serde_device_id_vec")]
+    pub extra_devices: Vec<DeviceId>,
 }
 
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct StaleDevices {
-    pub stale_devices: Vec<u32>,
+    #[serde(with = "serde_device_id_vec")]
+    pub stale_devices: Vec<DeviceId>,
 }
 
 #[derive(Clone)]
diff --git a/src/sender.rs b/src/sender.rs
@@ -29,7 +29,7 @@ use crate::{
     service_address::ServiceIdExt,
     session_store::SessionStoreExt,
     unidentified_access::UnidentifiedAccess,
-    utils::serde_service_id,
+    utils::{serde_device_id, serde_service_id},
     websocket::{self, SignalWebSocket},
 };
 
@@ -39,7 +39,8 @@ pub use crate::proto::ContactDetails;
 #[serde(rename_all = "camelCase")]
 pub struct OutgoingPushMessage {
     pub r#type: u32,
-    pub destination_device_id: u32,
+    #[serde(with = "serde_device_id")]
+    pub destination_device_id: DeviceId,
     pub destination_registration_id: u32,
     pub content: String,
 }
@@ -631,9 +632,8 @@ where
                         );
                         self.protocol_store
                             .delete_service_addr_device_session(
-                                &recipient.to_protocol_address(
-                                    (*extra_device_id).try_into()?,
-                                )?,
+                                &recipient
+                                    .to_protocol_address(*extra_device_id)?,
                             )
                             .await?;
                     }
@@ -643,9 +643,8 @@ where
                             "creating session with missing device {}",
                             missing_device_id
                         );
-                        let remote_address = recipient.to_protocol_address(
-                            (*missing_device_id).try_into()?,
-                        )?;
+                        let remote_address = recipient
+                            .to_protocol_address(*missing_device_id)?;
                         let pre_key = self
                             .identified_ws
                             .get_pre_key(&recipient, *missing_device_id)
@@ -677,9 +676,8 @@ where
                         );
                         self.protocol_store
                             .delete_service_addr_device_session(
-                                &recipient.to_protocol_address(
-                                    (*extra_device_id).try_into()?,
-                                )?,
+                                &recipient
+                                    .to_protocol_address(*extra_device_id)?,
                             )
                             .await?;
                     }
@@ -993,7 +991,7 @@ where
             );
             let pre_keys = match self
                 .identified_ws
-                .get_pre_keys(recipient, device_id.into())
+                .get_pre_keys(recipient, device_id)
                 .await
             {
                 Ok(ok) => {
diff --git a/src/utils.rs b/src/utils.rs
@@ -335,3 +335,55 @@ pub mod serde_aci {
             .ok_or_else(|| serde::de::Error::custom("invalid ACI string"))
     }
 }
+
+pub mod serde_device_id {
+    use libsignal_core::DeviceId;
+    use serde::{Deserialize, Deserializer, Serializer};
+
+    pub fn serialize<S>(id: &DeviceId, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_u8(u8::from(*id))
+    }
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<DeviceId, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        DeviceId::try_from(u8::deserialize(deserializer)?)
+            .map_err(|_| serde::de::Error::custom("invalid device id"))
+    }
+}
+
+pub mod serde_device_id_vec {
+    use libsignal_core::DeviceId;
+    use serde::{ser::SerializeSeq, Deserialize, Deserializer, Serializer};
+
+    pub fn serialize<S>(
+        ids: &Vec<DeviceId>,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut seq = serializer.serialize_seq(Some(ids.len()))?;
+        for id in ids {
+            seq.serialize_element(&u8::from(*id))?;
+        }
+        seq.end()
+    }
+
+    pub fn deserialize<'de, D>(
+        deserializer: D,
+    ) -> Result<Vec<DeviceId>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Vec::<u8>::deserialize(deserializer)?
+            .into_iter()
+            .map(DeviceId::try_from)
+            .collect::<Result<Vec<_>, _>>()
+            .map_err(|_| serde::de::Error::custom("invalid device id"))
+    }
+}
diff --git a/src/websocket/account.rs b/src/websocket/account.rs
@@ -5,25 +5,42 @@ use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
 use crate::{
-    content::ServiceError, utils::serde_optional_base64,
-    utils::serde_phone_number, websocket,
+    content::ServiceError,
+    utils::serde_optional_base64,
+    utils::{serde_device_id, serde_phone_number},
+    websocket,
 };
 
 use super::SignalWebSocket;
 
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct DeviceId {
-    pub device_id: u32,
+    #[serde(with = "serde_device_id")]
+    pub device_id: libsignal_core::DeviceId,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct DeviceInfo {
-    pub id: u8,
+    #[serde(with = "serde_device_id")]
+    pub id: libsignal_core::DeviceId,
+    pub registration_id: i32,
     pub name: Option<String>,
     #[serde(with = "chrono::serde::ts_milliseconds")]
-    pub created: DateTime<Utc>,
+    pub created_at: DateTime<Utc>,
+    #[serde(with = "chrono::serde::ts_milliseconds")]
+    pub last_seen: DateTime<Utc>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct DeviceInfoEncrypted {
+    #[serde(with = "serde_device_id")]
+    pub id: libsignal_core::DeviceId,
+    pub name: Option<String>,
+    pub registration_id: i32,
+    pub created_at_ciphertext: String,
     #[serde(with = "chrono::serde::ts_milliseconds")]
     pub last_seen: DateTime<Utc>,
 }
@@ -95,10 +112,12 @@ impl SignalWebSocket<websocket::Identified> {
     /// Fetches a list of all devices tied to the authenticated account.
     ///
     /// This list include the device that sends the request.
-    pub async fn devices(&mut self) -> Result<Vec<DeviceInfo>, ServiceError> {
+    pub(crate) async fn devices(
+        &mut self,
+    ) -> Result<Vec<DeviceInfoEncrypted>, ServiceError> {
         #[derive(serde::Deserialize)]
         struct DeviceInfoList {
-            devices: Vec<DeviceInfo>,
+            devices: Vec<DeviceInfoEncrypted>,
         }
 
         let devices: DeviceInfoList = self
diff --git a/src/websocket/keys.rs b/src/websocket/keys.rs
diff --git a/src/websocket/linking.rs b/src/websocket/linking.rs
