Struct PkiHeader 

pub struct PkiHeader<'a> {
    pub pvno: Pvno,
    pub sender: GeneralName<'a>,
    pub recipient: GeneralName<'a>,
    pub message_time: Option<GeneralizedTime>,
    pub protection_alg: Option<AlgorithmIdentifierOwned>,
    pub sender_kid: Option<OctetString>,
    pub recip_kid: Option<OctetString>,
    pub trans_id: Option<OctetString>,
    pub sender_nonce: Option<OctetString>,
    pub recip_nonce: Option<OctetString>,
    pub free_text: Option<PkiFreeText>,
    pub general_info: Option<GeneralInfo>,
}

The PKIHeader type is defined in RFC 4210 Section 5.1.1.

    PKIHeader ::= SEQUENCE {
    pvno                INTEGER     { cmp1999(1), cmp2000(2) },
    sender              GeneralName,
    -- identifies the sender
    recipient           GeneralName,
    -- identifies the intended recipient
    messageTime     [0] GeneralizedTime         OPTIONAL,
    -- time of production of this message (used when sender
    -- believes that the transport will be "suitable"; i.e.,
    -- that the time will still be meaningful upon receipt)
    protectionAlg   [1] AlgorithmIdentifier{ALGORITHM, {...}}
    OPTIONAL,
    -- algorithm used for calculation of protection bits
    senderKID       [2] KeyIdentifier           OPTIONAL,
    recipKID        [3] KeyIdentifier           OPTIONAL,
    -- to identify specific keys used for protection
    transactionID   [4] OCTET STRING            OPTIONAL,
    -- identifies the transaction; i.e., this will be the same in
    -- corresponding request, response, certConf, and PKIConf
    -- messages
    senderNonce     [5] OCTET STRING            OPTIONAL,
    recipNonce      [6] OCTET STRING            OPTIONAL,
    -- nonces used to provide replay protection, senderNonce
    -- is inserted by the creator of this message; recipNonce
    -- is a nonce previously inserted in a related message by
    -- the intended recipient of this message
    freeText        [7] PKIFreeText             OPTIONAL,
    -- this may be used to indicate context-specific instructions
    -- (this field is intended for human consumption)
    generalInfo     [8] SEQUENCE SIZE (1..MAX) OF
    InfoTypeAndValue     OPTIONAL
    -- this may be used to convey context-specific information
    -- (this field not primarily intended for human consumption)
    }

Tags are EXPLICIT TAG in default according to rfc4210#appendix-F.

Fields

pvno: Pvno

sender: GeneralName<'a>

recipient: GeneralName<'a>

message_time: Option<GeneralizedTime>

protection_alg: Option<AlgorithmIdentifierOwned>

sender_kid: Option<OctetString>

recip_kid: Option<OctetString>

trans_id: Option<OctetString>

sender_nonce: Option<OctetString>

recip_nonce: Option<OctetString>

free_text: Option<PkiFreeText>

general_info: Option<GeneralInfo>

Trait Implementations

impl<'a> BERDecodable for PkiHeader<'a>

fn decode_ber(reader: BERReader<'_, '_>) -> ASN1Result<Self>

Reads an ASN.1 value from BERReader and converts it to Self.

impl<'a> Clone for PkiHeader<'a>

fn clone(&self) -> PkiHeader<'a>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for PkiHeader<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> DerWrite for PkiHeader<'a>

fn write(&self, writer: DERWriter<'_>)

impl<'a> Eq for PkiHeader<'a>

impl<'a> Hash for PkiHeader<'a>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a> PartialEq for PkiHeader<'a>

fn eq(&self, other: &PkiHeader<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> StructuralPartialEq for PkiHeader<'a>