yasna/deserializer/
mod.rs

1// Copyright 2016 Masaki Hara
2//
3// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
4// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
5// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
6// option. This file may not be copied, modified, or distributed
7// except according to those terms.
8
9#![forbid(missing_docs)]
10
11use alloc::vec::Vec;
12use alloc::string::String;
13
14#[cfg(feature = "num-bigint")]
15use num_bigint::{BigInt,BigUint};
16#[cfg(feature = "bit-vec")]
17use bit_vec::BitVec;
18
19use super::{ASN1Result,BERMode,BERReader,parse_ber_general};
20use super::models::{ObjectIdentifier,TaggedDerValue};
21#[cfg(feature = "time")]
22use super::models::{UTCTime,GeneralizedTime};
23
24/// Types decodable in BER.
25///
26/// # Examples
27///
28/// ```
29/// use yasna;
30/// let asn : i64 = yasna::decode_der(&[2, 3, 0, 255, 255]).unwrap();
31/// assert_eq!(asn, 65535);
32/// ```
33///
34/// # Limitations
35///
36/// Rust types don't correspond to ASN.1 types one-to-one. Not all kinds
37/// of ASN.1 types can be decoded via default `BERDecodable` implementation.
38///
39/// If you want to decode ASN.1, you may implement `BERDecodable` for your
40/// own types or use [`parse_der`](crate::parse_der)/
41/// [`parse_ber`](crate::parse_ber).
42///
43/// # Default implementations
44///
45/// - The decoder for `Vec<T>` is implemented as SEQUENCE OF decoder.
46/// - `()` as NULL decoder.
47/// - Tuples (except `()`) as SEQUENCE decoder.
48/// - `Vec<u8>` as OCTETSTRING decoder.
49/// - `BitVec` as BITSTRING decoder.
50/// - `String` as UTF8String decoder.
51/// - `i64`, `u64`, `i32`, `u32`, `i16`, `u16`, `BigInt`, `BigUint`
52///   as INTEGER decoder. (`u8` is avoided because of confliction.)
53/// - `bool` as BOOLEAN decoder.
54/// - `ObjectIdentifier` as OBJECTT IDENTIFIER decoder.
55/// - `UTCTime`/`GeneralizedTime` as UTCTime/GeneralizedTime decoder.
56pub trait BERDecodable: Sized {
57    /// Reads an ASN.1 value from `BERReader` and converts it to `Self`.
58    ///
59    /// # Examples
60    ///
61    /// ```
62    /// use yasna::{BERDecodable,BERReader,ASN1Result};
63    /// struct Entry {
64    ///     name: String,
65    ///     age: i64,
66    /// }
67    ///
68    /// impl BERDecodable for Entry {
69    ///     fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
70    ///         reader.read_sequence(|reader| {
71    ///             let name = reader.next().read_visible_string()?;
72    ///             let age = reader.next().read_i64()?;
73    ///             return Ok(Entry {
74    ///                 name: name,
75    ///                 age: age,
76    ///             });
77    ///         })
78    ///     }
79    /// }
80    /// fn main() {
81    ///     let entry : Entry = yasna::decode_der(
82    ///         &[48, 9, 26, 4, 74, 111, 104, 110, 2, 1, 32]).unwrap();
83    ///     assert_eq!(entry.name, "John");
84    ///     assert_eq!(entry.age, 32);
85    /// }
86    /// ```
87    fn decode_ber<'a, 'b>(reader: BERReader<'a, 'b>) -> ASN1Result<Self>;
88}
89
90/// Decodes DER/BER-encoded data.
91///
92/// [`decode_ber`] and [`decode_der`] are shorthands
93/// for this function.
94pub fn decode_ber_general<T:BERDecodable>(src: &[u8], mode: BERMode)
95        -> ASN1Result<T> {
96    parse_ber_general(src, mode, |reader| {
97        T::decode_ber(reader)
98    })
99}
100
101/// Reads an ASN.1 value from `&[u8]`.
102///
103/// If you want to accept only DER-encoded data,
104/// use [`decode_der`].
105///
106/// # Examples
107///
108/// ```
109/// use yasna;
110/// let asn : i64 = yasna::decode_ber(&[2, 3, 0, 255, 255]).unwrap();
111/// assert_eq!(asn, 65535);
112/// ```
113pub fn decode_ber<T:BERDecodable>(src: &[u8]) -> ASN1Result<T> {
114    decode_ber_general(src, BERMode::Ber)
115}
116
117/// Reads an ASN.1 value from `&[u8]`.
118///
119/// If you want to decode BER-encoded data in general,
120/// use [`decode_ber`].
121///
122/// # Examples
123///
124/// ```
125/// use yasna;
126/// let asn : i64 = yasna::decode_der(&[2, 3, 0, 255, 255]).unwrap();
127/// assert_eq!(asn, 65535);
128/// ```
129pub fn decode_der<T:BERDecodable>(src: &[u8]) -> ASN1Result<T> {
130    decode_ber_general(src, BERMode::Der)
131}
132
133impl<T> BERDecodable for Vec<T> where T: BERDecodable {
134    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
135        reader.read_sequence(|reader| {
136            let mut ret = Vec::new();
137            loop {
138                let result = reader.read_optional(|reader| {
139                    T::decode_ber(reader)
140                })?;
141                match result {
142                    Some(result) => {
143                        ret.push(result);
144                    },
145                    None => {
146                        break;
147                    }
148                };
149            }
150            return Ok(ret);
151        })
152    }
153}
154
155impl BERDecodable for i64 {
156    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
157        reader.read_i64()
158    }
159}
160
161impl BERDecodable for u64 {
162    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
163        reader.read_u64()
164    }
165}
166
167impl BERDecodable for i32 {
168    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
169        reader.read_i32()
170    }
171}
172
173impl BERDecodable for u32 {
174    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
175        reader.read_u32()
176    }
177}
178
179impl BERDecodable for i16 {
180    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
181        reader.read_i16()
182    }
183}
184
185impl BERDecodable for u16 {
186    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
187        reader.read_u16()
188    }
189}
190
191#[cfg(feature = "num-bigint")]
192impl BERDecodable for BigInt {
193    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
194        reader.read_bigint()
195    }
196}
197
198#[cfg(feature = "num-bigint")]
199impl BERDecodable for BigUint {
200    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
201        reader.read_biguint()
202    }
203}
204
205impl BERDecodable for bool {
206    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
207        reader.read_bool()
208    }
209}
210
211#[cfg(feature = "bit-vec")]
212impl BERDecodable for BitVec {
213    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
214        reader.read_bitvec()
215    }
216}
217
218impl BERDecodable for Vec<u8> {
219    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
220        reader.read_bytes()
221    }
222}
223
224impl BERDecodable for String {
225    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
226        reader.read_utf8string()
227    }
228}
229
230impl BERDecodable for ObjectIdentifier {
231    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
232        reader.read_oid()
233    }
234}
235
236#[cfg(feature = "time")]
237impl BERDecodable for UTCTime {
238    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
239        reader.read_utctime()
240    }
241}
242
243#[cfg(feature = "time")]
244impl BERDecodable for GeneralizedTime {
245    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
246        reader.read_generalized_time()
247    }
248}
249
250impl BERDecodable for () {
251    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
252        reader.read_null()
253    }
254}
255
256impl<T0> BERDecodable for (T0,)
257        where T0: BERDecodable {
258    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
259        reader.read_sequence(|reader| {
260            let t0 = T0::decode_ber(reader.next())?;
261            return Ok((t0,));
262        })
263    }
264}
265
266impl<T0, T1> BERDecodable for (T0, T1)
267        where T0: BERDecodable, T1: BERDecodable {
268    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
269        reader.read_sequence(|reader| {
270            let t0 = T0::decode_ber(reader.next())?;
271            let t1 = T1::decode_ber(reader.next())?;
272            return Ok((t0, t1));
273        })
274    }
275}
276
277impl<T0, T1, T2> BERDecodable for (T0, T1, T2)
278        where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable {
279    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
280        reader.read_sequence(|reader| {
281            let t0 = T0::decode_ber(reader.next())?;
282            let t1 = T1::decode_ber(reader.next())?;
283            let t2 = T2::decode_ber(reader.next())?;
284            return Ok((t0, t1, t2));
285        })
286    }
287}
288
289impl<T0, T1, T2, T3> BERDecodable for (T0, T1, T2, T3)
290        where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
291            T3: BERDecodable {
292    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
293        reader.read_sequence(|reader| {
294            let t0 = T0::decode_ber(reader.next())?;
295            let t1 = T1::decode_ber(reader.next())?;
296            let t2 = T2::decode_ber(reader.next())?;
297            let t3 = T3::decode_ber(reader.next())?;
298            return Ok((t0, t1, t2, t3));
299        })
300    }
301}
302
303impl<T0, T1, T2, T3, T4> BERDecodable for (T0, T1, T2, T3, T4)
304        where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
305            T3: BERDecodable, T4: BERDecodable {
306    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
307        reader.read_sequence(|reader| {
308            let t0 = T0::decode_ber(reader.next())?;
309            let t1 = T1::decode_ber(reader.next())?;
310            let t2 = T2::decode_ber(reader.next())?;
311            let t3 = T3::decode_ber(reader.next())?;
312            let t4 = T4::decode_ber(reader.next())?;
313            return Ok((t0, t1, t2, t3, t4));
314        })
315    }
316}
317
318impl<T0, T1, T2, T3, T4, T5> BERDecodable for (T0, T1, T2, T3, T4, T5)
319        where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
320            T3: BERDecodable, T4: BERDecodable, T5: BERDecodable {
321    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
322        reader.read_sequence(|reader| {
323            let t0 = T0::decode_ber(reader.next())?;
324            let t1 = T1::decode_ber(reader.next())?;
325            let t2 = T2::decode_ber(reader.next())?;
326            let t3 = T3::decode_ber(reader.next())?;
327            let t4 = T4::decode_ber(reader.next())?;
328            let t5 = T5::decode_ber(reader.next())?;
329            return Ok((t0, t1, t2, t3, t4, t5));
330        })
331    }
332}
333
334impl<T0, T1, T2, T3, T4, T5, T6> BERDecodable for (T0, T1, T2, T3, T4, T5, T6)
335        where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
336            T3: BERDecodable, T4: BERDecodable, T5: BERDecodable,
337            T6: BERDecodable {
338    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
339        reader.read_sequence(|reader| {
340            let t0 = T0::decode_ber(reader.next())?;
341            let t1 = T1::decode_ber(reader.next())?;
342            let t2 = T2::decode_ber(reader.next())?;
343            let t3 = T3::decode_ber(reader.next())?;
344            let t4 = T4::decode_ber(reader.next())?;
345            let t5 = T5::decode_ber(reader.next())?;
346            let t6 = T6::decode_ber(reader.next())?;
347            return Ok((t0, t1, t2, t3, t4, t5, t6));
348        })
349    }
350}
351
352impl<T0, T1, T2, T3, T4, T5, T6, T7> BERDecodable
353        for (T0, T1, T2, T3, T4, T5, T6, T7)
354        where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
355            T3: BERDecodable, T4: BERDecodable, T5: BERDecodable,
356            T6: BERDecodable, T7: BERDecodable {
357    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
358        reader.read_sequence(|reader| {
359            let t0 = T0::decode_ber(reader.next())?;
360            let t1 = T1::decode_ber(reader.next())?;
361            let t2 = T2::decode_ber(reader.next())?;
362            let t3 = T3::decode_ber(reader.next())?;
363            let t4 = T4::decode_ber(reader.next())?;
364            let t5 = T5::decode_ber(reader.next())?;
365            let t6 = T6::decode_ber(reader.next())?;
366            let t7 = T7::decode_ber(reader.next())?;
367            return Ok((t0, t1, t2, t3, t4, t5, t6, t7));
368        })
369    }
370}
371
372impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> BERDecodable
373        for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
374        where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
375            T3: BERDecodable, T4: BERDecodable, T5: BERDecodable,
376            T6: BERDecodable, T7: BERDecodable, T8: BERDecodable {
377    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
378        reader.read_sequence(|reader| {
379            let t0 = T0::decode_ber(reader.next())?;
380            let t1 = T1::decode_ber(reader.next())?;
381            let t2 = T2::decode_ber(reader.next())?;
382            let t3 = T3::decode_ber(reader.next())?;
383            let t4 = T4::decode_ber(reader.next())?;
384            let t5 = T5::decode_ber(reader.next())?;
385            let t6 = T6::decode_ber(reader.next())?;
386            let t7 = T7::decode_ber(reader.next())?;
387            let t8 = T8::decode_ber(reader.next())?;
388            return Ok((t0, t1, t2, t3, t4, t5, t6, t7, t8));
389        })
390    }
391}
392
393impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> BERDecodable
394        for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
395        where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
396            T3: BERDecodable, T4: BERDecodable, T5: BERDecodable,
397            T6: BERDecodable, T7: BERDecodable, T8: BERDecodable,
398            T9: BERDecodable {
399    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
400        reader.read_sequence(|reader| {
401            let t0 = T0::decode_ber(reader.next())?;
402            let t1 = T1::decode_ber(reader.next())?;
403            let t2 = T2::decode_ber(reader.next())?;
404            let t3 = T3::decode_ber(reader.next())?;
405            let t4 = T4::decode_ber(reader.next())?;
406            let t5 = T5::decode_ber(reader.next())?;
407            let t6 = T6::decode_ber(reader.next())?;
408            let t7 = T7::decode_ber(reader.next())?;
409            let t8 = T8::decode_ber(reader.next())?;
410            let t9 = T9::decode_ber(reader.next())?;
411            return Ok((t0, t1, t2, t3, t4, t5, t6, t7, t8, t9));
412        })
413    }
414}
415
416impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> BERDecodable
417        for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
418        where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
419            T3: BERDecodable, T4: BERDecodable, T5: BERDecodable,
420            T6: BERDecodable, T7: BERDecodable, T8: BERDecodable,
421            T9: BERDecodable, T10: BERDecodable {
422    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
423        reader.read_sequence(|reader| {
424            let t0 = T0::decode_ber(reader.next())?;
425            let t1 = T1::decode_ber(reader.next())?;
426            let t2 = T2::decode_ber(reader.next())?;
427            let t3 = T3::decode_ber(reader.next())?;
428            let t4 = T4::decode_ber(reader.next())?;
429            let t5 = T5::decode_ber(reader.next())?;
430            let t6 = T6::decode_ber(reader.next())?;
431            let t7 = T7::decode_ber(reader.next())?;
432            let t8 = T8::decode_ber(reader.next())?;
433            let t9 = T9::decode_ber(reader.next())?;
434            let t10 = T10::decode_ber(reader.next())?;
435            return Ok((t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10));
436        })
437    }
438}
439
440impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> BERDecodable
441        for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
442        where T0: BERDecodable, T1: BERDecodable, T2: BERDecodable,
443            T3: BERDecodable, T4: BERDecodable, T5: BERDecodable,
444            T6: BERDecodable, T7: BERDecodable, T8: BERDecodable,
445            T9: BERDecodable, T10: BERDecodable, T11: BERDecodable {
446    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
447        reader.read_sequence(|reader| {
448            let t0 = T0::decode_ber(reader.next())?;
449            let t1 = T1::decode_ber(reader.next())?;
450            let t2 = T2::decode_ber(reader.next())?;
451            let t3 = T3::decode_ber(reader.next())?;
452            let t4 = T4::decode_ber(reader.next())?;
453            let t5 = T5::decode_ber(reader.next())?;
454            let t6 = T6::decode_ber(reader.next())?;
455            let t7 = T7::decode_ber(reader.next())?;
456            let t8 = T8::decode_ber(reader.next())?;
457            let t9 = T9::decode_ber(reader.next())?;
458            let t10 = T10::decode_ber(reader.next())?;
459            let t11 = T11::decode_ber(reader.next())?;
460            return Ok((t0, t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11));
461        })
462    }
463}
464
465impl BERDecodable for TaggedDerValue  {
466    fn decode_ber(reader: BERReader) -> ASN1Result<Self> {
467        reader.read_tagged_der()
468    }
469}
yasna/deserializer/mod.rs

yasna/deserializer/
mod.rs
