SwiftASN1

Implicit tagging replaces an object's usual tag with a new one, saving space (at least 2 bytes) but making the encoding non-self-describing.

To support implicit tagging, a type should conform to DERImplicitlyTaggable. This requires implementing:

• init(derEncoded:withIdentifier:)
• serialize(into:withIdentifier:)

Warning: Do not use implicit tagging for CHOICE types. Because CHOICE types encode as the chosen value itself, losing the original tag makes it impossible to determine which case was selected during decoding.

When decoding or encoding, you must manually construct the ASN1Identifier with the correct tagClass (usually .contextSpecific) and tagNumber.

// Example: Decoding an implicitly tagged INTEGER within a SEQUENCE
init(derEncoded rootNode: ASN1Node) throws {
    self = try DER.sequence(rootNode, identifier: .sequence) { nodes in
        let value = try Int64(derEncoded: &nodes, withIdentifier: .init(tagWithNumber: 0, tagClass: .contextSpecific))
        return ContainsImplicitTag(value: value)
    }
}

// Example: Encoding an implicitly tagged INTEGER within a SEQUENCE
func serialize(into coder: inout DER.Serializer) throws {
    try coder.appendConstructedNode(identifier: .sequence) { coder in
        try self.value.serialize(into: &coder, withIdentifier: .init(tagWithNumber: 0, tagClass: .contextSpecific))
    }
}

Explicit tagging wraps an object in a new constructed object with the specified tag. Unlike implicit tagging, the underlying object retains its original tag, keeping the encoding self-describing. This method can be applied to any node.

To decode an explicitly tagged value, use ASN1.explicitlyTagged. To encode it, use serialize(..., explicitlyTaggedWithTagNumber:tagClass:) on the value.

// Example: Decoding an explicitly tagged INTEGER within a SEQUENCE
init(derEncoded rootNode: ASN1Node) throws {
    self = try DER.sequence(rootNode, identifier: .sequence) { nodes in
        let value = try ASN1.explicitlyTagged(&nodes, tagNumber: 0, tagClass: .contextSpecific) { 
            try Int64(derEncoded: $0) 
        }
        return ContainsExplicitTag(value: value)
    }
}

// Example: Encoding an explicitly tagged INTEGER within a SEQUENCE
func serialize(into coder: inout DER.Serializer) throws {
    try coder.appendConstructedNode(identifier: .sequence) { coder in
        try coder.serialize(self.value, explicitlyTaggedWithTagNumber: 0, tagClass: .contextSpecific)
    }
}

SwiftASN1 does not provide an ASN.1 compiler to automatically generate serialization code. Instead, you must manually implement encoding and decoding by conforming your types to DERImplicitlyTaggable (for SEQUENCE types) or DERParseable (for individual objects).

Decoding Pattern

1. Conform to DERImplicitlyTaggable: This is the standard approach for SEQUENCE types. Implement init(derEncoded:withIdentifier:).
2. Unwrap the Sequence: Use DER.sequence(_:identifier:_:) to validate the root node's identifier and access its children via an ASN1NodeCollection.Iterator.
3. Recursive Decoding: Use the DERParseable initializer init(derEncoded:) on the child nodes. This method automatically consumes the next node from the iterator.

Encoding Pattern

1. Implement serialize(into:withIdentifier:): This is required by DERImplicitlyTaggable.
2. Append Constructed Nodes: For sequences, use coder.appendConstructedNode(identifier:_:). This method provides a closure with a new inout reference to the serializer.
3. Recursive Serialization: Use coder.serialize(_:) on your fields, which invokes the DERSerializable implementation for those types.

struct ECDSASignature: DERImplicitlyTaggable {
    static var defaultIdentifier: ASN1Identifier { .sequence }

    var r: ArraySlice<UInt8>
    var s: ArraySlice<UInt8>

    init(r: ArraySlice<UInt8>, s: ArraySlice<UInt8>) {
        self.r = r
        self.s = s
    }

    // Decoding
    init(derEncoded rootNode: ASN1Node, withIdentifier identifier: ASN1Identifier) throws {
        self = try DER.sequence(rootNode, identifier: identifier) { nodes in
            let r = try ArraySlice<UInt8>(derEncoded: &nodes)
            let s = try ArraySlice<UInt8>(derEncoded: &nodes)
            return ECDSASignature(r: r, s: s)
        }
    }

    // Encoding
    func serialize(into coder: inout DER.Serializer, withIdentifier identifier: ASN1Identifier) throws {
        try coder.appendConstructedNode(identifier: identifier) { coder in
            try coder.serialize(self.r)
            try coder.serialize(self.s)
        }
    }
}