Struct NegTokenTarg

pub struct NegTokenTarg<'a> {
    pub neg_result: Option<NegResult>,
    pub supported_mech: Option<MechType>,
    pub response_token: Option<OctetStringRef<'a>>,
    pub mech_list_mic: Option<OctetStringRef<'a>>,
}

Available on crate feature rfc2478 only.

NegTokenTarg as defined in RFC 2479 Section 3.2.1.

NegTokenTarg ::= SEQUENCE {
    negResult      [0] ENUMERATED {
                            accept_completed    (0),
                            accept_incomplete   (1),
                            reject              (2) }          OPTIONAL,
    supportedMech  [1] MechType                                OPTIONAL,
    responseToken  [2] OCTET STRING                            OPTIONAL,
    mechListMIC    [3] OCTET STRING                            OPTIONAL
}

Fields

neg_result: Option<NegResult>

The result accept_completed indicates that a context has been successfully established, while the result accept_incomplete indicates that additional token exchanges are needed.

Note:: For the case where (a) a single-token context setup is used and (b) the preferred mechanism does not support the integrity facility which would cause a mechListMIC to be generated and enclosed, this feature allows to make a difference between a mechToken sent by the initiator but not processed by the target (accept_incomplete) and a mechToken sent by the initiator and processed by the target (accept_completed).

supported_mech: Option<MechType>

This field has to be present when negResult is “accept_completed” or “accept_incomplete”. It is a choice from the mechanisms offered by the initiator.

response_token: Option<OctetStringRef<'a>>

This field may be used either to transmit the response to the mechToken when sent by the initiator and when the first mechanism from the list has been selected by the target or to carry the tokens specific to the selected security mechanism.

mech_list_mic: Option<OctetStringRef<'a>>

If the selected mechanism is capable of integrity protection, this field must be present in the last message of the negotiation, (i.e., when the underlying mechanism returns a non-empty token and a major status of GSS_S_COMPLETE); it contains the result of a GetMIC of the MechTypes field in the initial NegTokenInit. It allows to verify that the list initially sent by the initiator has been received unmodified by the target.

Trait Implementations

impl<'a> Clone for NegTokenTarg<'a>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for NegTokenTarg<'a>

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

Formats the value using the given formatter.

impl<'a> DecodeValue<'a> for NegTokenTarg<'a>

fn decode_value<R: Reader<'a>>(reader: &mut R, header: Header) -> Result<Self>

Attempt to decode this message using the provided Reader.

impl<'a> EncodeValue for NegTokenTarg<'a>

fn value_len(&self) -> Result<Length>

Compute the length of this value (sans [Tag]+Length header) when encoded as ASN.1 DER.

fn encode_value(&self, writer: &mut impl Writer) -> Result<()>

Encode value (sans [Tag]+Length header) as ASN.1 DER using the provided Writer.

fn header(&self) -> Result<Header, Error>

where Self: Tagged,

Get the Header used to encode this value.

impl<'a> PartialEq for NegTokenTarg<'a>

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

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

const 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> Copy for NegTokenTarg<'a>

impl<'a> Eq for NegTokenTarg<'a>

impl<'a> Sequence<'a> for NegTokenTarg<'a>

impl<'a> StructuralPartialEq for NegTokenTarg<'a>