// SPDX-License-Identifier: GPL-2.0-only
/*
 * Simple encoder primitives for ASN.1 BER/DER/CER
 *
 * Copyright (C) 2019 James.Bottomley@HansenPartnership.com
 */

#include <linux/asn1_encoder.h>
#include <linux/bug.h>
#include <linux/string.h>
#include <linux/module.h>

/**
 * asn1_encode_integer() - encode positive integer to ASN.1
 * @data:       pointer to the pointer to the data
 * @end_data:   end of data pointer, points one beyond last usable byte in @data
 * @integer:    integer to be encoded
 *
 * This is a simplified encoder: it only currently does
 * positive integers, but it should be simple enough to add the
 * negative case if a use comes along.
 */
unsigned char *
asn1_encode_integer(unsigned char *data, const unsigned char *end_data,
                    s64 integer)
{
        int data_len = end_data - data;
        unsigned char *d = &data[2];
        bool found = false;
        int i;

        if (WARN(integer < 0,
                 "BUG: integer encode only supports positive integers"))
                return ERR_PTR(-EINVAL);

        if (IS_ERR(data))
                return data;

        /* need at least 3 bytes for tag, length and integer encoding */
        if (data_len < 3)
                return ERR_PTR(-EINVAL);

        /* remaining length where at d (the start of the integer encoding) */
        data_len -= 2;

        data[0] = _tag(UNIV, PRIM, INT);
        if (integer == 0) {
                *d++ = 0;
                goto out;
        }

        for (i = sizeof(integer); i > 0 ; i--) {
                int byte = integer >> (8 * (i - 1));

                if (!found && byte == 0)
                        continue;

                /*
                 * for a positive number the first byte must have bit
                 * 7 clear in two's complement (otherwise it's a
                 * negative number) so prepend a leading zero if
                 * that's not the case
                 */
                if (!found && (byte & 0x80)) {
                        /*
                         * no check needed here, we already know we
                         * have len >= 1
                         */
                        *d++ = 0;
                        data_len--;
                }

                found = true;
                if (data_len == 0)
                        return ERR_PTR(-EINVAL);

                *d++ = byte;
                data_len--;
        }

 out:
        data[1] = d - data - 2;

        return d;
}
EXPORT_SYMBOL_GPL(asn1_encode_integer);

/* calculate the base 128 digit values setting the top bit of the first octet */
static int asn1_encode_oid_digit(unsigned char **_data, int *data_len, u32 oid)
{
        unsigned char *data = *_data;
        int start = 7 + 7 + 7 + 7;
        int ret = 0;

        if (*data_len < 1)
                return -EINVAL;

        /* quick case */
        if (oid == 0) {
                *data++ = 0x80;
                (*data_len)--;
                goto out;
        }

        while (oid >> start == 0)
                start -= 7;

        while (start > 0 && *data_len > 0) {
                u8 byte;

                byte = oid >> start;
                oid = oid - (byte << start);
                start -= 7;
                byte |= 0x80;
                *data++ = byte;
                (*data_len)--;
        }

        if (*data_len > 0) {
                *data++ = oid;
                (*data_len)--;
        } else {
                ret = -EINVAL;
        }

 out:
        *_data = data;
        return ret;
}

/**
 * asn1_encode_oid() - encode an oid to ASN.1
 * @data:       position to begin encoding at
 * @end_data:   end of data pointer, points one beyond last usable byte in @data
 * @oid:        array of oids
 * @oid_len:    length of oid array
 *
 * this encodes an OID up to ASN.1 when presented as an array of OID values
 */
unsigned char *
asn1_encode_oid(unsigned char *data, const unsigned char *end_data,
                u32 oid[], int oid_len)
{
        int data_len = end_data - data;
        unsigned char *d = data + 2;
        int i, ret;

        if (WARN(oid_len < 2, "OID must have at least two elements"))
                return ERR_PTR(-EINVAL);

        if (WARN(oid_len > 32, "OID is too large"))
                return ERR_PTR(-EINVAL);

        if (IS_ERR(data))
                return data;


        /* need at least 3 bytes for tag, length and OID encoding */
        if (data_len < 3)
                return ERR_PTR(-EINVAL);

        data[0] = _tag(UNIV, PRIM, OID);
        *d++ = oid[0] * 40 + oid[1];

        data_len -= 3;

        for (i = 2; i < oid_len; i++) {
                ret = asn1_encode_oid_digit(&d, &data_len, oid[i]);
                if (ret < 0)
                        return ERR_PTR(ret);
        }

        data[1] = d - data - 2;

        return d;
}
EXPORT_SYMBOL_GPL(asn1_encode_oid);

