Skip to main content

ipatool_kit/
store.rs

1//! Sync facade over vendored `ipatool-kit-core` (SAP auth + download) and native DAAP purchases.
2//!
3//! Core patches vs crates.io 0.1.8 / Go majd/ipatool parity (see `vendor/ipatool-kit-core`):
4//! bag `?guid=` + `urlBag`, HTML-safe plist parse, `serialNumber` on product POSTs,
5//! volumeStore→redownload→updateProduct, purchase `jingleDocType`/`status`, auth HTTP
6//! retry, login Content-Type `application/x-www-form-urlencoded`. IPA-only: macOS `.pkg`
7//! decrypt path is intentionally not ported (clear error if Apple returns a Mac package).
8
9use std::path::{Path, PathBuf};
10use std::sync::OnceLock;
11
12use ipatool_core::api::{auth, bag, download as core_download, purchase as core_purchase, versions};
13use ipatool_core::client::AppleClient;
14use ipatool_core::guid::generate_machine_identity;
15use ipatool_core::ipa::patch::patch_ipa;
16use ipatool_core::model::Account;
17use ipatool_core::sap::{self, ActionSigner};
18use tokio::runtime::Runtime;
19
20use crate::client::{AuthInfo, DownloadRequest, LoginRequest, VersionInfo};
21use crate::error::{IpatoolError, Result};
22use crate::purchases::{self, OwnedApp};
23use crate::session;
24
25fn runtime() -> &'static Runtime {
26    static RT: OnceLock<Runtime> = OnceLock::new();
27    RT.get_or_init(|| {
28        tokio::runtime::Builder::new_multi_thread()
29            .enable_all()
30            .build()
31            .expect("tokio runtime")
32    })
33}
34
35fn map_err(e: impl std::fmt::Display) -> IpatoolError {
36    IpatoolError::msg(e.to_string())
37}
38
39fn new_client() -> Result<AppleClient> {
40    session::ensure_dirs()?;
41    let machine = generate_machine_identity().map_err(map_err)?;
42    let cookies = session::cookies_path();
43    let cache = session::cache_dir().ok_or_else(|| IpatoolError::msg("HOME not set"))?;
44    AppleClient::new(machine, cookies.as_deref(), cache).map_err(map_err)
45}
46
47fn save_cookies(client: &AppleClient) {
48    if let Some(path) = session::cookies_path() {
49        if client.save_cookies(&path).is_ok() {
50            session::chmod_secret_file(&path);
51        }
52    }
53}
54
55fn note(progress: &mut dyn FnMut(&str), msg: &str) {
56    progress(msg);
57}
58
59/// True when ipatool-kit-core SAP framework blobs are already cached under ~/.ipatool/cache.
60pub fn sap_cache_ready() -> bool {
61    let Some(dir) = session::cache_dir() else {
62        return false;
63    };
64    ["CommerceKit", "CommerceCore", "CoreFP", "CoreFP.icxs"]
65        .iter()
66        .all(|name| dir.join(name).is_file())
67}
68
69fn sap_progress_msg() -> &'static str {
70    if sap_cache_ready() {
71        "progress.sap_cached"
72    } else {
73        "progress.sap_download"
74    }
75}
76
77/// Normalize 2FA like majd/ipatool: strip spaces, require exactly 6 digits.
78pub(crate) fn normalize_auth_code(code: Option<&str>) -> Result<Option<String>> {
79    let Some(code) = code else {
80        return Ok(None);
81    };
82    let mut code = code.trim().to_string();
83    if code.starts_with("\u{1b}[200~") && code.ends_with("\u{1b}[201~") {
84        code = code
85            .trim_start_matches("\u{1b}[200~")
86            .trim_end_matches("\u{1b}[201~")
87            .to_string();
88    }
89    let digits: String = code.chars().filter(|c| !c.is_whitespace()).collect();
90    if digits.is_empty() {
91        return Ok(None);
92    }
93    if digits.len() != 6 || !digits.chars().all(|c| c.is_ascii_digit()) {
94        return Err(IpatoolError::msg("2FA code must contain exactly six digits"));
95    }
96    Ok(Some(digits))
97}
98
99pub fn auth_info() -> Result<AuthInfo> {
100    let Some(acc) = session::load_account()? else {
101        return Err(IpatoolError::msg("not logged in"));
102    };
103    Ok(AuthInfo {
104        email: acc.email,
105        name: acc.name,
106        storefront: acc.store_front,
107        success: true,
108    })
109}
110
111pub fn login(req: &LoginRequest) -> Result<AuthInfo> {
112    login_with(req, &mut |_| {})
113}
114
115pub fn login_with(req: &LoginRequest, progress: &mut dyn FnMut(&str)) -> Result<AuthInfo> {
116    note(progress, "progress.preparing_session");
117    session::ensure_dirs()?;
118    let auth_code = normalize_auth_code(req.auth_code.as_deref())?;
119    let mut client = new_client()?;
120
121    note(progress, "progress.fetch_bag");
122    let bag_cfg = runtime()
123        .block_on(bag::fetch_bag(&client))
124        .map_err(map_err)?;
125
126    note(progress, sap_progress_msg());
127    let signer = runtime()
128        .block_on(sap::new_default_signer(
129            &client,
130            &bag_cfg.sap,
131            client.hardware_id(),
132        ))
133        .map_err(map_err)?;
134
135    note(
136        progress,
137        if auth_code.is_some() {
138            "progress.auth_2fa"
139        } else {
140            "progress.auth"
141        },
142    );
143    let account = runtime()
144        .block_on(auth::login(
145            &client,
146            &req.email,
147            &req.password,
148            auth_code.as_deref(),
149            &bag_cfg.auth_endpoint,
150            Some(&signer as &dyn ActionSigner),
151        ))
152        .map_err(|e| {
153            let s = e.to_string();
154            let lower = s.to_lowercase();
155            if auth_code.is_some()
156                && (lower.contains("badlogin")
157                    || lower.contains("verification")
158                    || lower.contains("auth code"))
159            {
160                IpatoolError::msg("apple did not complete verification; try a fresh 2FA code")
161            } else if lower.contains("auth code")
162                || lower.contains("2fa")
163                || lower.contains("verification")
164                || lower.contains("badlogin")
165            {
166                IpatoolError::msg("auth code required")
167            } else {
168                map_err(e)
169            }
170        })?;
171
172    // Keep password in keyring (via save_account) for silent reauth; not in account.json.
173    note(progress, "progress.saving_session");
174    let mut account = account;
175    account.password = Some(req.password.clone());
176    client.set_account(account.clone());
177    session::save_account(&account)?;
178    save_cookies(&client);
179
180    note(progress, "progress.login_complete");
181    Ok(AuthInfo {
182        email: account.email,
183        name: account.name,
184        storefront: account.store_front,
185        success: true,
186    })
187}
188
189pub fn revoke() -> Result<()> {
190    session::delete_account()?;
191    if let Some(p) = session::cookies_path() {
192        let _ = std::fs::remove_file(p);
193    }
194    Ok(())
195}
196
197pub fn require_account() -> Result<Account> {
198    session::load_account()?.ok_or_else(|| IpatoolError::msg("not logged in"))
199}
200
201pub fn purchase(app_id: i64) -> Result<()> {
202    purchase_with(app_id, &mut |_| {})
203}
204
205pub fn purchase_with(app_id: i64, progress: &mut dyn FnMut(&str)) -> Result<()> {
206    note(progress, "progress.loading_account");
207    let account = require_account()?;
208    let client = new_client()?;
209    note(progress, "progress.purchasing");
210    runtime()
211        .block_on(core_purchase::purchase(&client, app_id, &account))
212        .map_err(map_err)?;
213    save_cookies(&client);
214    note(progress, "progress.purchase_done");
215    Ok(())
216}
217
218pub fn list_versions(app_id: i64) -> Result<Vec<String>> {
219    list_versions_with(app_id, &mut |_| {})
220}
221
222pub fn list_versions_with(app_id: i64, progress: &mut dyn FnMut(&str)) -> Result<Vec<String>> {
223    note(progress, "progress.loading_account");
224    let account = require_account()?;
225    let client = new_client()?;
226    note(progress, "progress.fetch_versions");
227    let out = runtime()
228        .block_on(versions::list_versions(&client, app_id, &account))
229        .map_err(map_err)?;
230    Ok(out
231        .versions
232        .into_iter()
233        .map(|v| v.external_version_id)
234        .collect())
235}
236
237pub fn get_version_metadata(app_id: i64, external_version_id: &str) -> Result<VersionInfo> {
238    get_version_metadata_with(app_id, external_version_id, &mut |_| {})
239}
240
241pub fn get_version_metadata_with(
242    app_id: i64,
243    external_version_id: &str,
244    progress: &mut dyn FnMut(&str),
245) -> Result<VersionInfo> {
246    note(progress, "progress.version_meta");
247    let account = require_account()?;
248    let client = new_client()?;
249    let meta = runtime()
250        .block_on(versions::get_version_metadata(
251            &client,
252            app_id,
253            &account,
254            external_version_id,
255        ))
256        .map_err(map_err)?;
257    Ok(VersionInfo {
258        external_id: external_version_id.to_string(),
259        display_version: meta
260            .bundle_short_version
261            .or(meta.bundle_version)
262            .unwrap_or_default(),
263        release_date: meta.release_date.unwrap_or_default(),
264    })
265}
266
267pub fn download(req: &DownloadRequest) -> Result<String> {
268    download_with(req, &mut |_| {}, false)
269}
270
271/// `show_file_progress` enables indicatif bar (needs a normal, non-raw TTY).
272pub fn download_with(
273    req: &DownloadRequest,
274    progress: &mut dyn FnMut(&str),
275    show_file_progress: bool,
276) -> Result<String> {
277    let app_id = req
278        .app_id
279        .ok_or_else(|| IpatoolError::msg("app id required"))?;
280    note(progress, "progress.loading_account");
281    let mut account = require_account()?;
282    let client = new_client()?;
283
284    // Match Go `ipatool download --purchase`: try download first; only call
285    // buyProduct when Apple returns license-not-found. Eager purchase breaks
286    // already-owned apps that now return failureType 2040 on buyProduct.
287    let item = {
288        let mut last_err: Option<ipatool_core::error::ClientError> = None;
289        let mut acquired_license = false;
290        let mut downloaded = None;
291
292        for _ in 0..3 {
293            if last_err.as_ref().is_some_and(|e| e.is_token_expired()) {
294                if account.password.is_none() {
295                    break;
296                }
297                note(progress, "progress.reauth");
298                note(progress, "progress.fetch_bag");
299                let bag_cfg = runtime()
300                    .block_on(bag::fetch_bag(&client))
301                    .map_err(map_err)?;
302                note(progress, sap_progress_msg());
303                let signer = runtime()
304                    .block_on(sap::new_default_signer(
305                        &client,
306                        &bag_cfg.sap,
307                        client.hardware_id(),
308                    ))
309                    .map_err(map_err)?;
310                let pw = account.password.clone().unwrap();
311                note(progress, "progress.auth");
312                account = runtime()
313                    .block_on(auth::login(
314                        &client,
315                        &account.email,
316                        &pw,
317                        None,
318                        &bag_cfg.auth_endpoint,
319                        Some(&signer as &dyn ActionSigner),
320                    ))
321                    .map_err(map_err)?;
322                account.password = Some(pw);
323                session::save_account(&account)?;
324                save_cookies(&client);
325            }
326
327            if last_err.as_ref().is_some_and(|e| e.is_license_not_found())
328                && req.purchase
329                && !acquired_license
330            {
331                note(progress, "progress.ensure_license");
332                match runtime().block_on(core_purchase::purchase(&client, app_id, &account)) {
333                    Ok(()) => {}
334                    Err(e) if e.is_license_already_exists() => {}
335                    Err(e) => return Err(map_err(e)),
336                }
337                acquired_license = true;
338                save_cookies(&client);
339            }
340
341            note(
342                progress,
343                if last_err.is_some() {
344                    "progress.retry_download_info"
345                } else {
346                    "progress.download_info"
347                },
348            );
349            match runtime().block_on(core_download::get_download_info(
350                &client,
351                app_id,
352                &account,
353                req.external_version_id.as_deref(),
354            )) {
355                Ok(item) => {
356                    downloaded = Some(item);
357                    break;
358                }
359                Err(e) => {
360                    let retry = (e.is_token_expired() && account.password.is_some())
361                        || (e.is_license_not_found() && req.purchase && !acquired_license);
362                    last_err = Some(e);
363                    if !retry {
364                        break;
365                    }
366                }
367            }
368        }
369
370        match downloaded {
371            Some(item) => item,
372            None => {
373                return Err(map_err(
374                    last_err.unwrap_or_else(|| {
375                        ipatool_core::error::ClientError::UnexpectedResponse(
376                            "download failed".into(),
377                        )
378                    }),
379                ))
380            }
381        }
382    };
383
384    let out = req
385        .output
386        .clone()
387        .unwrap_or_else(|| format!("{app_id}.ipa"));
388    let out_path = PathBuf::from(&out);
389    let tmp = out_path.with_extension("ipa.partial");
390
391    note(progress, "progress.downloading_ipa");
392    runtime()
393        .block_on(core_download::download_file(
394            &client,
395            &item.url,
396            &tmp,
397            show_file_progress,
398        ))
399        .map_err(map_err)?;
400
401    note(progress, "progress.patching");
402    patch_ipa(&tmp, &out_path, &item, &account.email).map_err(map_err)?;
403    let _ = std::fs::remove_file(&tmp);
404    save_cookies(&client);
405    note(progress, "progress.download_complete");
406    Ok(out_path.display().to_string())
407}
408
409pub fn list_purchases() -> Result<Vec<OwnedApp>> {
410    list_purchases_with(&mut |_| {})
411}
412
413pub fn list_purchases_with(progress: &mut dyn FnMut(&str)) -> Result<Vec<OwnedApp>> {
414    note(progress, "progress.loading_account");
415    let account = require_account()?;
416    let client = new_client()?;
417
418    note(progress, "progress.fetch_bag");
419    let bag = runtime()
420        .block_on(bag::fetch_bag(&client))
421        .map_err(map_err)?;
422
423    note(progress, sap_progress_msg());
424    let signer = runtime()
425        .block_on(sap::new_default_signer(
426            &client,
427            &bag.sap,
428            client.hardware_id(),
429        ))
430        .map_err(map_err)?;
431
432    note(progress, "progress.history_ios");
433    let mut apps = runtime().block_on(purchases::fetch_owned_apps_store(
434        &client, &account, &signer, "34",
435    ))?;
436    note(progress, "progress.history_mac");
437    apps.extend(runtime().block_on(purchases::fetch_owned_apps_store(
438        &client, &account, &signer, "13",
439    ))?);
440    let apps = purchases::merge_apps(apps);
441    save_cookies(&client);
442    note(
443        progress,
444        &format!("progress.history_ready\x1f{}", apps.len()),
445    );
446    Ok(apps)
447}
448
449pub fn download_to(path: &Path, app_id: i64, external_version_id: Option<&str>) -> Result<String> {
450    download(&DownloadRequest {
451        app_id: Some(app_id),
452        bundle_id: None,
453        output: Some(path.display().to_string()),
454        external_version_id: external_version_id.map(str::to_string),
455        purchase: true,
456        keychain_passphrase: None,
457    })
458}
459
460#[cfg(test)]
461mod tests {
462    use super::normalize_auth_code;
463
464    #[test]
465    fn auth_code_strips_spaces() {
466        let c = normalize_auth_code(Some("12 34 56")).unwrap().unwrap();
467        assert_eq!(c, "123456");
468    }
469
470    #[test]
471    fn auth_code_rejects_non_digits() {
472        assert!(normalize_auth_code(Some("12ab56")).is_err());
473    }
474
475    #[test]
476    fn auth_code_empty_is_none() {
477        assert!(normalize_auth_code(None).unwrap().is_none());
478        assert!(normalize_auth_code(Some("   ")).unwrap().is_none());
479    }
480}