Fix text forwarding

Author: TaeHagen

src/ids/identity_manager.rs

@@ -18,7 +18,7 @@ use std::fmt::Debug;
 
 use crate::{aps::{get_message, APSConnection, APSInterestToken}, ids::{user::IDSIdentity, MessageBody}, register, util::{base64_decode, base64_encode, bin_deserialize, bin_deserialize_sha, bin_serialize, duration_since_epoch, encode_hex, plist_to_bin, plist_to_string, ungzip, Resource, ResourceManager}, APSConnectionResource, APSMessage, IDSUser, MessageInst, OSConfig, PushError};
 
-use super::{user::{IDSDeliveryData, IDSNGMIdentity, IDSPublicIdentity, IDSService, IDSUserIdentity, PrivateDeviceInfo, QueryOptions, ReportMessage}, CertifiedContext, IDSRecvMessage};
+use super::{user::{IDSDeliveryData, IDSNGMIdentity, IDSPublicIdentity, IDSService, IDSUserIdentity, IDSUserType, PrivateDeviceInfo, QueryOptions, ReportMessage}, CertifiedContext, IDSRecvMessage};
 
 const EMPTY_REFRESH: Duration = Duration::from_secs(3600); // one hour
 
@@ -255,6 +255,10 @@ impl KeyCache {
         let target_tokens = keys_for.iter().map(|i| Ok(match i {
             MessageTarget::Token(token) => token,
             MessageTarget::Uuid(uuid) => {
+                // the handle cache is madrid-only, TODO maybe fix if we ever need to
+                let Some(handle_cache) = self.cache.get("com.apple.madrid").and_then(|a| a.get(handle)) else {
+                    return Err(PushError::KeyNotFound(handle.to_string()))
+                };
                 let Some(saved) = handle_cache.private_data.iter().find(|p| p.uuid.as_ref() == Some(uuid)) else {
                     return Err(PushError::KeyNotFound(uuid.to_string()))
                 };
@@ -585,6 +589,12 @@ impl IdentityResource {
         Ok(private_self.clone())
     }
 
+    // gets phone handles *REGISTERED BY THIS DEVICE*
+    pub async fn get_my_phone_handles(&self) -> Vec<String> {
+        let user_lock = self.users.read().await;
+        user_lock.iter().filter(|user| user.user_type == IDSUserType::Phone).flat_map(|user| user.registration["com.apple.madrid"].handles.clone()).collect()
+    }
+
     pub async fn token_to_uuid(&self, handle: &str, token: &[u8]) -> Result<String, PushError> {
         let mut cache_lock = self.cache.lock().await;
         let private_self = &cache_lock.cache["com.apple.madrid"].get(handle).unwrap().private_data;
@@ -940,7 +950,7 @@ pub struct SendMessage {
     pub encryption: Option<String>,
     #[serde(rename = "ua")]
     pub user_agent: String,
-    pub v: Option<u8>,
+    pub v: Option<u32>,
     #[serde(rename = "i")]
     pub message_id: u32,
     #[serde(rename = "U")]
@@ -1050,7 +1060,7 @@ impl InnerSendJob {
                 command: message.command,
                 encryption: if !matches!(message.raw, Raw::None) { Some("pair".to_string()) } else { None },
                 user_agent: self.user_agent.clone(),
-                v: if !is_relay_message { Some(8) } else { None },
+                v: if !is_relay_message { Some(if self.topic == "com.apple.private.alloy.sms" { 1850 } else { 8 }) } else { None },
                 message_id: msg_id,
                 uuid: uuid.clone().into(),
                 payloads: group,

src/imessage/messages.rs

@@ -307,8 +307,8 @@ impl MessageParts {
         msg
     }
 
-    fn to_sms(&self, using_number: &str, mms: bool) -> (String, Vec<RawSmsIncomingMessageData>) {
-        let mut parts = vec![format!("s:{}", using_number)];
+    fn to_sms(&self, from_handle: &str, mms: bool) -> (String, Vec<RawSmsIncomingMessageData>) {
+        let mut parts = vec![format!("s:{}", from_handle)];
         let mut out = vec![];
         if !mms {
             parts.push("(null)(0)".to_string());
@@ -360,13 +360,7 @@ impl MessageParts {
     }
 
     fn parse_sms(raw: &RawSmsIncomingMessage) -> MessageParts {
-        MessageParts(raw.format.split("|").skip(1).enumerate().map(|(idx, part)| {
-            let corresponding = if part.starts_with("(null)") {
-                raw.content.iter().find(|i| i.content_id.is_none()).unwrap()
-            } else {
-                let filename = part.split("(").next().unwrap();
-                raw.content.iter().find(|i| i.content_location.as_ref().map(|i| i.as_str()) == Some(filename)).unwrap()
-            };
+        fn parse_data(idx: usize, corresponding: &RawSmsIncomingMessageData) -> IndexedMessagePart {
             let typ = if corresponding.mime_type == "text/plain" {
                 MessagePart::Text(String::from_utf8(corresponding.data.clone().into()).unwrap(), Default::default())
             } else {
@@ -384,7 +378,21 @@ impl MessageParts {
                 idx: None,
                 ext: None
             }
-        }).collect())
+        }
+
+        if raw.format.starts_with("s:") {
+            MessageParts(raw.format.split("|").skip(1).enumerate().map(|(idx, part)| {
+                let corresponding = if part.starts_with("(null)") {
+                    raw.content.iter().find(|i| i.content_id.is_none()).unwrap()
+                } else {
+                    let filename = part.split("(").next().unwrap();
+                    raw.content.iter().find(|i| i.content_location.as_ref().map(|i| i.as_str()) == Some(filename)).unwrap()
+                };
+                parse_data(idx, corresponding)
+            }).collect())
+        } else {
+            MessageParts(raw.content.iter().enumerate().map(|(idx, part)| parse_data(idx, part)).collect())
+        }
     }
 
     // parse XML parts
@@ -1539,13 +1547,23 @@ impl Message {
     pub fn get_c(&self) -> u8 {
         match self {
             Self::Message(msg) => {
-                match msg.service {
+                match &msg.service {
                     MessageType::IMessage => 100,
-                    MessageType::SMS { is_phone: _, using_number: _, from_handle: _ } => {
-                        if msg.parts.has_attachments() {
-                            144
+                    MessageType::SMS { is_phone: _, using_number: _, from_handle } => {
+                        if let Some(_) = from_handle {
+                            // forwarded message
+                            if msg.parts.has_attachments() {
+                                141
+                            } else {
+                                140
+                            }
                         } else {
-                            143
+                            // non-forwarded message
+                            if msg.parts.has_attachments() {
+                                144
+                            } else {
+                                143
+                            }
                         }
                     }
                 }
@@ -1621,6 +1639,9 @@ impl Message {
                 ("gC", Value::Integer(70000.into())),
                 ("pID", Value::Dictionary(Dictionary::new())),
             ]),
+            Message::Message(NormalMessage { service: MessageType::SMS { .. }, .. }) => Dictionary::from_iter([
+                ("htu", Value::Boolean(true)),
+            ]),
             _ => Default::default(),
         }
     }
@@ -2179,7 +2200,7 @@ impl MessageInst {
                                 .filter(|p| *p != self.sender.as_ref().unwrap() && *p != from_handle)
                                 .map(|p| p.replace("tel:", "")).collect();
                             let is_mms = my_participants.len() > 1 || normal.parts.has_attachments();
-                            let (format, content) = normal.parts.to_sms(&using_number, is_mms);
+                            let (format, content) = normal.parts.to_sms(&from_handle, is_mms);
                             let raw = RawSmsIncomingMessage {
                                 participants: if is_mms { my_participants } else { vec![] },
                                 sender: from_handle.replace("tel:", ""),
@@ -2610,7 +2631,12 @@ impl MessageInst {
             let mut msg = wrapper.to_message(
                 Some(ConversationData {
                     participants: if loaded.participants.len() > 0 {
-                        loaded.participants.iter().chain(std::iter::once(&loaded.sender)).map(|p| format!("tel:{p}")).collect()
+                        let mut participants = loaded.participants.clone();
+                        // duplicates cause chat matching in dart to fail (it is duplicate for RCS)
+                        if !participants.contains(&loaded.sender) {
+                            participants.push(loaded.sender.clone());
+                        }
+                        participants.iter().map(|p| format!("tel:{p}")).collect()
                     } else {
                         vec![format!("tel:{}", loaded.sender), format!("tel:{}", loaded.recieved_number)]
                     },
@@ -2637,6 +2663,7 @@ impl MessageInst {
                 })
             )?;
             msg.sent_timestamp = system_recv.duration_since(UNIX_EPOCH).unwrap().as_millis() as u64;
+            return Ok(msg);
         }
         if let Ok(loaded) = plist::from_value::<RawSmsOutgoingMessage>(&value) {
             let parts = loaded.message.xhtml.as_ref().map_or_else(|| {

src/imessage/rawmessages.rs

@@ -226,6 +226,14 @@ struct RawSmsActivateMessage {
     ar: bool,
 }
 
+#[derive(Serialize, Deserialize)]
+struct RawSmsStatusMessage {
+    #[serde(rename = "g")]
+    guid: String,
+    #[serde(rename = "e")]
+    date_read: Date,
+}
+
 #[derive(Serialize, Deserialize)]
 struct RawSmsDeactivateMessage {
     ue: bool,
@@ -244,7 +252,7 @@ struct RawSmsParticipant {
 #[derive(Serialize, Deserialize)]
 struct RawSmsOutgoingInnerMessage {
     handle: Option<String>, // only for single SMS
-    service: String, // always SMS, even for MMS chats
+    service: String, // always SMS, even for MMS chats (RCS for rcs)
     #[serde(rename = "sV")]
     version: String, // always 1
     guid: String, // same as outside encryption
@@ -259,7 +267,7 @@ struct RawSmsOutgoingInnerMessage {
 struct RawSmsOutgoingMessage {
     #[serde(rename = "re")]
     participants: Vec<RawSmsParticipant>,
-    ic: u32, // always seems to be 1
+    ic: u32, // always seems to be 1, 2 for rcs
     #[serde(rename = "fR")]
     already_sent: Option<bool>,
     #[serde(rename = "chat-style")]

src/relay.rs

@@ -168,22 +168,37 @@ impl OSConfig for RelayConfig {
     fn get_private_data(&self) -> Dictionary {
         let apple_epoch = SystemTime::UNIX_EPOCH + Duration::from_secs(978307200);
         Dictionary::from_iter([
-            ("ap", Value::String("0".to_string())), // 1 for ios
+            // apple pay
+            ("ap", Value::String("0".to_string())),
 
             ("d", Value::String(format!("{:.6}", apple_epoch.elapsed().unwrap().as_secs_f64()))),
+            // device type
             ("dt", Value::Integer(1.into())),
+            // green tea - ??
             ("gt", Value::String("0".to_string())),
+            // supports handoff
             ("h", Value::String("1".to_string())),
-            ("m", Value::String("0".to_string())),
+            // supports phone calls
             ("p", Value::String("0".to_string())),
 
             ("pb", Value::String(self.version.software_build_id.clone())),
             ("pn", Value::String(if self.version.software_name == "MacOS" { "macOS".to_string() } else { self.version.software_name.clone() })),
             ("pv", Value::String(self.version.software_version.clone())),
-
-            ("s", Value::String("0".to_string())),
+            
+            // mms router support
+            ("m", Value::String("1".to_string())),
+            // sms router support
+            ("s", Value::String("1".to_string())),
+
+            // tethering support
+            // ec = enclosure color
+            // c = data color
+            // ss = service signatures
+            // ktf = key transparency flags
+            // ktv = key transparency version
             ("t", Value::String("0".to_string())),
             ("u", Value::String(self.dev_uuid.clone().to_uppercase())),
+            // version
             ("v", Value::String("1".to_string())),
         ])
     }