/**
 * asn1_encode_length() - encode a length to follow an ASN.1 tag
 * @data: pointer to encode at
 * @data_len: pointer to remaining length (adjusted by routine)
 * @len: length to encode
 *
 * This routine can encode lengths up to 65535 using the ASN.1 rules.
 * It will accept a negative length and place a zero length tag
 * instead (to keep the ASN.1 valid).  This convention allows other
 * encoder primitives to accept negative lengths as singalling the
 * sequence will be re-encoded when the length is known.
 */
static int asn1_encode_length(unsigned char **data, int *data_len, int len)
{
        if (*data_len < 1)
                return -EINVAL;

        if (len < 0) {
                *((*data)++) = 0;
                (*data_len)--;
                return 0;
        }

        if (len <= 0x7f) {
                *((*data)++) = len;
                (*data_len)--;
                return 0;
        }

        if (*data_len < 2)
                return -EINVAL;

        if (len <= 0xff) {
                *((*data)++) = 0x81;
                *((*data)++) = len & 0xff;
                *data_len -= 2;
                return 0;
        }

        if (*data_len < 3)
                return -EINVAL;

        if (len <= 0xffff) {
                *((*data)++) = 0x82;
                *((*data)++) = (len >> 8) & 0xff;
                *((*data)++) = len & 0xff;
                *data_len -= 3;
                return 0;
        }

        if (WARN(len > 0xffffff, "ASN.1 length can't be > 0xffffff"))
                return -EINVAL;

        if (*data_len < 4)
                return -EINVAL;
        *((*data)++) = 0x83;
        *((*data)++) = (len >> 16) & 0xff;
        *((*data)++) = (len >> 8) & 0xff;
        *((*data)++) = len & 0xff;
        *data_len -= 4;

        return 0;
}

/**
 * asn1_encode_tag() - add a tag for optional or explicit value
 * @data:       pointer to place tag at
 * @end_data:   end of data pointer, points one beyond last usable byte in @data
 * @tag:        tag to be placed
 * @string:     the data to be tagged
 * @len:        the length of the data to be tagged
 *
 * Note this currently only handles short form tags < 31.
 *
 * Standard usage is to pass in a @tag, @string and @length and the
 * @string will be ASN.1 encoded with @tag and placed into @data.  If
 * the encoding would put data past @end_data then an error is
 * returned, otherwise a pointer to a position one beyond the encoding
 * is returned.
 *
 * To encode in place pass a NULL @string and -1 for @len and the
 * maximum allowable beginning and end of the data; all this will do
 * is add the current maximum length and update the data pointer to
 * the place where the tag contents should be placed is returned.  The
 * data should be copied in by the calling routine which should then
 * repeat the prior statement but now with the known length.  In order
 * to avoid having to keep both before and after pointers, the repeat
 * expects to be called with @data pointing to where the first encode
 * returned it and still NULL for @string but the real length in @len.
 */
unsigned char *
asn1_encode_tag(unsigned char *data, const unsigned char *end_data,
                u32 tag, const unsigned char *string, int len)
{
        int data_len = end_data - data;
        int ret;

        if (WARN(tag > 30, "ASN.1 tag can't be > 30"))
                return ERR_PTR(-EINVAL);

        if (!string && WARN(len > 127,
                            "BUG: recode tag is too big (>127)"))
                return ERR_PTR(-EINVAL);

        if (IS_ERR(data))
                return data;

        if (!string && len > 0) {
                /*
                 * we're recoding, so move back to the start of the
                 * tag and install a dummy length because the real
                 * data_len should be NULL
                 */
                data -= 2;
                data_len = 2;
        }

        if (data_len < 2)
                return ERR_PTR(-EINVAL);

        *(data++) = _tagn(CONT, CONS, tag);
        data_len--;
        ret = asn1_encode_length(&data, &data_len, len);
        if (ret < 0)
                return ERR_PTR(ret);

        if (!string)
                return data;

        if (data_len < len)
                return ERR_PTR(-EINVAL);

        memcpy(data, string, len);
        data += len;

        return data;
}
EXPORT_SYMBOL_GPL(asn1_encode_tag);

