libkrimes 0.1.0

A pure rust, minimal kerberos library
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

use super::authorization_data::AuthorizationData;
use super::encryption_key::EncryptionKey;
use super::host_addresses::HostAddresses;
use super::kerberos_time::KerberosTime;
use super::principal_name::PrincipalName;
use super::realm::Realm;
use super::ticket_flags::TicketFlags;
use super::transited_encoding::TransitedEncoding;
use der::{Decode, DecodeValue, Encode, EncodeValue, FixedTag, Sequence, Tag, TagNumber};

/// ```text
/// EncTicketPart   ::= [APPLICATION 3] SEQUENCE {
///         flags                   [0] TicketFlags,
///         key                     [1] EncryptionKey,
///         crealm                  [2] Realm,
///         cname                   [3] PrincipalName,
///         transited               [4] TransitedEncoding,
///         authtime                [5] KerberosTime,
///         starttime               [6] KerberosTime OPTIONAL,
///         endtime                 [7] KerberosTime,
///         renew-till              [8] KerberosTime OPTIONAL,
///         caddr                   [9] HostAddresses OPTIONAL,
///         authorization-data      [10] AuthorizationData OPTIONAL
/// }
/// ````
#[derive(Debug, Eq, PartialEq, Sequence)]
pub(crate) struct EncTicketPart {
    #[asn1(context_specific = "0")]
    pub flags: TicketFlags,
    #[asn1(context_specific = "1")]
    pub key: EncryptionKey,
    #[asn1(context_specific = "2")]
    pub crealm: Realm,
    #[asn1(context_specific = "3")]
    pub cname: PrincipalName,
    #[asn1(context_specific = "4")]
    pub transited: TransitedEncoding,
    #[asn1(context_specific = "5")]
    pub auth_time: KerberosTime,
    #[asn1(context_specific = "6", optional = "true")]
    pub start_time: Option<KerberosTime>,
    #[asn1(context_specific = "7")]
    pub end_time: KerberosTime,
    #[asn1(context_specific = "8", optional = "true")]
    pub renew_till: Option<KerberosTime>,
    #[asn1(context_specific = "9", optional = "true")]
    pub client_addresses: Option<HostAddresses>,
    /// Per RFC4120: Experience has shown that the name of this
    /// field is confusing, and that a better name would be
    /// "restrictions".
    #[asn1(context_specific = "10", optional = "true")]
    pub authorization_data: Option<Vec<AuthorizationData>>,
}

#[derive(Debug, Eq, PartialEq)]
pub(crate) struct TaggedEncTicketPart(pub EncTicketPart);

/*
impl TaggedEncTicketPart {
    pub fn new(tkt: EncTicketPart) -> Self {
        Self(tkt)
    }
}
*/

impl FixedTag for TaggedEncTicketPart {
    const TAG: Tag = Tag::Application {
        constructed: true,
        number: TagNumber(3),
    };
}

impl<'a> DecodeValue<'a> for TaggedEncTicketPart {
    type Error = der::Error;

    fn decode_value<R: der::Reader<'a>>(reader: &mut R, _header: der::Header) -> der::Result<Self> {
        let t: EncTicketPart = EncTicketPart::decode(reader)?;
        Ok(Self(t))
    }
}

impl EncodeValue for TaggedEncTicketPart {
    fn value_len(&self) -> der::Result<der::Length> {
        self.0.encoded_len()
    }
    fn encode_value(&self, encoder: &mut impl der::Writer) -> der::Result<()> {
        self.0.encode(encoder)?;
        Ok(())
    }
}

impl From<TaggedEncTicketPart> for EncTicketPart {
    fn from(value: TaggedEncTicketPart) -> Self {
        value.0
    }
}