feat(x509): implement RFC 4514 string serialization for x509 names

[npmccallum]

The main commit is the last one. The previous commits are just enablement.

This PR depends on:

• fix(der): export the Newtype derive #467
• fix(der): manually impl Default for SetOfVec #468
• feat(oiddb): make name search case-insensitive #469
• feat(oiddb): sort by oid and name length #470

Resolves: #417

[tarcieri]

I'm a little confused by the fn parse name along with parse_str and parse_der. These seem to be combination parser/serializer methods?

[npmccallum]

Yes, I agree it is a bit awkward. Basically, RFC 4514 defines a human readable encoding for certificate name types. That is, we want to convert from the name type into a string (this part is easy) and from the string back into the relevant name type. The latter operation is difficult because the result needs to be owned, but the name types borrow references.

The compromise is that we parse the string into an owned buffer. Then we create the named type referencing that owned buffer. Then, because of the lifetime issues, we serialize the named type to der.

In practice it looks like this to avoid the lifetime issues:

let der = RdnSequence::parse("CN=foo").unwrap();let rdns = RdnSequence::from_der(&der).unwrap();

If you have alternative suggestions, I'm all ears.

[tarcieri]

Since it's producing encoded DER, I'd suggest something like RdnSequence::encode_*, like RdnSequence::encode_from_string

[npmccallum]

I renamed all the public functions to encode_from_string(). The internal functions were renamed to encode_str() and encode_hex().

[tarcieri]

A few small nits, otherwise looks good

[npmccallum]

The main commit is the last one. The previous commits are just enablement.

This PR depends on:

• fix(der): export the Newtype derive #467
• fix(der): manually impl Default for SetOfVec #468
• feat(oiddb): make name search case-insensitive #469
• feat(oiddb): sort by oid and name length #470

Resolves: #417

[tarcieri]

I'm a little confused by the fn parse name along with parse_str and parse_der. These seem to be combination parser/serializer methods?

[npmccallum]

Yes, I agree it is a bit awkward. Basically, RFC 4514 defines a human readable encoding for certificate name types. That is, we want to convert from the name type into a string (this part is easy) and from the string back into the relevant name type. The latter operation is difficult because the result needs to be owned, but the name types borrow references.

The compromise is that we parse the string into an owned buffer. Then we create the named type referencing that owned buffer. Then, because of the lifetime issues, we serialize the named type to der.

In practice it looks like this to avoid the lifetime issues:

let der = RdnSequence::parse("CN=foo").unwrap();let rdns = RdnSequence::from_der(&der).unwrap();

If you have alternative suggestions, I'm all ears.

[tarcieri]

Since it's producing encoded DER, I'd suggest something like RdnSequence::encode_*, like RdnSequence::encode_from_string

[npmccallum]

I renamed all the public functions to encode_from_string(). The internal functions were renamed to encode_str() and encode_hex().

[tarcieri]

A few small nits, otherwise looks good

[npmccallum]

The main commit is the last one. The previous commits are just enablement.

This PR depends on:

• fix(der): export the Newtype derive #467
• fix(der): manually impl Default for SetOfVec #468
• feat(oiddb): make name search case-insensitive #469
• feat(oiddb): sort by oid and name length #470

Resolves: #417

[tarcieri]

I'm a little confused by the fn parse name along with parse_str and parse_der. These seem to be combination parser/serializer methods?

[npmccallum]

Yes, I agree it is a bit awkward. Basically, RFC 4514 defines a human readable encoding for certificate name types. That is, we want to convert from the name type into a string (this part is easy) and from the string back into the relevant name type. The latter operation is difficult because the result needs to be owned, but the name types borrow references.

The compromise is that we parse the string into an owned buffer. Then we create the named type referencing that owned buffer. Then, because of the lifetime issues, we serialize the named type to der.

In practice it looks like this to avoid the lifetime issues:

let der = RdnSequence::parse("CN=foo").unwrap();let rdns = RdnSequence::from_der(&der).unwrap();

If you have alternative suggestions, I'm all ears.

[tarcieri]

Since it's producing encoded DER, I'd suggest something like RdnSequence::encode_*, like RdnSequence::encode_from_string

[npmccallum]

I renamed all the public functions to encode_from_string(). The internal functions were renamed to encode_str() and encode_hex().

[tarcieri]

A few small nits, otherwise looks good

[npmccallum]

The main commit is the last one. The previous commits are just enablement.

This PR depends on:

• fix(der): export the Newtype derive #467
• fix(der): manually impl Default for SetOfVec #468
• feat(oiddb): make name search case-insensitive #469
• feat(oiddb): sort by oid and name length #470

Resolves: #417

[tarcieri]

I'm a little confused by the fn parse name along with parse_str and parse_der. These seem to be combination parser/serializer methods?

[npmccallum]

Yes, I agree it is a bit awkward. Basically, RFC 4514 defines a human readable encoding for certificate name types. That is, we want to convert from the name type into a string (this part is easy) and from the string back into the relevant name type. The latter operation is difficult because the result needs to be owned, but the name types borrow references.

The compromise is that we parse the string into an owned buffer. Then we create the named type referencing that owned buffer. Then, because of the lifetime issues, we serialize the named type to der.

In practice it looks like this to avoid the lifetime issues:

let der = RdnSequence::parse("CN=foo").unwrap();let rdns = RdnSequence::from_der(&der).unwrap();

If you have alternative suggestions, I'm all ears.

[tarcieri]

Since it's producing encoded DER, I'd suggest something like RdnSequence::encode_*, like RdnSequence::encode_from_string

[npmccallum]

I renamed all the public functions to encode_from_string(). The internal functions were renamed to encode_str() and encode_hex().

[tarcieri]

