1use std::collections::BTreeMap;
4use std::time::{SystemTime, UNIX_EPOCH};
5
6use base64::Engine;
7use ipatool_core::client::AppleClient;
8use ipatool_core::model::Account;
9use ipatool_core::sap::ActionSigner;
10use serde::{Deserialize, Serialize};
11
12use crate::error::{IpatoolError, Result};
13
14const DAAP_BASE: &str = "https://pd.itunes.apple.com/WebObjects/MZPurchaseDaap.woa/purchase";
15const MEDIA_KIND_APPS: u64 = 131_072;
16const MEDIA_KIND_ARCADE: u64 = 262_144;
17const MEDIA_KIND_MAC: u64 = 67_108_864;
18
19#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
20pub struct OwnedApp {
21 #[serde(default, alias = "trackId")]
22 pub id: i64,
23 #[serde(default, alias = "bundleId", rename = "bundleID")]
24 pub bundle_id: String,
25 #[serde(default, alias = "trackName")]
26 pub name: String,
27 #[serde(default)]
28 pub version: String,
29 #[serde(default, alias = "purchaseDate")]
30 pub purchase_date: String,
31 #[serde(default)]
32 pub platforms: Vec<String>,
33}
34
35pub async fn fetch_owned_apps(
36 client: &AppleClient,
37 account: &Account,
38 signer: &dyn ActionSigner,
39) -> Result<Vec<OwnedApp>> {
40 let mut apps = Vec::new();
41 for store in ["34", "13"] {
42 apps.extend(fetch_owned_apps_store(client, account, signer, store).await?);
43 }
44 Ok(merge_owned_apps(apps))
45}
46
47pub async fn fetch_owned_apps_store(
50 client: &AppleClient,
51 account: &Account,
52 signer: &dyn ActionSigner,
53 store: &str,
54) -> Result<Vec<OwnedApp>> {
55 let guid = client.guid().to_string();
56 let store_front_base = account
57 .store_front
58 .split(',')
59 .next()
60 .unwrap_or(&account.store_front)
61 .to_string();
62 let mut acc = account.clone();
63 acc.store_front = format!("{store_front_base},{store}");
64 fetch_owned_apps_for_storefront(client, &acc, &guid, signer).await
65}
66
67pub fn merge_apps(apps: Vec<OwnedApp>) -> Vec<OwnedApp> {
68 merge_owned_apps(apps)
69}
70
71async fn fetch_owned_apps_for_storefront(
72 client: &AppleClient,
73 account: &Account,
74 guid: &str,
75 signer: &dyn ActionSigner,
76) -> Result<Vec<OwnedApp>> {
77 let login_body = client
81 .http()
82 .post(format!("{DAAP_BASE}/login"))
83 .headers(owned_headers(account, guid)?)
84 .header(reqwest::header::CONTENT_LENGTH, "0")
85 .body(Vec::<u8>::new())
86 .send()
87 .await
88 .map_err(|e| IpatoolError::Http(e.to_string()))?;
89 let login_status = login_body.status().as_u16();
90 let login_bytes = login_body
91 .bytes()
92 .await
93 .map_err(|e| IpatoolError::Http(e.to_string()))?;
94 check_http("purchase history login", login_status)?;
95 check_dmap_status("purchase history login", &login_bytes)?;
96
97 let session_id = first_dmap_u32(&login_bytes, "mlid")
98 .ok_or_else(|| IpatoolError::msg("purchase history login: missing session id"))?;
99
100 let query = format!(
101 "('com.apple.itunes.extended\\-media\\-kind:{MEDIA_KIND_APPS}','com.apple.itunes.extended\\-media\\-kind:{MEDIA_KIND_ARCADE}','com.apple.itunes.extended\\-media\\-kind:{MEDIA_KIND_MAC}')"
102 );
103 let update_body = format!("session-id={session_id}&revision-number=(null)&query={query}");
104 let update_bytes = update_body.into_bytes();
105 let signature = signer
106 .sign(&update_bytes)
107 .map_err(|e| IpatoolError::msg(format!("SAP sign: {e}")))?;
108 let mut headers = owned_headers(account, guid)?;
109 headers.insert(
110 reqwest::header::CONTENT_TYPE,
111 "application/x-www-form-urlencoded"
112 .parse()
113 .map_err(|e| IpatoolError::msg(format!("header: {e}")))?,
114 );
115 headers.insert(
116 reqwest::header::HeaderName::from_static("x-apple-actionsignature"),
117 encode_sig(&signature)?,
118 );
119
120 let update_resp = client
121 .http()
122 .post(format!("{DAAP_BASE}/update"))
123 .headers(headers)
124 .body(update_bytes)
125 .send()
126 .await
127 .map_err(|e| IpatoolError::Http(e.to_string()))?;
128 let update_status = update_resp.status().as_u16();
129 let update_data = update_resp
130 .bytes()
131 .await
132 .map_err(|e| IpatoolError::Http(e.to_string()))?;
133 check_http("purchase history update", update_status)?;
134 check_dmap_status("purchase history update", &update_data)?;
135
136 let latest = first_dmap_u32(&update_data, "musr")
137 .ok_or_else(|| IpatoolError::msg("purchase history update: missing revision"))?;
138
139 let items_body = owned_items_body(session_id, latest, &query);
140 let items_sig = signer
141 .sign(&items_body)
142 .map_err(|e| IpatoolError::msg(format!("SAP sign: {e}")))?;
143 let mut items_headers = owned_headers(account, guid)?;
144 items_headers.insert(
145 reqwest::header::CONTENT_TYPE,
146 "application/x-dmap-tagged"
147 .parse()
148 .map_err(|e| IpatoolError::msg(format!("header: {e}")))?,
149 );
150 items_headers.insert(
151 reqwest::header::HeaderName::from_static("x-apple-actionsignature"),
152 encode_sig(&items_sig)?,
153 );
154
155 let items_resp = client
156 .http()
157 .post(format!("{DAAP_BASE}/databases/{latest}/items"))
158 .headers(items_headers)
159 .body(items_body)
160 .send()
161 .await
162 .map_err(|e| IpatoolError::Http(e.to_string()))?;
163 let items_status = items_resp.status().as_u16();
164 let items_data = items_resp
165 .bytes()
166 .await
167 .map_err(|e| IpatoolError::Http(e.to_string()))?;
168 check_http("purchase history items", items_status)?;
169 check_dmap_status("purchase history items", &items_data)?;
170
171 parse_owned_apps(&items_data)
172}
173
174fn encode_sig(sig: &[u8]) -> Result<reqwest::header::HeaderValue> {
175 let b64 = base64::engine::general_purpose::STANDARD.encode(sig);
176 b64.parse()
177 .map_err(|e| IpatoolError::msg(format!("sig header: {e}")))
178}
179
180fn owned_headers(account: &Account, guid: &str) -> Result<reqwest::header::HeaderMap> {
181 let now = SystemTime::now();
182 let unix = now
183 .duration_since(UNIX_EPOCH)
184 .map(|d| d.as_secs())
185 .unwrap_or(0);
186 let http_date = httpdate_now(unix);
188 let iso = format_iso(unix);
189
190 let mut h = reqwest::header::HeaderMap::new();
191 let pairs = [
192 ("accept", "*/*"),
193 ("accept-language", "en-us"),
194 ("client-cloud-daap-request-reason", "5"),
195 ("client-cloud-purchase-daap-version", "1.1/Configurator-2.0"),
196 ("client-daap-version", "3.12"),
197 ("date", http_date.as_str()),
198 ("icloud-dsid", account.directory_services_id.as_str()),
199 ("x-apple-i-client-time", iso.as_str()),
200 ("x-apple-i-locale", "en_US"),
201 ("x-apple-i-timezone", "UTC"),
202 ("x-apple-store-front", account.store_front.as_str()),
203 ("x-apple-tz", "0"),
204 ("x-dsid", account.directory_services_id.as_str()),
205 ("x-guid", guid),
206 ("x-token", account.password_token.as_str()),
207 ];
208 for (k, v) in pairs {
209 let name = reqwest::header::HeaderName::from_bytes(k.as_bytes())
210 .map_err(|e| IpatoolError::msg(format!("header name: {e}")))?;
211 let val = reqwest::header::HeaderValue::from_str(v)
212 .map_err(|e| IpatoolError::msg(format!("header value: {e}")))?;
213 h.insert(name, val);
214 }
215 Ok(h)
216}
217
218fn httpdate_now(unix: u64) -> String {
219 const DAYS: [&str; 7] = ["Thu", "Fri", "Sat", "Sun", "Mon", "Tue", "Wed"];
221 const MONTHS: [&str; 12] = [
222 "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
223 ];
224 let secs = unix as i64;
225 let days = secs.div_euclid(86400);
226 let tod = secs.rem_euclid(86400) as u32;
227 let hh = tod / 3600;
228 let mm = (tod % 3600) / 60;
229 let ss = tod % 60;
230 let (y, m, d) = civil_from_days(days + 719_468);
232 let weekday = DAYS[((days % 7) + 7) as usize % 7];
233 format!(
234 "{weekday}, {d:02} {} {y} {hh:02}:{mm:02}:{ss:02} GMT",
235 MONTHS[(m - 1) as usize]
236 )
237}
238
239fn format_iso(unix: u64) -> String {
240 let secs = unix as i64;
241 let days = secs.div_euclid(86400);
242 let tod = secs.rem_euclid(86400) as u32;
243 let hh = tod / 3600;
244 let mm = (tod % 3600) / 60;
245 let ss = tod % 60;
246 let (y, m, d) = civil_from_days(days + 719_468);
247 format!("{y:04}-{m:02}-{d:02}T{hh:02}:{mm:02}:{ss:02}Z")
248}
249
250fn civil_from_days(z: i64) -> (i32, u32, u32) {
252 let era = if z >= 0 { z } else { z - 146_096 }.div_euclid(146_097);
253 let doe = (z - era * 146_097) as u64;
254 let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146_096) / 365;
255 let y = (yoe as i64) + era * 400;
256 let doy = doe - (365 * yoe + yoe / 4 - yoe / 100);
257 let mp = (5 * doy + 2) / 153;
258 let d = doy - (153 * mp + 2) / 5 + 1;
259 let m = if mp < 10 { mp + 3 } else { mp - 9 };
260 let y = if m <= 2 { y + 1 } else { y };
261 (y as i32, m as u32, d as u32)
262}
263
264fn owned_items_body(session_id: u32, latest: u32, query: &str) -> Vec<u8> {
265 let now = SystemTime::now()
266 .duration_since(UNIX_EPOCH)
267 .map(|d| d.as_secs() as u32)
268 .unwrap_or(0);
269 let mut payload = Vec::new();
270 payload.extend(dmap_u32("mstc", now));
271 payload.extend(dmap_u32("mlid", session_id));
272 payload.extend(dmap_u8("mikd", 2));
273 payload.extend(dmap_u32("musr", latest));
274 payload.extend(dmap_u32("mder", 0));
275 payload.extend(dmap_str("mque", query));
276 payload.extend(dmap_tag("aetl", &[]));
277 dmap_tag("adsr", &payload)
278}
279
280fn dmap_tag(name: &str, payload: &[u8]) -> Vec<u8> {
281 let mut out = Vec::with_capacity(8 + payload.len());
282 out.extend_from_slice(name.as_bytes());
283 out.extend_from_slice(&(payload.len() as u32).to_be_bytes());
284 out.extend_from_slice(payload);
285 out
286}
287
288fn dmap_u8(name: &str, v: u8) -> Vec<u8> {
289 dmap_tag(name, &[v])
290}
291
292fn dmap_u32(name: &str, v: u32) -> Vec<u8> {
293 dmap_tag(name, &v.to_be_bytes())
294}
295
296fn dmap_str(name: &str, v: &str) -> Vec<u8> {
297 dmap_tag(name, v.as_bytes())
298}
299
300fn check_http(label: &str, status: u16) -> Result<()> {
301 if status == 401 || status == 403 {
302 return Err(IpatoolError::msg(format!(
303 "{label}: token expired (HTTP {status})"
304 )));
305 }
306 if status != 200 {
307 return Err(IpatoolError::msg(format!(
308 "{label}: HTTP {status}"
309 )));
310 }
311 Ok(())
312}
313
314fn check_dmap_status(label: &str, data: &[u8]) -> Result<()> {
315 if let Some(status) = first_dmap_u32(data, "mstt") {
316 if status == 401 || status == 403 {
317 return Err(IpatoolError::msg(format!(
318 "{label}: token expired (DAAP {status})"
319 )));
320 }
321 if status != 200 {
322 return Err(IpatoolError::msg(format!(
323 "{label}: DAAP status {status}"
324 )));
325 }
326 }
327 Ok(())
328}
329
330fn first_dmap_u32(data: &[u8], target: &str) -> Option<u32> {
331 let mut found = None;
332 let _ = walk_dmap(data, &mut |tag, payload| {
333 if found.is_none() && tag == target {
334 found = match payload.len() {
335 4 => payload.try_into().ok().map(u32::from_be_bytes),
336 8 => payload
337 .try_into()
338 .ok()
339 .map(|b| u64::from_be_bytes(b) as u32),
340 _ => None,
341 };
342 }
343 Ok(())
344 });
345 found
346}
347
348fn walk_dmap(data: &[u8], f: &mut dyn FnMut(&str, &[u8]) -> Result<()>) -> Result<()> {
349 let mut i = 0;
350 while i + 8 <= data.len() {
351 let tag = std::str::from_utf8(&data[i..i + 4])
352 .map_err(|_| IpatoolError::msg("invalid DMAP tag"))?;
353 let len = u32::from_be_bytes(data[i + 4..i + 8].try_into().unwrap()) as usize;
354 i += 8;
355 if i + len > data.len() {
356 return Err(IpatoolError::msg("truncated DMAP payload"));
357 }
358 let payload = &data[i..i + len];
359 f(tag, payload)?;
360 if is_container(tag) {
362 walk_dmap(payload, f)?;
363 }
364 i += len;
365 }
366 Ok(())
367}
368
369fn is_container(tag: &str) -> bool {
370 matches!(
371 tag,
372 "adbs" | "adsr" | "aply" | "avdb" | "mbcl" | "mccr" | "mcty" | "mdcl" | "mlcl" | "mlit"
373 | "mlog" | "msrv" | "mupd"
374 )
375}
376
377fn parse_owned_apps(data: &[u8]) -> Result<Vec<OwnedApp>> {
378 let mut apps = Vec::new();
379 walk_dmap(data, &mut |tag, payload| {
380 if tag == "mlit" {
381 if let Some(app) = parse_owned_app(payload)? {
382 apps.push(app);
383 }
384 }
385 Ok(())
386 })?;
387 Ok(merge_owned_apps(apps))
388}
389
390fn parse_owned_app(data: &[u8]) -> Result<Option<OwnedApp>> {
391 let mut app = OwnedApp {
392 id: 0,
393 bundle_id: String::new(),
394 name: String::new(),
395 version: String::new(),
396 purchase_date: String::new(),
397 platforms: Vec::new(),
398 };
399 let mut media_kind = 0u64;
400 let mut supported = 0u64;
401
402 walk_dmap(data, &mut |tag, payload| {
403 match tag {
404 "aeMk" | "aeSS" => {
405 let v = dmap_int(payload)?;
406 if tag == "aeMk" {
407 media_kind = v;
408 } else {
409 supported = v;
410 }
411 }
412 "aeSI" => app.id = dmap_int(payload)? as i64,
413 "aeBI" => app.bundle_id = String::from_utf8_lossy(payload).into_owned(),
414 "aeLN" => app.name = String::from_utf8_lossy(payload).into_owned(),
415 "minm" => {
416 if app.name.is_empty() {
417 app.name = String::from_utf8_lossy(payload).into_owned();
418 }
419 }
420 "aePd" => app.version = String::from_utf8_lossy(payload).into_owned(),
421 "asdp" if payload.len() == 4 => {
422 let ts = u32::from_be_bytes(payload.try_into().unwrap());
423 app.purchase_date = format_iso(ts as u64);
424 }
425 _ => {}
426 }
427 Ok(())
428 })?;
429
430 if app.id == 0 {
431 return Ok(None);
432 }
433
434 app.platforms = platforms_from_kind(media_kind, supported);
435 Ok(Some(app))
436}
437
438fn platforms_from_kind(media_kind: u64, supported: u64) -> Vec<String> {
439 let mut platforms = Vec::new();
440 match media_kind {
441 MEDIA_KIND_MAC => platforms.push("macos".into()),
442 MEDIA_KIND_APPS | MEDIA_KIND_ARCADE => {
443 for (mask, name) in [
444 (1u64, "iphone"),
445 (2, "ipad"),
446 (16, "visionos"),
447 (8, "macos"),
448 ] {
449 if supported & mask != 0 {
450 platforms.push(name.into());
451 }
452 }
453 if platforms.is_empty() {
454 platforms.push("unknown".into());
455 }
456 }
457 _ => {
458 if platforms.is_empty() {
459 platforms.push("unknown".into());
460 }
461 }
462 }
463 platforms
464}
465
466fn dmap_int(payload: &[u8]) -> Result<u64> {
467 Ok(match payload.len() {
468 1 => payload[0] as u64,
469 2 => u16::from_be_bytes(payload.try_into().unwrap()) as u64,
470 4 => u32::from_be_bytes(payload.try_into().unwrap()) as u64,
471 8 => u64::from_be_bytes(payload.try_into().unwrap()),
472 n => {
473 return Err(IpatoolError::msg(format!(
474 "DMAP int length {n}"
475 )))
476 }
477 })
478}
479
480fn merge_owned_apps(apps: Vec<OwnedApp>) -> Vec<OwnedApp> {
481 let mut map: BTreeMap<i64, OwnedApp> = BTreeMap::new();
482 for app in apps {
483 map.entry(app.id)
484 .and_modify(|existing| {
485 for p in &app.platforms {
486 if !existing.platforms.contains(p) {
487 existing.platforms.push(p.clone());
488 }
489 }
490 if app.purchase_date > existing.purchase_date {
491 existing.purchase_date = app.purchase_date.clone();
492 }
493 if existing.name.is_empty() {
494 existing.name = app.name.clone();
495 }
496 if existing.bundle_id.is_empty() {
497 existing.bundle_id = app.bundle_id.clone();
498 }
499 if existing.version.is_empty() {
500 existing.version = app.version.clone();
501 }
502 })
503 .or_insert(app);
504 }
505 let mut out: Vec<_> = map.into_values().collect();
506 out.sort_by(|a, b| b.purchase_date.cmp(&a.purchase_date));
507 out
508}
509
510#[cfg(test)]
511mod tests {
512 use super::*;
513
514 #[test]
515 fn mac_mask_bit_8_on_apps_kind() {
516 let p = platforms_from_kind(MEDIA_KIND_APPS, 8);
517 assert_eq!(p, vec!["macos".to_string()]);
518 }
519
520 #[test]
521 fn combined_masks_include_macos() {
522 let p = platforms_from_kind(MEDIA_KIND_APPS, 1 | 2 | 8 | 16);
523 assert_eq!(
524 p,
525 vec![
526 "iphone".to_string(),
527 "ipad".to_string(),
528 "visionos".to_string(),
529 "macos".to_string(),
530 ]
531 );
532 }
533
534 #[test]
535 fn empty_mask_is_unknown_not_iphone() {
536 let p = platforms_from_kind(MEDIA_KIND_APPS, 0);
537 assert_eq!(p, vec!["unknown".to_string()]);
538 }
539
540 #[test]
541 fn mac_media_kind() {
542 let p = platforms_from_kind(MEDIA_KIND_MAC, 0);
543 assert_eq!(p, vec!["macos".to_string()]);
544 }
545}