152 lines
5.5 KiB
C
152 lines
5.5 KiB
C
/*
|
|
* asn1.c: Unit tests for SimpleTLV parser and encoder
|
|
*
|
|
* Copyright (C) 2019 Red Hat, Inc.
|
|
*
|
|
* Author: Jakub Jelen <jjelen@redhat.com>
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "torture.h"
|
|
#include "libopensc/sc.c"
|
|
#include "libopensc/simpletlv.c"
|
|
|
|
static void torture_simpletlv_read_tag_null(void **state)
|
|
{
|
|
const u8 *data = NULL;
|
|
size_t datalen = 0;
|
|
u8 tag = 0;
|
|
size_t taglen = 0;
|
|
int rv;
|
|
|
|
rv = sc_simpletlv_read_tag(&data, datalen, &tag, &taglen);
|
|
assert_int_equal(rv, SC_ERROR_INVALID_TLV_OBJECT);
|
|
assert_int_equal(tag, 0);
|
|
assert_int_equal(taglen, 0);
|
|
}
|
|
|
|
#define TORTURE_READ_TAG(name, data, tag_value, len_value, error) \
|
|
static void torture_simpletlv_read_tag_## name (void **state) \
|
|
{ \
|
|
u8 buf[] = data; \
|
|
const u8 *bufptr = buf; \
|
|
size_t buflen = sizeof(buf) - 1; \
|
|
u8 tag = 0; \
|
|
size_t taglen = 0; \
|
|
int rv; \
|
|
\
|
|
rv = sc_simpletlv_read_tag(&bufptr, buflen, &tag, &taglen); \
|
|
assert_int_equal(rv, error); \
|
|
assert_int_equal(tag, tag_value); \
|
|
assert_int_equal(taglen, len_value); \
|
|
}
|
|
#define TORTURE_READ_TAG_SUCCESS(name, data, tag_value, len_value) \
|
|
TORTURE_READ_TAG(name, data, tag_value, len_value, SC_SUCCESS)
|
|
#define TORTURE_READ_TAG_ERROR(name, data, error) \
|
|
TORTURE_READ_TAG(name, data, 0, 0, error)
|
|
|
|
TORTURE_READ_TAG_ERROR(short, "\x42", SC_ERROR_INVALID_TLV_OBJECT)
|
|
TORTURE_READ_TAG_SUCCESS(minimal,
|
|
"\x42\x00", 0x42, 0)
|
|
TORTURE_READ_TAG_SUCCESS(minimal2,
|
|
"\x42\x00", 0x42, 0)
|
|
TORTURE_READ_TAG_SUCCESS(valid_short,
|
|
"\x42\x02\x01\x02", 0x42, 2)
|
|
TORTURE_READ_TAG_ERROR(incomplete_length,
|
|
"\x42\xff", SC_ERROR_INVALID_TLV_OBJECT)
|
|
TORTURE_READ_TAG_SUCCESS(long_length,
|
|
"\x42\xff\x00\x00", 0x42, 0)
|
|
TORTURE_READ_TAG(missing_data,
|
|
"\x42\xff\x02\x00", 0x42, 2, SC_ERROR_TLV_END_OF_CONTENTS)
|
|
TORTURE_READ_TAG_SUCCESS(valid_long,
|
|
"\x42\xff\x02\x00\x01\x02", 0x42, 2)
|
|
|
|
static void torture_simpletlv_put_tag_null(void **state)
|
|
{
|
|
u8 *data = NULL;
|
|
size_t datalen = 0;
|
|
u8 *outptr = NULL;
|
|
int rv;
|
|
|
|
rv = sc_simpletlv_put_tag(0x42, 2, data, datalen, &outptr);
|
|
assert_int_equal(rv, SC_ERROR_INVALID_ARGUMENTS);
|
|
assert_null(outptr);
|
|
}
|
|
|
|
#define TORTURE_PUT_TAG(name, tag, taglen, data_len, exp_data, error) \
|
|
static void torture_simpletlv_put_tag_## name(void **state) \
|
|
{ \
|
|
u8 data[data_len] = {}; \
|
|
size_t datalen = sizeof(data); \
|
|
u8 *outptr = NULL; \
|
|
int rv; \
|
|
\
|
|
rv = sc_simpletlv_put_tag(tag, taglen, data, datalen, &outptr); \
|
|
assert_int_equal(rv, error); \
|
|
assert_memory_equal(data, exp_data, MIN(sizeof(data), sizeof(exp_data))); \
|
|
if (rv == SC_SUCCESS) { \
|
|
assert_non_null(outptr); \
|
|
} else { \
|
|
assert_null(outptr); \
|
|
} \
|
|
}
|
|
#define TORTURE_PUT_TAG_ERROR(name, tag, taglen, data_len, error) \
|
|
TORTURE_PUT_TAG(name, tag, taglen, data_len, "", error)
|
|
#define TORTURE_PUT_TAG_SUCCESS(name, tag, taglen, data_len, exp_data) \
|
|
TORTURE_PUT_TAG(name, tag, taglen, data_len, exp_data, SC_SUCCESS)
|
|
|
|
TORTURE_PUT_TAG_ERROR(too_small, 0x42, 2, 1, SC_ERROR_INVALID_ARGUMENTS)
|
|
TORTURE_PUT_TAG_SUCCESS(valid_short, 0x42, 2, 2, "\x42\x02")
|
|
TORTURE_PUT_TAG_ERROR(invalid_tag, 0x00, 2, 2, SC_ERROR_INVALID_ARGUMENTS)
|
|
TORTURE_PUT_TAG_ERROR(invalid_tag2, 0xff, 2, 2, SC_ERROR_INVALID_ARGUMENTS)
|
|
TORTURE_PUT_TAG_SUCCESS(max_short, 0x42, 0xfe, 2, "\x42\xfe")
|
|
TORTURE_PUT_TAG_ERROR(too_long_length, 0x42, 512, 3, SC_ERROR_INVALID_ARGUMENTS)
|
|
TORTURE_PUT_TAG_SUCCESS(valid_long, 0x42, 512, 4, "\x42\xff\x00\x02")
|
|
TORTURE_PUT_TAG_SUCCESS(first_long, 0x42, 0xff, 4, "\x42\xff\xff\x00")
|
|
TORTURE_PUT_TAG_SUCCESS(last_long, 0x42, 0xffff, 4, "\x42\xff\xff\xff")
|
|
TORTURE_PUT_TAG_ERROR(too_large_length, 0x42, 0x10000, 4, SC_ERROR_WRONG_LENGTH)
|
|
|
|
int main(void)
|
|
{
|
|
int rc;
|
|
struct CMUnitTest tests[] = {
|
|
/* simpletlv_read_tag() */
|
|
cmocka_unit_test(torture_simpletlv_read_tag_null),
|
|
cmocka_unit_test(torture_simpletlv_read_tag_short),
|
|
cmocka_unit_test(torture_simpletlv_read_tag_minimal),
|
|
cmocka_unit_test(torture_simpletlv_read_tag_minimal2),
|
|
cmocka_unit_test(torture_simpletlv_read_tag_valid_short),
|
|
cmocka_unit_test(torture_simpletlv_read_tag_incomplete_length),
|
|
cmocka_unit_test(torture_simpletlv_read_tag_long_length),
|
|
cmocka_unit_test(torture_simpletlv_read_tag_missing_data),
|
|
cmocka_unit_test(torture_simpletlv_read_tag_valid_long),
|
|
/* simpletlv_put_tag() */
|
|
cmocka_unit_test(torture_simpletlv_put_tag_null),
|
|
cmocka_unit_test(torture_simpletlv_put_tag_too_small),
|
|
cmocka_unit_test(torture_simpletlv_put_tag_valid_short),
|
|
cmocka_unit_test(torture_simpletlv_put_tag_invalid_tag),
|
|
cmocka_unit_test(torture_simpletlv_put_tag_invalid_tag2),
|
|
cmocka_unit_test(torture_simpletlv_put_tag_max_short),
|
|
cmocka_unit_test(torture_simpletlv_put_tag_too_long_length),
|
|
cmocka_unit_test(torture_simpletlv_put_tag_valid_long),
|
|
cmocka_unit_test(torture_simpletlv_put_tag_first_long),
|
|
cmocka_unit_test(torture_simpletlv_put_tag_last_long),
|
|
cmocka_unit_test(torture_simpletlv_put_tag_too_large_length),
|
|
};
|
|
|
|
rc = cmocka_run_group_tests(tests, NULL, NULL);
|
|
return rc;
|
|
}
|