/* $OpenBSD: ber_test.c,v 1.20 2019/10/24 12:39:26 tb Exp $
*/
/*
 * Copyright (c) Rob Pierce <rob@openbsd.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <sys/types.h>

#include <ber.h>
#include <errno.h>
#include <stdio.h>
#include <string.h>

#define SUCCEED 0
#define FAIL    1

struct test_vector {
        int              fail;          /* 1 means test is expected to fail */
        int              memcheck;      /* 1 when short forms used */
        char             title[128];
        size_t           length;
        unsigned char    input[1024];
};

struct test_vector test_vectors[] = {
        {
                SUCCEED,
                1,
                "boolean",
                3,
                {
                        0x01, 0x01, 0xff
                },
        },
        {
                FAIL,
                0,
                "boolean (constructed - expected failure)",
                3,
                {
                        0x21, 0x01, 0xff
                },
        },
        {
                FAIL,
                0,
                "boolean (more than 1 content octet - expected failure)",
                4,
                {
                        0x01, 0x02, 0x00, 0xff
                },
        },
        {
                SUCCEED,
                1,
                "enum",
                3,
                {
                        0x0a, 0x01, 0x00
                },
        },
        {
                FAIL,
                0,
                "enum (constructed - expected failure)",
                3,
                {
                        0x2a, 0x01, 0x00
                },
        },
        {
                FAIL,
                0,
                "enum minimal contents octets (expected failure)",
                4,
                {
                        0x0a, 0x02, 0x00, 0x01
                },
        },
        {
                SUCCEED,
                1,
                "integer (zero)",
                3,
                {
                        0x02, 0x01, 0x00
                },
        },
        {
                FAIL,
                0,
                "integer (constructed - expected failure)",
                3,
                {
                        0x22, 0x01, 0x01
                },
        },
        {
                SUCCEED,
                1,
                "positive integer",
                3,
                {
                        0x02, 0x01, 0x63
                },
        },
        {
                SUCCEED,
                1,
                "large positive integer",
                5,
                {
                        0x02, 0x03, 0x01, 0x00, 0x00
                },
        },
        {
                SUCCEED,
                1,
                "negative integer",
                4,
                {
                        0x02, 0x02, 0xff, 0x7f
                },
        },
        {
                FAIL,
                0,
                "integer minimal contents octets (expected failure)",
                4,
                {
                        0x02, 0x02, 0x00, 0x01
                },
        },
        {
                SUCCEED,
                1,
                "bit string",
                6,
                {
                        0x03, 0x04, 0xde, 0xad, 0xbe, 0xef
                },
        },
        {
                SUCCEED,
                1,
                "octet string",
                10,
                {
                        0x04, 0x08, 0x01, 0x23, 0x45,
                        0x67, 0x89, 0xab, 0xcd, 0xef
                },
        },
        {
                SUCCEED,
                1,
                "null",
                2,
                {
                        0x05, 0x00
                },
        },
        {
                FAIL,
                0,
                "null (constructed - expected failure)",
                2,
                {
                        0x25, 0x00
                },
        },
        {
                SUCCEED,
                1,
                "object identifier",
                8,
                {
                        0x06, 0x06, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d
                }
        },
        {
                SUCCEED,
                1,
                "sequence",     /* ldap */
                14,
                {
                        0x30, 0x0c, 0x02, 0x01, 0x01, 0x60, 0x07, 0x02,
                        0x01, 0x03, 0x04, 0x00, 0x80, 0x00
                }
        },
        {
                SUCCEED,
                1,
                "ldap bind",
                30,
                {
                        0x30, 0x1c, 0x02, 0x01, 0x01, 0x60, 0x17, 0x02,
                        0x01, 0x03, 0x04, 0x08, 0x63, 0x6e, 0x3d, 0x61,
                        0x64, 0x6d, 0x69, 0x6e, 0x80, 0x08, 0x70, 0x61,
                        0x73, 0x73, 0x77, 0x6f, 0x72, 0x64
                }
        },
        {
                SUCCEED,
                1,
                "ldap search",
                37,
                {
                        0x30, 0x23, 0x02, 0x01, 0x01, 0x60, 0x1e, 0x04,
                        0x09, 0x6f, 0x75, 0x3d, 0x70, 0x65, 0x6f, 0x70,
                        0x6c, 0x65, 0x0a, 0x01, 0x00, 0x0a, 0x01, 0x00,
                        0x02, 0x01, 0x00, 0x02, 0x01, 0x00, 0x01, 0x01,
                        0x00, 0x04, 0x02, 0x63, 0x6e
                }
        },
        {
                SUCCEED,
                1,
                "snmpd encode",
                15,
                {
                        0x30, 0x0d, 0x02, 0x01, 0x01, 0x02, 0x02, 0x20,
                        0x00, 0x04, 0x01, 0x01, 0x02, 0x01, 0x03
                }
        },
        {
                SUCCEED,
                1,
                "set with integer and boolean",
                8,
                {
                        0x31, 0x06, 0x02, 0x01, 0x04, 0x01, 0x01, 0xff
                }
        },
        {
                FAIL,
                0,
                "indefinite encoding (expected failure)",
                4,
                {
                        0x30, 0x80, 0x00, 0x00
                }
        },
        {
                FAIL,
                0,
                "reserved for future use (expected failure)",
                4,
                {
                        0x30, 0xff, 0x01, 0x01
                }
        },
        {
                FAIL,
                0,
                "long form tagging prohibited (expected failure)",
                5,
                {
                        0x1f, 0x80, 0x02, 0x01, 0x01
                },
        },
        {
                SUCCEED,
                0,
                "max long form length octets (i.e. 4 bytes)", 
                7,
                {
                        0x02, 0x84, 0x00, 0x00, 0x00, 0x01, 0x01
                },
        },
        {
                FAIL,
                0,
                "overflow long form length octets (expected failure)",
                8,
                {
                        0x02, 0x85, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01
                },
        },
        {
                FAIL,
                0,
                "incorrect length - not enough data (expected failure)",
                3,
                {
                        0x02, 0x02, 0x01
                }
        }
};

