der_parser/ber/
multi.rs

1use crate::ber::*;
2use crate::error::*;
3use nom::bytes::complete::take;
4use nom::combinator::{all_consuming, complete, cut, map};
5use nom::error::ParseError;
6use nom::multi::many0;
7use nom::{Err, IResult};
8
9/// Parse a SEQUENCE OF object
10///
11/// Given a subparser for a BER type, parse a sequence of identical objects.
12///
13/// ```rust
14/// # use der_parser::ber::{parse_ber_integer, parse_ber_sequence_of, BerObject};
15/// # use der_parser::error::BerResult;
16/// #
17/// /// Read a SEQUENCE OF INTEGER
18/// fn parser(i:&[u8]) -> BerResult<BerObject> {
19///     parse_ber_sequence_of(parse_ber_integer)(i)
20/// }
21///
22/// # let empty = &b""[..];
23/// # let bytes = [ 0x30, 0x0a,
24/// #               0x02, 0x03, 0x01, 0x00, 0x01,
25/// #               0x02, 0x03, 0x01, 0x00, 0x00,
26/// # ];
27/// # let expected  = BerObject::from_seq(vec![
28/// #     BerObject::from_int_slice(b"\x01\x00\x01"),
29/// #     BerObject::from_int_slice(b"\x01\x00\x00"),
30/// # ]);
31/// # assert_eq!(parser(&bytes), Ok((empty, expected)));
32/// let (rem, v) = parser(&bytes).expect("parsing failed");
33/// ```
34pub fn parse_ber_sequence_of<'a, F>(f: F) -> impl FnMut(&'a [u8]) -> BerResult<'a>
35where
36    F: Fn(&'a [u8]) -> BerResult<'a>,
37{
38    map(parse_ber_sequence_of_v(f), BerObject::from_seq)
39}
40
41/// Parse a SEQUENCE OF object (returning a vec)
42///
43/// Given a subparser for a BER type, parse a sequence of identical objects.
44///
45/// This differs from `parse_ber_sequence_of` in the parse function and return type.
46///
47/// ```rust
48/// # use der_parser::ber::{parse_ber_integer, parse_ber_sequence_of_v, BerObject};
49/// # use der_parser::error::BerResult;
50/// #
51/// /// Read a SEQUENCE OF INTEGER
52/// fn parser(i:&[u8]) -> BerResult<Vec<BerObject>> {
53///     parse_ber_sequence_of_v(parse_ber_integer)(i)
54/// }
55///
56/// # let empty = &b""[..];
57/// # let bytes = [ 0x30, 0x0a,
58/// #               0x02, 0x03, 0x01, 0x00, 0x01,
59/// #               0x02, 0x03, 0x01, 0x00, 0x00,
60/// # ];
61/// # let expected  = vec![
62/// #     BerObject::from_int_slice(b"\x01\x00\x01"),
63/// #     BerObject::from_int_slice(b"\x01\x00\x00"),
64/// # ];
65/// let (rem, v) = parser(&bytes).expect("parsing failed");
66/// # assert_eq!(v, expected);
67/// ```
68pub fn parse_ber_sequence_of_v<'a, T, F, E>(
69    f: F,
70) -> impl FnMut(&'a [u8]) -> IResult<&'a [u8], Vec<T>, E>
71where
72    F: FnMut(&'a [u8]) -> IResult<&'a [u8], T, E>,
73    E: ParseError<&'a [u8]> + From<BerError>,
74{
75    let mut subparser = all_consuming(many0(complete(cut(f))));
76    parse_ber_sequence_defined_g(move |data, _| subparser(data))
77}
78
79/// Parse a defined sequence of DER elements (function version)
80///
81/// Given a list of expected parsers, apply them to build a DER sequence and
82/// return the remaining bytes and the built object.
83///
84/// The remaining bytes point *after* the sequence: any bytes that are part of the sequence but not
85/// parsed are ignored.
86///
87/// The object header is not available to the parsing function, and the returned type is always a
88/// `BerObject`.
89/// For a generic version, see
90/// [`parse_ber_sequence_defined_g`](fn.parse_ber_sequence_defined_g.html).
91///
92/// # Examples
93///
94/// Parsing a sequence of identical types (same as `parse_ber_sequence_of`):
95///
96/// ```rust
97/// # use der_parser::ber::{parse_ber_integer, parse_ber_sequence_defined, BerObject};
98/// # use der_parser::error::BerResult;
99/// use nom::combinator::complete;
100/// use nom::multi::many1;
101///
102/// fn localparse_seq(i:&[u8]) -> BerResult {
103///     parse_ber_sequence_defined(
104///         many1(complete(parse_ber_integer))
105///     )(i)
106/// }
107///
108/// # let empty = &b""[..];
109/// # let bytes = [ 0x30, 0x0a,
110/// #               0x02, 0x03, 0x01, 0x00, 0x01,
111/// #               0x02, 0x03, 0x01, 0x00, 0x00,
112/// # ];
113/// # let expected  = BerObject::from_seq(vec![
114/// #     BerObject::from_int_slice(b"\x01\x00\x01"),
115/// #     BerObject::from_int_slice(b"\x01\x00\x00"),
116/// # ]);
117/// # assert_eq!(localparse_seq(&bytes), Ok((empty, expected)));
118/// let (rem, v) = localparse_seq(&bytes).expect("parsing failed");
119/// ```
120///
121/// Parsing a defined sequence with different types:
122///
123/// ```rust
124/// # use der_parser::ber::*;
125/// # use der_parser::error::BerResult;
126/// use nom::combinator::map;
127/// use nom::sequence::tuple;
128///
129/// /// Read a DER-encoded object:
130/// /// SEQUENCE {
131/// ///     a INTEGER,
132/// ///     b OCTETSTRING
133/// /// }
134/// fn localparse_seq(i:&[u8]) -> BerResult {
135///     parse_ber_sequence_defined(
136///         // the nom `tuple` combinator returns a tuple, so we have to map it
137///         // to a list
138///         map(
139///             tuple((parse_ber_integer, parse_ber_octetstring)),
140///             |(a, b)| vec![a, b]
141///         )
142///     )(i)
143/// }
144///
145/// # let empty = &b""[..];
146/// # let bytes = [ 0x30, 0x0a,
147/// #               0x02, 0x03, 0x01, 0x00, 0x01,
148/// #               0x04, 0x03, 0x01, 0x00, 0x00,
149/// # ];
150/// # let expected  = BerObject::from_seq(vec![
151/// #     BerObject::from_int_slice(b"\x01\x00\x01"),
152/// #     BerObject::from_obj(BerObjectContent::OctetString(b"\x01\x00\x00")),
153/// # ]);
154/// # assert_eq!(localparse_seq(&bytes), Ok((empty, expected)));
155/// let (rem, v) = localparse_seq(&bytes).expect("parsing failed");
156/// ```
157pub fn parse_ber_sequence_defined<'a, F>(mut f: F) -> impl FnMut(&'a [u8]) -> BerResult<'a>
158where
159    F: FnMut(&'a [u8]) -> BerResult<'a, Vec<BerObject<'a>>>,
160{
161    map(
162        parse_ber_sequence_defined_g(move |data, _| f(data)),
163        BerObject::from_seq,
164    )
165}
166
167/// Parse a defined SEQUENCE object (generic function)
168///
169/// Given a parser for sequence content, apply it to build a DER sequence and
170/// return the remaining bytes and the built object.
171///
172/// The remaining bytes point *after* the sequence: any bytes that are part of the sequence but not
173/// parsed are ignored.
174///
175/// Unlike `parse_ber_sequence_defined`, this function allows returning any object or error type,
176/// and also passes the object header to the callback.
177///
178/// # Examples
179///
180/// Parsing a defined sequence with different types:
181///
182/// ```rust
183/// # use der_parser::ber::*;
184/// # use der_parser::error::BerResult;
185/// #
186/// # #[derive(Debug, PartialEq)]
187/// pub struct MyObject<'a> {
188///     a: u32,
189///     b: &'a [u8],
190/// }
191///
192/// /// Read a DER-encoded object:
193/// /// SEQUENCE {
194/// ///     a INTEGER (0..4294967295),
195/// ///     b OCTETSTRING
196/// /// }
197/// fn parse_myobject(i: &[u8]) -> BerResult<MyObject> {
198///     parse_ber_sequence_defined_g(
199///         |i:&[u8], _| {
200///             let (i, a) = parse_ber_u32(i)?;
201///             let (i, obj) = parse_ber_octetstring(i)?;
202///             let b = obj.as_slice().unwrap();
203///             Ok((i, MyObject{ a, b }))
204///         }
205///     )(i)
206/// }
207///
208/// # let empty = &b""[..];
209/// # let bytes = [ 0x30, 0x0a,
210/// #               0x02, 0x03, 0x01, 0x00, 0x01,
211/// #               0x04, 0x03, 0x01, 0x00, 0x00,
212/// # ];
213/// # let expected  = MyObject {
214/// #   a: 0x010001,
215/// #   b: &[01, 00, 00]
216/// # };
217/// # assert_eq!(parse_myobject(&bytes), Ok((empty, expected)));
218/// let (rem, v) = parse_myobject(&bytes).expect("parsing failed");
219/// ```
220pub fn parse_ber_sequence_defined_g<'a, O, F, E>(
221    mut f: F,
222) -> impl FnMut(&'a [u8]) -> IResult<&'a [u8], O, E>
223where
224    F: FnMut(&'a [u8], Header<'a>) -> IResult<&'a [u8], O, E>,
225    E: ParseError<&'a [u8]> + From<BerError>,
226{
227    parse_ber_container(move |i, hdr| {
228        hdr.assert_tag(Tag::Sequence)
229            .map_err(|e| Err::Error(e.into()))?;
230        f(i, hdr)
231    })
232}
233
234/// Parse a SET OF object
235///
236/// Given a subparser for a BER type, parse a set of identical objects.
237///
238/// ```rust
239/// # use der_parser::ber::{parse_ber_integer, parse_ber_set_of, BerObject};
240/// # use der_parser::error::BerResult;
241/// #
242/// /// Read a SET OF INTEGER
243/// fn parser(i:&[u8]) -> BerResult<BerObject> {
244///     parse_ber_set_of(parse_ber_integer)(i)
245/// }
246///
247/// # let empty = &b""[..];
248/// # let bytes = [ 0x31, 0x0a,
249/// #               0x02, 0x03, 0x01, 0x00, 0x01,
250/// #               0x02, 0x03, 0x01, 0x00, 0x00,
251/// # ];
252/// # let expected  = BerObject::from_set(vec![
253/// #     BerObject::from_int_slice(b"\x01\x00\x01"),
254/// #     BerObject::from_int_slice(b"\x01\x00\x00"),
255/// # ]);
256/// # assert_eq!(parser(&bytes), Ok((empty, expected)));
257/// let (rem, v) = parser(&bytes).expect("parsing failed");
258/// ```
259pub fn parse_ber_set_of<'a, F>(f: F) -> impl FnMut(&'a [u8]) -> BerResult<'a>
260where
261    F: Fn(&'a [u8]) -> BerResult<'a>,
262{
263    map(parse_ber_set_of_v(f), BerObject::from_set)
264}
265
266/// Parse a SET OF object (returning a vec)
267///
268/// Given a subparser for a BER type, parse a set of identical objects.
269///
270/// This differs from `parse_ber_set_of` in the parse function and return type.
271///
272/// ```rust
273/// # use der_parser::ber::{parse_ber_integer, parse_ber_set_of_v, BerObject};
274/// # use der_parser::error::BerResult;
275/// #
276/// /// Read a SET OF INTEGER
277/// fn parser(i:&[u8]) -> BerResult<Vec<BerObject>> {
278///     parse_ber_set_of_v(parse_ber_integer)(i)
279/// }
280///
281/// # let empty = &b""[..];
282/// # let bytes = [ 0x31, 0x0a,
283/// #               0x02, 0x03, 0x01, 0x00, 0x01,
284/// #               0x02, 0x03, 0x01, 0x00, 0x00,
285/// # ];
286/// # let expected  = vec![
287/// #     BerObject::from_int_slice(b"\x01\x00\x01"),
288/// #     BerObject::from_int_slice(b"\x01\x00\x00"),
289/// # ];
290/// let (rem, v) = parser(&bytes).expect("parsing failed");
291/// # assert_eq!(v, expected);
292/// ```
293pub fn parse_ber_set_of_v<'a, T, F, E>(f: F) -> impl FnMut(&'a [u8]) -> IResult<&'a [u8], Vec<T>, E>
294where
295    F: FnMut(&'a [u8]) -> IResult<&'a [u8], T, E>,
296    E: ParseError<&'a [u8]> + From<BerError>,
297{
298    let mut subparser = all_consuming(many0(complete(cut(f))));
299    parse_ber_set_defined_g(move |data, _| subparser(data))
300}
301
302/// Parse a defined set of DER elements (function version)
303///
304/// Given a list of expected parsers, apply them to build a DER set and
305/// return the remaining bytes and the built object.
306///
307/// The remaining bytes point *after* the set: any bytes that are part of the sequence but not
308/// parsed are ignored.
309/// The nom combinator `all_consuming` can be used to ensure all the content is parsed.
310///
311/// The object header is not available to the parsing function, and the returned type is always a
312/// `BerObject`.
313/// For a generic version, see [`parse_ber_set_defined_g`](fn.parse_ber_set_defined_g.html).
314///
315/// # Examples
316///
317/// Parsing a set of identical types (same as `parse_ber_set_of`):
318///
319/// ```rust
320/// # use der_parser::ber::{parse_ber_integer, parse_ber_set_defined, BerObject};
321/// # use der_parser::error::BerResult;
322/// use nom::combinator::complete;
323/// use nom::multi::many1;
324///
325/// fn localparse_seq(i:&[u8]) -> BerResult {
326///     parse_ber_set_defined(
327///         many1(complete(parse_ber_integer))
328///     )(i)
329/// }
330///
331/// # let empty = &b""[..];
332/// # let bytes = [ 0x31, 0x0a,
333/// #               0x02, 0x03, 0x01, 0x00, 0x01,
334/// #               0x02, 0x03, 0x01, 0x00, 0x00,
335/// # ];
336/// # let expected  = BerObject::from_set(vec![
337/// #     BerObject::from_int_slice(b"\x01\x00\x01"),
338/// #     BerObject::from_int_slice(b"\x01\x00\x00"),
339/// # ]);
340/// # assert_eq!(localparse_seq(&bytes), Ok((empty, expected)));
341/// let (rem, v) = localparse_seq(&bytes).expect("parsing failed");
342/// ```
343///
344/// Parsing a defined set with different types:
345///
346/// ```rust
347/// # use der_parser::ber::*;
348/// # use der_parser::error::BerResult;
349/// use nom::combinator::map;
350/// use nom::sequence::tuple;
351///
352/// /// Read a DER-encoded object:
353/// /// SET {
354/// ///     a INTEGER,
355/// ///     b OCTETSTRING
356/// /// }
357/// fn localparse_set(i:&[u8]) -> BerResult {
358///     parse_ber_set_defined(
359///         // the nom `tuple` combinator returns a tuple, so we have to map it
360///         // to a list
361///         map(
362///             tuple((parse_ber_integer, parse_ber_octetstring)),
363///             |(a, b)| vec![a, b]
364///         )
365///     )(i)
366/// }
367///
368/// # let empty = &b""[..];
369/// # let bytes = [ 0x31, 0x0a,
370/// #               0x02, 0x03, 0x01, 0x00, 0x01,
371/// #               0x04, 0x03, 0x01, 0x00, 0x00,
372/// # ];
373/// # let expected  = BerObject::from_set(vec![
374/// #     BerObject::from_int_slice(b"\x01\x00\x01"),
375/// #     BerObject::from_obj(BerObjectContent::OctetString(b"\x01\x00\x00")),
376/// # ]);
377/// # assert_eq!(localparse_set(&bytes), Ok((empty, expected)));
378/// let (rem, v) = localparse_set(&bytes).expect("parsing failed");
379/// ```
380pub fn parse_ber_set_defined<'a, F>(mut f: F) -> impl FnMut(&'a [u8]) -> BerResult<'a>
381where
382    F: FnMut(&'a [u8]) -> BerResult<'a, Vec<BerObject<'a>>>,
383{
384    map(
385        parse_ber_set_defined_g(move |data, _| f(data)),
386        BerObject::from_set,
387    )
388}
389
390/// Parse a defined SET object (generic version)
391///
392/// Given a parser for set content, apply it to build a DER set and
393/// return the remaining bytes and the built object.
394///
395/// The remaining bytes point *after* the set: any bytes that are part of the sequence but not
396/// parsed are ignored.
397/// The nom combinator `all_consuming` can be used to ensure all the content is parsed.
398///
399/// Unlike `parse_ber_set_defined`, this function allows returning any object or error type,
400/// and also passes the object header to the callback.
401///
402/// # Examples
403///
404/// Parsing a defined set with different types:
405///
406/// ```rust
407/// # use der_parser::ber::*;
408/// # use der_parser::error::BerResult;
409/// #
410/// # #[derive(Debug, PartialEq)]
411/// pub struct MyObject<'a> {
412///     a: u32,
413///     b: &'a [u8],
414/// }
415///
416/// /// Read a DER-encoded object:
417/// /// SET {
418/// ///     a INTEGER (0..4294967295),
419/// ///     b OCTETSTRING
420/// /// }
421/// fn parse_myobject(i: &[u8]) -> BerResult<MyObject> {
422///     parse_ber_set_defined_g(
423///         |i:&[u8], _| {
424///             let (i, a) = parse_ber_u32(i)?;
425///             let (i, obj) = parse_ber_octetstring(i)?;
426///             let b = obj.as_slice().unwrap();
427///             Ok((i, MyObject{ a, b }))
428///         }
429///     )(i)
430/// }
431///
432/// # let empty = &b""[..];
433/// # let bytes = [ 0x31, 0x0a,
434/// #               0x02, 0x03, 0x01, 0x00, 0x01,
435/// #               0x04, 0x03, 0x01, 0x00, 0x00,
436/// # ];
437/// # let expected  = MyObject {
438/// #   a: 0x010001,
439/// #   b: &[01, 00, 00]
440/// # };
441/// # assert_eq!(parse_myobject(&bytes), Ok((empty, expected)));
442/// let (rem, v) = parse_myobject(&bytes).expect("parsing failed");
443/// ```
444pub fn parse_ber_set_defined_g<'a, O, F, E>(
445    mut f: F,
446) -> impl FnMut(&'a [u8]) -> IResult<&'a [u8], O, E>
447where
448    F: FnMut(&'a [u8], Header<'a>) -> IResult<&'a [u8], O, E>,
449    E: ParseError<&'a [u8]> + From<BerError>,
450{
451    parse_ber_container(move |i, hdr| {
452        hdr.assert_tag(Tag::Set).map_err(|e| Err::Error(e.into()))?;
453        f(i, hdr)
454    })
455}
456
457/// Parse a BER object and apply provided function to content
458///
459/// Given a parser for content, read BER object header and apply parser to
460/// return the remaining bytes and the parser result.
461///
462/// The remaining bytes point *after* the content: any bytes that are part of the content but not
463/// parsed are ignored.
464/// The nom combinator `all_consuming` can be used to ensure all the content is parsed.
465///
466/// This function is mostly intended for constructed objects, but can be used for any valid BER
467/// object.
468///
469/// # Examples
470///
471/// Parsing a defined sequence with different types:
472///
473/// ```rust
474/// # use der_parser::ber::*;
475/// # use der_parser::error::{BerError, BerResult};
476/// #
477/// # #[derive(Debug, PartialEq)]
478/// pub struct MyObject<'a> {
479///     a: u32,
480///     b: &'a [u8],
481/// }
482///
483/// /// Read a DER-encoded object:
484/// /// SEQUENCE {
485/// ///     a INTEGER (0..4294967295),
486/// ///     b OCTETSTRING
487/// /// }
488/// fn parse_myobject(i: &[u8]) -> BerResult<MyObject> {
489///     parse_ber_container(
490///         |i: &[u8], hdr: Header| {
491///             if hdr.tag() != Tag::Sequence {
492///                 return Err(nom::Err::Error(BerError::BerTypeError.into()));
493///             }
494///             let (i, a) = parse_ber_u32(i)?;
495///             let (i, obj) = parse_ber_octetstring(i)?;
496///             let b = obj.as_slice().unwrap();
497///             Ok((i, MyObject{ a, b }))
498///         }
499///     )(i)
500/// }
501///
502/// # let empty = &b""[..];
503/// # let bytes = [ 0x30, 0x0a,
504/// #               0x02, 0x03, 0x01, 0x00, 0x01,
505/// #               0x04, 0x03, 0x01, 0x00, 0x00,
506/// # ];
507/// # let expected  = MyObject {
508/// #   a: 0x010001,
509/// #   b: &[01, 00, 00]
510/// # };
511/// # assert_eq!(parse_myobject(&bytes), Ok((empty, expected)));
512/// let (rem, v) = parse_myobject(&bytes).expect("parsing failed");
513/// ```
514pub fn parse_ber_container<'a, O, F, E>(mut f: F) -> impl FnMut(&'a [u8]) -> IResult<&'a [u8], O, E>
515where
516    F: FnMut(&'a [u8], Header<'a>) -> IResult<&'a [u8], O, E>,
517    E: ParseError<&'a [u8]> + From<BerError>,
518{
519    move |i: &[u8]| {
520        let (i, hdr) = ber_read_element_header(i).map_err(Err::convert)?;
521        let (i, data) = match hdr.length() {
522            Length::Definite(len) => take(len)(i)?,
523            Length::Indefinite => {
524                ber_get_object_content(i, &hdr, MAX_RECURSION).map_err(Err::convert)?
525            }
526        };
527        let (_rest, v) = f(data, hdr)?;
528        Ok((i, v))
529    }
530}
der_parser/ber/multi.rs

der_parser/ber/
multi.rs
