1use crate::error::{Error, ErrorCode, Result};
36
37pub const TAG_BOOLEAN: u8 = 0x01;
41pub const TAG_INTEGER: u8 = 0x02;
43pub const TAG_BIT_STRING: u8 = 0x03;
45pub const TAG_OCTET_STRING: u8 = 0x04;
47pub const TAG_NULL: u8 = 0x05;
49pub const TAG_OID: u8 = 0x06;
51pub const TAG_UTF8_STRING: u8 = 0x0C;
53pub const TAG_PRINTABLE_STRING: u8 = 0x13;
55pub const TAG_IA5_STRING: u8 = 0x16;
57pub const TAG_UTC_TIME: u8 = 0x17;
59pub const TAG_GENERALIZED_TIME: u8 = 0x18;
61pub const TAG_SEQUENCE: u8 = 0x30;
63pub const TAG_SET: u8 = 0x31;
65
66#[must_use]
68pub const fn context_constructed(number: u8) -> u8 {
69 0xA0 | (number & 0x1F)
70}
71
72#[must_use]
74pub const fn context_primitive(number: u8) -> u8 {
75 0x80 | (number & 0x1F)
76}
77
78pub const OID_ECDSA_WITH_SHA256: &[u8] = &[0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x02];
82pub const OID_EC_PUBLIC_KEY: &[u8] = &[0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x02, 0x01];
84pub const OID_PRIME256V1: &[u8] = &[0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x07];
86pub const OID_SHA256: &[u8] = &[0x60, 0x86, 0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01];
88pub const OID_SIGNED_DATA: &[u8] = &[0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x07, 0x02];
90pub const OID_PKCS7_DATA: &[u8] = &[0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x07, 0x01];
92pub const OID_EXTENSION_REQUEST: &[u8] = &[0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x09, 0x0E];
94pub const OID_ORGANIZATION_NAME: &[u8] = &[0x55, 0x04, 0x0A];
96pub const OID_COMMON_NAME: &[u8] = &[0x55, 0x04, 0x03];
98
99pub const OID_CE_PREFIX: &[u8] = &[0x55, 0x1D];
101pub const OID_KP_PREFIX: &[u8] = &[0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03];
103pub const OID_MATTER_PREFIX: &[u8] = &[0x2B, 0x06, 0x01, 0x04, 0x01, 0x82, 0xA2, 0x7C];
107
108pub const OID_MATTER_DN_PREFIX: &[u8] = &[0x2B, 0x06, 0x01, 0x04, 0x01, 0x82, 0xA2, 0x7C, 0x01];
111
112pub const OID_MATTER_ATTESTATION_PREFIX: &[u8] =
115 &[0x2B, 0x06, 0x01, 0x04, 0x01, 0x82, 0xA2, 0x7C, 0x02];
116pub const OID_DOMAIN_COMPONENT: &[u8] =
118 &[0x09, 0x92, 0x26, 0x89, 0x93, 0xF2, 0x2C, 0x64, 0x01, 0x19];
119
120fn malformed() -> Error {
121 Error::new(ErrorCode::DerMalformed)
122}
123
124#[derive(Debug, Clone, Copy, PartialEq, Eq)]
128pub struct Element<'a> {
129 pub tag: u8,
131 pub content: &'a [u8],
133 pub raw: &'a [u8],
136}
137
138impl<'a> Element<'a> {
139 #[must_use]
141 pub const fn content_reader(&self) -> DerReader<'a> {
142 DerReader::new(self.content)
143 }
144
145 pub fn bit_string_octets(&self) -> Result<&'a [u8]> {
151 if self.tag != TAG_BIT_STRING {
152 return Err(malformed());
153 }
154 match self.content.split_first() {
155 Some((0, rest)) => Ok(rest),
156 _ => Err(malformed()),
157 }
158 }
159}
160
161#[derive(Debug, Clone)]
163pub struct DerReader<'a> {
164 buf: &'a [u8],
165 pos: usize,
166}
167
168impl<'a> DerReader<'a> {
169 #[must_use]
171 pub const fn new(buf: &'a [u8]) -> Self {
172 Self { buf, pos: 0 }
173 }
174
175 #[must_use]
177 pub const fn is_empty(&self) -> bool {
178 self.pos >= self.buf.len()
179 }
180
181 #[must_use]
183 pub fn remaining(&self) -> &'a [u8] {
184 self.buf.get(self.pos..).unwrap_or(&[])
185 }
186
187 #[must_use]
189 pub fn peek_tag(&self) -> Option<u8> {
190 self.buf.get(self.pos).copied()
191 }
192
193 pub fn next_element(&mut self) -> Result<Element<'a>> {
195 let start = self.pos;
196 let tag = *self.buf.get(self.pos).ok_or_else(malformed)?;
197 if tag & 0x1F == 0x1F {
201 return Err(Error::new(ErrorCode::Unsupported));
202 }
203 let mut at = self.pos.checked_add(1).ok_or_else(malformed)?;
204
205 let first = *self.buf.get(at).ok_or_else(malformed)?;
206 at = at.checked_add(1).ok_or_else(malformed)?;
207 let len = if first < 0x80 {
208 usize::from(first)
209 } else {
210 let count = usize::from(first & 0x7F);
211 if count == 0 || count > 4 {
214 return Err(malformed());
215 }
216 let end = at.checked_add(count).ok_or_else(malformed)?;
217 let octets = self.buf.get(at..end).ok_or_else(malformed)?;
218 if octets.first() == Some(&0) {
221 return Err(malformed());
222 }
223 let mut value = 0usize;
224 for byte in octets {
225 value = value
226 .checked_mul(256)
227 .and_then(|v| v.checked_add(usize::from(*byte)))
228 .ok_or_else(malformed)?;
229 }
230 if value < 0x80 {
231 return Err(malformed());
232 }
233 at = end;
234 value
235 };
236
237 let end = at.checked_add(len).ok_or_else(malformed)?;
238 let content = self.buf.get(at..end).ok_or_else(malformed)?;
239 let raw = self.buf.get(start..end).ok_or_else(malformed)?;
240 self.pos = end;
241 Ok(Element { tag, content, raw })
242 }
243
244 pub fn expect(&mut self, tag: u8) -> Result<Element<'a>> {
246 let element = self.next_element()?;
247 if element.tag == tag {
248 Ok(element)
249 } else {
250 Err(malformed())
251 }
252 }
253
254 pub fn expect_sequence(&mut self) -> Result<Self> {
256 Ok(self.expect(TAG_SEQUENCE)?.content_reader())
257 }
258
259 pub fn expect_set(&mut self) -> Result<Self> {
261 Ok(self.expect(TAG_SET)?.content_reader())
262 }
263
264 pub fn expect_oid(&mut self, expected: &[u8]) -> Result<()> {
266 if self.expect(TAG_OID)?.content == expected {
267 Ok(())
268 } else {
269 Err(malformed())
270 }
271 }
272
273 pub fn expect_unsigned(&mut self) -> Result<&'a [u8]> {
283 let content = self.expect(TAG_INTEGER)?.content;
284 let (first, rest) = content.split_first().ok_or_else(malformed)?;
285 if *first & 0x80 != 0 {
286 return Err(malformed());
288 }
289 if *first == 0 && rest.first().is_some_and(|b| *b < 0x80) {
290 return Err(malformed());
292 }
293 Ok(if *first == 0 { rest } else { content })
294 }
295
296 pub fn expect_uint(&mut self) -> Result<u64> {
298 let magnitude = self.expect_unsigned()?;
299 if magnitude.len() > 8 {
300 return Err(malformed());
301 }
302 let mut value = 0u64;
303 for byte in magnitude {
304 value = value
305 .checked_mul(256)
306 .and_then(|v| v.checked_add(u64::from(*byte)))
307 .ok_or_else(malformed)?;
308 }
309 Ok(value)
310 }
311
312 pub fn take_if(&mut self, tag: u8) -> Result<Option<Element<'a>>> {
318 if self.peek_tag() == Some(tag) {
319 Ok(Some(self.next_element()?))
320 } else {
321 Ok(None)
322 }
323 }
324
325 pub fn finish(&self) -> Result<()> {
330 if self.is_empty() {
331 Ok(())
332 } else {
333 Err(malformed())
334 }
335 }
336}
337
338#[derive(Debug)]
343pub struct DerWriter<'a> {
344 buf: &'a mut [u8],
345 pos: usize,
347}
348
349impl<'a> DerWriter<'a> {
350 #[must_use]
352 pub fn new(buf: &'a mut [u8]) -> Self {
353 let pos = buf.len();
354 Self { buf, pos }
355 }
356
357 #[must_use]
359 pub const fn len(&self) -> usize {
360 self.buf.len().saturating_sub(self.pos)
361 }
362
363 #[must_use]
365 pub const fn is_empty(&self) -> bool {
366 self.len() == 0
367 }
368
369 #[must_use]
371 pub fn finish(self) -> &'a [u8] {
372 let pos = self.pos;
373 self.buf.get(pos..).unwrap_or(&[])
374 }
375
376 #[must_use]
379 pub const fn mark(&self) -> usize {
380 self.pos
381 }
382
383 pub fn byte(&mut self, value: u8) -> Result<()> {
385 let next = self
386 .pos
387 .checked_sub(1)
388 .ok_or_else(|| Error::new(ErrorCode::BufferTooSmall))?;
389 let Some(slot) = self.buf.get_mut(next) else {
390 return Err(Error::new(ErrorCode::BufferTooSmall));
391 };
392 *slot = value;
393 self.pos = next;
394 Ok(())
395 }
396
397 pub fn slice(&mut self, value: &[u8]) -> Result<()> {
399 let next = self
400 .pos
401 .checked_sub(value.len())
402 .ok_or_else(|| Error::new(ErrorCode::BufferTooSmall))?;
403 let Some(slot) = self.buf.get_mut(next..self.pos) else {
404 return Err(Error::new(ErrorCode::BufferTooSmall));
405 };
406 slot.copy_from_slice(value);
407 self.pos = next;
408 Ok(())
409 }
410
411 pub fn header(&mut self, tag: u8, mark: usize) -> Result<()> {
414 let len = mark
415 .checked_sub(self.pos)
416 .ok_or_else(|| Error::new(ErrorCode::BufferTooSmall))?;
417 if len < 0x80 {
420 let short = u8::try_from(len).map_err(|_| malformed())?;
421 self.byte(short)?;
422 } else {
423 let bytes = len.to_be_bytes();
424 let first = bytes.iter().position(|b| *b != 0).unwrap_or(bytes.len());
425 let significant = bytes.get(first..).unwrap_or(&[]);
426 self.slice(significant)?;
427 let count = u8::try_from(significant.len()).map_err(|_| malformed())?;
428 self.byte(0x80 | count)?;
429 }
430 self.byte(tag)
431 }
432
433 pub fn primitive(&mut self, tag: u8, content: &[u8]) -> Result<()> {
435 let mark = self.mark();
436 self.slice(content)?;
437 self.header(tag, mark)
438 }
439
440 pub fn oid_with_arc(&mut self, prefix: &[u8], arc: u8) -> Result<()> {
442 let mark = self.mark();
443 self.byte(arc)?;
444 self.slice(prefix)?;
445 self.header(TAG_OID, mark)
446 }
447
448 pub fn bit_string(&mut self, octets: &[u8]) -> Result<()> {
450 let mark = self.mark();
451 self.slice(octets)?;
452 self.byte(0)?;
454 self.header(TAG_BIT_STRING, mark)
455 }
456
457 pub fn unsigned_integer(&mut self, scalar: &[u8]) -> Result<()> {
460 let first = scalar
461 .iter()
462 .position(|b| *b != 0)
463 .unwrap_or(scalar.len().saturating_sub(1));
464 let trimmed = scalar.get(first..).unwrap_or(&[0]);
465 let mark = self.mark();
466 self.slice(trimmed)?;
467 if trimmed.first().is_some_and(|b| *b & 0x80 != 0) {
468 self.byte(0)?;
469 }
470 self.header(TAG_INTEGER, mark)
471 }
472
473 pub fn algorithm_identifier(&mut self, oid: &[u8]) -> Result<()> {
478 let mark = self.mark();
479 self.primitive(TAG_OID, oid)?;
480 self.header(TAG_SEQUENCE, mark)
481 }
482
483 pub fn subject_public_key_info(&mut self, public_key: &[u8]) -> Result<()> {
485 let mark = self.mark();
486 self.bit_string(public_key)?;
487 let algo = self.mark();
488 self.primitive(TAG_OID, OID_PRIME256V1)?;
489 self.primitive(TAG_OID, OID_EC_PUBLIC_KEY)?;
490 self.header(TAG_SEQUENCE, algo)?;
491 self.header(TAG_SEQUENCE, mark)
492 }
493
494 pub fn ecdsa_sig_value(&mut self, raw: &[u8]) -> Result<()> {
497 let half = raw.len().checked_div(2).ok_or_else(malformed)?;
498 let (r, s) = raw.split_at(half);
499 let mark = self.mark();
500 self.unsigned_integer(s)?;
501 self.unsigned_integer(r)?;
502 self.header(TAG_SEQUENCE, mark)
503 }
504}
505
506pub fn ecdsa_sig_value_to_raw(der: &[u8], out: &mut [u8; 64]) -> Result<()> {
511 let mut reader = DerReader::new(der);
512 let mut seq = reader.expect_sequence()?;
513 reader.finish()?;
514 for half in 0..2usize {
515 let value = seq.expect_unsigned()?;
516 if value.len() > 32 {
517 return Err(malformed());
518 }
519 let start = half
520 .checked_mul(32)
521 .and_then(|s| s.checked_add(32))
522 .and_then(|e| e.checked_sub(value.len()))
523 .ok_or_else(malformed)?;
524 let end = start.checked_add(value.len()).ok_or_else(malformed)?;
525 out.get_mut(start..end)
526 .ok_or_else(malformed)?
527 .copy_from_slice(value);
528 }
529 seq.finish()?;
530 Ok(())
531}
532
533pub const MATTER_EPOCH_UNIX: i64 = 946_684_800;
540
541pub const GENERALIZED_TIME_FROM: u32 = 2050;
543
544#[derive(Debug, Clone, Copy, PartialEq, Eq)]
546pub struct Civil {
547 pub year: u32,
549 pub month: u32,
551 pub day: u32,
553 pub hour: u32,
555 pub minute: u32,
557 pub second: u32,
559}
560
561#[expect(
573 clippy::arithmetic_side_effects,
574 reason = "every intermediate is bounded by the u32 input; see above"
575)]
576pub fn civil_from_epoch_s(epoch_s: u32) -> Result<Civil> {
577 let unix = i64::from(epoch_s)
578 .checked_add(MATTER_EPOCH_UNIX)
579 .ok_or_else(malformed)?;
580 let days = unix.div_euclid(86_400);
581 let secs_of_day = unix.rem_euclid(86_400);
582
583 let z = days.checked_add(719_468).ok_or_else(malformed)?;
584 let era = z.div_euclid(146_097);
585 let doe = z.rem_euclid(146_097); let yoe = (doe - doe / 1460 + doe / 36524 - doe / 146_096) / 365; let y = yoe + era * 400;
588 let doy = doe - (365 * yoe + yoe / 4 - yoe / 100); let mp = (5 * doy + 2) / 153; let d = doy - (153 * mp + 2) / 5 + 1; let m = if mp < 10 { mp + 3 } else { mp - 9 }; let year = if m <= 2 { y + 1 } else { y };
593
594 Ok(Civil {
595 year: u32::try_from(year).map_err(|_| malformed())?,
596 month: u32::try_from(m).map_err(|_| malformed())?,
597 day: u32::try_from(d).map_err(|_| malformed())?,
598 hour: u32::try_from(secs_of_day / 3600).map_err(|_| malformed())?,
599 minute: u32::try_from((secs_of_day / 60) % 60).map_err(|_| malformed())?,
600 second: u32::try_from(secs_of_day % 60).map_err(|_| malformed())?,
601 })
602}
603
604pub fn write_time(writer: &mut DerWriter<'_>, epoch_s: u32) -> Result<()> {
606 let civil = civil_from_epoch_s(epoch_s)?;
607 let mut out = [0u8; 15];
608 if civil.year < GENERALIZED_TIME_FROM {
609 let digits = out.get_mut(..13).ok_or_else(malformed)?;
611 write_two(digits, 0, civil.year % 100)?;
612 write_two(digits, 2, civil.month)?;
613 write_two(digits, 4, civil.day)?;
614 write_two(digits, 6, civil.hour)?;
615 write_two(digits, 8, civil.minute)?;
616 write_two(digits, 10, civil.second)?;
617 *digits.get_mut(12).ok_or_else(malformed)? = b'Z';
618 writer.primitive(TAG_UTC_TIME, digits)
619 } else {
620 write_two(&mut out, 0, civil.year / 100)?;
622 write_two(&mut out, 2, civil.year % 100)?;
623 write_two(&mut out, 4, civil.month)?;
624 write_two(&mut out, 6, civil.day)?;
625 write_two(&mut out, 8, civil.hour)?;
626 write_two(&mut out, 10, civil.minute)?;
627 write_two(&mut out, 12, civil.second)?;
628 *out.get_mut(14).ok_or_else(malformed)? = b'Z';
629 writer.primitive(TAG_GENERALIZED_TIME, &out)
630 }
631}
632
633fn write_two(out: &mut [u8], at: usize, value: u32) -> Result<()> {
634 if value > 99 {
635 return Err(malformed());
636 }
637 let tens = u8::try_from(value / 10).map_err(|_| malformed())?;
638 let ones = u8::try_from(value % 10).map_err(|_| malformed())?;
639 *out.get_mut(at).ok_or_else(malformed)? = b'0'.wrapping_add(tens);
640 *out.get_mut(at.checked_add(1).ok_or_else(malformed)?)
641 .ok_or_else(malformed)? = b'0'.wrapping_add(ones);
642 Ok(())
643}
644
645#[expect(
655 clippy::arithmetic_side_effects,
656 reason = "every intermediate is bounded by the validated field widths; see civil_from_epoch_s"
657)]
658#[must_use]
659pub fn epoch_s_from_civil(civil: &Civil) -> Option<u32> {
660 if civil.month < 1 || civil.month > 12 || civil.day < 1 || civil.day > 31 {
661 return None;
662 }
663 if civil.hour > 23 || civil.minute > 59 || civil.second > 59 {
664 return None;
665 }
666 let y = i64::from(civil.year) - i64::from(civil.month <= 2);
667 let era = y.div_euclid(400);
668 let yoe = y - era * 400; let m = i64::from(civil.month);
670 let d = i64::from(civil.day);
671 let doy = (153 * (if m > 2 { m - 3 } else { m + 9 }) + 2) / 5 + d - 1; let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy; let days = era * 146_097 + doe - 719_468;
674
675 let secs = days * 86_400
676 + i64::from(civil.hour) * 3600
677 + i64::from(civil.minute) * 60
678 + i64::from(civil.second);
679 u32::try_from(secs - MATTER_EPOCH_UNIX).ok()
680}
681
682pub const NO_EXPIRY: &[u8] = b"99991231235959Z";
685
686pub fn read_time(element: &Element<'_>) -> Result<Option<u32>> {
695 let (text, century_from_yy) = match element.tag {
696 TAG_UTC_TIME => (element.content, true),
697 TAG_GENERALIZED_TIME => (element.content, false),
698 _ => return Err(malformed()),
699 };
700 if text == NO_EXPIRY {
701 return Ok(None);
702 }
703 let expected = if century_from_yy { 13 } else { 15 };
704 if text.len() != expected || text.last() != Some(&b'Z') {
705 return Err(malformed());
706 }
707
708 let mut at = 0usize;
709 let mut take = |digits: usize| -> Result<u32> {
710 let end = at.checked_add(digits).ok_or_else(malformed)?;
711 let slot = text.get(at..end).ok_or_else(malformed)?;
712 at = end;
713 let mut value = 0u32;
714 for byte in slot {
715 let digit = byte
716 .checked_sub(b'0')
717 .filter(|d| *d < 10)
718 .ok_or_else(malformed)?;
719 value = value
720 .checked_mul(10)
721 .and_then(|v| v.checked_add(u32::from(digit)))
722 .ok_or_else(malformed)?;
723 }
724 Ok(value)
725 };
726
727 let year = if century_from_yy {
728 let yy = take(2)?;
729 if yy >= 50 {
732 yy.saturating_add(1900)
733 } else {
734 yy.saturating_add(2000)
735 }
736 } else {
737 take(4)?
738 };
739 let civil = Civil {
740 year,
741 month: take(2)?,
742 day: take(2)?,
743 hour: take(2)?,
744 minute: take(2)?,
745 second: take(2)?,
746 };
747 epoch_s_from_civil(&civil).map(Some).ok_or_else(malformed)
748}
749
750#[cfg(test)]
751mod tests {
752 use super::*;
753
754 #[test]
755 fn a_short_form_length_reads() {
756 let mut reader = DerReader::new(&[0x02, 0x01, 0x2A]);
757 let element = reader.next_element().expect("element");
758 assert_eq!(element.tag, TAG_INTEGER);
759 assert_eq!(element.content, &[0x2A]);
760 assert_eq!(element.raw, &[0x02, 0x01, 0x2A]);
761 reader.finish().expect("consumed");
762 }
763
764 #[test]
765 fn a_long_form_length_reads() {
766 let mut bytes = [0u8; 132];
767 bytes[0] = TAG_OCTET_STRING;
768 bytes[1] = 0x81;
769 bytes[2] = 129;
770 let mut reader = DerReader::new(&bytes);
771 assert_eq!(reader.next_element().expect("element").content.len(), 129);
772 }
773
774 #[test]
775 fn a_non_minimal_length_is_refused() {
776 for bytes in [
779 &[0x04, 0x81, 0x01, 0xAA][..],
781 &[0x04, 0x82, 0x00, 0x01, 0xAA][..],
783 &[0x30, 0x80, 0x00, 0x00][..],
785 ] {
786 assert!(
787 DerReader::new(bytes).next_element().is_err(),
788 "{bytes:02x?}"
789 );
790 }
791 }
792
793 #[test]
794 fn a_length_past_the_end_is_an_error_not_a_truncation() {
795 assert!(DerReader::new(&[0x04, 0x05, 0xAA]).next_element().is_err());
796 }
797
798 #[test]
799 fn truncation_at_every_length_is_an_error_not_a_panic() {
800 let full = [0x30, 0x06, 0x02, 0x01, 0x2A, 0x04, 0x01, 0xFF];
801 for len in 0..full.len() {
802 let mut reader = DerReader::new(&full[..len]);
803 while let Ok(element) = reader.next_element() {
805 let _ = element;
806 }
807 }
808 }
809
810 #[test]
811 fn a_multi_octet_tag_is_refused_rather_than_misread() {
812 assert_eq!(
815 DerReader::new(&[0x1F, 0x81, 0x00, 0x00])
816 .next_element()
817 .map(|_| ())
818 .unwrap_err()
819 .code(),
820 ErrorCode::Unsupported
821 );
822 }
823
824 #[test]
825 fn integers_are_read_as_der_defines_them() {
826 let cases: &[(&[u8], Option<u64>)] = &[
828 (&[0x02, 0x01, 0x00], Some(0)),
829 (&[0x02, 0x01, 0x7F], Some(127)),
830 (&[0x02, 0x02, 0x00, 0x80], Some(128)),
831 (&[0x02, 0x02, 0x01, 0x00], Some(256)),
832 (&[0x02, 0x01, 0x80], None),
834 (&[0x02, 0x02, 0x00, 0x01], None),
836 ];
837 for (bytes, expected) in cases {
838 assert_eq!(
839 DerReader::new(bytes).expect_uint().ok(),
840 *expected,
841 "{bytes:02x?}"
842 );
843 }
844 }
845
846 #[test]
847 fn a_bit_string_with_unused_bits_is_refused() {
848 let element = DerReader::new(&[0x03, 0x02, 0x00, 0xAB])
850 .next_element()
851 .expect("element");
852 assert_eq!(element.bit_string_octets().expect("octets"), &[0xAB]);
853
854 let element = DerReader::new(&[0x03, 0x02, 0x04, 0xB0])
855 .next_element()
856 .expect("element");
857 assert!(element.bit_string_octets().is_err());
858 }
859
860 #[test]
861 fn take_if_does_not_consume_the_wrong_element() {
862 let mut reader = DerReader::new(&[0x02, 0x01, 0x07, 0x04, 0x01, 0xFF]);
865 assert!(reader.take_if(TAG_OCTET_STRING).expect("look").is_none());
866 assert_eq!(reader.expect_uint().expect("int"), 7);
867 assert_eq!(
868 reader
869 .take_if(TAG_OCTET_STRING)
870 .expect("look")
871 .expect("present")
872 .content,
873 &[0xFF]
874 );
875 }
876
877 #[test]
878 fn trailing_octets_are_refused() {
879 let mut reader = DerReader::new(&[0x02, 0x01, 0x07, 0xFF]);
881 reader.expect_uint().expect("int");
882 assert!(reader.finish().is_err());
883 }
884
885 #[test]
886 fn the_writer_and_the_reader_agree() {
887 let mut buf = [0u8; 128];
888 let mut w = DerWriter::new(&mut buf);
889 let mark = w.mark();
890 w.primitive(TAG_OCTET_STRING, &[0xDE, 0xAD])
892 .expect("octets");
893 w.primitive(TAG_INTEGER, &[0x2A]).expect("int");
894 w.header(TAG_SEQUENCE, mark).expect("sequence");
895 let bytes = w.finish();
896 assert_eq!(
897 bytes,
898 &[0x30, 0x07, 0x02, 0x01, 0x2A, 0x04, 0x02, 0xDE, 0xAD]
899 );
900
901 let mut reader = DerReader::new(bytes);
902 let mut seq = reader.expect_sequence().expect("sequence");
903 assert_eq!(seq.expect_uint().expect("int"), 42);
904 assert_eq!(
905 seq.expect(TAG_OCTET_STRING).expect("octets").content,
906 &[0xDE, 0xAD]
907 );
908 seq.finish().expect("consumed");
909 reader.finish().expect("consumed");
910 }
911
912 #[test]
913 fn a_signature_survives_the_round_trip_through_der() {
914 let cases: [[u8; 64]; 4] = [
917 [0x01; 64],
918 [0xFF; 64],
919 {
920 let mut v = [0u8; 64];
921 v[31] = 1;
922 v[63] = 2;
923 v
924 },
925 {
926 let mut v = [0x7Fu8; 64];
927 v[0] = 0x80;
928 v[32] = 0x00;
929 v
930 },
931 ];
932 for raw in cases {
933 let mut buf = [0u8; 128];
934 let mut w = DerWriter::new(&mut buf);
935 w.ecdsa_sig_value(&raw).expect("write");
936 let der = w.finish();
937 let mut back = [0u8; 64];
938 ecdsa_sig_value_to_raw(der, &mut back).expect("read");
939 assert_eq!(back, raw, "{raw:02x?}");
940 }
941 }
942
943 #[test]
944 fn the_two_time_directions_are_inverses() {
945 let mut at = 0u32;
949 while at < 1_900_000_000 {
950 let civil = civil_from_epoch_s(at).expect("civil");
951 assert_eq!(epoch_s_from_civil(&civil), Some(at), "{at}");
952 at = at.saturating_add(1_000_003);
953 }
954 }
955
956 #[test]
957 fn leap_days_land_where_they_should() {
958 let cases = [
962 (0u32, 2000, 1, 1),
963 (59 * 86_400, 2000, 2, 29),
964 (60 * 86_400, 2000, 3, 1),
965 (365 * 86_400, 2000, 12, 31),
966 (366 * 86_400, 2001, 1, 1),
967 ];
968 for (epoch, year, month, day) in cases {
969 let civil = civil_from_epoch_s(epoch).expect("civil");
970 assert_eq!(
971 (civil.year, civil.month, civil.day),
972 (year, month, day),
973 "{epoch}"
974 );
975 }
976 }
977
978 #[test]
979 fn an_x509_time_reads_as_the_spec_prints_it() {
980 let element = DerReader::new(&[
984 0x17, 0x0D, b'2', b'0', b'1', b'0', b'1', b'5', b'1', b'4', b'2', b'3', b'4', b'3',
985 b'Z',
986 ])
987 .next_element()
988 .expect("element");
989 assert_eq!(read_time(&element).expect("time"), Some(0x271B_17EF));
990 }
991
992 #[test]
993 fn a_two_digit_year_uses_rfc_5280s_pivot() {
994 let mut bytes = [
998 0x17, 0x0D, b'4', b'9', b'0', b'1', b'0', b'1', b'0', b'0', b'0', b'0', b'0', b'0',
999 b'Z',
1000 ];
1001 let element = DerReader::new(&bytes).next_element().expect("element");
1002 let civil =
1003 civil_from_epoch_s(read_time(&element).expect("time").expect("a time")).expect("civil");
1004 assert_eq!(civil.year, 2049);
1005
1006 bytes[2] = b'5';
1007 bytes[3] = b'0';
1008 let element = DerReader::new(&bytes).next_element().expect("element");
1009 assert!(
1010 read_time(&element).is_err(),
1011 "1950 is before the Matter epoch"
1012 );
1013 }
1014
1015 #[test]
1016 fn the_no_expiry_time_is_a_value_not_an_error() {
1017 let mut bytes = [0u8; 17];
1020 bytes[0] = TAG_GENERALIZED_TIME;
1021 bytes[1] = 15;
1022 bytes[2..17].copy_from_slice(NO_EXPIRY);
1023 let element = DerReader::new(&bytes).next_element().expect("element");
1024 assert_eq!(read_time(&element).expect("time"), None);
1025 }
1026
1027 #[test]
1028 fn a_time_that_is_not_zulu_is_refused() {
1029 let element = DerReader::new(&[
1032 0x17, 0x0D, b'2', b'0', b'1', b'0', b'1', b'5', b'1', b'4', b'2', b'3', b'4', b'3',
1033 b'+',
1034 ])
1035 .next_element()
1036 .expect("element");
1037 assert!(read_time(&element).is_err());
1038 }
1039
1040 #[test]
1041 fn a_time_with_a_non_digit_is_refused() {
1042 let element = DerReader::new(&[
1043 0x17, 0x0D, b'2', b'0', b'1', b'0', b'1', b'5', b'1', b'4', b'2', b'3', b'4', b'x',
1044 b'Z',
1045 ])
1046 .next_element()
1047 .expect("element");
1048 assert!(read_time(&element).is_err());
1049 }
1050
1051 #[test]
1052 fn a_buffer_that_is_too_small_is_an_error_at_every_length() {
1053 let mut full = [0u8; 32];
1054 let written = {
1055 let mut w = DerWriter::new(&mut full);
1056 w.primitive(TAG_OCTET_STRING, &[0xAA; 8]).expect("write");
1057 w.len()
1058 };
1059 for len in 0..written {
1060 let mut small = [0u8; 32];
1061 let slot = small.get_mut(..len).expect("in range");
1062 let mut w = DerWriter::new(slot);
1063 assert!(w.primitive(TAG_OCTET_STRING, &[0xAA; 8]).is_err(), "{len}");
1064 }
1065 }
1066}