/*
- * Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2017-2021 The OpenSSL Project Authors. All Rights Reserved.
*
- * Licensed under the OpenSSL license (the "License"). You may not use
+ * Licensed under the Apache License 2.0 (the "License"). You may not use
* this file except in compliance with the License. You can obtain a copy
* in the file LICENSE in the source distribution or at
* https://www.openssl.org/source/license.html
ENCDEC_DATA(-1, -1), \
ENCDEC_DATA(0, ASN1_LONG_UNDEF)
-#if OPENSSL_API_COMPAT < 0x10200000L
+#ifndef OPENSSL_NO_DEPRECATED_3_0
/***** LONG ******************************************************************/
typedef struct {
} ASN1_LONG_DATA;
ASN1_SEQUENCE(ASN1_LONG_DATA) = {
- ASN1_SIMPLE(ASN1_LONG_DATA, success, ASN1_FBOOLEAN),
+ ASN1_SIMPLE(ASN1_LONG_DATA, success, ASN1_BOOLEAN),
ASN1_SIMPLE(ASN1_LONG_DATA, test_long, LONG),
ASN1_EXP_OPT(ASN1_LONG_DATA, test_zlong, ZLONG, 0)
} static_ASN1_SEQUENCE_END(ASN1_LONG_DATA)
} ASN1_INT32_DATA;
ASN1_SEQUENCE(ASN1_INT32_DATA) = {
- ASN1_SIMPLE(ASN1_INT32_DATA, success, ASN1_FBOOLEAN),
+ ASN1_SIMPLE(ASN1_INT32_DATA, success, ASN1_BOOLEAN),
ASN1_EMBED(ASN1_INT32_DATA, test_int32, INT32),
ASN1_EXP_OPT_EMBED(ASN1_INT32_DATA, test_zint32, ZINT32, 0)
} static_ASN1_SEQUENCE_END(ASN1_INT32_DATA)
} ASN1_UINT32_DATA;
ASN1_SEQUENCE(ASN1_UINT32_DATA) = {
- ASN1_SIMPLE(ASN1_UINT32_DATA, success, ASN1_FBOOLEAN),
+ ASN1_SIMPLE(ASN1_UINT32_DATA, success, ASN1_BOOLEAN),
ASN1_EMBED(ASN1_UINT32_DATA, test_uint32, UINT32),
ASN1_EXP_OPT_EMBED(ASN1_UINT32_DATA, test_zuint32, ZUINT32, 0)
} static_ASN1_SEQUENCE_END(ASN1_UINT32_DATA)
} ASN1_INT64_DATA;
ASN1_SEQUENCE(ASN1_INT64_DATA) = {
- ASN1_SIMPLE(ASN1_INT64_DATA, success, ASN1_FBOOLEAN),
+ ASN1_SIMPLE(ASN1_INT64_DATA, success, ASN1_BOOLEAN),
ASN1_EMBED(ASN1_INT64_DATA, test_int64, INT64),
ASN1_EXP_OPT_EMBED(ASN1_INT64_DATA, test_zint64, ZINT64, 0)
} static_ASN1_SEQUENCE_END(ASN1_INT64_DATA)
CUSTOM_EXPECTED_FAILURE, /* t_8bytes_3_pad (illegal padding) */
CUSTOM_EXPECTED_SUCCESS(INT64_MIN, INT64_MIN), /* t_8bytes_4_neg */
CUSTOM_EXPECTED_FAILURE, /* t_8bytes_5_negpad (illegal padding) */
- CUSTOM_EXPECTED_SUCCESS(0x1ffffffff, 0x1ffffffff), /* t_5bytes_1 */
+ CUSTOM_EXPECTED_SUCCESS(0x1ffffffffULL, 0x1ffffffffULL), /* t_5bytes_1 */
CUSTOM_EXPECTED_SUCCESS(0x80000000, 0x80000000), /* t_4bytes_1 */
CUSTOM_EXPECTED_SUCCESS(INT32_MAX - 1, INT32_MAX -1), /* t_4bytes_2 */
CUSTOM_EXPECTED_FAILURE, /* t_4bytes_3_pad (illegal padding) */
} ASN1_UINT64_DATA;
ASN1_SEQUENCE(ASN1_UINT64_DATA) = {
- ASN1_SIMPLE(ASN1_UINT64_DATA, success, ASN1_FBOOLEAN),
+ ASN1_SIMPLE(ASN1_UINT64_DATA, success, ASN1_BOOLEAN),
ASN1_EMBED(ASN1_UINT64_DATA, test_uint64, UINT64),
ASN1_EXP_OPT_EMBED(ASN1_UINT64_DATA, test_zuint64, ZUINT64, 0)
} static_ASN1_SEQUENCE_END(ASN1_UINT64_DATA)
CUSTOM_EXPECTED_FAILURE, /* t_8bytes_3_pad */
CUSTOM_EXPECTED_FAILURE, /* t_8bytes_4_neg */
CUSTOM_EXPECTED_FAILURE, /* t_8bytes_5_negpad */
- CUSTOM_EXPECTED_SUCCESS(0x1ffffffff, 0x1ffffffff), /* t_5bytes_1 */
+ CUSTOM_EXPECTED_SUCCESS(0x1ffffffffULL, 0x1ffffffffULL), /* t_5bytes_1 */
CUSTOM_EXPECTED_SUCCESS(0x80000000, 0x80000000), /* t_4bytes_1 */
CUSTOM_EXPECTED_SUCCESS(INT32_MAX - 1, INT32_MAX -1), /* t_4bytes_2 */
CUSTOM_EXPECTED_FAILURE, /* t_4bytes_3_pad (illegal padding) */
if (pp != NULL) {
if (lenbytes == 1) {
- *(*pp)++ = len;
+ *(*pp)++ = (unsigned char)len;
} else {
- *(*pp)++ = lenbytes - 1;
+ *(*pp)++ = (unsigned char)(lenbytes - 1);
if (lenbytes == 2) {
- *(*pp)++ = 0x80 | len;
+ *(*pp)++ = (unsigned char)(0x80 | len);
} else {
- *(*pp)++ = 0x80 | (len >> 8);
- *(*pp)++ = len & 0xff;
+ *(*pp)++ = (unsigned char)(0x80 | (len >> 8));
+ *(*pp)++ = (unsigned char)(len);
}
}
}
{
unsigned char *encoding = NULL;
/*
- * We force the defaults to be explicitely encoded to make sure we test
+ * We force the defaults to be explicitly encoded to make sure we test
* for defaults that shouldn't be present (i.e. we check for failure)
*/
size_t encoding_length = make_custom_der(custom_data, &encoding, 1);
static int do_print_item(const TEST_PACKAGE *package)
{
#define DATA_BUF_SIZE 256
- unsigned char buf[DATA_BUF_SIZE];
const ASN1_ITEM *i = ASN1_ITEM_ptr(package->asn1_type);
- ASN1_VALUE *o = (ASN1_VALUE *)&buf;
+ ASN1_VALUE *o;
int ret;
OPENSSL_assert(package->encode_expectations_elem_size <= DATA_BUF_SIZE);
+ if ((o = OPENSSL_malloc(DATA_BUF_SIZE)) == NULL)
+ return 0;
- (void)RAND_bytes(buf, (int)package->encode_expectations_elem_size);
+ (void)RAND_bytes((unsigned char*)o,
+ (int)package->encode_expectations_elem_size);
ret = ASN1_item_print(bio_err, o, 0, i, NULL);
+ OPENSSL_free(o);
return ret;
}
sizeof(test_custom_data) / sizeof(test_custom_data[0]));
for (i = 0; i < nelems; i++) {
size_t pos = i * package->encode_expectations_elem_size;
- switch (do_encode_custom((EXPECTED *)&((unsigned char *)package
- ->encode_expectations)[pos],
- &test_custom_data[i], package)) {
+ EXPECTED *expected
+ = (EXPECTED *)&((unsigned char *)package->encode_expectations)[pos];
+
+ switch (do_encode_custom(expected, &test_custom_data[i], package)) {
case -1:
- TEST_error("Failed custom encode round trip %u of %s",
- i, package->name);
- TEST_openssl_errors();
- fail++;
+ if (expected->success) {
+ TEST_error("Failed custom encode round trip %u of %s",
+ i, package->name);
+ TEST_openssl_errors();
+ fail++;
+ }
break;
case 0:
TEST_error("Custom encode round trip %u of %s mismatch",
OPENSSL_die("do_encode_custom() return unknown value",
__FILE__, __LINE__);
}
- switch (do_decode_custom(&test_custom_data[i],
- (EXPECTED *)&((unsigned char *)package
- ->encode_expectations)[pos],
+ switch (do_decode_custom(&test_custom_data[i], expected,
package->encode_expectations_elem_size,
package)) {
case -1:
- TEST_error("Failed custom decode round trip %u of %s",
- i, package->name);
- TEST_openssl_errors();
- fail++;
+ if (expected->success) {
+ TEST_error("Failed custom decode round trip %u of %s",
+ i, package->name);
+ TEST_openssl_errors();
+ fail++;
+ }
break;
case 0:
TEST_error("Custom decode round trip %u of %s mismatch",
nelems = package->encdec_data_size / package->encdec_data_elem_size;
for (i = 0; i < nelems; i++) {
size_t pos = i * package->encdec_data_elem_size;
- switch (do_enc_dec((EXPECTED *)&((unsigned char *)package
- ->encdec_data)[pos],
- package->encdec_data_elem_size,
- package)) {
+ EXPECTED *expected
+ = (EXPECTED *)&((unsigned char *)package->encdec_data)[pos];
+
+ switch (do_enc_dec(expected, package->encdec_data_elem_size, package)) {
case -1:
- TEST_error("Failed encode/decode round trip %u of %s",
- i, package->name);
- TEST_openssl_errors();
- fail++;
+ if (expected->success) {
+ TEST_error("Failed encode/decode round trip %u of %s",
+ i, package->name);
+ TEST_openssl_errors();
+ fail++;
+ }
break;
case 0:
TEST_error("Encode/decode round trip %u of %s mismatch",
return fail == 0;
}
-#if OPENSSL_API_COMPAT < 0x10200000L
+#ifndef OPENSSL_NO_DEPRECATED_3_0
static int test_long_32bit(void)
{
return test_intern(&long_test_package_32bit);
return test_intern(&uint64_test_package);
}
-void register_tests(void)
+typedef struct {
+ ASN1_STRING *invalidDirString;
+} INVALIDTEMPLATE;
+
+ASN1_SEQUENCE(INVALIDTEMPLATE) = {
+ /*
+ * DirectoryString is a CHOICE type so it must use explicit tagging -
+ * but we deliberately use implicit here, which makes this template invalid.
+ */
+ ASN1_IMP(INVALIDTEMPLATE, invalidDirString, DIRECTORYSTRING, 12)
+} static_ASN1_SEQUENCE_END(INVALIDTEMPLATE)
+
+IMPLEMENT_STATIC_ASN1_ENCODE_FUNCTIONS(INVALIDTEMPLATE)
+IMPLEMENT_STATIC_ASN1_ALLOC_FUNCTIONS(INVALIDTEMPLATE)
+
+static int test_invalid_template(void)
+{
+ INVALIDTEMPLATE *temp = INVALIDTEMPLATE_new();
+ int ret;
+
+ if (!TEST_ptr(temp))
+ return 0;
+
+ ret = i2d_INVALIDTEMPLATE(temp, NULL);
+
+ INVALIDTEMPLATE_free(temp);
+
+ /* We expect the i2d operation to fail */
+ return ret < 0;
+}
+
+
+int setup_tests(void)
{
-#if OPENSSL_API_COMPAT < 0x10200000L
+#ifndef OPENSSL_NO_DEPRECATED_3_0
ADD_TEST(test_long_32bit);
ADD_TEST(test_long_64bit);
#endif
ADD_TEST(test_uint32);
ADD_TEST(test_int64);
ADD_TEST(test_uint64);
+ ADD_TEST(test_invalid_template);
+ return 1;
}
projects / openssl.git / blobdiff