pkix 0.2.6

TLS Certificate encoding and decoding helpers.
Documentation 
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

/* Copyright (c) Fortanix, Inc.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

use yasna::{DERWriter, construct_der};
use yasna::models::{ObjectIdentifier, TaggedDerValue};
use num_bigint::{BigInt, BigUint};
use bit_vec::BitVec;

pub trait DerWrite {
    fn write(&self, writer: DERWriter);
}

pub trait ToDer : DerWrite {
    fn to_der(&self) -> Vec<u8> {
        construct_der(|w| self.write(w))
    }
}

impl<T: DerWrite + ?Sized> ToDer for T {}

// uncomment once we have specialization
#[cfg(dont_compile="dont_compile")]
impl<'a, T: DerWrite> DerWrite for &'a T {
    fn write(&self, writer: DERWriter) {
        T::write(self, writer)
    }
}

impl DerWrite for bool {
    fn write(&self, writer: DERWriter) {
        writer.write_bool(*self)
    }
}

impl DerWrite for i64 {
    fn write(&self, writer: DERWriter) {
        writer.write_i64(*self)
    }
}

impl DerWrite for u64 {
    fn write(&self, writer: DERWriter) {
        writer.write_u64(*self)
    }
}

impl DerWrite for i32 {
    fn write(&self, writer: DERWriter) {
        writer.write_i32(*self)
    }
}

impl DerWrite for u32 {
    fn write(&self, writer: DERWriter) {
        writer.write_u32(*self)
    }
}

impl DerWrite for i16 {
    fn write(&self, writer: DERWriter) {
        writer.write_i16(*self)
    }
}

impl DerWrite for u16 {
    fn write(&self, writer: DERWriter) {
        writer.write_u16(*self)
    }
}

impl DerWrite for i8 {
    fn write(&self, writer: DERWriter) {
        writer.write_i8(*self)
    }
}

impl DerWrite for u8 {
    fn write(&self, writer: DERWriter) {
        writer.write_u8(*self)
    }
}

impl DerWrite for BigInt {
    fn write(&self, writer: DERWriter) {
        writer.write_bigint(self)
    }
}

impl DerWrite for BigUint {
    fn write(&self, writer: DERWriter) {
        writer.write_biguint(self)
    }
}

impl DerWrite for ObjectIdentifier {
    fn write(&self, writer: DERWriter) {
        writer.write_oid(self)
    }
}

impl DerWrite for BitVec {
    fn write(&self, writer: DERWriter) {
        writer.write_bitvec(self)
    }
}

impl DerWrite for [u8] {
    fn write(&self, writer: DERWriter) {
        writer.write_bytes(self)
    }
}

impl DerWrite for TaggedDerValue {
    fn write(&self, writer: DERWriter) {
        writer.write_tagged_der(self)
    }
}

pub trait WriteIa5StringSafe {
    fn write_ia5_string_safe(self, string: &str);
}

impl<'a> WriteIa5StringSafe for DERWriter<'a> {
    fn write_ia5_string_safe(self, string: &str) {
        // DERWriter::write_ia5_string() panics when the string contains non-ascii characters.
        // The return type must be (), so the best we can do instead is to filter out non-ascii
        // characters from the string up front.
        self.write_ia5_string(&string.replace(|c: char| !c.is_ascii(), ""))
    }
}