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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
//! DER decoder.
use crate::{asn1::*, Choice, Decodable, Error, ErrorKind, Length, Result, Tag, TagNumber};
use core::{
cmp::Ordering,
convert::{TryFrom, TryInto},
};
/// DER decoder.
#[derive(Debug)]
pub struct Decoder<'a> {
/// Byte slice being decoded.
///
/// In the event an error was previously encountered this will be set to
/// `None` to prevent further decoding while in a bad state.
bytes: Option<&'a [u8]>,
/// Position within the decoded slice.
position: Length,
}
impl<'a> Decoder<'a> {
/// Create a new decoder for the given byte slice.
pub fn new(bytes: &'a [u8]) -> Self {
Self {
bytes: Some(bytes),
position: Length::ZERO,
}
}
/// Decode a value which impls the [`Decodable`] trait.
pub fn decode<T: Decodable<'a>>(&mut self) -> Result<T> {
if self.is_failed() {
return Err(self.error(ErrorKind::Failed));
}
T::decode(self).map_err(|e| {
self.bytes.take();
e.nested(self.position)
})
}
/// Return an error with the given [`ErrorKind`], annotating it with
/// context about where the error occurred.
pub fn error(&mut self, kind: ErrorKind) -> Error {
self.bytes.take();
kind.at(self.position)
}
/// Return an error for an invalid value with the given tag.
pub fn value_error(&mut self, tag: Tag) -> Error {
self.error(tag.value_error().kind())
}
/// Did the decoding operation fail due to an error?
pub fn is_failed(&self) -> bool {
self.bytes.is_none()
}
/// Finish decoding, returning the given value if there is no
/// remaining data, or an error otherwise
pub fn finish<T>(self, value: T) -> Result<T> {
if self.is_failed() {
Err(ErrorKind::Failed.at(self.position))
} else if !self.is_finished() {
Err(ErrorKind::TrailingData {
decoded: self.position,
remaining: self.remaining_len()?,
}
.at(self.position))
} else {
Ok(value)
}
}
/// Have we decoded all of the bytes in this [`Decoder`]?
///
/// Returns `false` if we're not finished decoding or if a fatal error
/// has occurred.
pub fn is_finished(&self) -> bool {
self.remaining().map(|rem| rem.is_empty()).unwrap_or(false)
}
/// Attempt to decode an ASN.1 `ANY` value.
pub fn any(&mut self) -> Result<Any<'a>> {
self.decode()
}
/// Attempt to decode an `OPTIONAL` ASN.1 `ANY` value.
pub fn any_optional(&mut self) -> Result<Option<Any<'a>>> {
self.decode()
}
/// Attempt to decode ASN.1 `INTEGER` as `i8`
pub fn int8(&mut self) -> Result<i8> {
self.decode()
}
/// Attempt to decode ASN.1 `INTEGER` as `i16`
pub fn int16(&mut self) -> Result<i16> {
self.decode()
}
/// Attempt to decode unsigned ASN.1 `INTEGER` as `u8`
pub fn uint8(&mut self) -> Result<u8> {
self.decode()
}
/// Attempt to decode unsigned ASN.1 `INTEGER` as `u16`
pub fn uint16(&mut self) -> Result<u16> {
self.decode()
}
/// Attempt to decode an ASN.1 `INTEGER` as a [`UIntBytes`].
#[cfg(feature = "bigint")]
#[cfg_attr(docsrs, doc(cfg(feature = "bigint")))]
pub fn uint_bytes(&mut self) -> Result<UIntBytes<'a>> {
self.decode()
}
/// Attempt to decode an ASN.1 `BIT STRING`.
pub fn bit_string(&mut self) -> Result<BitString<'a>> {
self.decode()
}
/// Attempt to decode an ASN.1 `CONTEXT-SPECIFIC` field with the
/// provided [`TagNumber`].
///
/// This method has the following behavior which is designed to simplify
/// handling of extension fields, which are denoted in an ASN.1 schema
/// using the `...` ellipsis extension marker:
///
/// - Skips over [`ContextSpecific`] fields with a tag number lower than
/// the current one, consuming and ignoring them.
/// - Returns `Ok(None)` if a [`ContextSpecific`] field with a higher tag
/// number is encountered. These fields are not consumed in this case,
/// allowing a field with a lower tag number to be omitted, then the
/// higher numbered field consumed as a follow-up.
/// - Returns `Ok(None)` if anything other than a [`ContextSpecific`] field
/// is encountered.
pub fn context_specific(&mut self, tag: TagNumber) -> Result<Option<Any<'a>>> {
loop {
match self.peek().map(Tag::try_from).transpose()? {
Some(Tag::ContextSpecific(actual_tag)) => {
match actual_tag.cmp(&tag) {
Ordering::Less => {
// Decode and ignore lower-numbered fields if
// they parse correctly.
self.decode::<ContextSpecific<'_>>()?;
}
Ordering::Equal => {
return self
.decode::<ContextSpecific<'_>>()
.map(|cs| Some(cs.value))
}
Ordering::Greater => return Ok(None),
}
}
_ => return Ok(None),
}
}
}
/// Attempt to decode an ASN.1 `GeneralizedTime`.
pub fn generalized_time(&mut self) -> Result<GeneralizedTime> {
self.decode()
}
/// Attempt to decode an ASN.1 `IA5String`.
pub fn ia5_string(&mut self) -> Result<Ia5String<'a>> {
self.decode()
}
/// Attempt to decode an ASN.1 `NULL` value.
pub fn null(&mut self) -> Result<Null> {
self.decode()
}
/// Attempt to decode an ASN.1 `OCTET STRING`.
pub fn octet_string(&mut self) -> Result<OctetString<'a>> {
self.decode()
}
/// Attempt to decode an ASN.1 `OBJECT IDENTIFIER`.
#[cfg(feature = "oid")]
#[cfg_attr(docsrs, doc(cfg(feature = "oid")))]
pub fn oid(&mut self) -> Result<ObjectIdentifier> {
self.decode()
}
/// Attempt to decode an ASN.1 `OPTIONAL` value.
pub fn optional<T: Choice<'a>>(&mut self) -> Result<Option<T>> {
self.decode()
}
/// Attempt to decode an ASN.1 `PrintableString`.
pub fn printable_string(&mut self) -> Result<PrintableString<'a>> {
self.decode()
}
/// Attempt to decode an ASN.1 `UTCTime`.
pub fn utc_time(&mut self) -> Result<UtcTime> {
self.decode()
}
/// Attempt to decode an ASN.1 `UTF8String`.
pub fn utf8_string(&mut self) -> Result<Utf8String<'a>> {
self.decode()
}
/// Attempt to decode an ASN.1 `SEQUENCE`, creating a new nested
/// [`Decoder`] and calling the provided argument with it.
pub fn sequence<F, T>(&mut self, f: F) -> Result<T>
where
F: FnOnce(&mut Decoder<'a>) -> Result<T>,
{
Sequence::decode(self)?.decode_nested(f).map_err(|e| {
self.bytes.take();
e.nested(self.position)
})
}
/// Decode a single byte, updating the internal cursor.
pub(crate) fn byte(&mut self) -> Result<u8> {
match self.bytes(1u8)? {
[byte] => Ok(*byte),
_ => Err(self.error(ErrorKind::Truncated)),
}
}
/// Obtain a slice of bytes of the given length from the current cursor
/// position, or return an error if we have insufficient data.
pub(crate) fn bytes(&mut self, len: impl TryInto<Length>) -> Result<&'a [u8]> {
if self.is_failed() {
return Err(self.error(ErrorKind::Failed));
}
let len = len
.try_into()
.map_err(|_| self.error(ErrorKind::Overflow))?;
let result = self
.remaining()?
.get(..len.try_into()?)
.ok_or(ErrorKind::Truncated)?;
self.position = (self.position + len)?;
Ok(result)
}
/// Peek at the next byte in the decoder without modifying the cursor.
pub(crate) fn peek(&self) -> Option<u8> {
self.remaining()
.ok()
.and_then(|bytes| bytes.get(0).cloned())
}
/// Obtain the remaining bytes in this decoder from the current cursor
/// position.
fn remaining(&self) -> Result<&'a [u8]> {
let pos = usize::try_from(self.position)?;
self.bytes
.and_then(|b| b.get(pos..))
.ok_or_else(|| ErrorKind::Truncated.at(self.position))
}
/// Get the number of bytes still remaining in the buffer.
fn remaining_len(&self) -> Result<Length> {
self.remaining()?.len().try_into()
}
}
impl<'a> From<&'a [u8]> for Decoder<'a> {
fn from(bytes: &'a [u8]) -> Decoder<'a> {
Decoder::new(bytes)
}
}
#[cfg(test)]
mod tests {
use super::Decoder;
use crate::{Decodable, ErrorKind, Length, Tag, TagNumber};
use core::convert::TryFrom;
use hex_literal::hex;
#[test]
fn context_specific_with_expected_field() {
let tag = TagNumber::new(0);
// Empty message
let mut decoder = Decoder::new(&[]);
assert_eq!(decoder.context_specific(tag).unwrap(), None);
// Message containing a non-context-specific type
let mut decoder = Decoder::new(&hex!("020100"));
assert_eq!(decoder.context_specific(tag).unwrap(), None);
//
let mut decoder = Decoder::new(&hex!("A003020100"));
let field = decoder.context_specific(tag).unwrap().unwrap();
assert_eq!(u8::try_from(field).unwrap(), 0);
}
#[test]
fn context_specific_skipping_unknown_field() {
let tag = TagNumber::new(1);
let mut decoder = Decoder::new(&hex!("A003020100A103020101"));
let field = decoder.context_specific(tag).unwrap().unwrap();
assert_eq!(u8::try_from(field).unwrap(), 1);
}
#[test]
fn context_specific_returns_none_on_greater_tag_number() {
let tag = TagNumber::new(0);
let mut decoder = Decoder::new(&hex!("A103020101"));
assert_eq!(decoder.context_specific(tag).unwrap(), None);
}
#[test]
fn truncated_message() {
let mut decoder = Decoder::new(&[]);
let err = bool::decode(&mut decoder).err().unwrap();
assert_eq!(ErrorKind::Truncated, err.kind());
assert_eq!(Some(Length::ZERO), err.position());
}
#[test]
fn invalid_field_length() {
let mut decoder = Decoder::new(&[0x02, 0x01]);
let err = i8::decode(&mut decoder).err().unwrap();
assert_eq!(ErrorKind::Length { tag: Tag::Integer }, err.kind());
assert_eq!(Some(Length::from(2u8)), err.position());
}
#[test]
fn trailing_data() {
let mut decoder = Decoder::new(&[0x02, 0x01, 0x2A, 0x00]);
let x = decoder.decode().unwrap();
assert_eq!(42i8, x);
let err = decoder.finish(x).err().unwrap();
assert_eq!(
ErrorKind::TrailingData {
decoded: 3u8.into(),
remaining: 1u8.into()
},
err.kind()
);
assert_eq!(Some(Length::from(3u8)), err.position());
}
}