/**
 * asn1_encode_octet_string() - encode an ASN.1 OCTET STRING
 * @data:       pointer to encode at
 * @end_data:   end of data pointer, points one beyond last usable byte in @data
 * @string:     string to be encoded
 * @len:        length of string
 *
 * Note ASN.1 octet strings may contain zeros, so the length is obligatory.
 */
unsigned char *
asn1_encode_octet_string(unsigned char *data,
                         const unsigned char *end_data,
                         const unsigned char *string, u32 len)
{
        int data_len = end_data - data;
        int ret;

        if (IS_ERR(data))
                return data;

        /* need minimum of 2 bytes for tag and length of zero length string */
        if (data_len < 2)
                return ERR_PTR(-EINVAL);

        *(data++) = _tag(UNIV, PRIM, OTS);
        data_len--;

        ret = asn1_encode_length(&data, &data_len, len);
        if (ret)
                return ERR_PTR(ret);

        if (data_len < len)
                return ERR_PTR(-EINVAL);

        memcpy(data, string, len);
        data += len;

        return data;
}
EXPORT_SYMBOL_GPL(asn1_encode_octet_string);

/**
 * asn1_encode_sequence() - wrap a byte stream in an ASN.1 SEQUENCE
 * @data:       pointer to encode at
 * @end_data:   end of data pointer, points one beyond last usable byte in @data
 * @seq:        data to be encoded as a sequence
 * @len:        length of the data to be encoded as a sequence
 *
 * Fill in a sequence.  To encode in place, pass NULL for @seq and -1
 * for @len; then call again once the length is known (still with NULL
 * for @seq). In order to avoid having to keep both before and after
 * pointers, the repeat expects to be called with @data pointing to
 * where the first encode placed it.
 */
unsigned char *
asn1_encode_sequence(unsigned char *data, const unsigned char *end_data,
                     const unsigned char *seq, int len)
{
        int data_len = end_data - data;
        int ret;

        if (!seq && WARN(len > 127,
                         "BUG: recode sequence is too big (>127)"))
                return ERR_PTR(-EINVAL);

        if (IS_ERR(data))
                return data;

        if (!seq && len >= 0) {
                /*
                 * we're recoding, so move back to the start of the
                 * sequence and install a dummy length because the
                 * real length should be NULL
                 */
                data -= 2;
                data_len = 2;
        }

        if (data_len < 2)
                return ERR_PTR(-EINVAL);

        *(data++) = _tag(UNIV, CONS, SEQ);
        data_len--;

        ret = asn1_encode_length(&data, &data_len, len);
        if (ret)
                return ERR_PTR(ret);

        if (!seq)
                return data;

        if (data_len < len)
                return ERR_PTR(-EINVAL);

        memcpy(data, seq, len);
        data += len;

        return data;
}
EXPORT_SYMBOL_GPL(asn1_encode_sequence);

/**
 * asn1_encode_boolean() - encode a boolean value to ASN.1
 * @data:       pointer to encode at
 * @end_data:   end of data pointer, points one beyond last usable byte in @data
 * @val:        the boolean true/false value
 */
unsigned char *
asn1_encode_boolean(unsigned char *data, const unsigned char *end_data,
                    bool val)
{
        int data_len = end_data - data;

        if (IS_ERR(data))
                return data;

        /* booleans are 3 bytes: tag, length == 1 and value == 0 or 1 */
        if (data_len < 3)
                return ERR_PTR(-EINVAL);

        *(data++) = _tag(UNIV, PRIM, BOOL);
        data_len--;

        asn1_encode_length(&data, &data_len, 1);

        if (val)
                *(data++) = 1;
        else
                *(data++) = 0;

        return data;
}
EXPORT_SYMBOL_GPL(asn1_encode_boolean);

MODULE_DESCRIPTION("Simple encoder primitives for ASN.1 BER/DER/CER");
MODULE_LICENSE("GPL");