alsmost done basic profile except tensors

Package.swift

@@ -4,14 +4,12 @@ import PackageDescription
 import class Foundation.ProcessInfo
 
 let package = Package(
-    name: "chat-asn1",
+    name: "chat-x509",
     platforms: [ .macOS(.v12), .iOS(.v13) ],
-    products: [ .library(name: "chat-asn1", targets: ["ASN1SCG"]), ],
-    targets: [ .target(name: "ASN1SCG", dependencies: [ 
-       .product(name: "SwiftASN1", package: "swift-asn1"), ]), ]
+    products: [ .executable(name: "chat-x509", targets: ["Suite"]), ],
+    targets: [ .executableTarget(name: "Suite", dependencies: [ .product(name: "SwiftASN1", package: "swift-asn1"), ]), ]
 )
 
 if ProcessInfo.processInfo.environment["SWIFTCI_USE_LOCAL_DEPS"] == nil {
-    package.dependencies += [
-       .package(url: "https://github.com/apple/swift-asn1.git", from: "1.2.0"), ]
+    package.dependencies += [ .package(url: "https://github.com/apple/swift-asn1.git", from: "1.2.0"), ]
 }

Sources/Suite/ASN1Identifier.swift

@@ -0,0 +1,74 @@
+import SwiftASN1
+import Foundation
+
+public struct ASN1VisibleString: DERImplicitlyTaggable {
+
+    @inlinable
+    public static var defaultIdentifier: ASN1Identifier {
+        .visibleString
+    }
+
+    public var bytes: ArraySlice<UInt8>
+
+    @inlinable
+    public init(contentBytes: ArraySlice<UInt8>) {
+        self.bytes = contentBytes
+    }
+
+    @inlinable
+    public init(derEncoded node: ASN1Node, withIdentifier identifier: ASN1Identifier) throws {
+        guard node.identifier == identifier else {
+            throw ASN1Error.unexpectedFieldType(node.identifier)
+        }
+
+        guard case .primitive(let content) = node.content else {
+            preconditionFailure("ASN.1 parser generated primitive node with constructed content")
+        }
+
+        self.bytes = content
+    }
+
+    @inlinable
+    public func serialize(into coder: inout DER.Serializer, withIdentifier identifier: ASN1Identifier) throws {
+        let octet = ASN1OctetString(contentBytes: self.bytes)
+        try octet.serialize(into: &coder, withIdentifier: identifier)
+    }
+
+}
+
+extension ASN1Identifier {
+    public static let sequenceOf         = ASN1Identifier(tagWithNumber: 0x10, tagClass: ASN1Identifier.TagClass.universal)
+    public static let setOf              = ASN1Identifier(tagWithNumber: 0x11, tagClass: ASN1Identifier.TagClass.universal)
+/*
+    public static let boolean            = ASN1Identifier(tagWithNumber: 0x01, tagClass: ASN1Identifier.TagClass.universal)
+    public static let integer            = ASN1Identifier(tagWithNumber: 0x02, tagClass: ASN1Identifier.TagClass.universal)
+    public static let bitString          = ASN1Identifier(tagWithNumber: 0x03, tagClass: ASN1Identifier.TagClass.universal)
+    public static let octetString        = ASN1Identifier(tagWithNumber: 0x04, tagClass: ASN1Identifier.TagClass.universal)
+    public static let null               = ASN1Identifier(tagWithNumber: 0x05, tagClass: ASN1Identifier.TagClass.universal)
+    public static let objectIdentifier   = ASN1Identifier(tagWithNumber: 0x06, tagClass: ASN1Identifier.TagClass.universal)
+    public static let objectDescriptor   = ASN1Identifier(tagWithNumber: 0x07, tagClass: ASN1Identifier.TagClass.universal)
+    public static let external           = ASN1Identifier(tagWithNumber: 0x08, tagClass: ASN1Identifier.TagClass.universal)
+    public static let real               = ASN1Identifier(tagWithNumber: 0x09, tagClass: ASN1Identifier.TagClass.universal)
+    public static let enumerated         = ASN1Identifier(tagWithNumber: 0x0a, tagClass: ASN1Identifier.TagClass.universal)
+    public static let embedded           = ASN1Identifier(tagWithNumber: 0x0b, tagClass: ASN1Identifier.TagClass.universal)
+    public static let utf8String         = ASN1Identifier(tagWithNumber: 0x0c, tagClass: ASN1Identifier.TagClass.universal)
+    public static let relativeIdentifier = ASN1Identifier(tagWithNumber: 0x0d, tagClass: ASN1Identifier.TagClass.universal)
+    public static let time               = ASN1Identifier(tagWithNumber: 0x0e, tagClass: ASN1Identifier.TagClass.universal)
+    public static let numericString      = ASN1Identifier(tagWithNumber: 0x12, tagClass: ASN1Identifier.TagClass.universal)
+    public static let printableString    = ASN1Identifier(tagWithNumber: 0x13, tagClass: ASN1Identifier.TagClass.universal)
+    public static let teletexString      = ASN1Identifier(tagWithNumber: 0x14, tagClass: ASN1Identifier.TagClass.universal)
+    public static let videotexString     = ASN1Identifier(tagWithNumber: 0x15, tagClass: ASN1Identifier.TagClass.universal)
+    public static let ia5String          = ASN1Identifier(tagWithNumber: 0x16, tagClass: ASN1Identifier.TagClass.universal)
+    public static let utcTime            = ASN1Identifier(tagWithNumber: 0x17, tagClass: ASN1Identifier.TagClass.universal)
+    public static let generalizedTime    = ASN1Identifier(tagWithNumber: 0x18, tagClass: ASN1Identifier.TagClass.universal)
+    public static let graphicString      = ASN1Identifier(tagWithNumber: 0x19, tagClass: ASN1Identifier.TagClass.universal)
+    public static let visibleString      = ASN1Identifier(tagWithNumber: 0x1a, tagClass: ASN1Identifier.TagClass.universal)
+    public static let generalString      = ASN1Identifier(tagWithNumber: 0x1b, tagClass: ASN1Identifier.TagClass.universal)
+    public static let universalString    = ASN1Identifier(tagWithNumber: 0x1c, tagClass: ASN1Identifier.TagClass.universal)
+    public static let bmpString          = ASN1Identifier(tagWithNumber: 0x1e, tagClass: ASN1Identifier.TagClass.universal)
+    public static let sequence           = ASN1Identifier(tagWithNumber: 0x30, tagClass: ASN1Identifier.TagClass.universal)
+    public static let set                = ASN1Identifier(tagWithNumber: 0x31, tagClass: ASN1Identifier.TagClass.universal)
+*/
+}
+
+

