Skip to main content

ipatool_kit/
plist.rs

1//! Minimal Apple plist (XML + binary) encoder/decoder.
2
3use std::collections::BTreeMap;
4
5use base64::{engine::general_purpose::STANDARD as B64, Engine};
6
7use crate::error::{IpatoolError, Result};
8
9#[derive(Debug, Clone, PartialEq)]
10pub enum PlistValue {
11    String(String),
12    Integer(i64),
13    Real(f64),
14    Bool(bool),
15    Data(Vec<u8>),
16    Date(String),
17    Dict(PlistDict),
18    Array(Vec<PlistValue>),
19    Null,
20}
21
22pub type PlistDict = BTreeMap<String, PlistValue>;
23
24pub fn base64_encode(data: &[u8]) -> String {
25    B64.encode(data)
26}
27
28pub fn base64_decode(s: &str) -> Vec<u8> {
29    // Match C++: skip invalid chars, stop at '='
30    let mut idx = [-1i8; 256];
31    for (i, c) in b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
32        .iter()
33        .enumerate()
34    {
35        idx[*c as usize] = i as i8;
36    }
37    let mut out = Vec::new();
38    let mut bits: u32 = 0;
39    let mut nbits = 0;
40    for &c in s.as_bytes() {
41        if c == b'=' {
42            break;
43        }
44        let v = idx[c as usize];
45        if v < 0 {
46            continue;
47        }
48        bits = (bits << 6) | (v as u32);
49        nbits += 6;
50        if nbits >= 8 {
51            nbits -= 8;
52            out.push((bits >> nbits) as u8);
53            bits &= (1u32 << nbits) - 1;
54        }
55    }
56    out
57}
58
59fn xml_unescape(s: &str) -> String {
60    let out = s
61        .replace("&lt;", "<")
62        .replace("&gt;", ">")
63        .replace("&quot;", "\"")
64        .replace("&apos;", "'");
65    // numeric character references
66    let bytes = out.as_bytes();
67    let mut res = String::new();
68    let mut i = 0;
69    while i < bytes.len() {
70        if bytes[i] == b'&' && i + 2 < bytes.len() && bytes[i + 1] == b'#' {
71            if let Some(semi) = bytes[i + 2..].iter().position(|&c| c == b';') {
72                let semi = i + 2 + semi;
73                let body = &out[i + 2..semi];
74                let cp =
75                    if let Some(hex) = body.strip_prefix('x').or_else(|| body.strip_prefix('X')) {
76                        u32::from_str_radix(hex, 16).ok()
77                    } else {
78                        body.parse::<u32>().ok()
79                    };
80                if let Some(cp) = cp {
81                    if let Some(ch) = char::from_u32(cp) {
82                        res.push(ch);
83                        i = semi + 1;
84                        continue;
85                    }
86                }
87            }
88        }
89        res.push(out[i..].chars().next().unwrap());
90        i += out[i..].chars().next().unwrap().len_utf8();
91    }
92    res.replace("&amp;", "&")
93}
94
95pub fn decode_plist(src: &str) -> PlistDict {
96    let bytes = src.as_bytes();
97    if bytes.len() >= 8 && &bytes[..8] == b"bplist00" {
98        return decode_bplist(bytes).unwrap_or_default();
99    }
100    decode_plist_xml(src).unwrap_or_default()
101}
102
103pub fn decode_plist_bytes(data: &[u8]) -> PlistDict {
104    if data.len() >= 8 && &data[..8] == b"bplist00" {
105        return decode_bplist(data).unwrap_or_default();
106    }
107    match std::str::from_utf8(data) {
108        Ok(s) => decode_plist(s),
109        Err(_) => PlistDict::new(),
110    }
111}
112
113fn decode_bplist(data: &[u8]) -> Result<PlistDict> {
114    let value: plist::Value =
115        plist::from_bytes(data).map_err(|e| IpatoolError::Plist(e.to_string()))?;
116    match plist_crate_to_ours(&value) {
117        PlistValue::Dict(d) => Ok(d),
118        _ => Ok(PlistDict::new()),
119    }
120}
121
122fn plist_crate_to_ours(v: &plist::Value) -> PlistValue {
123    match v {
124        plist::Value::String(s) => PlistValue::String(s.clone()),
125        plist::Value::Integer(i) => PlistValue::Integer(i.as_signed().unwrap_or(0)),
126        plist::Value::Real(r) => PlistValue::Real(*r),
127        plist::Value::Boolean(b) => PlistValue::Bool(*b),
128        plist::Value::Data(d) => PlistValue::Data(d.clone()),
129        plist::Value::Date(d) => PlistValue::Date(d.to_xml_format()),
130        plist::Value::Array(a) => PlistValue::Array(a.iter().map(plist_crate_to_ours).collect()),
131        plist::Value::Dictionary(d) => {
132            let mut out = PlistDict::new();
133            for (k, v) in d {
134                out.insert(k.clone(), plist_crate_to_ours(v));
135            }
136            PlistValue::Dict(out)
137        }
138        _ => PlistValue::Null,
139    }
140}
141
142fn decode_plist_xml(src: &str) -> Result<PlistDict> {
143    // Find root <dict>...</dict>
144    let start = src.find("<dict>").or_else(|| src.find("<dict "));
145    let end = src.rfind("</dict>");
146    let (Some(start), Some(end)) = (start, end) else {
147        return Err(IpatoolError::Plist("no dict".into()));
148    };
149    let inner = &src[start..end + "</dict>".len()];
150    match parse_value(inner)? {
151        PlistValue::Dict(d) => Ok(d),
152        _ => Err(IpatoolError::Plist("root not dict".into())),
153    }
154}
155
156fn parse_value(s: &str) -> Result<PlistValue> {
157    let s = s.trim();
158    if s.starts_with("<true") {
159        return Ok(PlistValue::Bool(true));
160    }
161    if s.starts_with("<false") {
162        return Ok(PlistValue::Bool(false));
163    }
164    if let Some(rest) = s.strip_prefix("<string>") {
165        let end = rest
166            .find("</string>")
167            .ok_or_else(|| IpatoolError::Plist("string".into()))?;
168        return Ok(PlistValue::String(xml_unescape(&rest[..end])));
169    }
170    if s.starts_with("<string/>") || s.starts_with("<string />") {
171        return Ok(PlistValue::String(String::new()));
172    }
173    if let Some(rest) = s.strip_prefix("<integer>") {
174        let end = rest
175            .find("</integer>")
176            .ok_or_else(|| IpatoolError::Plist("int".into()))?;
177        let n: i64 = rest[..end].trim().parse().unwrap_or(0);
178        return Ok(PlistValue::Integer(n));
179    }
180    if let Some(rest) = s.strip_prefix("<real>") {
181        let end = rest
182            .find("</real>")
183            .ok_or_else(|| IpatoolError::Plist("real".into()))?;
184        let n: f64 = rest[..end].trim().parse().unwrap_or(0.0);
185        return Ok(PlistValue::Real(n));
186    }
187    if let Some(rest) = s.strip_prefix("<data>") {
188        let end = rest
189            .find("</data>")
190            .ok_or_else(|| IpatoolError::Plist("data".into()))?;
191        return Ok(PlistValue::Data(base64_decode(&rest[..end])));
192    }
193    if let Some(rest) = s.strip_prefix("<date>") {
194        let end = rest
195            .find("</date>")
196            .ok_or_else(|| IpatoolError::Plist("date".into()))?;
197        return Ok(PlistValue::Date(xml_unescape(&rest[..end])));
198    }
199    if s.starts_with("<dict>") {
200        return Ok(PlistValue::Dict(parse_dict(s)?));
201    }
202    if s.starts_with("<array>") {
203        return Ok(PlistValue::Array(parse_array(s)?));
204    }
205    Err(IpatoolError::Plist(format!(
206        "unknown value: {}",
207        &s[..s.len().min(40)]
208    )))
209}
210
211fn parse_dict(s: &str) -> Result<PlistDict> {
212    let inner = strip_tag(s, "dict")?;
213    let mut d = PlistDict::new();
214    let mut rest = inner.as_str();
215    while let Some(ks) = rest.find("<key>") {
216        rest = &rest[ks + 5..];
217        let ke = rest
218            .find("</key>")
219            .ok_or_else(|| IpatoolError::Plist("key".into()))?;
220        let key = xml_unescape(rest[..ke].trim());
221        rest = rest[ke + 6..].trim_start();
222        let (val, consumed) = take_one_value(rest)?;
223        d.insert(key, val);
224        rest = &rest[consumed..];
225    }
226    Ok(d)
227}
228
229fn parse_array(s: &str) -> Result<Vec<PlistValue>> {
230    let inner = strip_tag(s, "array")?;
231    let mut out = Vec::new();
232    let mut rest = inner.trim();
233    while !rest.is_empty() && rest.starts_with('<') {
234        let (val, consumed) = take_one_value(rest)?;
235        out.push(val);
236        rest = rest[consumed..].trim_start();
237    }
238    Ok(out)
239}
240
241fn strip_tag(s: &str, tag: &str) -> Result<String> {
242    let open = format!("<{tag}>");
243    let close = format!("</{tag}>");
244    let s = s.trim();
245    if !s.starts_with(&open) {
246        return Err(IpatoolError::Plist(format!("expected {open}")));
247    }
248    if !s.ends_with(&close) {
249        return Err(IpatoolError::Plist(format!("expected {close}")));
250    }
251    Ok(s[open.len()..s.len() - close.len()].to_string())
252}
253
254fn take_one_value(s: &str) -> Result<(PlistValue, usize)> {
255    let s = s.trim_start();
256    // self-closing leaves / empty containers
257    for tag in [
258        "<true/>",
259        "<true />",
260        "<false/>",
261        "<false />",
262        "<string/>",
263        "<string />",
264    ] {
265        if s.starts_with(tag) {
266            let v = parse_value(tag)?;
267            return Ok((v, tag.len()));
268        }
269    }
270    for (tag, v) in [
271        ("<dict/>", PlistValue::Dict(PlistDict::new())),
272        ("<dict />", PlistValue::Dict(PlistDict::new())),
273        ("<array/>", PlistValue::Array(Vec::new())),
274        ("<array />", PlistValue::Array(Vec::new())),
275        ("<data/>", PlistValue::Data(Vec::new())),
276        ("<data />", PlistValue::Data(Vec::new())),
277    ] {
278        if s.starts_with(tag) {
279            return Ok((v, tag.len()));
280        }
281    }
282    // find matching close for dict/array or simple tags
283    if s.starts_with("<dict>") {
284        let end = find_matching(s, "dict")?;
285        let chunk = &s[..end];
286        return Ok((parse_value(chunk)?, end));
287    }
288    if s.starts_with("<array>") {
289        let end = find_matching(s, "array")?;
290        let chunk = &s[..end];
291        return Ok((parse_value(chunk)?, end));
292    }
293    for tag in ["string", "integer", "real", "data", "date"] {
294        let open = format!("<{tag}>");
295        let close = format!("</{tag}>");
296        if s.starts_with(&open) {
297            if let Some(rel) = s[open.len()..].find(&close) {
298                let end = open.len() + rel + close.len();
299                return Ok((parse_value(&s[..end])?, end));
300            }
301        }
302    }
303    Err(IpatoolError::Plist(format!(
304        "cannot parse value at {}",
305        &s[..s.len().min(40)]
306    )))
307}
308
309fn find_matching(s: &str, tag: &str) -> Result<usize> {
310    let open = format!("<{tag}>");
311    let close = format!("</{tag}>");
312    let mut depth = 0usize;
313    let mut i = 0usize;
314    while i < s.len() {
315        if s[i..].starts_with(&open) {
316            depth += 1;
317            i += open.len();
318            continue;
319        }
320        if s[i..].starts_with(&close) {
321            depth -= 1;
322            i += close.len();
323            if depth == 0 {
324                return Ok(i);
325            }
326            continue;
327        }
328        i += s[i..].chars().next().unwrap().len_utf8();
329    }
330    Err(IpatoolError::Plist(format!("unclosed <{tag}>")))
331}
332
333pub fn dict_str(d: &PlistDict, key: &str) -> String {
334    match d.get(key) {
335        Some(PlistValue::String(s)) => s.clone(),
336        Some(PlistValue::Date(s)) => s.clone(),
337        _ => String::new(),
338    }
339}
340