Initial project import

tools/v/vlib/x/encoding/asn1/sequence.v

@@ -0,0 +1,282 @@
+// Copyright (c) 2022, 2024 blackshirt. All rights reserved.
+// Use of this source code is governed by a MIT License
+// that can be found in the LICENSE file.
+module asn1
+
+// default_sequence_tag is the default tag of ASN.1 SEQUENCE (SEQUENCE OF) type.
+pub const default_sequence_tag = Tag{.universal, true, int(TagType.sequence)}
+
+// constant for sequence(of) and set(of) internal value
+// vfmt off
+const max_sequence_size 		= 256 // max of seq size
+const max_sequence_bytes_length = (1 << 23 - 1) // 
+const default_sequence_size 	= 64 // default size
+// vfmt on
+
+// ASN.1 UNIVERSAL CLASS OF SEQUENCE and SEQUENCE OF TYPE.
+//
+// https://letsencrypt.org/docs/a-warm-welcome-to-asn1-and-der
+// These are two very different types.
+// A SEQUENCE is equivalent to “struct” in most programming languages.
+// It holds a fixed number of fields of different types.
+// A SEQUENCE OF, holds an arbitrary number of fields of a single type.
+// This is analogous to an array or a list in a programming language.
+// Sequence structure can represents both SEQUENCE and SEQUENCE OF type.
+// The encoding of a sequence value shall be constructed.
+// in DER encoded of SEQUENCE or SET, never encode a default value.
+pub struct Sequence {
+mut:
+	//	maximal size of this sequence fields
+	size int = default_sequence_size
+	// fields is the elements of the sequence
+	fields []Element
+}
+
+// new creates new Sequence with default size.
+pub fn Sequence.new() !Sequence {
+	return Sequence.new_with_size(default_sequence_size)!
+}
+
+// from_list creates new Sequence from list of elements.
+pub fn Sequence.from_list(els []Element) !Sequence {
+	if els.len > max_sequence_size {
+		return error('Sequence size exceed limit')
+	}
+	return Sequence{
+		fields: els
+	}
+}
+
+fn Sequence.new_with_size(size int) !Sequence {
+	if size > max_sequence_size {
+		return error('size is exceed limit')
+	}
+	if size < 0 {
+		return error('Provides with correct size')
+	}
+
+	// if size is 0, use default_sequence_size
+	limit := if size == 0 { default_sequence_size } else { size }
+	return Sequence{
+		size: limit
+	}
+}
+
+// tag returns the tag of Sequence element.
+pub fn (seq Sequence) tag() Tag {
+	return default_sequence_tag
+}
+
+// payload returns the payload of Sequence element.
+pub fn (seq Sequence) payload() ![]u8 {
+	return seq.payload_with_rule(.der)!
+}
+
+fn (seq Sequence) payload_with_rule(rule EncodingRule) ![]u8 {
+	mut out := []u8{}
+	for el in seq.fields {
+		obj := encode_with_rule(el, rule)!
+		out << obj
+	}
+	return out
+}
+
+// encoded_len tells the length of serialized Sequence element in bytes.
+pub fn (seq Sequence) encoded_len() int {
+	mut n := 0
+	n += seq.tag().tag_size()
+	fields := ElementList(seq.fields)
+	len := fields.encoded_len()
+	length := Length.new(len) or { panic(err) }
+	n += length.length_size() or { panic(err) }
+	n += len
+	return n
+}
+
+// fields returns the Sequences fields.
+pub fn (seq Sequence) fields() []Element {
+	return seq.fields
+}
+
+// parse tries to parse into Sequence from ongoing Parser p.
+// Uts return a parsed Sequence or error on fails.
+fn Sequence.parse(mut p Parser) !Sequence {
+	tag := p.read_tag()!
+	if !tag.equal(default_sequence_tag) {
+		return error('Get non Sequence tag')
+	}
+	length := p.read_length()!
+	content := p.read_bytes(length)!
+
+	seq := Sequence.from_bytes(content)!
+	return seq
+}
+
+// decode tries to decode bytes into Sequence.
+// Its return a decoded Sequence and next offset to read on
+// if possible, or return error on fails.
+fn Sequence.decode(bytes []u8) !(Sequence, int) {
+	return Sequence.decode_with_rule(bytes, 0, .der)!
+}
+
+fn Sequence.decode_with_rule(bytes []u8, loc int, rule EncodingRule) !(Sequence, int) {
+	tag, length_pos := Tag.decode_with_rule(bytes, loc, rule)!
+	if !tag.equal(default_sequence_tag) {
+		return error('Get unexpected non-sequence tag')
+	}
+	length, content_pos := Length.decode_with_rule(bytes, length_pos, rule)!
+	payload := if length == 0 {
+		[]u8{}
+	} else {
+		if content_pos + length > bytes.len {
+			return error('Not enought bytes to read on')
+		}
+		unsafe { bytes[content_pos..content_pos + length] }
+	}
+	next := content_pos + length
+	seq := Sequence.from_bytes(payload)!
+	return seq, next
+}
+
+// bytes should seq.fields payload, not includes the tag
+fn Sequence.from_bytes(bytes []u8) !Sequence {
+	mut seq := Sequence{}
+	if bytes.len == 0 {
+		return seq
+	}
+	mut i := 0
+	for i < bytes.len {
+		el, pos := Element.decode_with_rule(bytes, i, .der)!
+		i = pos
+		seq.add_element(el)!
+	}
+
+	if i > bytes.len {
+		return error('i > bytes.len')
+	}
+	if i < bytes.len {
+		return error('The src contains unprocessed bytes')
+	}
+	return seq
+}
+
+// set_size sets maximal size of this sequence fields.
+pub fn (mut seq Sequence) set_size(size int) ! {
+	if size <= 0 {
+		return error('provides with correct limit')
+	}
+	if size > max_sequence_size {
+		return error('Provided limit was exceed current one')
+	}
+	seq.size = size
+}
+
+// add_element adds an element el into Sequence fields.
+// By default its allows adding element with the same tag.
+pub fn (mut seq Sequence) add_element(el Element) ! {
+	seq.relaxed_add_element(el, true)!
+}
+
+// add_element allows adding a new element into current sequence fields.
+// Its does not allow adding element when is already the same tag in the fields.
+// but, some exception when you set relaxed to true
+fn (mut seq Sequence) relaxed_add_element(el Element, relaxed bool) ! {
+	// todo: check against size
+	if seq.fields.len == 0 {
+		// just adds it then return
+		seq.fields << el
+		return
+	}
+
+	// for item in seq.fields {
+	//	if item.equal_with(el) {
+	//		return error('has already in the fields')
+	//	}
+	// }
+	filtered_by_tag := seq.fields.filter(it.tag().equal(el.tag()))
+	if filtered_by_tag.len == 0 {
+		seq.fields << el
+		return
+	} else {
+		if !relaxed {
+			return error('You can not insert element without forcing')
+		}
+		seq.fields << el
+		return
+	}
+}
+
+// is_sequence_of[T] checks whether this sequence is SequenceOf[T] type.
+pub fn (seq Sequence) is_sequence_of[T]() bool {
+	return seq.fields.all(it is T)
+}
+
+// into_sequence_of[T] turns this sequence into SequenceOf[T] element.
+pub fn (seq Sequence) into_sequence_of[T]() !SequenceOf[T] {
+	if seq.is_sequence_of[T]() {
+		return error('This sequence is not SequenceOf[T]')
+	}
+	mut sqof := SequenceOf[T]{}
+	for el in seq.fields {
+		obj := el.into_object[T]()!
+		sqof.fields << obj
+	}
+	return sqof
+}
+
+// ASN.1 SEQUENCE OF TYPE.
+// SequenceOf[T] is an arrays of generic T, so the generic T should fullfill Element interface.
+// We dont use generic aliases because generic type aliases are not yet implemented.
+pub struct SequenceOf[T] {
+mut:
+	size   int = default_sequence_size
+	fields []T
+}
+
+// SequenceOf.new creates a new SequenceOf[T]
+pub fn SequenceOf.new[T]() SequenceOf[T] {
+	return SequenceOf[T]{}
+}
+
+// SequenceOf.from_list creates a new SequenceOf[T] from arrays of T type.
+pub fn SequenceOf.from_list[T](els []T) !SequenceOf[T] {
+	if els.len > max_sequence_size {
+		return error('SequenceOf size exceed limit')
+	}
+	$if T !is Element {
+		return error('T not hold element')
+	}
+	return SequenceOf[T]{
+		fields: els
+	}
+}
+
+// The tag of SequenceOf element.
+pub fn (so SequenceOf[T]) tag() Tag {
+	return default_sequence_tag
+}
+
+// The payload of SequenceOf element.
+pub fn (so SequenceOf[T]) payload() ![]u8 {
+	return so.payload_with_rule(.der)!
+}
+
+fn (so SequenceOf[T]) payload_with_rule(rule EncodingRule) ![]u8 {
+	$if T !is Element {
+		return error('T is not an element')
+	}
+	mut out := []u8{}
+	for el in so.fields {
+		// placing el directly bring into error: `el` cannot be used as interface object
+		// outside `unsafe` blocks as it might be stored on stack.
+		curr := unsafe { el }
+		obj := encode_with_rule(curr, rule)!
+		out << obj
+	}
+	return out
+}
+
+// fields returns underlying arrays of T from the SequenceOf[T].
+pub fn (so SequenceOf[T]) fields() []T {
+	return so.fields
+}