Sources/ASN1SCG/AlgorithmIdentifier.swift → Sources/Suite/ASN1SCG/AlgorithmIdentifier.swift

@@ -5,24 +5,24 @@ import Foundation
 @usableFromInline struct AlgorithmIdentifier: DERImplicitlyTaggable, Hashable, Sendable {
     @inlinable static var defaultIdentifier: ASN1Identifier { .sequence }
     @usableFromInline var algorithm: ASN1ObjectIdentifier
-    @usableFromInline var parameters: ASN1Any
-    @inlinable init(algorithm: ASN1ObjectIdentifier, parameters: ASN1Any) {
+    @usableFromInline var parameters: ASN1Any?
+    @inlinable init(algorithm: ASN1ObjectIdentifier, parameters: ASN1Any?) {
         self.algorithm = algorithm
         self.parameters = parameters
     }
     @inlinable init(derEncoded root: ASN1Node,
         withIdentifier identifier: ASN1Identifier) throws {
         self = try DER.sequence(root, identifier: identifier) { nodes in
             let algorithm: ASN1ObjectIdentifier = try ASN1ObjectIdentifier(derEncoded: &nodes)
-            let parameters: ASN1Any = try ASN1Any(derEncoded: &nodes)
+            let parameters: ASN1Any? = nodes.next().map { ASN1Any(derEncoded: $0) }
             return AlgorithmIdentifier(algorithm: algorithm, parameters: parameters)
         }
     }
     @inlinable func serialize(into coder: inout DER.Serializer,
         withIdentifier identifier: ASN1Identifier) throws {
         try coder.appendConstructedNode(identifier: identifier) { coder in
             try coder.serialize(algorithm)
-            try coder.serialize(parameters)
+            if let parameters = self.parameters { try coder.serialize(parameters) }
         }
     }
 }

Sources/ASN1SCG/Attribute.swift → Sources/Suite/ASN1SCG/Attribute.swift

@@ -5,16 +5,16 @@ import Foundation
 @usableFromInline struct Attribute: DERImplicitlyTaggable, Hashable, Sendable {
     @inlinable static var defaultIdentifier: ASN1Identifier { .sequence }
     @usableFromInline var attrType: ASN1ObjectIdentifier
-    @usableFromInline var attrValues: [ASN1Any]
-    @inlinable init(attrType: ASN1ObjectIdentifier, attrValues: [ASN1Any]) {
+    @usableFromInline var attrValues: [ASN1OctetString]
+    @inlinable init(attrType: ASN1ObjectIdentifier, attrValues: [ASN1OctetString]) {
         self.attrType = attrType
         self.attrValues = attrValues
     }
     @inlinable init(derEncoded root: ASN1Node,
         withIdentifier identifier: ASN1Identifier) throws {
         self = try DER.sequence(root, identifier: identifier) { nodes in
             let attrType: ASN1ObjectIdentifier = try ASN1ObjectIdentifier(derEncoded: &nodes)
-            let attrValues: [ASN1Any] = try DER.set(of: ASN1Any.self, identifier: .set, nodes: &nodes)
+            let attrValues: [ASN1OctetString] = try DER.set(of: ASN1OctetString.self, identifier: .set, nodes: &nodes)
             return Attribute(attrType: attrType, attrValues: attrValues)
         }
     }

Sources/ASN1SCG/AttributeTypeAndValue.swift → Sources/Suite/ASN1SCG/AttributeTypeAndValue.swift

@@ -5,16 +5,16 @@ import Foundation
 @usableFromInline struct AttributeTypeAndValue: DERImplicitlyTaggable, Hashable, Sendable {
     @inlinable static var defaultIdentifier: ASN1Identifier { .sequence }
     @usableFromInline var type: ASN1ObjectIdentifier
-    @usableFromInline var value: ASN1OctetString
-    @inlinable init(type: ASN1ObjectIdentifier, value: ASN1OctetString) {
+    @usableFromInline var value: ASN1Any
+    @inlinable init(type: ASN1ObjectIdentifier, value: ASN1Any) {
         self.type = type
         self.value = value
     }
     @inlinable init(derEncoded root: ASN1Node,
         withIdentifier identifier: ASN1Identifier) throws {
         self = try DER.sequence(root, identifier: identifier) { nodes in
             let type: ASN1ObjectIdentifier = try ASN1ObjectIdentifier(derEncoded: &nodes)
-            let value: ASN1OctetString = try ASN1OctetString(derEncoded: &nodes)
+            let value: ASN1Any = try ASN1Any(derEncoded: &nodes)
             return AttributeTypeAndValue(type: type, value: value)
         }
     }

Sources/ASN1SCG/Control.swift → Sources/Suite/ASN1SCG/Control.swift

@@ -16,7 +16,7 @@ import Foundation
         withIdentifier identifier: ASN1Identifier) throws {
         self = try DER.sequence(root, identifier: identifier) { nodes in
             let controlType: ASN1OctetString = try ASN1OctetString(derEncoded: &nodes)
-            let criticality: Bool = try Bool(derEncoded: &nodes)
+            let criticality: Bool = try DER.decodeDefault(&nodes, defaultValue: false)
             let controlValue: ASN1OctetString? = try ASN1OctetString(derEncoded: &nodes)
             return Control(controlType: controlType, criticality: criticality, controlValue: controlValue)
         }

Sources/ASN1SCG/ExtendedRequest.swift → Sources/Suite/ASN1SCG/ExtendedRequest.swift

@@ -13,7 +13,7 @@ import Foundation
     @inlinable init(derEncoded root: ASN1Node,
         withIdentifier identifier: ASN1Identifier) throws {
         self = try DER.sequence(root, identifier: identifier) { nodes in
-            let requestName: ASN1OctetString = try DER.optionalImplicitlyTagged(&nodes, tag: ASN1Identifier(tagWithNumber: 0, tagClass: .contextSpecific))
+            let requestName: ASN1OctetString = (try DER.optionalImplicitlyTagged(&nodes, tag: ASN1Identifier(tagWithNumber: 0, tagClass: .contextSpecific)))!
             let requestValue: ASN1OctetString? = try DER.optionalImplicitlyTagged(&nodes, tag: ASN1Identifier(tagWithNumber: 1, tagClass: .contextSpecific))
             return ExtendedRequest(requestName: requestName, requestValue: requestValue)
         }

Sources/ASN1SCG/Extension.swift → Sources/Suite/ASN1SCG/Extension.swift

@@ -16,7 +16,7 @@ import Foundation
         withIdentifier identifier: ASN1Identifier) throws {
         self = try DER.sequence(root, identifier: identifier) { nodes in
             let extnID: ASN1ObjectIdentifier = try ASN1ObjectIdentifier(derEncoded: &nodes)
-            let critical: Bool = try Bool(derEncoded: &nodes)
+            let critical: Bool = try DER.decodeDefault(&nodes, defaultValue: false)
             let extnvalue: ASN1OctetString = try ASN1OctetString(derEncoded: &nodes)
             return Extension(extnID: extnID, critical: critical, extnvalue: extnvalue)
         }

Sources/ASN1SCG/MatchingRuleAssertion.swift → Sources/Suite/ASN1SCG/MatchingRuleAssertion.swift

@@ -19,8 +19,8 @@ import Foundation
         self = try DER.sequence(root, identifier: identifier) { nodes in
             let matchingRule: ASN1OctetString? = try DER.optionalImplicitlyTagged(&nodes, tag: ASN1Identifier(tagWithNumber: 1, tagClass: .contextSpecific))
             let type: ASN1OctetString? = try DER.optionalImplicitlyTagged(&nodes, tag: ASN1Identifier(tagWithNumber: 2, tagClass: .contextSpecific))
-            let matchValue: ASN1OctetString = try DER.optionalImplicitlyTagged(&nodes, tag: ASN1Identifier(tagWithNumber: 3, tagClass: .contextSpecific))
-            let dnAttributes: Bool = try DER.optionalImplicitlyTagged(&nodes, tag: ASN1Identifier(tagWithNumber: 4, tagClass: .contextSpecific))
+            let matchValue: ASN1OctetString = (try DER.optionalImplicitlyTagged(&nodes, tag: ASN1Identifier(tagWithNumber: 3, tagClass: .contextSpecific)))!
+            let dnAttributes: Bool = (try DER.optionalImplicitlyTagged(&nodes, tag: ASN1Identifier(tagWithNumber: 4, tagClass: .contextSpecific)))!
             return MatchingRuleAssertion(matchingRule: matchingRule, type: type, matchValue: matchValue, dnAttributes: dnAttributes)
         }
     }

Sources/ASN1SCG/ModifyDNRequest.swift → Sources/Suite/ASN1SCG/ModifyDNRequest.swift

@@ -19,7 +19,7 @@ import Foundation
         self = try DER.sequence(root, identifier: identifier) { nodes in
             let entry: ASN1OctetString = try ASN1OctetString(derEncoded: &nodes)
             let newrdn: ASN1OctetString = try ASN1OctetString(derEncoded: &nodes)
-            let deleteoldrdn: Bool = try Bool(derEncoded: &nodes)
+            let deleteoldrdn: Bool = try DER.decodeDefault(&nodes, defaultValue: false)
             let newSuperior: ASN1OctetString? = try DER.optionalImplicitlyTagged(&nodes, tag: ASN1Identifier(tagWithNumber: 0, tagClass: .contextSpecific))
             return ModifyDNRequest(entry: entry, newrdn: newrdn, deleteoldrdn: deleteoldrdn, newSuperior: newSuperior)
         }

Sources/Suite/ASN1SCG/Name.swift

@@ -0,0 +1,42 @@
+// Generated by ASN1.ERP.UNO Compiler, Copyright © 2023 Namdak Tonpa.
+import SwiftASN1
+import Foundation
+
+// 'NameRDN':encode('Name',{'rdnSequence',[[{'AttributeTypeAndValue',{2,5,4,6},<<19,2,85,65>>}]]}).
+// {ok,<<48,13,49,11,48,9,6,3,85,4,6,19,2,85,65>>}
+// DER.name [48,13,49,11,48,9,6,3,85,4,6,19,2,85,65]
+
+@usableFromInline indirect enum Name: DERParseable, DERSerializable, Hashable, Sendable {
+    case rdnSequence([[AttributeTypeAndValue]])
+    @inlinable init(derEncoded root: ASN1Node) throws {
+        switch root.identifier {
+            case ASN1Identifier.sequenceOf:
+                var w: [[AttributeTypeAndValue]] = []
+                try DER.sequence(root, identifier: .sequence) { nodes in
+                     var w1: [AttributeTypeAndValue] = []
+                     while let node = nodes.next() {
+                       w1.append(contentsOf:
+                          try DER.set(of: AttributeTypeAndValue.self, identifier: .set, rootNode: node))
+                     }
+                     w.append(w1)
+                }
+                self = Name.rdnSequence(w)
+            default: throw ASN1Error.unexpectedFieldType(root.identifier)
+        }
+
+    }
+    @inlinable func serialize(into coder: inout DER.Serializer) throws {
+        switch self {
+            case .rdnSequence(let w):
+                try coder.appendConstructedNode(identifier: ASN1Identifier.sequence) { codec1 in
+                    for w1 in w {
+                        try codec1.appendConstructedNode(identifier: ASN1Identifier.set) { codec1_1 in
+                            for w2 in w1 {
+                                try codec1_1.serialize(w2)
+                            }
+                        }
+                    }
+                }
+        }
+    }
+}

Sources/ASN1SCG/PolicyQualifierInfo.swift → Sources/Suite/ASN1SCG/PolicyQualifierInfo.swift

@@ -14,7 +14,7 @@ import Foundation
         withIdentifier identifier: ASN1Identifier) throws {
         self = try DER.sequence(root, identifier: identifier) { nodes in
             let policyQualifierId: ASN1ObjectIdentifier = try ASN1ObjectIdentifier(derEncoded: &nodes)
-            let qualifier: ASN1Any? = try ASN1Any(derEncoded: &nodes)
+            let qualifier: ASN1Any? = nodes.next().map { ASN1Any(derEncoded: $0) }
             return PolicyQualifierInfo(policyQualifierId: policyQualifierId, qualifier: qualifier)
         }
     }