A few small nits, otherwise looks good

[npmccallum]

The main commit is the last one. The previous commits are just enablement.

This PR depends on:

• fix(der): export the Newtype derive #467
• fix(der): manually impl Default for SetOfVec #468
• feat(oiddb): make name search case-insensitive #469
• feat(oiddb): sort by oid and name length #470

Resolves: #417

[tarcieri]

I'm a little confused by the fn parse name along with parse_str and parse_der. These seem to be combination parser/serializer methods?

[npmccallum]

Yes, I agree it is a bit awkward. Basically, RFC 4514 defines a human readable encoding for certificate name types. That is, we want to convert from the name type into a string (this part is easy) and from the string back into the relevant name type. The latter operation is difficult because the result needs to be owned, but the name types borrow references.

The compromise is that we parse the string into an owned buffer. Then we create the named type referencing that owned buffer. Then, because of the lifetime issues, we serialize the named type to der.

In practice it looks like this to avoid the lifetime issues:

let der = RdnSequence::parse("CN=foo").unwrap();let rdns = RdnSequence::from_der(&der).unwrap();

If you have alternative suggestions, I'm all ears.

[tarcieri]

Since it's producing encoded DER, I'd suggest something like RdnSequence::encode_*, like RdnSequence::encode_from_string

[npmccallum]

I renamed all the public functions to encode_from_string(). The internal functions were renamed to encode_str() and encode_hex().

[tarcieri]

A few small nits, otherwise looks good

[npmccallum]

The main commit is the last one. The previous commits are just enablement.

This PR depends on:

• fix(der): export the Newtype derive #467
• fix(der): manually impl Default for SetOfVec #468
• feat(oiddb): make name search case-insensitive #469
• feat(oiddb): sort by oid and name length #470

Resolves: #417

[tarcieri]

I'm a little confused by the fn parse name along with parse_str and parse_der. These seem to be combination parser/serializer methods?

[npmccallum]

Yes, I agree it is a bit awkward. Basically, RFC 4514 defines a human readable encoding for certificate name types. That is, we want to convert from the name type into a string (this part is easy) and from the string back into the relevant name type. The latter operation is difficult because the result needs to be owned, but the name types borrow references.

The compromise is that we parse the string into an owned buffer. Then we create the named type referencing that owned buffer. Then, because of the lifetime issues, we serialize the named type to der.

In practice it looks like this to avoid the lifetime issues:

let der = RdnSequence::parse("CN=foo").unwrap();let rdns = RdnSequence::from_der(&der).unwrap();

If you have alternative suggestions, I'm all ears.

[tarcieri]

Since it's producing encoded DER, I'd suggest something like RdnSequence::encode_*, like RdnSequence::encode_from_string

[npmccallum]

I renamed all the public functions to encode_from_string(). The internal functions were renamed to encode_str() and encode_hex().

[tarcieri]

A few small nits, otherwise looks good

[npmccallum]

The main commit is the last one. The previous commits are just enablement.

This PR depends on:

• fix(der): export the Newtype derive #467
• fix(der): manually impl Default for SetOfVec #468
• feat(oiddb): make name search case-insensitive #469
• feat(oiddb): sort by oid and name length #470

Resolves: #417

[tarcieri]

I'm a little confused by the fn parse name along with parse_str and parse_der. These seem to be combination parser/serializer methods?

[npmccallum]

Yes, I agree it is a bit awkward. Basically, RFC 4514 defines a human readable encoding for certificate name types. That is, we want to convert from the name type into a string (this part is easy) and from the string back into the relevant name type. The latter operation is difficult because the result needs to be owned, but the name types borrow references.

The compromise is that we parse the string into an owned buffer. Then we create the named type referencing that owned buffer. Then, because of the lifetime issues, we serialize the named type to der.

In practice it looks like this to avoid the lifetime issues:

let der = RdnSequence::parse("CN=foo").unwrap();let rdns = RdnSequence::from_der(&der).unwrap();

If you have alternative suggestions, I'm all ears.

[tarcieri]

Since it's producing encoded DER, I'd suggest something like RdnSequence::encode_*, like RdnSequence::encode_from_string

[npmccallum]

I renamed all the public functions to encode_from_string(). The internal functions were renamed to encode_str() and encode_hex().

[tarcieri]

A few small nits, otherwise looks good

[npmccallum]

The main commit is the last one. The previous commits are just enablement.

This PR depends on:

• fix(der): export the Newtype derive #467
• fix(der): manually impl Default for SetOfVec #468
• feat(oiddb): make name search case-insensitive #469
• feat(oiddb): sort by oid and name length #470

Resolves: #417

[tarcieri]

I'm a little confused by the fn parse name along with parse_str and parse_der. These seem to be combination parser/serializer methods?

[npmccallum]

Yes, I agree it is a bit awkward. Basically, RFC 4514 defines a human readable encoding for certificate name types. That is, we want to convert from the name type into a string (this part is easy) and from the string back into the relevant name type. The latter operation is difficult because the result needs to be owned, but the name types borrow references.

The compromise is that we parse the string into an owned buffer. Then we create the named type referencing that owned buffer. Then, because of the lifetime issues, we serialize the named type to der.

In practice it looks like this to avoid the lifetime issues:

let der = RdnSequence::parse("CN=foo").unwrap();let rdns = RdnSequence::from_der(&der).unwrap();

If you have alternative suggestions, I'm all ears.

[tarcieri]

Since it's producing encoded DER, I'd suggest something like RdnSequence::encode_*, like RdnSequence::encode_from_string

[npmccallum]

I renamed all the public functions to encode_from_string(). The internal functions were renamed to encode_str() and encode_hex().

[tarcieri]

A few small nits, otherwise looks good