static void
hexdump(const unsigned char *buf, size_t len)
{
        size_t  i;

        for (i = 1; i < len; i++)
                fprintf(stderr, " 0x%02hhx,%s", buf[i - 1], i % 8 ? "": "\n");

        fprintf(stderr, " 0x%02hhx", buf[i - 1]);
        fprintf(stderr, "\n");
}

unsigned int
ldap_application(struct ber_element *elm)
{
        return BER_TYPE_OCTETSTRING;
}

static int
test(int i)
{
        int                      pos, b;
        char                    *string;
        void                    *p = NULL;
        ssize_t                  len = 0;
        struct ber_element      *elm = NULL, *ptr = NULL;
        struct ber               ber;
        long long                val;
        void                    *bstring = NULL;
        struct ber_oid           oid;
        struct ber_octetstring   ostring;

        bzero(&ber, sizeof(ber));
        ober_set_readbuf(&ber, test_vectors[i].input, test_vectors[i].length);
        ober_set_application(&ber, ldap_application);

        elm = ober_read_elements(&ber, elm);
        if (elm == NULL && test_vectors[i].fail &&
            (errno == EINVAL || errno == ERANGE || errno == ECANCELED))
                return 0;
        else if (elm != NULL && test_vectors[i].fail) {
                printf("expected failure of ober_read_elements did not occur\n");
                return 1;
        } else if (elm == NULL) {
                printf("unexpectedly failed ober_read_elements\n");
                return 1;
        }

        /*
         * short form tagged elements start at the 3rd octet (i.e. position 2).
         */
        if (test_vectors[i].memcheck) {
                pos = ober_getpos(elm);
                if (pos != 2) {
                        printf("unexpected element position within "
                            "byte stream\n");
                        return 1;
                }
        }

        switch (elm->be_encoding) {
        case BER_TYPE_EOC:
                if (ober_get_eoc(elm) == -1) {
                        printf("failed (eoc) encoding check\n");
                        return 1;
                }
                if (ober_scanf_elements(elm, ".", &val) == -1) {
                        printf("failed (eoc) ober_scanf_elements\n");
                        return 1;
                }
                break;
        case BER_TYPE_BOOLEAN:
                if (ober_get_boolean(elm, &b) == -1) {
                        printf("failed (boolean) encoding check\n");
                        return 1;
                }
                if (ober_scanf_elements(elm, "b", &b) == -1) {
                        printf("failed (boolean) ober_scanf_elements\n");
                        return 1;
                }
                break;
        case BER_TYPE_INTEGER:
                if (ober_get_integer(elm, &val) == -1) {
                        printf("failed (int) encoding check\n");
                        return 1;
                }
                if (ober_scanf_elements(elm, "i", &val) == -1) {
                        printf("failed (int) ober_scanf_elements (i)\n");
                        return 1;
                }
                if (ober_scanf_elements(elm, "d", &val) == -1) {
                        printf("failed (int) ober_scanf_elements (d)\n");
                        return 1;
                }
                break;
        case BER_TYPE_ENUMERATED:
                if (ober_get_enumerated(elm, &val) == -1) {
                        printf("failed (enum) encoding check\n");
                        return 1;
                }
                if (ober_scanf_elements(elm, "E", &val) == -1) {
                        printf("failed (enum) ober_scanf_elements (E)\n");
                        return 1;
                }
                break;
        case BER_TYPE_BITSTRING:
                if (ober_get_bitstring(elm, &bstring, &len) == -1) {
                        printf("failed (bit string) encoding check\n");
                        return 1;
                }
                break;
        case BER_TYPE_OCTETSTRING:
                if (ober_get_ostring(elm, &ostring) == -1) {
                        printf("failed (octet string) encoding check\n");
                        return 1;
                }
                if (ober_scanf_elements(elm, "s", &string) == -1) {
                        printf("failed (octet string) ober_scanf_elements\n");
                        return 1;
                }
                break;
        case BER_TYPE_NULL:
                if (ober_get_null(elm) == -1) {
                        printf("failed (null) encoding check\n");
                        return 1;
                }
                if (ober_scanf_elements(elm, "0", &val) == -1) {
                        printf("failed (null) ober_scanf_elements\n");
                        return 1;
                }
                break;
        case BER_TYPE_OBJECT:   /* OID */
                if (ober_get_oid(elm, &oid) == -1) {
                        printf("failed (oid) encoding check\n");
                        return 1;
                }
                if (ober_scanf_elements(elm, "o", &oid) == -1) {
                        printf("failed (oid) ober_scanf_elements\n");
                        return 1;
                }
                break;
        case BER_TYPE_SET:
        case BER_TYPE_SEQUENCE:
                if (elm->be_sub != NULL) {
                        ptr = elm->be_sub;
                        if (ober_getpos(ptr) <= pos) {
                                printf("unexpected element position within "
                                    "byte stream\n");
                                return 1;
                        }
                } else {
                        printf("expected sub element was not present\n");
                        return 1;
                }
                break;
        default:
                printf("failed with unknown encoding (%ud)\n",
                    elm->be_encoding);
                return 1;
        }

        /*
         * additional testing on short form encoding
         */
        if (test_vectors[i].memcheck) {
                len = ober_calc_len(elm);
                if (len != test_vectors[i].length) {
                        printf("failed to calculate length\n");
                        return 1;
                }

                ber.br_wbuf = NULL;
                len = ober_write_elements(&ber, elm);
                if (len != test_vectors[i].length) {
                        printf("failed length check (was %zd want "
                            "%zd)\n", len, test_vectors[i].length);
                        return 1;
                }

                if (memcmp(ber.br_wbuf, test_vectors[i].input,
                    test_vectors[i].length) != 0) {
                        printf("failed byte stream compare\n");
                        printf("Got:\n");
                        hexdump(ber.br_wbuf, len);
                        printf("Expected:\n");
                        hexdump(test_vectors[i].input, test_vectors[i].length);
                        return 1;
                }
                ober_free(&ber);

        }
        ober_free_elements(elm);

        return 0;
}

