der_parser/der/
multi.rs

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

der_parser/der/
multi.rs
