Make the tag size optionally based on 7816 rules

[gwachob]

Glad to see this library! A feature request which I think will make this much more useable for some domains:

ISO 7816-4 Annex D.2 (find it here: https://cardwerk.com/iso7816-4-annex-d-use-of-basic-encoding-rules-asn-1/) specifies an encoding for tags that specify variable lengths for tags, instead of having a single length for all tags. It's a bit obtuse, but it's in common use and it would be nice to have this encoding/decoding support in this library.

Ideally, instead of just setting tag_size to a fixed number, you would also be able to specify an encoding scheme (e.g. 7816, or fixed). An example of a library that enumerates different schemes (both for T encoding and L encoding) is https://www.openscdp.org/scriptingserver/tlv.html (though "EMV" should really be ISO7816/ISO8825)

Dealing with non-open standards is not fun. I'm happy to provide some examples as I can - but you can download EMV book 3 for free which has tons of examples. https://www.emvco.com/wp-content/uploads/documents/EMV_v4.3_Book_3_Application_Specification_20120607062110791.pdf (especially section 7)

[ustropo]

Thank you for your comment!

The default behavior of the TLV class already supports variable length (when you set tag.len_size to 0 or None). If the length is less than 127, it encodes the length using one byte. If it's greater than 127, it sets the first bit to 1 and uses the remaining 7 bits to encode how many bytes the length field actually has (0x80 + length):

    def encode_length(self, value: bytes) -> bytes:
        """Translate the length of value into an array."""
        required_len_size = math.ceil(len(value).bit_length() / 8)
        if required_len_size > 16:
            raise AttributeError(
                f"Max allowed value length is {2**(8*15)-1} bytes, "
                f"given value is {len(value)} bytes"
            )

        if not self.len_size:
            if len(value) < 128:
                return len(value).to_bytes(1, byteorder=self.endian)

            return bytes((0x80 + required_len_size,)) + len(value).to_bytes(
                required_len_size, byteorder=self.endian
            )

        if self.len_size < required_len_size:
            raise ValueError(
                f"{value} takes up {required_len_size} bytes, "
                f"but len_size was defined as {self.len_size}"
            )

        return len(value).to_bytes(self.len_size, byteorder=self.endian)

You can check an example here.
As for EMV and other encoding standards, I'm working on a new version of this library that will make it easy to implement.

If you have any other suggestions or examples on how can I improve this, just comment.

[gwachob]

Actually section B1 of book 3 of EMV has a formal definition that seems to be common to 7816 as well.

[ustropo]

Sorry, I have confused the length_size with tag_size.

Yes, indeed, this need to be done. As I said, I'm working on a new version that will make it easier to create different protocols and specifications and will take it into account.

Thanks for noticing it!