indispensable-asn1/at.asitplus.signum.indispensable.asn1

Package-level declarations

Types

Asn1BitString

class Asn1BitString : Asn1Encodable<Asn1Primitive>

ASN.1 BIT STRING

Asn1CustomStructure

class Asn1CustomStructure : Asn1Structure

ASN1 structure (i.e. containing child nodes) with custom tag

Asn1Decodable

interface Asn1Decodable<A : Asn1Element, T : Asn1Encodable<A>>

Interface providing convenience methods to decode from ASN.1. Especially useful when companion objects of classes implementing Asn1Encodable implement it.

Asn1Element

@Serializable(with = Asn1EncodableSerializer::class)

sealed class Asn1Element

Base ASN.1 data class. Can either be a primitive (holding a value), or a structure (holding other ASN.1 elements)

Asn1EncapsulatingOctetString

@Serializable(with = Asn1EncodableSerializer::class)

class Asn1EncapsulatingOctetString(children: List<Asn1Element>) : Asn1Structure, Asn1OctetString<Asn1EncapsulatingOctetString>

ASN.1 OCTET STRING 0x04 (BERTags.OCTET_STRING) containing an Asn1Element

Asn1Encodable

interface Asn1Encodable<A : Asn1Element>

Interface providing methods to encode to ASN.1

Asn1EncodableSerializer

object Asn1EncodableSerializer : KSerializer<Asn1Element>

Asn1Exception

open class Asn1Exception(message: String?, cause: Throwable?) : Throwable

Asn1ExplicitlyTagged

class Asn1ExplicitlyTagged : Asn1Structure

Explicit ASN.1 Tag. Can contain any number of children

Asn1Integer

@Serializable(with = Asn1IntegerSerializer::class)

sealed class Asn1Integer

A very simple implementation of an ASN.1 variable-length integer. It is only good for reading from and writing to ASN.1 structures. It is not a BigInt, nor does it define any operations. It has a sign though, and supports twosComplement representation and converting fromTwosComplement. Hence, it directly interoperates with Kotlin MP BigNum and the JVM BigInteger.

Asn1IntegerSerializer

object Asn1IntegerSerializer : KSerializer<Asn1Integer>

Asn1OctetString

interface Asn1OctetString<T : Asn1Element>

Interface describing an ASN.1 OCTET STRING. This is really more of a crutch, since an octet string is either an

Asn1OidException

class Asn1OidException(message: String, val oid: ObjectIdentifier) : Asn1Exception

Asn1Primitive

open class Asn1Primitive(val tag: Asn1Element.Tag, val content: ByteArray) : Asn1Element

ASN.1 primitive. Hold o children, but content under tag

Asn1PrimitiveOctetString

class Asn1PrimitiveOctetString(val content: ByteArray) : Asn1Primitive, Asn1OctetString<Asn1PrimitiveOctetString>

ASN.1 OCTET STRING 0x04 (BERTags.OCTET_STRING) containing data, which does not decode to an Asn1Element

Asn1Sequence

class Asn1Sequence : Asn1Structure

ASN.1 SEQUENCE 0x30 (BERTags.SEQUENCE OR BERTags.CONSTRUCTED)

Asn1Set

open class Asn1Set : Asn1Structure

ASN.1 SET 0x31 (BERTags.SET OR BERTags.CONSTRUCTED)

Asn1SetOf

class Asn1SetOf : Asn1Set

ASN.1 SET OF 0x31 (BERTags.SET OR BERTags.CONSTRUCTED)

Asn1String

@Serializable

sealed class Asn1String : Asn1Encodable<Asn1Primitive>

ASN.! String class used as wrapper do discriminate between different ASN.1 string types

Asn1StructuralException

class Asn1StructuralException(message: String, cause: Throwable? = null) : Asn1Exception

Asn1Structure

sealed class Asn1Structure : Asn1Element

ASN.1 structure. Contains no data itself, but holds zero or more children

Asn1TagMismatchException

class Asn1TagMismatchException(val expected: Asn1Element.Tag, val actual: Asn1Element.Tag, detailedMessage: String? = null) : Asn1Exception

Asn1Time

@Serializable(with = Asn1TimeSerializer::class)

class Asn1Time(instant: Instant, formatOverride: Asn1Time.Format? = null) : Asn1Encodable<Asn1Primitive>

ASN.1 TIME (required since GENERALIZED TIME and UTC TIME exist)

Asn1TimeSerializer

object Asn1TimeSerializer : KSerializer<Asn1Time>

BERTags

object BERTags

BitSet

@Serializable(with = BitSetSerializer::class)

class BitSet : Iterable<Boolean>

Pure Kotlin Bit Set created by throwing a bunch of extension functions at a MutableList<Byte>. As a mental model: this BitSet grows from left to right, just like writing a text.

BitSetSerializer

object BitSetSerializer : KSerializer<BitSet>

CONSTRUCTED

object CONSTRUCTED : TagProperty

Identifiable

interface Identifiable

Adds oid to the implementing class

KnownOIDs

object KnownOIDs

ObjectIdentifier

@Serializable(with = ObjectIdSerializer::class)

class ObjectIdentifier : Asn1Encodable<Asn1Primitive>

ASN.1 OBJECT IDENTIFIER featuring the most cursed encoding of numbers known to man, which probably surfaced due to an ungodly combination of madness, cruelty and a twisted sense of humour. Courtesy of what were most probably tormented souls to begin with.

ObjectIdSerializer

object ObjectIdSerializer : KSerializer<ObjectIdentifier>

TagClass

enum TagClass : Enum<TagClass>

TagProperty

sealed interface TagProperty

Functions

Asn1Integer

fun Asn1Integer(number: Int): Asn1Integer

fun Asn1Integer(number: Long): Asn1Integer

assertTag

inline fun <T : Asn1Element> T.assertTag(tag: Asn1Element.Tag): T

asserts that this element's tag matches tag.

inline fun <T : Asn1Element> T.assertTag(tagNumber: ULong): T

Asserts only the tag number, but neither class, nor CONSTRUCTED bit.

memDump

fun ByteArray.memDump(): String

Returns a binary representation of this byte array's memory layout Bytes are separated by a single space. An empty byte array results in an empty string.

readOid

fun Asn1Primitive.readOid(): ObjectIdentifier

decodes this Asn1Primitive's content into an ObjectIdentifier

runRethrowing

inline fun <R> runRethrowing(block: () -> R): R

Runs block inside catching and encapsulates any thrown exception in an Asn1Exception unless it already is one

toBitSet

fun ByteArray.toBitSet(): BitSet

toBitString

fun ByteArray.toBitString(): String

Returns all bits as they are accessible by the global bit index (i.e. after wrapping this ByteArray into a BitSet)

wrapInUnsafeSource

fun ByteArray.wrapInUnsafeSource(): Source

Directly moves the byte array to a buffer without copying. Thus, it keeps bytes managed by a Buffer accessible. The bytes may be overwritten through the Buffer or even recycled to be used by another buffer. Therefore, operating on these bytes after wrapping leads to undefined behaviour.