int
test_ber_printf_elements_integer(void) {
        int                      val = 1, len = 0;
        struct ber_element      *elm = NULL;
        struct ber               ber;

        unsigned char            exp[3] = { 0x02, 0x01, 0x01 };

        elm = ober_printf_elements(elm, "d", val);
        if (elm == NULL) {
                printf("failed ober_printf_elements\n");
                return 1;
        }

        bzero(&ber, sizeof(ber));
        ber.br_wbuf = NULL;
        len = ober_write_elements(&ber, elm);
        if (len != sizeof(exp)) {
                printf("failed length check (was %d want %zd)\n", len,
                    sizeof(exp));
                return 1;
        }

        if (memcmp(ber.br_wbuf, exp, len) != 0) {
                printf("failed (int) byte stream compare\n");
                return 1;
        }

        ober_free_elements(elm);
        ober_free(&ber);
        return 0;
}

#define LDAP_REQ_BIND           0
#define LDAP_REQ_SEARCH         0
#define VERSION                 3
#define LDAP_AUTH_SIMPLE        0

int
test_ber_printf_elements_ldap_bind(void) {
        int                      len = 0, msgid = 1;
        char                    *binddn = "cn=admin";
        char                    *bindcred = "password";
        struct ber_element      *root = NULL, *elm = NULL;
        struct ber               ber;

        unsigned char            exp[] = {
                0x30, 0x1c,
                0x02, 0x01, 0x01,
                0x60, 0x17,
                0x02, 0x01, 0x03,
                0x04, 0x08, 0x63, 0x6e, 0x3d, 0x61, 0x64, 0x6d, 0x69, 0x6e,
                0x80, 0x08, 0x70, 0x61, 0x73, 0x73, 0x77, 0x6f, 0x72, 0x64
        };

        if ((root = ober_add_sequence(NULL)) == NULL)
                return 1;

        elm = ober_printf_elements(root, "d{tdsst", msgid,
            BER_CLASS_APP, LDAP_REQ_BIND,
            VERSION,
            binddn, bindcred,
            BER_CLASS_CONTEXT, LDAP_AUTH_SIMPLE);

        if (elm == NULL) {
                printf("failed ober_printf_elements\n");
                return 1;
        }

        bzero(&ber, sizeof(ber));
        ber.br_wbuf = NULL;
        ober_set_application(&ber, ldap_application);
        len = ober_write_elements(&ber, root);
        if (len != sizeof(exp)) {
                printf("failed length check (was %d want %zd)\n", len,
                    sizeof(exp));
                return 1;
        }

        if (memcmp(ber.br_wbuf, exp, len) != 0) {
                printf("failed (ldap bind) byte stream compare\n");
                hexdump(ber.br_wbuf, len);
                return 1;
        }

        ober_free_elements(elm);
        ober_free(&ber);
        return 0;
}

