I'am not finding any example on how to parse a sequnce like the following:

QCStatement::= SEQUENCE {
    statementId OBJECT IDENTIFIER,
    statementInfo ANY DEFINED BY statementId OPTIONAL
}

I built a the structs like this:

#[derive(Debug, asn1::Asn1Read, asn1::Asn1Write)]
pub struct QCStatement<'a> {
    statement_id: asn1::ObjectIdentifier,
    statement_info: Option<StatementInfo<'a>>,
}

#[derive(Debug, asn1::Asn1Read, asn1::Asn1Write)]
pub enum StatementInfo<'a> {
    QcEuRetentionPeriod(u32),
    MonetaryValue(MonetaryValue<'a>),
    QcType(QcType),
    PSD2QcType(PSD2QcType<'a>),
    QcEuPDS(PdsLocations<'a>),
}

The parser seems able to choose between the u32 and the MonetaryValue, but it's not able to choose between the complex types. As i get this error: thread 'main' panicked at 'calledResult::unwrap()on anErrvalue: ParseError { kind: UnexpectedTag { actual: Tag { value: 6, constructed: false, class: Universal } }, location: [4, "QCStatement::statement_info", "StatementInfo::MonetaryValue", "MonetaryValue::currency"] }'

At this point I am trying to manually implement the parsing for the QCStatement<'a> as follows:

impl<'a> SimpleAsn1Readable<'a> for QCStatement<'a> {
    const TAG: asn1::Tag = asn1::Tag::primitive(0x20);
    #[inline]
    fn parse_data(data: &'a [u8]) -> asn1::ParseResult<QCStatement<'a>> {
        asn1::parse_single::<QCStatement<'a>>(data)
        asn1::parse(data, |d| {
            let statement_id = d.read_element::<asn1::ObjectIdentifier>()?;
            let statement_info = match statement_id.to_string().as_str() {
                "0.4.0.1862.1.2" => Option::Some(StatementInfo::MonetaryValue(
                    d.read_element::<MonetaryValue>()?,
                )),
                "0.4.0.1862.1.5" => {
                    Option::Some(StatementInfo::QcEuPDS(d.read_element::<PdsLocations>()?))
                }
                "0.4.0.1862.1.6" => {
                    Option::Some(StatementInfo::QcType(d.read_element::<QcType>()?))
                }
                "0.4.0.1862.1.3" => {
                    Option::Some(StatementInfo::QcEuRetentionPeriod(d.read_element::<u32>()?))
                }
                &_ => None,
            };
            return Ok(QCStatement::new(statement_id, statement_info));
        })
    }
}

But I'm not sure it's the intended way as it seems that even thought the struct are correct I constantly get unexpected tag.

Hello basically if i have a struct which contains an enum everything works: ``#[derive(asn1::Asn1Read, asn1::Asn1Write)] pub struct InfoAccessItem<'a> { oid: asn1::ObjectIdentifier, accessLocation: GeneralName<'a>, }

#[derive(Debug, asn1::Asn1Read, asn1::Asn1Write)] pub enum GeneralName<'a> { #[implicit(0)] OtherName(asn1::IA5String<'a>), #[implicit(1)] Rfc822Name(asn1::IA5String<'a>), #[implicit(2)] DNSName(asn1::IA5String<'a>), #[implicit(3)] X400Address(asn1::IA5String<'a>), #[implicit(4)] DirectoryName(asn1::IA5String<'a>), #[implicit(5)] EdiPartyName(asn1::IA5String<'a>), #[implicit(6)] UniformResourceIdentifier(asn1::IA5String<'a>), #[implicit(7)] IPAddress(&'a [u8]), #[implicit(8)] RegisteredID(asn1::ObjectIdentifier), }``

If i Have an Enum which contain another enum like this:

``#[derive(Debug, asn1::Asn1Read, asn1::Asn1Write)] pub struct DistributionPoint<'a> { #[implicit(0)] distributionPoint: Option<DistributionPointName<'a>>, #[implicit(1)] reasons: Option<asn1::BitString<'a>>, #[implicit(2)] crlissuer: Option<GeneralName<'a>>, }

#[derive(Debug, asn1::Asn1Read, asn1::Asn1Write)] enum DistributionPointName<'a> { #[implicit(0)] FullName(GeneralName<'a>), #[implicit(1)] NameRelativeToCRLIssuer(RelativeDistinguishedName<'a>), }

#[derive(asn1::Asn1Read, asn1::Asn1Write)] pub struct RelativeDistinguishedName<'a> { data: asn1::SequenceOf<'a, AttributeValueAssertion<'a>>, }

#[derive(Debug, asn1::Asn1Read, asn1::Asn1Write)] pub struct AttributeValueAssertion<'a> { attribute_type: asn1::ObjectIdentifier, attribute_value: asn1::IA5String<'a>, }``

Where General name is the same as the previous example, it gives me an error every nested enum as write and read asn1 trait not implemented. Am I doing something wrong or is it a bug?

I was able to derive some structs that deserialize correctly, but I'm struggling to figure out how to represent a SEQUENCE OF SEQUENCE in a struct. Is there an example of this anywhere? Is it possible, or do I need to write my own code with a d.read_element::<asn1::SequenceOf>() to do this?

The idea behind this change is such that when encoding an enum (via CHOICE) using tagging, you can determine which variant to read by peeking at the tag value without advancing the parser.

peek_explicit_tag() and peek_implicit_tag() return a tuple like

(<raw-tag>, <decoded-tag>)

such that raw-tag is the tag as it is read directly from the input bytes, and decoded-tag is the tag converted into the same format that would be passed to Writer.write_explicit_element() or Writer.write_implicit_element().

peek_implicit_tag() requires knowing the type you wish to decode up-front in order to retrieve an accurate decoded-tag value, as implicit tagging embeds the type within the tag.

Looks like a bit of bitrot set in

--> /home/jrconlin/.cargo/registry/src/github.com-1ecc6299db9ec823/asn1-0.1.0/src/lib.rs:9:24
  |
9 | use chrono::{DateTime, UTC};
  |                        ^^^ no `UTC` in the root

I'm not sure, but I belive that this is now Utc https://docs.rs/chrono/0.4.0/chrono/offset/struct.Utc.html

Hi Alex,

In order to successfully use the current Signature example in the README.md, the FieldDescription struct and its fields need to be public, otherwise the expansion of the asn1! macro will fail.

Easy fix ... although I don't know if this is your intention...

Cheers Marcus

TODO:

• [ ] CHOICE
• [ ] INTEGER { v1(0), v2(1), v3(2) }
• [ ] from_der() with OPTIONAL
• [ ] from_der() with DEFAULT
• [ ] from_der() with EXPLICIT tag
• [ ] from_der() with IMPLICIT tag
• [ ] to_der() with EXPLICIT tag
• [ ] to_der() with IMPLICIT tag
• [ ] Reference other SEQUENCE by name
• [x] Multiple declerations in a single asn1!() call.
• [ ] PrintableString
• [ ] UTCTime
• [ ] BIT STRING { x (0), y (1) }

Bumps actions/checkout from 3.1.0 to 3.2.0.

Dependabot will resolve any conflicts with this PR as long as you don't alter it yourself. You can also trigger a rebase manually by commenting @dependabot rebase.

Implement [#relaxeddefault(value)] attribute. The new attribute is an alternative to [#default(value)] that does not fail with ParseErrorKind::EncodedDefault when a component is encoded with default value.

DER requires that encoding of a set value or sequence value shall not include an encoding for any component value which is equal to its default value. However some systems use BER-like syntax and encode components with default values. OpenSSL and NSS are more relaxed and don't fail.

Signed-off-by: Christian Heimes [email protected]

I'm trying to write a Tlv value to a DER key, but I cannot figure out how. Is there any way to do this? Specifically, I am trying to write a NULL value. I don't see any public API to write any of this. Could there be an unsafe constructor added to the Tlv type? It implements Asn1Writable, but does not appear to be constructable.

A NULL type would only be a partial fix in my opinion. It would be very helpful to be able to construct a Tlv in user space code.

Right now we reserve space for the length, call write(), see how much data was written, and fill it in (potentially resizing the storage if more than 127 bytes are written). We should allow types to pre-declare their size to avoid resizing.

Hey! Thank you so much for your crate.

I found a requirement to write a raw DER slice into the writer. Something like https://docs.rs/yasna/0.4.0/yasna/struct.DERWriter.html#method.write_der. Would you please implement it?