Skip to main content

ipatool_kit/
purchases.rs

1//! Apple purchase-history (DAAP) — port of majd/ipatool OwnedApps.
2
3use 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
47/// One DAAP storefront (`34` = phone/pad, `13` = Mac). Sync callers can
48/// interleave progress between storefronts without capturing `FnMut` in a Send future.
49pub 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    // Empty POST: Go `bytes.NewReader(nil)` always sends Content-Length: 0.
78    // reqwest `.body(Vec::new())` alone sends NEITHER Content-Length NOR Transfer-Encoding
79    // → Apple DAAP returns HTTP 411 Length Required.
80    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    // Approximate UTC HTTP date without chrono.
187    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    // Minimal GMT formatter (good enough for Apple DAAP Date header).
220    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    // Civil date from days since 1970-01-01 (Thursday).
231    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
250/// Howard Hinnant civil_from_days (proleptic Gregorian).
251fn 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        // Containers recurse.
361        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}