Struct Name 

pub struct Name(/* private fields */);

X.501 Name as defined in RFC 5280 Section 4.1.2.4. X.501 Name is used to represent distinguished names.

Name ::= CHOICE { rdnSequence  RDNSequence }

To build name, the syntax described in RFC 4514 Section 3 is expected.

The following attribute names are recognized:

     String  X.500 AttributeType
     ------  --------------------------------------------
     CN      commonName (2.5.4.3)
     L       localityName (2.5.4.7)
     ST      stateOrProvinceName (2.5.4.8)
     O       organizationName (2.5.4.10)
     OU      organizationalUnitName (2.5.4.11)
     C       countryName (2.5.4.6)
     STREET  streetAddress (2.5.4.9)
     DC      domainComponent (0.9.2342.19200300.100.1.25)
     UID     userId (0.9.2342.19200300.100.1.1)

Example

use std::str::FromStr;
use x509_cert::name::Name;

// Multiple syntaxes are supported by `from_str`:
let subject = Name::from_str("CN=example.com").unwrap();
let subject = Name::from_str("C=US; ST=California; L=Los Angeles; O=InternetCorporationforAssignedNamesandNumbers; CN=www.example.org").unwrap();
let subject = Name::from_str("C=US,ST=California,L=Los Angeles,O=InternetCorporationforAssignedNamesandNumbers,CN=www.example.org").unwrap();
let subject = Name::from_str("C=US/ST=California/L=Los Angeles/O=InternetCorporationforAssignedNamesandNumbers/CN=www.example.org").unwrap();
let subject = Name::from_str("UID=jsmith,DC=example,DC=net").unwrap();
let subject = Name::from_str("OU=Sales+CN=J.  Smith,DC=example,DC=net").unwrap();
let subject = Name::from_str(r#"CN=James \"Jim\" Smith\, III,DC=example,DC=net"#).unwrap();
let subject = Name::from_str(r#"CN=Before\0dAfter,DC=example,DC=net"#).unwrap();
let subject = Name::from_str("1.3.6.1.4.1.1466.0=#04024869").unwrap();

Implementations

impl Name

pub fn hazmat_from_rdn_sequence(value: RdnSequence) -> Self

Build a name from an RdnSequence.

This is provided as an escape hatch (see RFC 5280 Section 4.1.2.4) to build names from bmpString, TeletexString, or UniversalString:

When CAs have previously issued certificates with issuer fields with
attributes encoded using TeletexString, BMPString, or
UniversalString, then the CA MAY continue to use these encodings of
the DirectoryString to preserve backward compatibility.

Safety

As the name implies, this is a dangerous helper. You are responsible for ensuring the RdnSequence complies with the RFC.

impl Name

pub fn is_empty(&self) -> bool

Is this Name empty?

pub fn len(&self) -> usize

Returns the number of RelativeDistinguishedName elements in this Name.

pub fn iter(&self) -> impl Iterator<Item = &AttributeTypeAndValue> + '_

Returns an iterator over the inner AttributeTypeAndValues.

This iterator does not expose which attributes are grouped together as RelativeDistinguishedNames. If you need this, use Self::iter_rdn.

pub fn iter_rdn(&self) -> impl Iterator<Item = &RelativeDistinguishedName> + '_

Returns an iterator over the inner RelativeDistinguishedNames.

impl Name

pub fn by_oid<'a, T>(&'a self, oid: ObjectIdentifier) -> Result<Option<T>>

where T: TryFrom<&'a Any, Error = Error> + Debug,

Returns the element found in the name identified by oid

This will return Ok(None) if no such element is present.

If more than one attribute is present with the specified OID, only the first attribute is returned. Later elements should be fetched using Name::iter.

Errors

This will return der::Error if the content is not serialized as expected

pub fn common_name(&self) -> Result<Option<DirectoryString>>

Returns the Common Name (CN) found in the name.

This will return Ok(None) if no CN is found.

If more than one value is present, only the first is returned. Later elements should be fetched using Name::iter.

Errors

This will return der::Error if the content is not serialized as a string.

pub fn country(&self) -> Result<Option<PrintableStringRef<'_>>>

Returns the Country (C) found in the name.

This will return Ok(None) if no Country is found.

If more than one value is present, only the first is returned. Later elements should be fetched using Name::iter.

Errors

This will return der::Error if the content is not serialized as a printableString.

pub fn state_or_province(&self) -> Result<Option<DirectoryString>>

Returns the State or Province (ST) found in the name.

This will return Ok(None) if no State or Province is found.

If more than one value is present, only the first is returned. Later elements should be fetched using Name::iter.

Errors

This will return der::Error if the content is not serialized as a string.

pub fn locality(&self) -> Result<Option<DirectoryString>>

Returns the Locality (L) found in the name.

This will return Ok(None) if no Locality is found.

If more than one value is present, only the first is returned. Later elements should be fetched using Name::iter.

Errors

This will return der::Error if the content is not serialized as a string.

pub fn organization(&self) -> Result<Option<DirectoryString>>

Returns the Organization (O) found in the name.

This will return Ok(None) if no Organization is found.

If more than one value is present, only the first is returned. Later elements should be fetched using Name::iter.

Errors

This will return der::Error if the content is not serialized as a string.

pub fn organization_unit(&self) -> Result<Option<DirectoryString>>

Returns the Organization Unit (OU) found in the name.

This will return Ok(None) if no Organization Unit is found.

If more than one value is present, only the first is returned. Later elements should be fetched using Name::iter.

Errors

This will return der::Error if the content is not serialized as a string.

pub fn email_address(&self) -> Result<Option<Ia5StringRef<'_>>>

Returns the Email Address (emailAddress) found in the name.

This will return Ok(None) if no email address is found.

If more than one value is present, only the first is returned. Later elements should be fetched using Name::iter.

Errors

This will return der::Error if the content is not serialized as an ia5String.

Trait Implementations

impl AsRef<RdnSequence> for Name

fn as_ref(&self) -> &RdnSequence

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Name

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Name

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

Formats the value using the given formatter.

impl<'a> DecodeValue<'a> for Name

type Error = Error

Type returned in the event of a decoding error.

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

Attempt to decode this value using the provided Reader.

impl Default for Name

fn default() -> Self

Returns the “default value” for a type.

impl Display for Name

Serializes the name according to the rules in RFC 4514.

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

Formats the value using the given formatter.

impl EncodeValue for Name

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

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

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

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

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

where Self: Tagged,

Get the Header used to encode this value.

impl Eq for Name

impl FixedTag for Name

const TAG: Tag = <RdnSequence as FixedTag>::TAG

ASN.1 tag

impl From<Name> for RdnSequence

fn from(value: Name) -> Self

Converts to this type from the input type.

impl FromStr for Name

Parse a Name string.

Follows the rules in RFC 4514.

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self>

Parses a string s to return a value of this type.

impl Hash for Name

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 PartialEq for Name

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Name

impl ValueOrd for Name

fn value_cmp(&self, other: &Self) -> Result<Ordering>

Return an Ordering between value portion of TLV-encoded self and other when serialized as ASN.1 DER.