Skip to main content

unityrs_core/env/
reader.rs

1// Ported from UnityPy 1.25.2 (MIT): UnityPy/environment.py, UnityPy/helpers/ImportHelper.py, UnityPy/files/File.py. See THIRD_PARTY_LICENSES.
2//! A binding's immutable Python buffer keeps its reader's origin and uses one
3//! input meter. The caller retains the bytes; all core storage is metered.
4use super::{Environment, load::Target};
5use crate::{
6    Bytes, Error, File, RawStr,
7    budget::Reservation,
8    detect::{FileType, check_file_type_with_reader, detect_at_position},
9    files::parse_file_with_reader,
10    limits::Meter,
11    stream::ReaderKind,
12};
13
14impl Environment {
15    /// Loads a bounded source and observes the exact immutable bytes that
16    /// detection and parsing consume, before either starts. Split companions
17    /// are joined by the source reader first; compressed containers are still
18    /// compressed here. The observer shares this load's input meter and may
19    /// refuse without publishing any files or CAB registrations.
20    #[allow(clippy::needless_pass_by_value)]
21    pub fn load_observed(
22        &self,
23        source: super::Source,
24        observe: impl FnOnce(&Bytes, &std::sync::Arc<Meter>) -> Result<(), Error>,
25    ) -> Result<File, Error> {
26        let name = super::source_name(&source);
27        #[cfg(feature = "test-counters")]
28        let load_id = crate::counters::LoadId::draw(&name);
29        let ctx = self.ctx();
30        let meter = Meter::for_input(&ctx.limits, ctx.budget.clone(), Reservation::Input);
31        let (data, reader) = super::registry::read_source(&source, &meter, ctx)?;
32        observe(&data, &meter)?;
33        let ty = check_file_type_with_reader(&data, &ctx.limits, reader)?;
34        let parsed = parse_file_with_reader(name.clone(), data, ty, None, &meter, ctx, reader);
35        #[cfg(feature = "test-counters")]
36        crate::testing::adopt(&parsed, || crate::testing::Key::load(load_id));
37        let file = parsed?;
38        let load = self.register_file(&name, &file, &mut Target::Caller)?;
39        self.list(name, file.clone(), false, load, &meter)?;
40        self.inner
41            .loaded
42            .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
43        Ok(file)
44    }
45
46    /// `ImportHelper`'s parser selection without detection or a top-level file
47    /// registration (helpers/ImportHelper.py:127-156). Container constructors
48    /// still register their child CABs (files/File.py:76-90).
49    pub fn parse_reader(
50        &self,
51        name: &RawStr,
52        data: Bytes,
53        reader: ReaderKind,
54        ty: FileType,
55        parent_file: Option<&File>,
56    ) -> Result<File, Error> {
57        self.parse_reader_with_state(name, data, reader, ty, parent_file, &mut None)
58    }
59
60    /// [`Self::parse_reader`] retaining a partial constructor's endian change.
61    pub fn parse_reader_with_state(
62        &self,
63        name: &RawStr,
64        data: Bytes,
65        reader: ReaderKind,
66        ty: FileType,
67        parent_file: Option<&File>,
68        endian: &mut Option<crate::stream::Endian>,
69    ) -> Result<File, Error> {
70        use crate::files::{Parent, ParentKind};
71        let ctx = self.ctx();
72        super::within_input_bytes(data.len() as u64, &ctx.limits)?;
73        let meter = Meter::for_input(&ctx.limits, ctx.budget.clone(), Reservation::Input);
74        let parent = match parent_file {
75            Some(File::Bundle(file)) => Some(Parent {
76                name: file.name().clone(),
77                kind: ParentKind::Bundle {
78                    version_engine: file.header().version_engine.clone(),
79                    bundle: std::sync::Arc::downgrade(file),
80                    dir_index: usize::MAX,
81                },
82                depth: file.parent().map_or(1, |p| p.depth.saturating_add(1)),
83                pinned: data.len() as u64,
84            }),
85            Some(File::Web(file)) => Some(Parent {
86                name: file.name().clone(),
87                kind: ParentKind::Web {
88                    web: std::sync::Arc::downgrade(file),
89                },
90                depth: file.parent().map_or(1, |p| p.depth.saturating_add(1)),
91                pinned: data.len() as u64,
92            }),
93            _ => None,
94        };
95        let file = crate::files::parse_file_with_state(
96            name.clone(),
97            data,
98            ty,
99            parent,
100            &meter,
101            ctx,
102            reader,
103            0,
104            endian,
105        )?;
106        if matches!(file, File::Bundle(_) | File::Web(_)) {
107            self.register_file(name, &file, &mut Target::Caller)?;
108        }
109        Ok(file)
110    }
111
112    /// Loads caller-owned bytes by the memory or stream reader's rules,
113    /// registers their CABs and lists the file with UnityPy's dependency flag
114    /// (environment.py:100-160). ZIP members are loaded and the result is None.
115    /// The caller's buffer is not copied or charged; tables, decoded bytes and
116    /// subsequent reads share this load's single input meter.
117    pub fn load_reader(
118        &self,
119        name: RawStr,
120        data: Bytes,
121        reader: ReaderKind,
122        is_dependency: bool,
123    ) -> Result<Option<File>, Error> {
124        self.load_reader_at_position(name, data, reader, is_dependency, 0)
125    }
126
127    /// [`Self::load_reader`] detecting from the caller's original position
128    /// before detection resets the reader for construction.
129    pub fn load_reader_at_position(
130        &self,
131        name: RawStr,
132        data: Bytes,
133        reader: ReaderKind,
134        is_dependency: bool,
135        position: i128,
136    ) -> Result<Option<File>, Error> {
137        let ctx = self.ctx();
138        super::within_input_bytes(data.len() as u64, &ctx.limits)?;
139        let meter = Meter::for_input(&ctx.limits, ctx.budget.clone(), Reservation::Input);
140        let ty = detect_at_position(&data, &ctx.limits, None, reader, position)?;
141        if ty == FileType::Zip {
142            self.load_zip_data(data, &meter)?;
143            self.list_zip_none(name, &meter)?;
144            return Ok(None);
145        }
146        let file = parse_file_with_reader(name.clone(), data, ty, None, &meter, ctx, reader)?;
147        let load = self.register_file(&name, &file, &mut Target::Caller)?;
148        self.list(name, file.clone(), is_dependency, load, &meter)?;
149        self.inner
150            .loaded
151            .fetch_add(1, std::sync::atomic::Ordering::Relaxed);
152        Ok(Some(file))
153    }
154}
155
156#[cfg(test)]
157mod tests {
158    use super::*;
159    use crate::detect::check_file_type_with_reader;
160    #[test]
161    fn forced_web_bypasses_detection_without_listing_a_root_file() {
162        let env = Environment::new(super::super::EnvOptions::unitypy());
163        let data = Bytes::from_static(b"UnityWebData\0\x11\0\0\0");
164        assert_eq!(
165            check_file_type_with_reader(&data, &env.ctx().limits, ReaderKind::Memory).unwrap(),
166            FileType::ResourceFile
167        );
168        let file = env
169            .parse_reader(
170                &"forced".into(),
171                data,
172                ReaderKind::Memory,
173                FileType::WebFile,
174                None,
175            )
176            .unwrap();
177        assert!(matches!(file, File::Web(_)));
178        assert_eq!(env.files().count(), 0);
179    }
180
181    #[test]
182    fn forced_reader_enforces_input_limit_before_parsing() {
183        let mut options = super::super::EnvOptions::unitypy();
184        let mut context = crate::FileContext::unitypy();
185        context.limits.max_input_bytes = 2;
186        options.context = std::sync::Arc::new(context);
187        let env = Environment::new(options);
188        assert!(matches!(
189            env.parse_reader(
190                &"forced".into(),
191                Bytes::from_static(b"raw"),
192                ReaderKind::Memory,
193                FileType::AssetsFile,
194                None,
195            ),
196            Err(Error::Limit(_))
197        ));
198        assert_eq!(env.files().count(), 0);
199    }
200
201    #[test]
202    fn memory_and_stream_origins_keep_their_detection_rules() {
203        let env = Environment::new(super::super::EnvOptions::unitypy());
204        let data = Bytes::from_static(b"AAAAAAAAAAAAAAAAAAAA");
205        assert!(matches!(
206            env.load_reader("memory".into(), data.clone(), ReaderKind::Memory, false),
207            Err(Error::Detect(crate::detect::DetectError::Unterminated))
208        ));
209        let file = env
210            .load_reader("stream".into(), data, ReaderKind::Stream, false)
211            .unwrap()
212            .unwrap();
213        let File::Raw(raw) = file else {
214            panic!("expected raw reader")
215        };
216        assert_eq!(raw.reader_kind(), ReaderKind::Stream);
217        assert_eq!(env.files().count(), 1);
218    }
219    #[test]
220    fn observed_load_sees_exact_joined_split_source_and_its_input_meter() {
221        let tmp = unityrs_testkit::scratch::Scratch::new("observed-split");
222        let data = unityrs_testkit::ngui::file(
223            &[],
224            &[unityrs_testkit::ngui::Object::new(
225                1,
226                49,
227                unityrs_testkit::ngui::st(
228                    "TextAsset",
229                    vec![("m_Name", unityrs_testkit::ngui::s("snapshot"))],
230                ),
231            )],
232            true,
233        )
234        .unwrap();
235        let split = data.len() / 2;
236        std::fs::write(tmp.join("source.assets.split0"), &data[..split]).unwrap();
237        std::fs::write(tmp.join("source.assets.split1"), &data[split..]).unwrap();
238        for name in ["source.assets", "source.assets.split0"] {
239            let env = Environment::new(super::super::EnvOptions::unitypy());
240            let mut observed = Vec::new();
241            let mut input_meter = None;
242            let file = env
243                .load_observed(
244                    super::super::Source::Path(tmp.join(name)),
245                    |bytes, meter| {
246                        assert_eq!(env.files().count(), 0);
247                        observed.extend_from_slice(bytes);
248                        input_meter = Some(meter.clone());
249                        meter.count_decode(bytes.len() as u64)?;
250                        Ok(())
251                    },
252                )
253                .unwrap();
254            assert_eq!(observed, data);
255            assert!(matches!(file, File::Serialized(_)));
256            assert!(std::sync::Arc::ptr_eq(file.meter(), &input_meter.unwrap()));
257            assert_eq!(env.files().count(), 1);
258        }
259    }
260
261    #[test]
262    fn observed_load_refusal_happens_before_detection_or_registration() {
263        let mut opts = super::super::EnvOptions::unitypy();
264        let mut context = (*opts.context).clone();
265        context.limits.max_decode_work = 0;
266        opts.context = std::sync::Arc::new(context);
267        let env = Environment::new(opts);
268        let result = env.load_observed(
269            super::super::Source::Bytes {
270                name: "malformed".into(),
271                data: Bytes::from_static(b"AAAAAAAAAAAAAAAAAAAA"),
272            },
273            |_, meter| {
274                meter.count_decode(1)?;
275                Ok(())
276            },
277        );
278        assert!(matches!(result, Err(Error::Limit(e)) if e.kind() == crate::LimitKind::DecodeWork));
279        assert_eq!(env.files().count(), 0);
280        assert_eq!(env.registry().keys().count(), 0);
281    }
282
283    #[test]
284    fn observed_load_sees_compressed_web_source_before_inflation() {
285        let source = unityrs_testkit::web::plain("UnityWebData1.0", &[("entry.resS", &[42; 256])]);
286        let compressed = unityrs_testkit::web::gzip(&source);
287        let env = Environment::new(super::super::EnvOptions::unitypy());
288        let mut observed = Vec::new();
289        let file = env
290            .load_observed(
291                super::super::Source::Bytes {
292                    name: "compressed.web".into(),
293                    data: Bytes::copy_from_slice(&compressed),
294                },
295                |bytes, _| {
296                    observed.extend_from_slice(bytes);
297                    Ok(())
298                },
299            )
300            .unwrap();
301        assert_eq!(observed, compressed);
302        let File::Web(web) = file else {
303            panic!("expected WebFile")
304        };
305        assert_eq!(web.data().as_ref(), source);
306        assert_eq!(env.files().count(), 1);
307    }
308}