int
test_ber_printf_elements_ldap_search(void) {
        int                      len = 0, msgid = 1;
        int                      sizelimit = 0, timelimit = 0;
        int                      typesonly = 0;
        long long                scope = 0, deref = 0;
        char                    *basedn = "ou=people";
        char                    *filter = "cn";
        struct ber_element      *root = NULL, *elm = NULL, *felm = NULL;
        struct ber               ber;

        unsigned char            exp[] = {
                0x30, 0x23, 0x02, 0x01, 0x01, 0x60, 0x1e, 0x04,
                0x09, 0x6f, 0x75, 0x3d, 0x70, 0x65, 0x6f, 0x70,
                0x6c, 0x65, 0x0a, 0x01, 0x00, 0x0a, 0x01, 0x00,
                0x02, 0x01, 0x00, 0x02, 0x01, 0x00, 0x01, 0x01,
                0x00, 0x04, 0x02, 0x63, 0x6e
        };

        if ((root = ober_add_sequence(NULL)) == NULL)
                return 1;

        elm = ober_printf_elements(root, "d{tsEEddbs",
            msgid, BER_CLASS_APP, LDAP_REQ_SEARCH,
            basedn, scope, deref, sizelimit, timelimit, typesonly, filter);
        if (elm == NULL) {
                printf("failed ober_printf_elements\n");
                return 1;
        }

        bzero(&ber, sizeof(ber));
        ber.br_wbuf = NULL;
        ober_set_application(&ber, ldap_application);
        len = ober_write_elements(&ber, root);
        if (len != sizeof(exp)) {
                printf("failed length check (was %d want %zd)\n", len,
                    sizeof(exp));
                return 1;
        }

        if (memcmp(ber.br_wbuf, exp, len) != 0) {
                printf("failed (ldap search) byte stream compare\n");
                hexdump(ber.br_wbuf, len);
                return 1;
        }

        ober_free_elements(elm);
        ober_free(&ber);
        return 0;
}

