1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110

//! # DER Parser
//!
//! A DER (X.690) parser, implemented with the [nom](https://github.com/Geal/nom)
//! parser combinator framework.
//!
//! The code is available on [Github](https://github.com/rusticata/der-parser)
//! and is part of the [Rusticata](https://github.com/rusticata) project.
//!
//! # DER parser design
//!
//! There are two different approaches for parsing DER objects: reading the objects recursively as
//! long as the tags are known, or specifying a description of the expected objects (generally from
//! the ASN.1 description).
//!
//! The first parsing method can be done using the [`parse_der`](fn.parse_der.html) method.
//! However, it cannot fully parse all objects, especially those containing IMPLICIT, OPTIONAL, or
//! DEFINED BY items.
//!
//! ```rust,no_run
//! # #[macro_use] extern crate der_parser;
//! use der_parser::parse_der;
//!
//! # fn main() {
//! let bytes = [ 0x30, 0x0a,
//!               0x02, 0x03, 0x01, 0x00, 0x01,
//!               0x02, 0x03, 0x01, 0x00, 0x00,
//! ];
//!
//! let parsed = parse_der(&bytes);
//! # }
//! ```
//!
//! The second (and preferred) parsing method is to specify the expected objects recursively. The
//! following macros can be used:
//! [`parse_der_sequence_defined`](macro.parse_der_sequence_defined.html) and similar functions,
//! [`parse_der_struct`](macro.parse_der_struct.html), etc.
//!
//! For example, to read a sequence containing two integers:
//!
//! ```rust,no_run
//! # #[macro_use] extern crate nom;
//! # #[macro_use] extern crate rusticata_macros;
//! # #[macro_use] extern crate der_parser;
//! use der_parser::*;
//! use nom::{IResult,Err,ErrorKind};
//!
//! # fn main() {
//! fn localparse_seq(i:&[u8]) -> IResult<&[u8],DerObject> {
//!     parse_der_sequence_defined!(i,
//!         parse_der_integer,
//!         parse_der_integer
//!     )
//! }
//! let bytes = [ 0x30, 0x0a,
//!               0x02, 0x03, 0x01, 0x00, 0x01,
//!               0x02, 0x03, 0x01, 0x00, 0x00,
//! ];
//! let parsed = localparse_seq(&bytes);
//! # }
//! ```
//!
//! All functions return an `IResult` object from `nom`: the parsed
//! [`DerObject`](struct.DerObject.html), an `Incomplete` value, or an error.
//!
//! # Notes
//!
//! - The DER constraints are not enforced or verified. Because of that, this parser is mostly
//! compatible with BER.
//! - DER integers can be of any size, so it is not possible to store them as simple integers (they
//! are stored as raw bytes). To get a simple value, use
//! [`DerObject::as_u32`](struct.DerObject.html#method.as_u32) (knowning that this method will
//! return an error if the integer is too large), or use the `bigint` feature of this crate and use
//! [`DerObject::as_bigint`](struct.DerObject.html#method.as_bigint).
//!
//! # References
//!
//! - [[X.680]](http://www.itu.int/rec/T-REC-X.680/en) Abstract Syntax Notation One (ASN.1):
//!   Specification of basic notation.
//! - [[X.690]](https://www.itu.int/rec/T-REC-X.690/en) ASN.1 encoding rules: Specification of
//!   Basic Encoding Rules (BER), Canonical Encoding Rules (CER) and Distinguished Encoding Rules
//!   (DER).

#![deny(/*missing_docs,*/unsafe_code,
        unstable_features,
        unused_import_braces, unused_qualifications)]

#[macro_use]
extern crate nom;

#[macro_use]
extern crate rusticata_macros;

#[macro_use] mod macros;

mod der;
pub use der::*;

mod der_parser;
pub use der_parser::*;

mod der_print;
pub use der_print::*;

mod error;
pub use error::*;

pub mod oid;

#[cfg(feature="bigint")]
extern crate num;