1use crate::core::reader::span::Span;
2use crate::ValidationError;
3
4pub mod section_header;
5pub mod types;
6
7#[derive(Clone)]
11pub struct WasmReader<'a> {
12 pub full_wasm_binary: &'a [u8],
14
15 pub pc: usize,
31}
32
33impl<'a> WasmReader<'a> {
34 pub const fn new(wasm: &'a [u8]) -> Self {
36 Self {
37 full_wasm_binary: wasm,
38 pc: 0,
39 }
40 }
41
42 pub fn move_start_to(&mut self, span: Span) -> Result<(), ValidationError> {
50 if span.from + span.len > self.full_wasm_binary.len() {
51 return Err(ValidationError::Eof);
52 }
53
54 self.pc = span.from;
55
56 Ok(())
57 }
58
59 pub fn remaining_bytes(&self) -> &[u8] {
61 &self.full_wasm_binary[self.pc..]
62 }
63
64 pub fn make_span(&self, len: usize) -> Result<Span, ValidationError> {
69 if self.pc + len > self.full_wasm_binary.len() {
70 return Err(ValidationError::Eof);
71 }
72 Ok(Span::new(self.pc, len))
73 }
74
75 pub fn strip_bytes<const N: usize>(&mut self) -> Result<[u8; N], ValidationError> {
86 if N > self.full_wasm_binary.len() - self.pc {
87 return Err(ValidationError::Eof);
88 }
89
90 let bytes = &self.full_wasm_binary[self.pc..(self.pc + N)];
91 self.pc += N;
92
93 Ok(bytes.try_into().expect("the slice length to be exactly N"))
94 }
95
96 pub fn peek_u8(&self) -> Result<u8, ValidationError> {
100 self.full_wasm_binary
101 .get(self.pc)
102 .copied()
103 .ok_or(ValidationError::Eof)
104 }
105
106 pub fn measure_num_read_bytes<T>(
116 &mut self,
117 f: impl FnOnce(&mut WasmReader) -> Result<T, ValidationError>,
118 ) -> Result<(T, usize), ValidationError> {
119 let before = self.pc;
120 let ret = f(self)?;
121
122 debug_assert!(
124 self.pc >= before,
125 "pc was advanced backwards towards the start"
126 );
127
128 let num_read_bytes = self.pc - before;
129 Ok((ret, num_read_bytes))
130 }
131
132 #[allow(dead_code)]
141 pub fn skip(&mut self, num_bytes: usize) -> Result<(), ValidationError> {
142 if num_bytes > self.full_wasm_binary.len() - self.pc {
143 return Err(ValidationError::Eof);
144 }
145 self.pc += num_bytes;
146 Ok(())
147 }
148
149 pub fn into_inner(self) -> &'a [u8] {
151 self.full_wasm_binary
152 }
153
154 #[allow(dead_code)]
159 pub fn handle_transaction<T, E>(
160 &mut self,
161 f: impl FnOnce(&mut WasmReader<'a>) -> Result<T, E>,
162 ) -> Result<T, E> {
163 let original = self.clone();
164 f(self).inspect_err(|_| {
165 *self = original;
166 })
167 }
168}
169
170pub trait WasmReadable: Sized {
171 fn read(wasm: &mut WasmReader) -> Result<Self, ValidationError>;
177}
178
179pub mod span {
180 use core::ops::Index;
181
182 use crate::core::reader::WasmReader;
183
184 #[derive(Copy, Clone, Debug, Hash)]
190 pub struct Span {
191 pub from: usize,
192 pub len: usize,
193 }
194
195 impl Span {
196 pub const fn new(from: usize, len: usize) -> Self {
198 Self { from, len }
199 }
200
201 pub const fn len(&self) -> usize {
203 self.len
204 }
205
206 pub const fn from(&self) -> usize {
207 self.from
208 }
209 }
210
211 impl<'a> Index<Span> for WasmReader<'a> {
212 type Output = [u8];
213
214 fn index(&self, index: Span) -> &'a Self::Output {
215 &self.full_wasm_binary[index.from..(index.from + index.len)]
216 }
217 }
218}
219
220#[cfg(test)]
221mod test {
222 use crate::ValType;
223
224 use super::*;
225 use alloc::vec;
226
227 #[test]
228 fn move_start_to() {
229 let my_bytes = vec![0x11, 0x12, 0x13, 0x14, 0x15];
230 let mut wasm_reader = WasmReader::new(&my_bytes);
231
232 let span = Span::new(0, 0);
233 wasm_reader.move_start_to(span).unwrap();
234 wasm_reader.peek_u8().unwrap();
236
237 let span = Span::new(0, my_bytes.len());
238 wasm_reader.move_start_to(span).unwrap();
239 wasm_reader.peek_u8().unwrap();
240 assert_eq!(wasm_reader[span], my_bytes);
241
242 let span = Span::new(my_bytes.len(), 0);
243 wasm_reader.move_start_to(span).unwrap();
244 let span = Span::new(my_bytes.len() - 1, 1);
247 wasm_reader.move_start_to(span).unwrap();
248
249 assert_eq!(wasm_reader.peek_u8().unwrap(), *my_bytes.last().unwrap());
250 }
251
252 #[test]
253 fn move_start_to_out_of_bounds_1() {
254 let my_bytes = vec![0x11, 0x12, 0x13, 0x14, 0x15];
255 let mut wasm_reader = WasmReader::new(&my_bytes);
256
257 let span = Span::new(my_bytes.len(), 1);
258 assert_eq!(wasm_reader.move_start_to(span), Err(ValidationError::Eof));
259 }
260
261 #[test]
262 fn move_start_to_out_of_bounds_2() {
263 let my_bytes = vec![0x11, 0x12, 0x13, 0x14, 0x15];
264 let mut wasm_reader = WasmReader::new(&my_bytes);
265
266 let span = Span::new(0, my_bytes.len() + 1);
267 assert_eq!(wasm_reader.move_start_to(span), Err(ValidationError::Eof));
268 }
269
270 #[test]
271 fn remaining_bytes_1() {
272 let my_bytes = vec![0x11, 0x12, 0x13, 0x14, 0x15];
273 let mut wasm_reader = WasmReader::new(&my_bytes);
274
275 assert_eq!(wasm_reader.remaining_bytes(), my_bytes);
276 wasm_reader.skip(4).unwrap();
277 assert_eq!(wasm_reader.peek_u8().unwrap(), 0x15);
278
279 assert_eq!(wasm_reader.remaining_bytes(), &my_bytes[4..]);
280 }
281
282 #[test]
283 fn remaining_bytes_2() {
284 let my_bytes = vec![0x11, 0x12, 0x13, 0x14, 0x15];
285 let mut wasm_reader = WasmReader::new(&my_bytes);
286
287 assert_eq!(wasm_reader.remaining_bytes(), my_bytes);
288 wasm_reader.skip(5).unwrap();
289 assert_eq!(wasm_reader.remaining_bytes(), &my_bytes[5..]);
290 assert_eq!(wasm_reader.remaining_bytes(), &[]);
291 }
292
293 #[test]
294 fn strip_bytes_1() {
295 let my_bytes = vec![0x11, 0x12, 0x13, 0x14, 0x15];
296 let mut wasm_reader = WasmReader::new(&my_bytes);
297
298 assert_eq!(wasm_reader.remaining_bytes(), my_bytes);
299 let stripped_bytes = wasm_reader.strip_bytes::<4>().unwrap();
300 assert_eq!(&stripped_bytes, &my_bytes[..4]);
301 assert_eq!(wasm_reader.remaining_bytes(), &[0x15]);
302 }
303
304 #[test]
305 fn strip_bytes_2() {
306 let my_bytes = vec![0x11, 0x12, 0x13, 0x14, 0x15];
307 let mut wasm_reader = WasmReader::new(&my_bytes);
308
309 assert_eq!(wasm_reader.remaining_bytes(), my_bytes);
310 wasm_reader.skip(1).unwrap();
311 let stripped_bytes = wasm_reader.strip_bytes::<4>().unwrap();
312 assert_eq!(&stripped_bytes, &my_bytes[1..5]);
313 assert_eq!(wasm_reader.remaining_bytes(), &[]);
314 }
315
316 #[test]
317 fn strip_bytes_3() {
318 let my_bytes = vec![0x11, 0x12, 0x13, 0x14, 0x15];
319 let mut wasm_reader = WasmReader::new(&my_bytes);
320
321 assert_eq!(wasm_reader.remaining_bytes(), my_bytes);
322 wasm_reader.skip(2).unwrap();
323 let stripped_bytes = wasm_reader.strip_bytes::<4>();
324 assert_eq!(stripped_bytes, Err(ValidationError::Eof));
325 }
326
327 #[test]
328 fn strip_bytes_4() {
329 let my_bytes = vec![0x11, 0x12, 0x13, 0x14, 0x15];
330 let mut wasm_reader = WasmReader::new(&my_bytes);
331
332 assert_eq!(wasm_reader.remaining_bytes(), my_bytes);
333 wasm_reader.skip(5).unwrap();
334 let stripped_bytes = wasm_reader.strip_bytes::<0>().unwrap();
335 assert_eq!(stripped_bytes, [0u8; 0]);
336 }
337
338 #[test]
339 fn skip_1() {
340 let my_bytes = vec![0x11, 0x12, 0x13, 0x14, 0x15];
341 let mut wasm_reader = WasmReader::new(&my_bytes);
342 assert_eq!(wasm_reader.remaining_bytes(), my_bytes);
343 assert_eq!(wasm_reader.skip(6), Err(ValidationError::Eof));
344 }
345
346 #[test]
347 fn reader_transaction() {
348 let bytes = [0x1, 0x2, 0x3, 0x4, 0x5, 0x6];
349 let mut reader = WasmReader::new(&bytes);
350
351 assert_eq!(
352 reader.handle_transaction(|reader| { reader.strip_bytes::<2>() }),
353 Ok([0x1, 0x2]),
354 );
355
356 let transaction_result: Result<(), ValidationError> = reader.handle_transaction(|reader| {
357 assert_eq!(reader.strip_bytes::<2>(), Ok([0x3, 0x4]));
358
359 Err(ValidationError::InvalidMagic)
361 });
362 assert_eq!(transaction_result, Err(ValidationError::InvalidMagic));
363
364 assert_eq!(reader.strip_bytes::<3>(), Ok([0x3, 0x4, 0x5]));
365 }
366
367 #[test]
368 fn reader_transaction_ergonomics() {
369 let bytes = [0x1, 0x2, 0x3, 0x4, 0x5, 0x6];
370 let mut reader = WasmReader::new(&bytes);
371
372 assert_eq!(reader.handle_transaction(WasmReader::read_u8), Ok(0x1));
373
374 assert_eq!(
375 reader.handle_transaction(ValType::read),
376 Err(ValidationError::InvalidValType)
377 );
378 }
379}