int
test_ber_printf_elements_snmp_v3_encode(void) {
        int                      len = 0;
        u_int8_t                 f = 0x01;      /* verbose */
        long long                secmodel = 3;  /* USM */
        long long                msgid = 1, max_msg_size = 8192;
        struct ber_element      *elm = NULL;
        struct ber               ber;

        unsigned char            exp[] = {
                0x30, 0x0d, 0x02, 0x01, 0x01, 0x02, 0x02, 0x20,
                0x00, 0x04, 0x01, 0x01, 0x02, 0x01, 0x03
        };

        elm = ober_printf_elements(elm, "{iixi}", msgid, max_msg_size,
            &f, sizeof(f), secmodel);
        if (elm == NULL) {
                printf("failed ober_printf_elements\n");
                return 1;
        }

        bzero(&ber, sizeof(ber));
        ber.br_wbuf = NULL;
        len = ober_write_elements(&ber, elm);
        if (len != sizeof(exp)) {
                printf("failed length check (was %d want %zd)\n", len,
                    sizeof(exp));
                return 1;
        }

        if (memcmp(ber.br_wbuf, exp, len) != 0) {
                printf("failed (snmp_v3_encode) byte stream compare\n");
                hexdump(ber.br_wbuf, len);
                return 1;
        }

        ober_free_elements(elm);
        ober_free(&ber);
        return 0;
}

int
test_ber_null(void)
{
        long long                val;
        struct ber_element      *elm = NULL;

        /* scanning into a null ber_element should fail */
        if (ober_scanf_elements(elm, "0", &val) != -1) {
                printf("failed (null ber_element) ober_scanf_elements empty\n");
                goto fail;
        }

        if ((elm = ober_printf_elements(elm, "{d}", 1)) == NULL) {
                printf("failed (null ber_element) ober_printf_elements\n");
        }

        /*
         * Scanning after the last valid element should be able to descend back
         * into the parent level.
         */
        if (ober_scanf_elements(elm, "{i}", &val) != 0) {
                printf("failed (null ber_element) ober_scanf_elements valid\n");
                goto fail;
        }
        /*
         * Scanning for a non-existent element should fail, even if it's just a
         * skip.
         */
        if (ober_scanf_elements(elm, "{lS}", &val) != -1) {
                printf("failed (null ber_element) ober_scanf_elements invalid\n");
                goto fail;
        }

        ober_free_elements(elm);
        return 0;

fail:
        ober_free_elements(elm);
        return 1;
}

int
main(void)
{
        extern char *__progname;

        ssize_t         len = 0;
        int             i, ret = 0;

        /*
         * drive test vectors for ber byte stream input validation, etc.
         */
        for (i = 0; i < sizeof(test_vectors) / sizeof(test_vectors[0]); i++) {
                if (test(i) != 0) {
                        printf("FAILED: %s\n", test_vectors[i].title);
                        ret = 1;
                } else
                        printf("SUCCESS: %s\n", test_vectors[i].title);
        }

        /*
         * run standalone functions for ber byte stream creation, etc.
         * (e.g. ldap, snmpd)
         */
        if (test_ber_printf_elements_integer() != 0) {
                printf("FAILED: test_ber_printf_elements_integer\n");
                ret = 1;
        } else
                printf("SUCCESS: test_ber_printf_elements_integer\n");

        if (test_ber_printf_elements_ldap_bind() != 0) {
                printf("FAILED: test_ber_printf_elements_ldap_bind\n");
                ret = 1;
        } else
                printf("SUCCESS: test_ber_printf_elements_ldap_bind\n");

        if (test_ber_printf_elements_ldap_search() != 0) {
                printf("FAILED: test_ber_printf_elements_ldap_search\n");
                ret = 1;
        } else
                printf("SUCCESS: test_ber_printf_elements_ldap_search\n");

        if (test_ber_printf_elements_snmp_v3_encode() != 0) {
                printf("FAILED: test_ber_printf_elements_snmpd_v3_encode\n");
                ret = 1;
        } else
                printf("SUCCESS: test_ber_printf_elements_snmpd_v3_encode\n");

        if (test_ber_null() != 0) {
                printf("FAILED: test_ber_null\n");
                ret = 1;
        } else
                printf("SUCCESS: test_ber_null\n");

        if (ret != 0) {
                printf("FAILED: %s\n", __progname);
                return 1;
        }

        return 0;
}