2501 lines
84 KiB
C
2501 lines
84 KiB
C
/*
|
|
* Copyright (c) 1999 - 2005 Kungliga Tekniska Högskolan
|
|
* (Royal Institute of Technology, Stockholm, Sweden).
|
|
* All rights reserved.
|
|
*
|
|
* Portions Copyright (c) 2009 Apple Inc. All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* 3. Neither the name of the Institute nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <config.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <err.h>
|
|
#include <roken.h>
|
|
|
|
#include <asn1-common.h>
|
|
#include <asn1_err.h>
|
|
#include <der.h>
|
|
#include <krb5_asn1.h>
|
|
#include <heim_asn1.h>
|
|
#include <rfc2459_asn1.h>
|
|
#include <x690sample_asn1.h>
|
|
#include <test_asn1.h>
|
|
#include <cms_asn1.h>
|
|
|
|
#include "check-common.h"
|
|
|
|
static char *lha_principal[] = { "lha" };
|
|
static char *lharoot_princ[] = { "lha", "root" };
|
|
static char *datan_princ[] = { "host", "nutcracker.e.kth.se" };
|
|
static char *nada_tgt_principal[] = { "krbtgt", "NADA.KTH.SE" };
|
|
|
|
static int
|
|
cmp_principal (void *a, void *b)
|
|
{
|
|
Principal *pa = a;
|
|
Principal *pb = b;
|
|
int i;
|
|
|
|
COMPARE_STRING(pa,pb,realm);
|
|
COMPARE_INTEGER(pa,pb,name.name_type);
|
|
COMPARE_INTEGER(pa,pb,name.name_string.len);
|
|
|
|
for (i = 0; i < pa->name.name_string.len; i++)
|
|
COMPARE_STRING(pa,pb,name.name_string.val[i]);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
test_principal (void)
|
|
{
|
|
|
|
struct test_case tests[] = {
|
|
{ NULL, 29,
|
|
"\x30\x1b\xa0\x10\x30\x0e\xa0\x03\x02\x01\x01\xa1\x07\x30\x05\x1b"
|
|
"\x03\x6c\x68\x61\xa1\x07\x1b\x05\x53\x55\x2e\x53\x45",
|
|
NULL
|
|
},
|
|
{ NULL, 35,
|
|
"\x30\x21\xa0\x16\x30\x14\xa0\x03\x02\x01\x01\xa1\x0d\x30\x0b\x1b"
|
|
"\x03\x6c\x68\x61\x1b\x04\x72\x6f\x6f\x74\xa1\x07\x1b\x05\x53\x55"
|
|
"\x2e\x53\x45",
|
|
NULL
|
|
},
|
|
{ NULL, 54,
|
|
"\x30\x34\xa0\x26\x30\x24\xa0\x03\x02\x01\x03\xa1\x1d\x30\x1b\x1b"
|
|
"\x04\x68\x6f\x73\x74\x1b\x13\x6e\x75\x74\x63\x72\x61\x63\x6b\x65"
|
|
"\x72\x2e\x65\x2e\x6b\x74\x68\x2e\x73\x65\xa1\x0a\x1b\x08\x45\x2e"
|
|
"\x4b\x54\x48\x2e\x53\x45",
|
|
NULL
|
|
}
|
|
};
|
|
|
|
|
|
Principal values[] = {
|
|
{ { KRB5_NT_PRINCIPAL, { 1, lha_principal } }, "SU.SE" },
|
|
{ { KRB5_NT_PRINCIPAL, { 2, lharoot_princ } }, "SU.SE" },
|
|
{ { KRB5_NT_SRV_HST, { 2, datan_princ } }, "E.KTH.SE" }
|
|
};
|
|
int i, ret;
|
|
int ntests = sizeof(tests) / sizeof(*tests);
|
|
|
|
for (i = 0; i < ntests; ++i) {
|
|
tests[i].val = &values[i];
|
|
if (asprintf (&tests[i].name, "Principal %d", i) < 0)
|
|
errx(1, "malloc");
|
|
if (tests[i].name == NULL)
|
|
errx(1, "malloc");
|
|
}
|
|
|
|
ret = generic_test (tests, ntests, sizeof(Principal),
|
|
(generic_encode)encode_Principal,
|
|
(generic_length)length_Principal,
|
|
(generic_decode)decode_Principal,
|
|
(generic_free)free_Principal,
|
|
cmp_principal,
|
|
NULL);
|
|
for (i = 0; i < ntests; ++i)
|
|
free (tests[i].name);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
cmp_authenticator (void *a, void *b)
|
|
{
|
|
Authenticator *aa = a;
|
|
Authenticator *ab = b;
|
|
int i;
|
|
|
|
COMPARE_INTEGER(aa,ab,authenticator_vno);
|
|
COMPARE_STRING(aa,ab,crealm);
|
|
|
|
COMPARE_INTEGER(aa,ab,cname.name_type);
|
|
COMPARE_INTEGER(aa,ab,cname.name_string.len);
|
|
|
|
for (i = 0; i < aa->cname.name_string.len; i++)
|
|
COMPARE_STRING(aa,ab,cname.name_string.val[i]);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
test_authenticator (void)
|
|
{
|
|
struct test_case tests[] = {
|
|
{ NULL, 63,
|
|
"\x62\x3d\x30\x3b\xa0\x03\x02\x01\x05\xa1\x0a\x1b\x08"
|
|
"\x45\x2e\x4b\x54\x48\x2e\x53\x45\xa2\x10\x30\x0e\xa0"
|
|
"\x03\x02\x01\x01\xa1\x07\x30\x05\x1b\x03\x6c\x68\x61"
|
|
"\xa4\x03\x02\x01\x0a\xa5\x11\x18\x0f\x31\x39\x37\x30"
|
|
"\x30\x31\x30\x31\x30\x30\x30\x31\x33\x39\x5a",
|
|
NULL
|
|
},
|
|
{ NULL, 67,
|
|
"\x62\x41\x30\x3f\xa0\x03\x02\x01\x05\xa1\x07\x1b\x05"
|
|
"\x53\x55\x2e\x53\x45\xa2\x16\x30\x14\xa0\x03\x02\x01"
|
|
"\x01\xa1\x0d\x30\x0b\x1b\x03\x6c\x68\x61\x1b\x04\x72"
|
|
"\x6f\x6f\x74\xa4\x04\x02\x02\x01\x24\xa5\x11\x18\x0f"
|
|
"\x31\x39\x37\x30\x30\x31\x30\x31\x30\x30\x31\x36\x33"
|
|
"\x39\x5a",
|
|
NULL
|
|
}
|
|
};
|
|
|
|
Authenticator values[] = {
|
|
{ 5, "E.KTH.SE", { KRB5_NT_PRINCIPAL, { 1, lha_principal } },
|
|
NULL, 10, 99, NULL, NULL, NULL },
|
|
{ 5, "SU.SE", { KRB5_NT_PRINCIPAL, { 2, lharoot_princ } },
|
|
NULL, 292, 999, NULL, NULL, NULL }
|
|
};
|
|
int i, ret;
|
|
int ntests = sizeof(tests) / sizeof(*tests);
|
|
|
|
for (i = 0; i < ntests; ++i) {
|
|
tests[i].val = &values[i];
|
|
if (asprintf (&tests[i].name, "Authenticator %d", i) < 0)
|
|
errx(1, "malloc");
|
|
if (tests[i].name == NULL)
|
|
errx(1, "malloc");
|
|
}
|
|
|
|
ret = generic_test (tests, ntests, sizeof(Authenticator),
|
|
(generic_encode)encode_Authenticator,
|
|
(generic_length)length_Authenticator,
|
|
(generic_decode)decode_Authenticator,
|
|
(generic_free)free_Authenticator,
|
|
cmp_authenticator,
|
|
(generic_copy)copy_Authenticator);
|
|
for (i = 0; i < ntests; ++i)
|
|
free(tests[i].name);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
cmp_KRB_ERROR (void *a, void *b)
|
|
{
|
|
KRB_ERROR *aa = a;
|
|
KRB_ERROR *ab = b;
|
|
int i;
|
|
|
|
COMPARE_INTEGER(aa,ab,pvno);
|
|
COMPARE_INTEGER(aa,ab,msg_type);
|
|
|
|
IF_OPT_COMPARE(aa,ab,ctime) {
|
|
COMPARE_INTEGER(aa,ab,ctime);
|
|
}
|
|
IF_OPT_COMPARE(aa,ab,cusec) {
|
|
COMPARE_INTEGER(aa,ab,cusec);
|
|
}
|
|
COMPARE_INTEGER(aa,ab,stime);
|
|
COMPARE_INTEGER(aa,ab,susec);
|
|
COMPARE_INTEGER(aa,ab,error_code);
|
|
|
|
IF_OPT_COMPARE(aa,ab,crealm) {
|
|
COMPARE_OPT_STRING(aa,ab,crealm);
|
|
}
|
|
#if 0
|
|
IF_OPT_COMPARE(aa,ab,cname) {
|
|
COMPARE_OPT_STRING(aa,ab,cname);
|
|
}
|
|
#endif
|
|
COMPARE_STRING(aa,ab,realm);
|
|
|
|
COMPARE_INTEGER(aa,ab,sname.name_string.len);
|
|
for (i = 0; i < aa->sname.name_string.len; i++)
|
|
COMPARE_STRING(aa,ab,sname.name_string.val[i]);
|
|
|
|
IF_OPT_COMPARE(aa,ab,e_text) {
|
|
COMPARE_OPT_STRING(aa,ab,e_text);
|
|
}
|
|
IF_OPT_COMPARE(aa,ab,e_data) {
|
|
/* COMPARE_OPT_OCTET_STRING(aa,ab,e_data); */
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
test_krb_error (void)
|
|
{
|
|
struct test_case tests[] = {
|
|
{ NULL, 127,
|
|
"\x7e\x7d\x30\x7b\xa0\x03\x02\x01\x05\xa1\x03\x02\x01\x1e\xa4\x11"
|
|
"\x18\x0f\x32\x30\x30\x33\x31\x31\x32\x34\x30\x30\x31\x31\x31\x39"
|
|
"\x5a\xa5\x05\x02\x03\x04\xed\xa5\xa6\x03\x02\x01\x1f\xa7\x0d\x1b"
|
|
"\x0b\x4e\x41\x44\x41\x2e\x4b\x54\x48\x2e\x53\x45\xa8\x10\x30\x0e"
|
|
"\xa0\x03\x02\x01\x01\xa1\x07\x30\x05\x1b\x03\x6c\x68\x61\xa9\x0d"
|
|
"\x1b\x0b\x4e\x41\x44\x41\x2e\x4b\x54\x48\x2e\x53\x45\xaa\x20\x30"
|
|
"\x1e\xa0\x03\x02\x01\x01\xa1\x17\x30\x15\x1b\x06\x6b\x72\x62\x74"
|
|
"\x67\x74\x1b\x0b\x4e\x41\x44\x41\x2e\x4b\x54\x48\x2e\x53\x45",
|
|
"KRB-ERROR Test 1"
|
|
}
|
|
};
|
|
int ntests = sizeof(tests) / sizeof(*tests);
|
|
KRB_ERROR e1;
|
|
PrincipalName lhaprincipalname = { 1, { 1, lha_principal } };
|
|
PrincipalName tgtprincipalname = { 1, { 2, nada_tgt_principal } };
|
|
char *realm = "NADA.KTH.SE";
|
|
|
|
e1.pvno = 5;
|
|
e1.msg_type = 30;
|
|
e1.ctime = NULL;
|
|
e1.cusec = NULL;
|
|
e1.stime = 1069632679;
|
|
e1.susec = 322981;
|
|
e1.error_code = 31;
|
|
e1.crealm = &realm;
|
|
e1.cname = &lhaprincipalname;
|
|
e1.realm = "NADA.KTH.SE";
|
|
e1.sname = tgtprincipalname;
|
|
e1.e_text = NULL;
|
|
e1.e_data = NULL;
|
|
|
|
tests[0].val = &e1;
|
|
|
|
return generic_test (tests, ntests, sizeof(KRB_ERROR),
|
|
(generic_encode)encode_KRB_ERROR,
|
|
(generic_length)length_KRB_ERROR,
|
|
(generic_decode)decode_KRB_ERROR,
|
|
(generic_free)free_KRB_ERROR,
|
|
cmp_KRB_ERROR,
|
|
(generic_copy)copy_KRB_ERROR);
|
|
}
|
|
|
|
static int
|
|
cmp_Name (void *a, void *b)
|
|
{
|
|
Name *aa = a;
|
|
Name *ab = b;
|
|
|
|
COMPARE_INTEGER(aa,ab,element);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
test_Name (void)
|
|
{
|
|
struct test_case tests[] = {
|
|
{ NULL, 35,
|
|
"\x30\x21\x31\x1f\x30\x0b\x06\x03\x55\x04\x03\x13\x04\x4c\x6f\x76"
|
|
"\x65\x30\x10\x06\x03\x55\x04\x07\x13\x09\x53\x54\x4f\x43\x4b\x48"
|
|
"\x4f\x4c\x4d",
|
|
"Name CN=Love+L=STOCKHOLM"
|
|
},
|
|
{ NULL, 35,
|
|
"\x30\x21\x31\x1f\x30\x0b\x06\x03\x55\x04\x03\x13\x04\x4c\x6f\x76"
|
|
"\x65\x30\x10\x06\x03\x55\x04\x07\x13\x09\x53\x54\x4f\x43\x4b\x48"
|
|
"\x4f\x4c\x4d",
|
|
"Name L=STOCKHOLM+CN=Love"
|
|
}
|
|
};
|
|
|
|
int ntests = sizeof(tests) / sizeof(*tests);
|
|
Name n1, n2;
|
|
RelativeDistinguishedName rdn1[1];
|
|
RelativeDistinguishedName rdn2[1];
|
|
AttributeTypeAndValue atv1[2];
|
|
AttributeTypeAndValue atv2[2];
|
|
unsigned cmp_CN[] = { 2, 5, 4, 3 };
|
|
unsigned cmp_L[] = { 2, 5, 4, 7 };
|
|
|
|
/* n1 */
|
|
n1.element = choice_Name_rdnSequence;
|
|
n1.u.rdnSequence.val = rdn1;
|
|
n1.u.rdnSequence.len = sizeof(rdn1)/sizeof(rdn1[0]);
|
|
rdn1[0].val = atv1;
|
|
rdn1[0].len = sizeof(atv1)/sizeof(atv1[0]);
|
|
|
|
atv1[0].type.length = sizeof(cmp_CN)/sizeof(cmp_CN[0]);
|
|
atv1[0].type.components = cmp_CN;
|
|
atv1[0].value.element = choice_DirectoryString_printableString;
|
|
atv1[0].value.u.printableString.data = "Love";
|
|
atv1[0].value.u.printableString.length = 4;
|
|
|
|
atv1[1].type.length = sizeof(cmp_L)/sizeof(cmp_L[0]);
|
|
atv1[1].type.components = cmp_L;
|
|
atv1[1].value.element = choice_DirectoryString_printableString;
|
|
atv1[1].value.u.printableString.data = "STOCKHOLM";
|
|
atv1[1].value.u.printableString.length = 9;
|
|
|
|
/* n2 */
|
|
n2.element = choice_Name_rdnSequence;
|
|
n2.u.rdnSequence.val = rdn2;
|
|
n2.u.rdnSequence.len = sizeof(rdn2)/sizeof(rdn2[0]);
|
|
rdn2[0].val = atv2;
|
|
rdn2[0].len = sizeof(atv2)/sizeof(atv2[0]);
|
|
|
|
atv2[0].type.length = sizeof(cmp_L)/sizeof(cmp_L[0]);
|
|
atv2[0].type.components = cmp_L;
|
|
atv2[0].value.element = choice_DirectoryString_printableString;
|
|
atv2[0].value.u.printableString.data = "STOCKHOLM";
|
|
atv2[0].value.u.printableString.length = 9;
|
|
|
|
atv2[1].type.length = sizeof(cmp_CN)/sizeof(cmp_CN[0]);
|
|
atv2[1].type.components = cmp_CN;
|
|
atv2[1].value.element = choice_DirectoryString_printableString;
|
|
atv2[1].value.u.printableString.data = "Love";
|
|
atv2[1].value.u.printableString.length = 4;
|
|
|
|
/* */
|
|
tests[0].val = &n1;
|
|
tests[1].val = &n2;
|
|
|
|
return generic_test (tests, ntests, sizeof(Name),
|
|
(generic_encode)encode_Name,
|
|
(generic_length)length_Name,
|
|
(generic_decode)decode_Name,
|
|
(generic_free)free_Name,
|
|
cmp_Name,
|
|
(generic_copy)copy_Name);
|
|
}
|
|
|
|
static int
|
|
cmp_KeyUsage (void *a, void *b)
|
|
{
|
|
KeyUsage *aa = a;
|
|
KeyUsage *ab = b;
|
|
|
|
return KeyUsage2int(*aa) != KeyUsage2int(*ab);
|
|
}
|
|
|
|
static int
|
|
test_bit_string (void)
|
|
{
|
|
struct test_case tests[] = {
|
|
{ NULL, 4,
|
|
"\x03\x02\x07\x80",
|
|
"bitstring 1"
|
|
},
|
|
{ NULL, 4,
|
|
"\x03\x02\x05\xa0",
|
|
"bitstring 2"
|
|
},
|
|
{ NULL, 5,
|
|
"\x03\x03\x07\x00\x80",
|
|
"bitstring 3"
|
|
},
|
|
{ NULL, 3,
|
|
"\x03\x01\x00",
|
|
"bitstring 4"
|
|
}
|
|
};
|
|
|
|
int ntests = sizeof(tests) / sizeof(*tests);
|
|
KeyUsage ku1, ku2, ku3, ku4;
|
|
|
|
memset(&ku1, 0, sizeof(ku1));
|
|
ku1.digitalSignature = 1;
|
|
tests[0].val = &ku1;
|
|
|
|
memset(&ku2, 0, sizeof(ku2));
|
|
ku2.digitalSignature = 1;
|
|
ku2.keyEncipherment = 1;
|
|
tests[1].val = &ku2;
|
|
|
|
memset(&ku3, 0, sizeof(ku3));
|
|
ku3.decipherOnly = 1;
|
|
tests[2].val = &ku3;
|
|
|
|
memset(&ku4, 0, sizeof(ku4));
|
|
tests[3].val = &ku4;
|
|
|
|
|
|
return generic_test (tests, ntests, sizeof(KeyUsage),
|
|
(generic_encode)encode_KeyUsage,
|
|
(generic_length)length_KeyUsage,
|
|
(generic_decode)decode_KeyUsage,
|
|
(generic_free)free_KeyUsage,
|
|
cmp_KeyUsage,
|
|
(generic_copy)copy_KeyUsage);
|
|
}
|
|
|
|
static int
|
|
cmp_TicketFlags (void *a, void *b)
|
|
{
|
|
TicketFlags *aa = a;
|
|
TicketFlags *ab = b;
|
|
|
|
return TicketFlags2int(*aa) != TicketFlags2int(*ab);
|
|
}
|
|
|
|
static int
|
|
test_bit_string_rfc1510 (void)
|
|
{
|
|
struct test_case tests[] = {
|
|
{ NULL, 7,
|
|
"\x03\x05\x00\x80\x00\x00\x00",
|
|
"TF bitstring 1"
|
|
},
|
|
{ NULL, 7,
|
|
"\x03\x05\x00\x40\x20\x00\x00",
|
|
"TF bitstring 2"
|
|
},
|
|
{ NULL, 7,
|
|
"\x03\x05\x00\x00\x20\x00\x00",
|
|
"TF bitstring 3"
|
|
},
|
|
{ NULL, 7,
|
|
"\x03\x05\x00\x00\x00\x00\x00",
|
|
"TF bitstring 4"
|
|
}
|
|
};
|
|
|
|
int ntests = sizeof(tests) / sizeof(*tests);
|
|
TicketFlags tf1, tf2, tf3, tf4;
|
|
|
|
memset(&tf1, 0, sizeof(tf1));
|
|
tf1.reserved = 1;
|
|
tests[0].val = &tf1;
|
|
|
|
memset(&tf2, 0, sizeof(tf2));
|
|
tf2.forwardable = 1;
|
|
tf2.pre_authent = 1;
|
|
tests[1].val = &tf2;
|
|
|
|
memset(&tf3, 0, sizeof(tf3));
|
|
tf3.pre_authent = 1;
|
|
tests[2].val = &tf3;
|
|
|
|
memset(&tf4, 0, sizeof(tf4));
|
|
tests[3].val = &tf4;
|
|
|
|
|
|
return generic_test (tests, ntests, sizeof(TicketFlags),
|
|
(generic_encode)encode_TicketFlags,
|
|
(generic_length)length_TicketFlags,
|
|
(generic_decode)decode_TicketFlags,
|
|
(generic_free)free_TicketFlags,
|
|
cmp_TicketFlags,
|
|
(generic_copy)copy_TicketFlags);
|
|
}
|
|
|
|
static int
|
|
cmp_KerberosTime (void *a, void *b)
|
|
{
|
|
KerberosTime *aa = a;
|
|
KerberosTime *ab = b;
|
|
|
|
return *aa != *ab;
|
|
}
|
|
|
|
static int
|
|
test_time (void)
|
|
{
|
|
struct test_case tests[] = {
|
|
{ NULL, 17,
|
|
"\x18\x0f\x31\x39\x37\x30\x30\x31\x30\x31\x30\x31\x31\x38\x33\x31"
|
|
"\x5a",
|
|
"time 1" },
|
|
{ NULL, 17,
|
|
"\x18\x0f\x32\x30\x30\x39\x30\x35\x32\x34\x30\x32\x30\x32\x34\x30"
|
|
"\x5a",
|
|
"time 2" }
|
|
};
|
|
|
|
int ntests = sizeof(tests) / sizeof(*tests);
|
|
KerberosTime times[] = {
|
|
4711,
|
|
1243130560
|
|
};
|
|
|
|
tests[0].val = ×[0];
|
|
tests[1].val = ×[1];
|
|
|
|
return generic_test (tests, ntests, sizeof(KerberosTime),
|
|
(generic_encode)encode_KerberosTime,
|
|
(generic_length)length_KerberosTime,
|
|
(generic_decode)decode_KerberosTime,
|
|
(generic_free)free_KerberosTime,
|
|
cmp_KerberosTime,
|
|
(generic_copy)copy_KerberosTime);
|
|
}
|
|
|
|
struct {
|
|
const char *cert;
|
|
size_t len;
|
|
} certs[] = {
|
|
{
|
|
"\x30\x82\x02\x6c\x30\x82\x01\xd5\xa0\x03\x02\x01\x02\x02\x09\x00"
|
|
"\x99\x32\xde\x61\x0e\x40\x19\x8a\x30\x0d\x06\x09\x2a\x86\x48\x86"
|
|
"\xf7\x0d\x01\x01\x05\x05\x00\x30\x2a\x31\x1b\x30\x19\x06\x03\x55"
|
|
"\x04\x03\x0c\x12\x68\x78\x35\x30\x39\x20\x54\x65\x73\x74\x20\x52"
|
|
"\x6f\x6f\x74\x20\x43\x41\x31\x0b\x30\x09\x06\x03\x55\x04\x06\x13"
|
|
"\x02\x53\x45\x30\x1e\x17\x0d\x30\x39\x30\x34\x32\x36\x32\x30\x32"
|
|
"\x39\x34\x30\x5a\x17\x0d\x31\x39\x30\x34\x32\x34\x32\x30\x32\x39"
|
|
"\x34\x30\x5a\x30\x2a\x31\x1b\x30\x19\x06\x03\x55\x04\x03\x0c\x12"
|
|
"\x68\x78\x35\x30\x39\x20\x54\x65\x73\x74\x20\x52\x6f\x6f\x74\x20"
|
|
"\x43\x41\x31\x0b\x30\x09\x06\x03\x55\x04\x06\x13\x02\x53\x45\x30"
|
|
"\x81\x9f\x30\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x01\x05"
|
|
"\x00\x03\x81\x8d\x00\x30\x81\x89\x02\x81\x81\x00\xb9\xd3\x1b\x67"
|
|
"\x1c\xf7\x5e\x26\x81\x3b\x82\xff\x03\xa4\x43\xb5\xb2\x63\x0b\x89"
|
|
"\x58\x43\xfe\x3d\xe0\x38\x7d\x93\x74\xbb\xad\x21\xa4\x29\xd9\x34"
|
|
"\x79\xf3\x1c\x8c\x5a\xd6\xb0\xd7\x19\xea\xcc\xaf\xe0\xa8\x40\x02"
|
|
"\x1d\x91\xf1\xac\x36\xb0\xfb\x08\xbd\xcc\x9a\xe1\xb7\x6e\xee\x0a"
|
|
"\x69\xbf\x6d\x2b\xee\x20\x82\x61\x06\xf2\x18\xcc\x89\x11\x64\x7e"
|
|
"\xb2\xff\x47\xd1\x3b\x52\x73\xeb\x5a\xc0\x03\xa6\x4b\xc7\x40\x7e"
|
|
"\xbc\xe1\x0e\x65\x44\x3f\x40\x8b\x02\x82\x54\x04\xd9\xcc\x2c\x67"
|
|
"\x01\xb6\x16\x82\xd8\x33\x53\x17\xd7\xde\x8d\x5d\x02\x03\x01\x00"
|
|
"\x01\xa3\x81\x99\x30\x81\x96\x30\x1d\x06\x03\x55\x1d\x0e\x04\x16"
|
|
"\x04\x14\x6e\x48\x13\xdc\xbf\x8b\x95\x4c\x13\xf3\x1f\x97\x30\xdd"
|
|
"\x27\x96\x59\x9b\x0e\x68\x30\x5a\x06\x03\x55\x1d\x23\x04\x53\x30"
|
|
"\x51\x80\x14\x6e\x48\x13\xdc\xbf\x8b\x95\x4c\x13\xf3\x1f\x97\x30"
|
|
"\xdd\x27\x96\x59\x9b\x0e\x68\xa1\x2e\xa4\x2c\x30\x2a\x31\x1b\x30"
|
|
"\x19\x06\x03\x55\x04\x03\x0c\x12\x68\x78\x35\x30\x39\x20\x54\x65"
|
|
"\x73\x74\x20\x52\x6f\x6f\x74\x20\x43\x41\x31\x0b\x30\x09\x06\x03"
|
|
"\x55\x04\x06\x13\x02\x53\x45\x82\x09\x00\x99\x32\xde\x61\x0e\x40"
|
|
"\x19\x8a\x30\x0c\x06\x03\x55\x1d\x13\x04\x05\x30\x03\x01\x01\xff"
|
|
"\x30\x0b\x06\x03\x55\x1d\x0f\x04\x04\x03\x02\x01\xe6\x30\x0d\x06"
|
|
"\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x05\x05\x00\x03\x81\x81\x00"
|
|
"\x52\x9b\xe4\x0e\xee\xc2\x5d\xb7\xf1\xba\x47\xe3\xfe\xaf\x3d\x51"
|
|
"\x10\xfd\xe8\x0d\x14\x58\x05\x36\xa7\xeb\xd8\x05\xe5\x27\x6f\x51"
|
|
"\xb8\xec\x90\xd9\x03\xe1\xbc\x9c\x93\x38\x21\x5c\xaf\x4e\x6c\x7b"
|
|
"\x6c\x65\xa9\x92\xcd\x94\xef\xa8\xae\x90\x12\x14\x78\x2d\xa3\x15"
|
|
"\xaa\x42\xf1\xd9\x44\x64\x2c\x3c\xc0\xbd\x3a\x48\xd8\x80\x45\x8b"
|
|
"\xd1\x79\x82\xe0\x0f\xdf\x08\x3c\x60\x21\x6f\x31\x47\x98\xae\x2f"
|
|
"\xcb\xb1\xa1\xb9\xc1\xa3\x71\x5e\x4a\xc2\x67\xdf\x66\x0a\x51\xb5"
|
|
"\xad\x60\x05\xdb\x02\xd4\x1a\xd2\xb9\x4e\x01\x08\x2b\xc3\x57\xaf",
|
|
624 },
|
|
{
|
|
"\x30\x82\x02\x54\x30\x82\x01\xbd\xa0\x03\x02\x01\x02\x02\x01\x08"
|
|
"\x30\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x05\x05\x00\x30"
|
|
"\x2a\x31\x1b\x30\x19\x06\x03\x55\x04\x03\x0c\x12\x68\x78\x35\x30"
|
|
"\x39\x20\x54\x65\x73\x74\x20\x52\x6f\x6f\x74\x20\x43\x41\x31\x0b"
|
|
"\x30\x09\x06\x03\x55\x04\x06\x13\x02\x53\x45\x30\x1e\x17\x0d\x30"
|
|
"\x39\x30\x34\x32\x36\x32\x30\x32\x39\x34\x30\x5a\x17\x0d\x31\x39"
|
|
"\x30\x34\x32\x34\x32\x30\x32\x39\x34\x30\x5a\x30\x1b\x31\x0b\x30"
|
|
"\x09\x06\x03\x55\x04\x06\x13\x02\x53\x45\x31\x0c\x30\x0a\x06\x03"
|
|
"\x55\x04\x03\x0c\x03\x6b\x64\x63\x30\x81\x9f\x30\x0d\x06\x09\x2a"
|
|
"\x86\x48\x86\xf7\x0d\x01\x01\x01\x05\x00\x03\x81\x8d\x00\x30\x81"
|
|
"\x89\x02\x81\x81\x00\xd2\x41\x7a\xf8\x4b\x55\xb2\xaf\x11\xf9\x43"
|
|
"\x9b\x43\x81\x09\x3b\x9a\x94\xcf\x00\xf4\x85\x75\x92\xd7\x2a\xa5"
|
|
"\x11\xf1\xa8\x50\x6e\xc6\x84\x74\x24\x17\xda\x84\xc8\x03\x37\xb2"
|
|
"\x20\xf3\xba\xb5\x59\x36\x21\x4d\xab\x70\xe2\xc3\x09\x93\x68\x14"
|
|
"\x12\x79\xc5\xbb\x9e\x1b\x4a\xf0\xc6\x24\x59\x25\xc3\x1c\xa8\x70"
|
|
"\x66\x5b\x3e\x41\x8e\xe3\x25\x71\x9a\x94\xa0\x5b\x46\x91\x6f\xdd"
|
|
"\x58\x14\xec\x89\xe5\x8c\x96\xc5\x38\x60\xe4\xab\xf2\x75\xee\x6e"
|
|
"\x62\xfc\xe1\xbd\x03\x47\xff\xc4\xbe\x0f\xca\x70\x73\xe3\x74\x58"
|
|
"\x3a\x2f\x04\x2d\x39\x02\x03\x01\x00\x01\xa3\x81\x98\x30\x81\x95"
|
|
"\x30\x09\x06\x03\x55\x1d\x13\x04\x02\x30\x00\x30\x0b\x06\x03\x55"
|
|
"\x1d\x0f\x04\x04\x03\x02\x05\xe0\x30\x12\x06\x03\x55\x1d\x25\x04"
|
|
"\x0b\x30\x09\x06\x07\x2b\x06\x01\x05\x02\x03\x05\x30\x1d\x06\x03"
|
|
"\x55\x1d\x0e\x04\x16\x04\x14\x3a\xd3\x73\xff\xab\xdb\x7d\x8d\xc6"
|
|
"\x3a\xa2\x26\x3e\xae\x78\x95\x80\xc9\xe6\x31\x30\x48\x06\x03\x55"
|
|
"\x1d\x11\x04\x41\x30\x3f\xa0\x3d\x06\x06\x2b\x06\x01\x05\x02\x02"
|
|
"\xa0\x33\x30\x31\xa0\x0d\x1b\x0b\x54\x45\x53\x54\x2e\x48\x35\x4c"
|
|
"\x2e\x53\x45\xa1\x20\x30\x1e\xa0\x03\x02\x01\x01\xa1\x17\x30\x15"
|
|
"\x1b\x06\x6b\x72\x62\x74\x67\x74\x1b\x0b\x54\x45\x53\x54\x2e\x48"
|
|
"\x35\x4c\x2e\x53\x45\x30\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01"
|
|
"\x01\x05\x05\x00\x03\x81\x81\x00\x83\xf4\x14\xa7\x6e\x59\xff\x80"
|
|
"\x64\xe7\xfa\xcf\x13\x80\x86\xe1\xed\x02\x38\xad\x96\x72\x25\xe5"
|
|
"\x06\x7a\x9a\xbc\x24\x74\xa9\x75\x55\xb2\x49\x80\x69\x45\x95\x4a"
|
|
"\x4c\x76\xa9\xe3\x4e\x49\xd3\xc2\x69\x5a\x95\x03\xeb\xba\x72\x23"
|
|
"\x9c\xfd\x3d\x8b\xc6\x07\x82\x3b\xf4\xf3\xef\x6c\x2e\x9e\x0b\xac"
|
|
"\x9e\x6c\xbb\x37\x4a\xa1\x9e\x73\xd1\xdc\x97\x61\xba\xfc\xd3\x49"
|
|
"\xa6\xc2\x4c\x55\x2e\x06\x37\x76\xb5\xef\x57\xe7\x57\x58\x8a\x71"
|
|
"\x63\xf3\xeb\xe7\x55\x68\x0d\xf6\x46\x4c\xfb\xf9\x43\xbb\x0c\x92"
|
|
"\x4f\x4e\x22\x7b\x63\xe8\x4f\x9c",
|
|
600
|
|
}
|
|
};
|
|
|
|
static int
|
|
test_cert(void)
|
|
{
|
|
Certificate c, c2;
|
|
size_t size;
|
|
size_t i;
|
|
int ret;
|
|
|
|
for (i = 0; i < sizeof(certs)/sizeof(certs[0]); i++) {
|
|
|
|
ret = decode_Certificate((unsigned char *)certs[i].cert,
|
|
certs[i].len, &c, &size);
|
|
if (ret)
|
|
return ret;
|
|
|
|
ret = copy_Certificate(&c, &c2);
|
|
free_Certificate(&c);
|
|
if (ret)
|
|
return ret;
|
|
|
|
free_Certificate(&c2);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
struct {
|
|
const char *sd;
|
|
size_t len;
|
|
} signeddata[] = {
|
|
{
|
|
"\x30\x80\x02\x01\x03\x31\x0b\x30\x09\x06\x05\x2b\x0e\x03\x02\x1a"
|
|
"\x05\x00\x30\x80\x06\x07\x2b\x06\x01\x05\x02\x03\x03\xa0\x80\x24"
|
|
"\x80\x04\x50\x30\x4e\xa0\x2b\x30\x29\xa0\x03\x02\x01\x12\xa1\x22"
|
|
"\x04\x20\x78\xf4\x86\x31\xc6\xc2\xc9\xcb\xef\x0c\xd7\x3a\x2a\xcd"
|
|
"\x8c\x13\x34\x83\xb1\x5c\xa8\xbe\xbf\x2f\xea\xd2\xbb\xd8\x8c\x18"
|
|
"\x47\x01\xa1\x1f\x30\x1d\xa0\x03\x02\x01\x0c\xa1\x16\x04\x14\xa6"
|
|
"\x2c\x52\xb2\x80\x98\x30\x40\xbc\x5f\xb0\x77\x2d\x8a\xd7\xa1\xda"
|
|
"\x3c\xc5\x62\x00\x00\x00\x00\x00\x00\xa0\x82\x02\x09\x30\x82\x02"
|
|
"\x05\x30\x82\x01\x6e\xa0\x03\x02\x01\x02\x02\x04\x49\x75\x57\xbf"
|
|
"\x30\x0b\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x05\x30\x3b\x31"
|
|
"\x1f\x30\x1d\x06\x03\x55\x04\x03\x0c\x16\x63\x6f\x6d\x2e\x61\x70"
|
|
"\x70\x6c\x65\x2e\x6b\x65\x72\x62\x65\x72\x6f\x73\x2e\x6b\x64\x63"
|
|
"\x31\x18\x30\x16\x06\x03\x55\x04\x0a\x0c\x0f\x53\x79\x73\x74\x65"
|
|
"\x6d\x20\x49\x64\x65\x6e\x74\x69\x74\x79\x30\x1e\x17\x0d\x30\x39"
|
|
"\x31\x32\x30\x34\x30\x30\x32\x30\x32\x34\x5a\x17\x0d\x32\x39\x31"
|
|
"\x31\x32\x39\x30\x30\x32\x30\x32\x34\x5a\x30\x3b\x31\x1f\x30\x1d"
|
|
"\x06\x03\x55\x04\x03\x0c\x16\x63\x6f\x6d\x2e\x61\x70\x70\x6c\x65"
|
|
"\x2e\x6b\x65\x72\x62\x65\x72\x6f\x73\x2e\x6b\x64\x63\x31\x18\x30"
|
|
"\x16\x06\x03\x55\x04\x0a\x0c\x0f\x53\x79\x73\x74\x65\x6d\x20\x49"
|
|
"\x64\x65\x6e\x74\x69\x74\x79\x30\x81\x9f\x30\x0d\x06\x09\x2a\x86"
|
|
"\x48\x86\xf7\x0d\x01\x01\x01\x05\x00\x03\x81\x8d\x00\x30\x81\x89"
|
|
"\x02\x81\x81\x00\xb2\xc5\x4b\x34\xe3\x93\x99\xbb\xaa\xd1\x70\x62"
|
|
"\x6c\x9c\xcc\xa6\xbc\x47\xc3\x23\xff\x15\xb9\x11\x27\x0a\xf8\x55"
|
|
"\x4c\xb2\x43\x34\x75\xad\x55\xbb\xb9\x8a\xd0\x25\x64\xa4\x8c\x82"
|
|
"\x74\x5d\x89\x52\xe2\x76\x75\x08\x67\xb5\x9c\x9c\x69\x86\x0c\x6d"
|
|
"\x79\xf7\xa0\xbe\x42\x8f\x90\x46\x0c\x18\xf4\x7a\x56\x17\xa4\x65"
|
|
"\x00\x3a\x5e\x3e\xbf\xbc\xf5\xe2\x2c\x26\x03\x52\xdd\xd4\x85\x3f"
|
|
"\x03\xd7\x0c\x45\x7f\xff\xdd\x1e\x70\x6c\x9f\xb0\x8c\xd0\x33\xad"
|
|
"\x92\x54\x17\x9d\x88\x89\x1a\xee\xef\xf7\x96\x3e\x68\xc3\xd1\x60"
|
|
"\x47\x86\x80\x5d\x02\x03\x01\x00\x01\xa3\x18\x30\x16\x30\x14\x06"
|
|
"\x03\x55\x1d\x25\x04\x0d\x30\x0b\x06\x09\x2a\x86\x48\x86\xf7\x63"
|
|
"\x64\x04\x04\x30\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x05"
|
|
"\x05\x00\x03\x81\x81\x00\x9b\xbb\xaa\x63\x66\xd8\x70\x84\x3e\xf6"
|
|
"\xa1\x3b\xf3\xe6\xd7\x3d\xfc\x4f\xc9\x45\xaa\x31\x43\x8d\xb5\x72"
|
|
"\xe4\x34\x95\x7b\x6e\x5f\xe5\xc8\x5e\xaf\x12\x08\x6d\xd7\x25\x76"
|
|
"\x40\xd5\xdc\x83\x7f\x2f\x74\xd1\x63\xc0\x7c\x26\x4d\x53\x10\xe7"
|
|
"\xfa\xcc\xf2\x60\x41\x63\xdf\x56\xd6\xd9\xc0\xb4\xd0\x73\x99\x54"
|
|
"\x40\xad\x90\x79\x2d\xd2\x5e\xcb\x13\x22\x2b\xd0\x76\xef\x8a\x48"
|
|
"\xfd\xb2\x6e\xca\x04\x4e\x91\x3f\xb4\x63\xad\x22\x3a\xf7\x20\x9c"
|
|
"\x4c\x0e\x47\x78\xe5\x2a\x85\x0e\x90\x7a\xce\x46\xe6\x15\x02\xb0"
|
|
"\x83\xe7\xac\xfa\x92\xf8\x31\x81\xe8\x30\x81\xe5\x02\x01\x01\x30"
|
|
"\x43\x30\x3b\x31\x1f\x30\x1d\x06\x03\x55\x04\x03\x0c\x16\x63\x6f"
|
|
"\x6d\x2e\x61\x70\x70\x6c\x65\x2e\x6b\x65\x72\x62\x65\x72\x6f\x73"
|
|
"\x2e\x6b\x64\x63\x31\x18\x30\x16\x06\x03\x55\x04\x0a\x0c\x0f\x53"
|
|
"\x79\x73\x74\x65\x6d\x20\x49\x64\x65\x6e\x74\x69\x74\x79\x02\x04"
|
|
"\x49\x75\x57\xbf\x30\x09\x06\x05\x2b\x0e\x03\x02\x1a\x05\x00\x30"
|
|
"\x0d\x06\x09\x2a\x86\x48\x86\xf7\x0d\x01\x01\x01\x05\x00\x04\x81"
|
|
"\x80\x50\x2c\x69\xe1\xd2\xc4\xd1\xcc\xdc\xe0\xe9\x8a\x6b\x6a\x97"
|
|
"\x1b\xb4\xe0\xa8\x20\xbe\x09\x6d\xe1\x55\x5f\x07\x70\x94\x2e\x14"
|
|
"\xed\x4e\xb1\x69\x75\x40\xbb\x99\x87\xed\x23\x50\x27\x5f\xaa\xc4"
|
|
"\x84\x60\x06\xfe\x45\xfd\x7e\x1b\x18\xe0\x0b\x77\x35\x2a\xb2\xf2"
|
|
"\xe0\x88\x31\xad\x82\x31\x4a\xbc\x6d\x71\x62\xe6\x4d\x33\xb4\x09"
|
|
"\x6e\x3f\x14\x12\xf2\x89\x29\x31\x84\x60\x2b\xa8\x2d\xe6\xca\x2f"
|
|
"\x03\x3d\xd4\x69\x89\xb3\x98\xfd\xac\x63\x14\xaf\x6a\x52\x2a\xac"
|
|
"\xe3\x8e\xfa\x21\x41\x8f\xcc\x04\x2d\x52\xee\x49\x54\x0d\x58\x51"
|
|
"\x77\x00\x00",
|
|
883
|
|
}
|
|
};
|
|
|
|
static int
|
|
test_SignedData(void)
|
|
{
|
|
SignedData sd;
|
|
size_t size, i;
|
|
int ret;
|
|
|
|
for (i = 0; i < sizeof(signeddata) / sizeof(signeddata[0]); i++) {
|
|
|
|
ret = decode_SignedData((unsigned char *)signeddata[i].sd,
|
|
signeddata[i].len, &sd, &size);
|
|
if (ret)
|
|
return ret;
|
|
|
|
free_SignedData(&sd);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
static int
|
|
cmp_TESTLargeTag (void *a, void *b)
|
|
{
|
|
TESTLargeTag *aa = a;
|
|
TESTLargeTag *ab = b;
|
|
|
|
COMPARE_INTEGER(aa,ab,foo);
|
|
COMPARE_INTEGER(aa,ab,bar);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
test_large_tag (void)
|
|
{
|
|
struct test_case tests[] = {
|
|
{ NULL, 15, "\x30\x0d\xbf\x7f\x03\x02\x01\x01\xbf\x81\x00\x03\x02\x01\x02", "large tag 1" }
|
|
};
|
|
|
|
int ntests = sizeof(tests) / sizeof(*tests);
|
|
TESTLargeTag lt1;
|
|
|
|
memset(<1, 0, sizeof(lt1));
|
|
lt1.foo = 1;
|
|
lt1.bar = 2;
|
|
|
|
tests[0].val = <1;
|
|
|
|
return generic_test (tests, ntests, sizeof(TESTLargeTag),
|
|
(generic_encode)encode_TESTLargeTag,
|
|
(generic_length)length_TESTLargeTag,
|
|
(generic_decode)decode_TESTLargeTag,
|
|
(generic_free)free_TESTLargeTag,
|
|
cmp_TESTLargeTag,
|
|
(generic_copy)copy_TESTLargeTag);
|
|
}
|
|
|
|
struct test_data {
|
|
int ok;
|
|
size_t len;
|
|
size_t expected_len;
|
|
void *data;
|
|
};
|
|
|
|
static int
|
|
check_tag_length(void)
|
|
{
|
|
struct test_data td[] = {
|
|
{ 1, 3, 3, "\x02\x01\x00"},
|
|
{ 1, 3, 3, "\x02\x01\x7f"},
|
|
{ 1, 4, 4, "\x02\x02\x00\x80"},
|
|
{ 1, 4, 4, "\x02\x02\x01\x00"},
|
|
{ 1, 4, 4, "\x02\x02\x02\x00"},
|
|
{ 0, 3, 0, "\x02\x02\x00"},
|
|
{ 0, 3, 0, "\x02\x7f\x7f"},
|
|
{ 0, 4, 0, "\x02\x03\x00\x80"},
|
|
{ 0, 4, 0, "\x02\x7f\x01\x00"},
|
|
{ 0, 5, 0, "\x02\xff\x7f\x02\x00"}
|
|
};
|
|
size_t sz;
|
|
TESTuint32 values[] = {0, 127, 128, 256, 512,
|
|
0, 127, 128, 256, 512 };
|
|
TESTuint32 u;
|
|
int i, ret, failed = 0;
|
|
void *buf;
|
|
|
|
for (i = 0; i < sizeof(td)/sizeof(td[0]); i++) {
|
|
struct map_page *page;
|
|
|
|
buf = map_alloc(OVERRUN, td[i].data, td[i].len, &page);
|
|
|
|
ret = decode_TESTuint32(buf, td[i].len, &u, &sz);
|
|
if (ret) {
|
|
if (td[i].ok) {
|
|
printf("failed with tag len test %d\n", i);
|
|
failed = 1;
|
|
}
|
|
} else {
|
|
if (td[i].ok == 0) {
|
|
printf("failed with success for tag len test %d\n", i);
|
|
failed = 1;
|
|
}
|
|
if (td[i].expected_len != sz) {
|
|
printf("wrong expected size for tag test %d\n", i);
|
|
failed = 1;
|
|
}
|
|
if (values[i] != u) {
|
|
printf("wrong value for tag test %d\n", i);
|
|
failed = 1;
|
|
}
|
|
}
|
|
map_free(page, "test", "decode");
|
|
}
|
|
return failed;
|
|
}
|
|
|
|
static int
|
|
check_tag_length64(void)
|
|
{
|
|
struct test_data td[] = {
|
|
{ 1, 3, 3, "\x02\x01\x00"},
|
|
{ 1, 7, 7, "\x02\x05\x01\xff\xff\xff\xff"},
|
|
{ 1, 7, 7, "\x02\x05\x02\x00\x00\x00\x00"},
|
|
{ 1, 9, 9, "\x02\x07\x7f\xff\xff\xff\xff\xff\xff"},
|
|
{ 1, 10, 10, "\x02\x08\x00\x80\x00\x00\x00\x00\x00\x00"},
|
|
{ 1, 10, 10, "\x02\x08\x7f\xff\xff\xff\xff\xff\xff\xff"},
|
|
{ 1, 11, 11, "\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff"},
|
|
{ 0, 3, 0, "\x02\x02\x00"},
|
|
{ 0, 3, 0, "\x02\x7f\x7f"},
|
|
{ 0, 4, 0, "\x02\x03\x00\x80"},
|
|
{ 0, 4, 0, "\x02\x7f\x01\x00"},
|
|
{ 0, 5, 0, "\x02\xff\x7f\x02\x00"}
|
|
};
|
|
size_t sz;
|
|
TESTuint64 values[] = {0, 8589934591LL, 8589934592LL,
|
|
36028797018963967LL, 36028797018963968LL,
|
|
9223372036854775807LL, 18446744073709551615ULL,
|
|
0, 127, 128, 256, 512 };
|
|
TESTuint64 u;
|
|
int i, ret, failed = 0;
|
|
void *buf;
|
|
|
|
if (sizeof(TESTuint64) != sizeof(uint64_t)) {
|
|
ret += 1;
|
|
printf("sizeof(TESTuint64) %d != sizeof(uint64_t) %d\n",
|
|
(int)sizeof(TESTuint64), (int)sizeof(uint64_t));
|
|
}
|
|
|
|
for (i = 0; i < sizeof(td)/sizeof(td[0]); i++) {
|
|
struct map_page *page;
|
|
|
|
buf = map_alloc(OVERRUN, td[i].data, td[i].len, &page);
|
|
|
|
ret = decode_TESTuint64(buf, td[i].len, &u, &sz);
|
|
if (ret) {
|
|
if (td[i].ok) {
|
|
printf("failed with tag len test %d\n", i);
|
|
printf("ret = %d\n", ret);
|
|
failed = 1;
|
|
}
|
|
} else {
|
|
if (td[i].ok == 0) {
|
|
printf("failed with success for tag len test %d\n", i);
|
|
failed = 1;
|
|
}
|
|
if (td[i].expected_len != sz) {
|
|
printf("wrong expected size for tag test %d\n", i);
|
|
printf("sz = %lu\n", (unsigned long)sz);
|
|
failed = 1;
|
|
}
|
|
if (values[i] != u) {
|
|
printf("wrong value for tag test %d\n", i);
|
|
printf("Expected value: %llu\nActual value: %llu\n",
|
|
(unsigned long long)values[i], (unsigned long long)u);
|
|
failed = 1;
|
|
}
|
|
}
|
|
map_free(page, "test", "decode");
|
|
}
|
|
return failed;
|
|
}
|
|
|
|
static int
|
|
check_tag_length64s(void)
|
|
{
|
|
struct test_data td[] = {
|
|
{ 1, 3, 3, "\x02\x01\x00"},
|
|
{ 1, 7, 7, "\x02\x05\xfe\x00\x00\x00\x01"},
|
|
{ 1, 7, 7, "\x02\x05\xfe\x00\x00\x00\x00"},
|
|
{ 1, 9, 9, "\x02\x07\x80\x00\x00\x00\x00\x00\x01"},
|
|
{ 1, 9, 9, "\x02\x07\x80\x00\x00\x00\x00\x00\x00"},
|
|
{ 1, 10, 10, "\x02\x08\x80\x00\x00\x00\x00\x00\x00\x01"},
|
|
{ 1, 9, 9, "\x02\x07\x80\x00\x00\x00\x00\x00\x01"},
|
|
{ 0, 3, 0, "\x02\x02\x00"},
|
|
{ 0, 3, 0, "\x02\x7f\x7f"},
|
|
{ 0, 4, 0, "\x02\x03\x00\x80"},
|
|
{ 0, 4, 0, "\x02\x7f\x01\x00"},
|
|
{ 0, 5, 0, "\x02\xff\x7f\x02\x00"}
|
|
};
|
|
size_t sz;
|
|
TESTint64 values[] = {0, -8589934591LL, -8589934592LL,
|
|
-36028797018963967LL, -36028797018963968LL,
|
|
-9223372036854775807LL, -36028797018963967LL,
|
|
0, 127, 128, 256, 512 };
|
|
TESTint64 u;
|
|
int i, ret, failed = 0;
|
|
void *buf;
|
|
|
|
for (i = 0; i < sizeof(td)/sizeof(td[0]); i++) {
|
|
struct map_page *page;
|
|
|
|
buf = map_alloc(OVERRUN, td[i].data, td[i].len, &page);
|
|
|
|
ret = decode_TESTint64(buf, td[i].len, &u, &sz);
|
|
if (ret) {
|
|
if (td[i].ok) {
|
|
printf("failed with tag len test %d\n", i);
|
|
printf("ret = %d\n", ret);
|
|
failed = 1;
|
|
}
|
|
} else {
|
|
if (td[i].ok == 0) {
|
|
printf("failed with success for tag len test %d\n", i);
|
|
failed = 1;
|
|
}
|
|
if (td[i].expected_len != sz) {
|
|
printf("wrong expected size for tag test %d\n", i);
|
|
printf("sz = %lu\n", (unsigned long)sz);
|
|
failed = 1;
|
|
}
|
|
if (values[i] != u) {
|
|
printf("wrong value for tag test %d\n", i);
|
|
printf("Expected value: %lld\nActual value: %lld\n",
|
|
(long long)values[i], (long long)u);
|
|
failed = 1;
|
|
}
|
|
}
|
|
map_free(page, "test", "decode");
|
|
}
|
|
return failed;
|
|
}
|
|
|
|
static int
|
|
cmp_TESTChoice (void *a, void *b)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
test_choice (void)
|
|
{
|
|
struct test_case tests[] = {
|
|
{ NULL, 5, "\xa1\x03\x02\x01\x01", "large choice 1" },
|
|
{ NULL, 5, "\xa2\x03\x02\x01\x02", "large choice 2" }
|
|
};
|
|
|
|
int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
|
|
TESTChoice1 c1;
|
|
TESTChoice1 c2_1;
|
|
TESTChoice2 c2_2;
|
|
|
|
memset(&c1, 0, sizeof(c1));
|
|
c1.element = choice_TESTChoice1_i1;
|
|
c1.u.i1 = 1;
|
|
tests[0].val = &c1;
|
|
|
|
memset(&c2_1, 0, sizeof(c2_1));
|
|
c2_1.element = choice_TESTChoice1_i2;
|
|
c2_1.u.i2 = 2;
|
|
tests[1].val = &c2_1;
|
|
|
|
ret += generic_test (tests, ntests, sizeof(TESTChoice1),
|
|
(generic_encode)encode_TESTChoice1,
|
|
(generic_length)length_TESTChoice1,
|
|
(generic_decode)decode_TESTChoice1,
|
|
(generic_free)free_TESTChoice1,
|
|
cmp_TESTChoice,
|
|
(generic_copy)copy_TESTChoice1);
|
|
|
|
memset(&c2_2, 0, sizeof(c2_2));
|
|
c2_2.element = choice_TESTChoice2_asn1_ellipsis;
|
|
c2_2.u.asn1_ellipsis.data = "\xa2\x03\x02\x01\x02";
|
|
c2_2.u.asn1_ellipsis.length = 5;
|
|
tests[1].val = &c2_2;
|
|
|
|
ret += generic_test (tests, ntests, sizeof(TESTChoice2),
|
|
(generic_encode)encode_TESTChoice2,
|
|
(generic_length)length_TESTChoice2,
|
|
(generic_decode)decode_TESTChoice2,
|
|
(generic_free)free_TESTChoice2,
|
|
cmp_TESTChoice,
|
|
(generic_copy)copy_TESTChoice2);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
cmp_TESTImplicit (void *a, void *b)
|
|
{
|
|
TESTImplicit *aa = a;
|
|
TESTImplicit *ab = b;
|
|
|
|
COMPARE_INTEGER(aa,ab,ti1);
|
|
COMPARE_INTEGER(aa,ab,ti2.foo);
|
|
COMPARE_INTEGER(aa,ab,ti3);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
cmp_TESTImplicit2 (void *a, void *b)
|
|
{
|
|
TESTImplicit2 *aa = a;
|
|
TESTImplicit2 *ab = b;
|
|
|
|
COMPARE_INTEGER(aa,ab,ti1);
|
|
COMPARE_INTEGER(aa,ab,ti3);
|
|
IF_OPT_COMPARE(aa,ab,ti4) {
|
|
COMPARE_INTEGER(aa,ab,ti4[0]);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
cmp_TESTImplicit3 (void *a, void *b)
|
|
{
|
|
TESTImplicit3 *aa = a;
|
|
TESTImplicit3 *ab = b;
|
|
|
|
COMPARE_INTEGER(aa,ab,element);
|
|
if (aa->element == choice_TESTImplicit3_ti1) {
|
|
COMPARE_INTEGER(aa,ab,u.ti1);
|
|
} else {
|
|
COMPARE_INTEGER(aa,ab,u.ti2.element);
|
|
COMPARE_INTEGER(aa,ab,u.ti2.u.i1);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
cmp_TESTImplicit4 (void *a, void *b)
|
|
{
|
|
TESTImplicit4 *aa = a;
|
|
TESTImplicit4 *ab = b;
|
|
|
|
COMPARE_INTEGER(aa,ab,element);
|
|
if (aa->element == choice_TESTImplicit4_ti1) {
|
|
COMPARE_INTEGER(aa,ab,u.ti1);
|
|
} else {
|
|
COMPARE_INTEGER(aa,ab,u.ti2.element);
|
|
COMPARE_INTEGER(aa,ab,u.ti2.u.i1);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
test_implicit (void)
|
|
{
|
|
int ret = 0;
|
|
/*
|
|
* UNIV CONS Sequence = 14 bytes {
|
|
* CONTEXT PRIM tag 0 = 1 bytes [0] IMPLICIT content
|
|
* CONTEXT CONS tag 1 = 6 bytes [1]
|
|
* CONTEXT CONS tag 127 = 3 bytes [127]
|
|
* UNIV PRIM Integer = integer 2
|
|
* CONTEXT PRIM tag 2 = 1 bytes [2] IMPLICIT content
|
|
* }
|
|
*/
|
|
struct test_case tests[] = {
|
|
{ NULL, 16,
|
|
"\x30\x0e\x80\x01\x00\xa1\x06\xbf\x7f\x03\x02\x01\x02\x82\x01\x03",
|
|
"implicit 1" }
|
|
};
|
|
/*
|
|
* UNIV CONS Sequence = 10 bytes {
|
|
* CONTEXT PRIM tag 0 = 1 bytes [0] IMPLICIT content
|
|
* CONTEXT PRIM tag 2 = 1 bytes [2] IMPLICIT content
|
|
* CONTEXT PRIM tag 51 = 1 bytes [51] IMPLICIT content
|
|
* }
|
|
*/
|
|
struct test_case tests2[] = {
|
|
{ NULL, 12,
|
|
"\x30\x0a\x80\x01\x01\x82\x01\x03\x9f\x33\x01\x04",
|
|
"implicit 2" }
|
|
};
|
|
/*
|
|
* CONTEXT CONS tag 5 = 5 bytes [5]
|
|
* CONTEXT CONS tag 1 = 3 bytes [1]
|
|
* UNIV PRIM Integer = integer 5
|
|
*/
|
|
struct test_case tests3[] = {
|
|
{ NULL, 7,
|
|
"\xa5\x05\xa1\x03\x02\x01\x05",
|
|
"implicit 3" }
|
|
};
|
|
/*
|
|
* Notice: same as tests3[].bytes.
|
|
*
|
|
* CONTEXT CONS tag 5 = 5 bytes [5]
|
|
* CONTEXT CONS tag 1 = 3 bytes [1]
|
|
* UNIV PRIM Integer = integer 5
|
|
*/
|
|
struct test_case tests4[] = {
|
|
{ NULL, 7,
|
|
"\xa5\x05\xa1\x03\x02\x01\x05",
|
|
"implicit 4" }
|
|
};
|
|
|
|
TESTImplicit c0;
|
|
TESTImplicit2 c1;
|
|
TESTImplicit3 c2;
|
|
TESTImplicit4 c3;
|
|
int ti4 = 4;
|
|
|
|
memset(&c0, 0, sizeof(c0));
|
|
c0.ti1 = 0;
|
|
c0.ti2.foo = 2;
|
|
c0.ti3 = 3;
|
|
tests[0].val = &c0;
|
|
|
|
memset(&c1, 0, sizeof(c1));
|
|
c1.ti1 = 1;
|
|
c1.ti3 = 3;
|
|
c1.ti4 = &ti4;
|
|
tests2[0].val = &c1;
|
|
|
|
memset(&c2, 0, sizeof(c2));
|
|
c2.element = choice_TESTImplicit3_ti2;
|
|
c2.u.ti2.element = choice_TESTImplicit3_ti2_i1;
|
|
c2.u.ti2.u.i1 = 5;
|
|
tests3[0].val = &c2;
|
|
|
|
memset(&c3, 0, sizeof(c3));
|
|
c3.element = choice_TESTImplicit4_ti2;
|
|
c3.u.ti2.element = choice_TESTChoice2_i1;
|
|
c3.u.ti2.u.i1 = 5;
|
|
tests4[0].val = &c3;
|
|
|
|
ret += generic_test(tests,
|
|
sizeof(tests) / sizeof(*tests),
|
|
sizeof(TESTImplicit),
|
|
(generic_encode)encode_TESTImplicit,
|
|
(generic_length)length_TESTImplicit,
|
|
(generic_decode)decode_TESTImplicit,
|
|
(generic_free)free_TESTImplicit,
|
|
cmp_TESTImplicit,
|
|
(generic_copy)copy_TESTImplicit);
|
|
|
|
ret += generic_test(tests2,
|
|
sizeof(tests2) / sizeof(*tests2),
|
|
sizeof(TESTImplicit2),
|
|
(generic_encode)encode_TESTImplicit2,
|
|
(generic_length)length_TESTImplicit2,
|
|
(generic_decode)decode_TESTImplicit2,
|
|
(generic_free)free_TESTImplicit2,
|
|
cmp_TESTImplicit2,
|
|
NULL);
|
|
|
|
ret += generic_test(tests3,
|
|
sizeof(tests3) / sizeof(*tests3),
|
|
sizeof(TESTImplicit3),
|
|
(generic_encode)encode_TESTImplicit3,
|
|
(generic_length)length_TESTImplicit3,
|
|
(generic_decode)decode_TESTImplicit3,
|
|
(generic_free)free_TESTImplicit3,
|
|
cmp_TESTImplicit3,
|
|
NULL);
|
|
|
|
ret += generic_test(tests4,
|
|
sizeof(tests4) / sizeof(*tests4),
|
|
sizeof(TESTImplicit4),
|
|
(generic_encode)encode_TESTImplicit4,
|
|
(generic_length)length_TESTImplicit4,
|
|
(generic_decode)decode_TESTImplicit4,
|
|
(generic_free)free_TESTImplicit4,
|
|
cmp_TESTImplicit4,
|
|
NULL);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
cmp_TESTAlloc (void *a, void *b)
|
|
{
|
|
TESTAlloc *aa = a;
|
|
TESTAlloc *ab = b;
|
|
|
|
IF_OPT_COMPARE(aa,ab,tagless) {
|
|
COMPARE_INTEGER(aa,ab,tagless->ai);
|
|
}
|
|
|
|
COMPARE_INTEGER(aa,ab,three);
|
|
|
|
IF_OPT_COMPARE(aa,ab,tagless2) {
|
|
COMPARE_OPT_OCTET_STRING(aa, ab, tagless2);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
UNIV CONS Sequence 12
|
|
UNIV CONS Sequence 5
|
|
CONTEXT CONS 0 3
|
|
UNIV PRIM Integer 1 01
|
|
CONTEXT CONS 1 3
|
|
UNIV PRIM Integer 1 03
|
|
|
|
UNIV CONS Sequence 5
|
|
CONTEXT CONS 1 3
|
|
UNIV PRIM Integer 1 03
|
|
|
|
UNIV CONS Sequence 8
|
|
CONTEXT CONS 1 3
|
|
UNIV PRIM Integer 1 04
|
|
UNIV PRIM Integer 1 05
|
|
|
|
*/
|
|
|
|
static int
|
|
test_taglessalloc (void)
|
|
{
|
|
struct test_case tests[] = {
|
|
{ NULL, 14,
|
|
"\x30\x0c\x30\x05\xa0\x03\x02\x01\x01\xa1\x03\x02\x01\x03",
|
|
"alloc 1" },
|
|
{ NULL, 7,
|
|
"\x30\x05\xa1\x03\x02\x01\x03",
|
|
"alloc 2" },
|
|
{ NULL, 10,
|
|
"\x30\x08\xa1\x03\x02\x01\x04\x02\x01\x05",
|
|
"alloc 3" }
|
|
};
|
|
|
|
int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
|
|
TESTAlloc c1, c2, c3;
|
|
heim_any any3;
|
|
|
|
memset(&c1, 0, sizeof(c1));
|
|
c1.tagless = ecalloc(1, sizeof(*c1.tagless));
|
|
c1.tagless->ai = 1;
|
|
c1.three = 3;
|
|
tests[0].val = &c1;
|
|
|
|
memset(&c2, 0, sizeof(c2));
|
|
c2.tagless = NULL;
|
|
c2.three = 3;
|
|
tests[1].val = &c2;
|
|
|
|
memset(&c3, 0, sizeof(c3));
|
|
c3.tagless = NULL;
|
|
c3.three = 4;
|
|
c3.tagless2 = &any3;
|
|
any3.data = "\x02\x01\x05";
|
|
any3.length = 3;
|
|
tests[2].val = &c3;
|
|
|
|
ret += generic_test (tests, ntests, sizeof(TESTAlloc),
|
|
(generic_encode)encode_TESTAlloc,
|
|
(generic_length)length_TESTAlloc,
|
|
(generic_decode)decode_TESTAlloc,
|
|
(generic_free)free_TESTAlloc,
|
|
cmp_TESTAlloc,
|
|
(generic_copy)copy_TESTAlloc);
|
|
|
|
free(c1.tagless);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
cmp_TESTOptional (void *a, void *b)
|
|
{
|
|
TESTOptional *aa = a;
|
|
TESTOptional *ab = b;
|
|
|
|
IF_OPT_COMPARE(aa,ab,zero) {
|
|
COMPARE_OPT_INTEGER(aa,ab,zero);
|
|
}
|
|
IF_OPT_COMPARE(aa,ab,one) {
|
|
COMPARE_OPT_INTEGER(aa,ab,one);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
UNIV CONS Sequence 5
|
|
CONTEXT CONS 0 3
|
|
UNIV PRIM Integer 1 00
|
|
|
|
UNIV CONS Sequence 5
|
|
CONTEXT CONS 1 3
|
|
UNIV PRIM Integer 1 03
|
|
|
|
UNIV CONS Sequence 10
|
|
CONTEXT CONS 0 3
|
|
UNIV PRIM Integer 1 00
|
|
CONTEXT CONS 1 3
|
|
UNIV PRIM Integer 1 01
|
|
|
|
*/
|
|
|
|
static int
|
|
test_optional (void)
|
|
{
|
|
struct test_case tests[] = {
|
|
{ NULL, 2,
|
|
"\x30\x00",
|
|
"optional 0" },
|
|
{ NULL, 7,
|
|
"\x30\x05\xa0\x03\x02\x01\x00",
|
|
"optional 1" },
|
|
{ NULL, 7,
|
|
"\x30\x05\xa1\x03\x02\x01\x01",
|
|
"optional 2" },
|
|
{ NULL, 12,
|
|
"\x30\x0a\xa0\x03\x02\x01\x00\xa1\x03\x02\x01\x01",
|
|
"optional 3" }
|
|
};
|
|
|
|
int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
|
|
TESTOptional c0, c1, c2, c3;
|
|
int zero = 0;
|
|
int one = 1;
|
|
|
|
c0.zero = NULL;
|
|
c0.one = NULL;
|
|
tests[0].val = &c0;
|
|
|
|
c1.zero = &zero;
|
|
c1.one = NULL;
|
|
tests[1].val = &c1;
|
|
|
|
c2.zero = NULL;
|
|
c2.one = &one;
|
|
tests[2].val = &c2;
|
|
|
|
c3.zero = &zero;
|
|
c3.one = &one;
|
|
tests[3].val = &c3;
|
|
|
|
ret += generic_test (tests, ntests, sizeof(TESTOptional),
|
|
(generic_encode)encode_TESTOptional,
|
|
(generic_length)length_TESTOptional,
|
|
(generic_decode)decode_TESTOptional,
|
|
(generic_free)free_TESTOptional,
|
|
cmp_TESTOptional,
|
|
(generic_copy)copy_TESTOptional);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
check_fail_largetag(void)
|
|
{
|
|
struct test_case tests[] = {
|
|
{NULL, 14, "\x30\x0c\xbf\x87\xff\xff\xff\xff\xff\x7f\x03\x02\x01\x01",
|
|
"tag overflow"},
|
|
{NULL, 0, "", "empty buffer"},
|
|
{NULL, 7, "\x30\x05\xa1\x03\x02\x02\x01",
|
|
"one too short" },
|
|
{NULL, 7, "\x30\x04\xa1\x03\x02\x02\x01",
|
|
"two too short" },
|
|
{NULL, 7, "\x30\x03\xa1\x03\x02\x02\x01",
|
|
"three too short" },
|
|
{NULL, 7, "\x30\x02\xa1\x03\x02\x02\x01",
|
|
"four too short" },
|
|
{NULL, 7, "\x30\x01\xa1\x03\x02\x02\x01",
|
|
"five too short" },
|
|
{NULL, 7, "\x30\x00\xa1\x03\x02\x02\x01",
|
|
"six too short" },
|
|
{NULL, 7, "\x30\x05\xa1\x04\x02\x02\x01",
|
|
"inner one too long" },
|
|
{NULL, 7, "\x30\x00\xa1\x02\x02\x02\x01",
|
|
"inner one too short" },
|
|
{NULL, 8, "\x30\x05\xbf\x7f\x03\x02\x02\x01",
|
|
"inner one too short"},
|
|
{NULL, 8, "\x30\x06\xbf\x64\x03\x02\x01\x01",
|
|
"wrong tag"},
|
|
{NULL, 10, "\x30\x08\xbf\x9a\x9b\x38\x03\x02\x01\x01",
|
|
"still wrong tag"}
|
|
};
|
|
int ntests = sizeof(tests) / sizeof(*tests);
|
|
|
|
return generic_decode_fail(tests, ntests, sizeof(TESTLargeTag),
|
|
(generic_decode)decode_TESTLargeTag);
|
|
}
|
|
|
|
|
|
static int
|
|
check_fail_sequence(void)
|
|
{
|
|
struct test_case tests[] = {
|
|
{NULL, 0, "", "empty buffer"},
|
|
{NULL, 24,
|
|
"\x30\x16\xa0\x03\x02\x01\x01\xa1\x08\x30\x06\xbf\x7f\x03\x02\x01\x01"
|
|
"\x02\x01\x01\xa2\x03\x02\x01\x01",
|
|
"missing one byte from the end, internal length ok"},
|
|
{NULL, 25,
|
|
"\x30\x18\xa0\x03\x02\x01\x01\xa1\x08\x30\x06\xbf\x7f\x03\x02\x01\x01"
|
|
"\x02\x01\x01\xa2\x03\x02\x01\x01",
|
|
"inner length one byte too long"},
|
|
{NULL, 24,
|
|
"\x30\x17\xa0\x03\x02\x01\x01\xa1\x08\x30\x06\xbf\x7f\x03\x02\x01"
|
|
"\x01\x02\x01\x01\xa2\x03\x02\x01\x01",
|
|
"correct buffer but missing one too short"}
|
|
};
|
|
int ntests = sizeof(tests) / sizeof(*tests);
|
|
|
|
return generic_decode_fail(tests, ntests, sizeof(TESTSeq),
|
|
(generic_decode)decode_TESTSeq);
|
|
}
|
|
|
|
static int
|
|
check_fail_choice(void)
|
|
{
|
|
struct test_case tests[] = {
|
|
{NULL, 6,
|
|
"\xa1\x02\x02\x01\x01",
|
|
"choice one too short"},
|
|
{NULL, 6,
|
|
"\xa1\x03\x02\x02\x01",
|
|
"choice one too short inner"}
|
|
};
|
|
int ntests = sizeof(tests) / sizeof(*tests);
|
|
|
|
return generic_decode_fail(tests, ntests, sizeof(TESTChoice1),
|
|
(generic_decode)decode_TESTChoice1);
|
|
}
|
|
|
|
static int
|
|
check_fail_Ticket(void)
|
|
{
|
|
char buf[100];
|
|
size_t i;
|
|
int ret;
|
|
struct test_case test;
|
|
Ticket ticket;
|
|
|
|
for (i = 0; i < sizeof(buf); i++) {
|
|
memset(buf, 0, sizeof(buf));
|
|
memset(&ticket, 0, sizeof(ticket));
|
|
test.val = &ticket;
|
|
test.byte_len = i;
|
|
test.bytes = buf;
|
|
test.name = "zero life";
|
|
ret = generic_decode_fail(&test, 1, sizeof(Ticket),
|
|
(generic_decode)decode_Ticket);
|
|
if (ret)
|
|
return ret;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
check_seq(void)
|
|
{
|
|
TESTSeqOf seq;
|
|
TESTInteger i;
|
|
int ret;
|
|
|
|
seq.val = NULL;
|
|
seq.len = 0;
|
|
|
|
ret = add_TESTSeqOf(&seq, &i);
|
|
if (ret) { printf("failed adding\n"); goto out; }
|
|
ret = add_TESTSeqOf(&seq, &i);
|
|
if (ret) { printf("failed adding\n"); goto out; }
|
|
ret = add_TESTSeqOf(&seq, &i);
|
|
if (ret) { printf("failed adding\n"); goto out; }
|
|
ret = add_TESTSeqOf(&seq, &i);
|
|
if (ret) { printf("failed adding\n"); goto out; }
|
|
|
|
ret = remove_TESTSeqOf(&seq, seq.len - 1);
|
|
if (ret) { printf("failed removing\n"); goto out; }
|
|
ret = remove_TESTSeqOf(&seq, 2);
|
|
if (ret) { printf("failed removing\n"); goto out; }
|
|
ret = remove_TESTSeqOf(&seq, 0);
|
|
if (ret) { printf("failed removing\n"); goto out; }
|
|
ret = remove_TESTSeqOf(&seq, 0);
|
|
if (ret) { printf("failed removing\n"); goto out; }
|
|
ret = remove_TESTSeqOf(&seq, 0);
|
|
if (ret == 0) {
|
|
printf("can remove from empty list");
|
|
return 1;
|
|
}
|
|
|
|
if (seq.len != 0) {
|
|
printf("seq not empty!");
|
|
return 1;
|
|
}
|
|
free_TESTSeqOf(&seq);
|
|
ret = 0;
|
|
|
|
out:
|
|
|
|
return ret;
|
|
}
|
|
|
|
#define test_seq_of(type, ok, ptr) \
|
|
{ \
|
|
heim_octet_string os; \
|
|
size_t size; \
|
|
type decode; \
|
|
ASN1_MALLOC_ENCODE(type, os.data, os.length, ptr, &size, ret); \
|
|
if (ret) \
|
|
return ret; \
|
|
if (os.length != size) \
|
|
abort(); \
|
|
ret = decode_##type(os.data, os.length, &decode, &size); \
|
|
free(os.data); \
|
|
if (ret) { \
|
|
if (ok) \
|
|
return 1; \
|
|
} else { \
|
|
free_##type(&decode); \
|
|
if (!ok) \
|
|
return 1; \
|
|
if (size != 0) \
|
|
return 1; \
|
|
} \
|
|
return 0; \
|
|
}
|
|
|
|
static int
|
|
check_seq_of_size(void)
|
|
{
|
|
#if 0 /* template */
|
|
TESTInteger integers[4] = { 1, 2, 3, 4 };
|
|
int ret;
|
|
|
|
{
|
|
TESTSeqSizeOf1 ssof1f1 = { 1, integers };
|
|
TESTSeqSizeOf1 ssof1ok1 = { 2, integers };
|
|
TESTSeqSizeOf1 ssof1f2 = { 3, integers };
|
|
|
|
test_seq_of(TESTSeqSizeOf1, 0, &ssof1f1);
|
|
test_seq_of(TESTSeqSizeOf1, 1, &ssof1ok1);
|
|
test_seq_of(TESTSeqSizeOf1, 0, &ssof1f2);
|
|
}
|
|
{
|
|
TESTSeqSizeOf2 ssof2f1 = { 0, NULL };
|
|
TESTSeqSizeOf2 ssof2ok1 = { 1, integers };
|
|
TESTSeqSizeOf2 ssof2ok2 = { 2, integers };
|
|
TESTSeqSizeOf2 ssof2f2 = { 3, integers };
|
|
|
|
test_seq_of(TESTSeqSizeOf2, 0, &ssof2f1);
|
|
test_seq_of(TESTSeqSizeOf2, 1, &ssof2ok1);
|
|
test_seq_of(TESTSeqSizeOf2, 1, &ssof2ok2);
|
|
test_seq_of(TESTSeqSizeOf2, 0, &ssof2f2);
|
|
}
|
|
{
|
|
TESTSeqSizeOf3 ssof3f1 = { 0, NULL };
|
|
TESTSeqSizeOf3 ssof3ok1 = { 1, integers };
|
|
TESTSeqSizeOf3 ssof3ok2 = { 2, integers };
|
|
|
|
test_seq_of(TESTSeqSizeOf3, 0, &ssof3f1);
|
|
test_seq_of(TESTSeqSizeOf3, 1, &ssof3ok1);
|
|
test_seq_of(TESTSeqSizeOf3, 1, &ssof3ok2);
|
|
}
|
|
{
|
|
TESTSeqSizeOf4 ssof4ok1 = { 0, NULL };
|
|
TESTSeqSizeOf4 ssof4ok2 = { 1, integers };
|
|
TESTSeqSizeOf4 ssof4ok3 = { 2, integers };
|
|
TESTSeqSizeOf4 ssof4f1 = { 3, integers };
|
|
|
|
test_seq_of(TESTSeqSizeOf4, 1, &ssof4ok1);
|
|
test_seq_of(TESTSeqSizeOf4, 1, &ssof4ok2);
|
|
test_seq_of(TESTSeqSizeOf4, 1, &ssof4ok3);
|
|
test_seq_of(TESTSeqSizeOf4, 0, &ssof4f1);
|
|
}
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
check_TESTMechTypeList(void)
|
|
{
|
|
TESTMechTypeList tl;
|
|
unsigned oid1[] = { 1, 2, 840, 48018, 1, 2, 2};
|
|
unsigned oid2[] = { 1, 2, 840, 113554, 1, 2, 2};
|
|
unsigned oid3[] = { 1, 3, 6, 1, 4, 1, 311, 2, 2, 30};
|
|
unsigned oid4[] = { 1, 3, 6, 1, 4, 1, 311, 2, 2, 10};
|
|
TESTMechType array[] = {{ 7, oid1 },
|
|
{ 7, oid2 },
|
|
{ 10, oid3 },
|
|
{ 10, oid4 }};
|
|
size_t size, len;
|
|
void *ptr;
|
|
int ret;
|
|
|
|
tl.len = 4;
|
|
tl.val = array;
|
|
|
|
ASN1_MALLOC_ENCODE(TESTMechTypeList, ptr, len, &tl, &size, ret);
|
|
if (ret)
|
|
errx(1, "TESTMechTypeList: %d", ret);
|
|
if (len != size)
|
|
abort();
|
|
free(ptr);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
cmp_TESTSeqOf4(void *a, void *b)
|
|
{
|
|
TESTSeqOf4 *aa = a;
|
|
TESTSeqOf4 *ab = b;
|
|
int i;
|
|
|
|
IF_OPT_COMPARE(aa, ab, b1) {
|
|
COMPARE_INTEGER(aa->b1, ab->b1, len);
|
|
for (i = 0; i < aa->b1->len; ++i) {
|
|
COMPARE_INTEGER(aa->b1->val+i, ab->b1->val+i, u1);
|
|
COMPARE_INTEGER(aa->b1->val+i, ab->b1->val+i, u2);
|
|
COMPARE_OCTET_STRING(aa->b1->val+i, ab->b1->val+i, s1);
|
|
COMPARE_OCTET_STRING(aa->b1->val+i, ab->b1->val+i, s2);
|
|
}
|
|
}
|
|
IF_OPT_COMPARE(aa, ab, b2) {
|
|
COMPARE_INTEGER(aa->b2, ab->b2, len);
|
|
for (i = 0; i < aa->b2->len; ++i) {
|
|
COMPARE_INTEGER(aa->b2->val+i, ab->b2->val+i, u1);
|
|
COMPARE_INTEGER(aa->b2->val+i, ab->b2->val+i, u2);
|
|
COMPARE_INTEGER(aa->b2->val+i, ab->b2->val+i, u3);
|
|
COMPARE_OCTET_STRING(aa->b2->val+i, ab->b2->val+i, s1);
|
|
COMPARE_OCTET_STRING(aa->b2->val+i, ab->b2->val+i, s2);
|
|
COMPARE_OCTET_STRING(aa->b2->val+i, ab->b2->val+i, s3);
|
|
}
|
|
}
|
|
IF_OPT_COMPARE(aa, ab, b3) {
|
|
COMPARE_INTEGER(aa->b3, ab->b3, len);
|
|
for (i = 0; i < aa->b3->len; ++i) {
|
|
COMPARE_INTEGER(aa->b3->val+i, ab->b3->val+i, u1);
|
|
COMPARE_INTEGER(aa->b3->val+i, ab->b3->val+i, u2);
|
|
COMPARE_INTEGER(aa->b3->val+i, ab->b3->val+i, u3);
|
|
COMPARE_INTEGER(aa->b3->val+i, ab->b3->val+i, u4);
|
|
COMPARE_OCTET_STRING(aa->b3->val+i, ab->b3->val+i, s1);
|
|
COMPARE_OCTET_STRING(aa->b3->val+i, ab->b3->val+i, s2);
|
|
COMPARE_OCTET_STRING(aa->b3->val+i, ab->b3->val+i, s3);
|
|
COMPARE_OCTET_STRING(aa->b3->val+i, ab->b3->val+i, s4);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
test_seq4 (void)
|
|
{
|
|
int ret = 0;
|
|
struct test_case tests[] = {
|
|
{ NULL, 2,
|
|
"\x30\x00",
|
|
"seq4 0" },
|
|
{ NULL, 4,
|
|
"\x30\x02" "\xa1\x00",
|
|
"seq4 1" },
|
|
{ NULL, 8,
|
|
"\x30\x06" "\xa0\x02\x30\x00" "\xa1\x00",
|
|
"seq4 2" },
|
|
{ NULL, 2 + (2 + 0x18) + (2 + 0x27) + (2 + 0x31),
|
|
"\x30\x76" /* 2 SEQ */
|
|
"\xa0\x18\x30\x16" /* 4 [0] SEQ */
|
|
"\x30\x14" /* 2 SEQ */
|
|
"\x04\x00" /* 2 OCTET-STRING */
|
|
"\x04\x02\x01\x02" /* 4 OCTET-STRING */
|
|
"\x02\x01\x01" /* 3 INT */
|
|
"\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff"
|
|
/* 11 INT */
|
|
"\xa1\x27" /* 2 [1] IMPL SEQ */
|
|
"\x30\x25" /* 2 SEQ */
|
|
"\x02\x01\x01" /* 3 INT */
|
|
"\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff"
|
|
/* 11 INT */
|
|
"\x02\x09\x00\x80\x00\x00\x00\x00\x00\x00\x00"
|
|
/* 11 INT */
|
|
"\x04\x00" /* 2 OCTET-STRING */
|
|
"\x04\x02\x01\x02" /* 4 OCTET-STRING */
|
|
"\x04\x04\x00\x01\x02\x03" /* 6 OCTET-STRING */
|
|
"\xa2\x31" /* 2 [2] IMPL SEQ */
|
|
"\x30\x2f" /* 2 SEQ */
|
|
"\x04\x00" /* 2 OCTET-STRING */
|
|
"\x02\x01\x01" /* 3 INT */
|
|
"\x04\x02\x01\x02" /* 4 OCTET-STRING */
|
|
"\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff"
|
|
/* 11 INT */
|
|
"\x04\x04\x00\x01\x02\x03" /* 6 OCTET-STRING */
|
|
"\x02\x09\x00\x80\x00\x00\x00\x00\x00\x00\x00"
|
|
/* 11 INT */
|
|
"\x04\x01\x00" /* 3 OCTET-STRING */
|
|
"\x02\x05\x01\x00\x00\x00\x00", /* 7 INT */
|
|
"seq4 3" },
|
|
};
|
|
|
|
int ntests = sizeof(tests) / sizeof(*tests);
|
|
TESTSeqOf4 c[4];
|
|
struct TESTSeqOf4_b1 b1[4];
|
|
struct TESTSeqOf4_b2 b2[4];
|
|
struct TESTSeqOf4_b3 b3[4];
|
|
struct TESTSeqOf4_b1_val b1val[4];
|
|
struct TESTSeqOf4_b2_val b2val[4];
|
|
struct TESTSeqOf4_b3_val b3val[4];
|
|
|
|
c[0].b1 = NULL;
|
|
c[0].b2 = NULL;
|
|
c[0].b3 = NULL;
|
|
tests[0].val = &c[0];
|
|
|
|
b2[1].len = 0;
|
|
b2[1].val = NULL;
|
|
c[1].b1 = NULL;
|
|
c[1].b2 = &b2[1];
|
|
c[1].b3 = NULL;
|
|
tests[1].val = &c[1];
|
|
|
|
b1[2].len = 0;
|
|
b1[2].val = NULL;
|
|
b2[2].len = 0;
|
|
b2[2].val = NULL;
|
|
c[2].b1 = &b1[2];
|
|
c[2].b2 = &b2[2];
|
|
c[2].b3 = NULL;
|
|
tests[2].val = &c[2];
|
|
|
|
b1val[3].s1.data = "";
|
|
b1val[3].s1.length = 0;
|
|
b1val[3].u1 = 1LL;
|
|
b1val[3].s2.data = "\x01\x02";
|
|
b1val[3].s2.length = 2;
|
|
b1val[3].u2 = -1LL;
|
|
|
|
b2val[3].s1.data = "";
|
|
b2val[3].s1.length = 0;
|
|
b2val[3].u1 = 1LL;
|
|
b2val[3].s2.data = "\x01\x02";
|
|
b2val[3].s2.length = 2;
|
|
b2val[3].u2 = -1LL;
|
|
b2val[3].s3.data = "\x00\x01\x02\x03";
|
|
b2val[3].s3.length = 4;
|
|
b2val[3].u3 = 1LL<<63;
|
|
|
|
b3val[3].s1.data = "";
|
|
b3val[3].s1.length = 0;
|
|
b3val[3].u1 = 1LL;
|
|
b3val[3].s2.data = "\x01\x02";
|
|
b3val[3].s2.length = 2;
|
|
b3val[3].u2 = -1LL;
|
|
b3val[3].s3.data = "\x00\x01\x02\x03";
|
|
b3val[3].s3.length = 4;
|
|
b3val[3].u3 = 1LL<<63;
|
|
b3val[3].s4.data = "\x00";
|
|
b3val[3].s4.length = 1;
|
|
b3val[3].u4 = 1LL<<32;
|
|
|
|
b1[3].len = 1;
|
|
b1[3].val = &b1val[3];
|
|
b2[3].len = 1;
|
|
b2[3].val = &b2val[3];
|
|
b3[3].len = 1;
|
|
b3[3].val = &b3val[3];
|
|
c[3].b1 = &b1[3];
|
|
c[3].b2 = &b2[3];
|
|
c[3].b3 = &b3[3];
|
|
tests[3].val = &c[3];
|
|
|
|
ret += generic_test (tests, ntests, sizeof(TESTSeqOf4),
|
|
(generic_encode)encode_TESTSeqOf4,
|
|
(generic_length)length_TESTSeqOf4,
|
|
(generic_decode)decode_TESTSeqOf4,
|
|
(generic_free)free_TESTSeqOf4,
|
|
cmp_TESTSeqOf4,
|
|
(generic_copy)copy_TESTSeqOf4);
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
cmp_test_seqof5 (void *a, void *b)
|
|
{
|
|
TESTSeqOf5 *aval = a;
|
|
TESTSeqOf5 *bval = b;
|
|
|
|
IF_OPT_COMPARE(aval, bval, outer) {
|
|
COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u0);
|
|
COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s0);
|
|
COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u1);
|
|
COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s1);
|
|
COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u2);
|
|
COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s2);
|
|
COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u3);
|
|
COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s3);
|
|
COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u4);
|
|
COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s4);
|
|
COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u5);
|
|
COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s5);
|
|
COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u6);
|
|
COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s6);
|
|
COMPARE_INTEGER(&aval->outer->inner, &bval->outer->inner, u7);
|
|
COMPARE_OCTET_STRING(&aval->outer->inner, &bval->outer->inner, s7);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
test_seqof5(void)
|
|
{
|
|
struct test_case tests[] = {
|
|
{ NULL, 2, "\x30\x00", "seq5 0" },
|
|
{ NULL, 126,
|
|
"\x30\x7c" /* SEQ */
|
|
"\x30\x7a" /* SEQ */
|
|
"\x30\x78" /* SEQ */
|
|
"\x02\x01\x01" /* INT 1 */
|
|
"\x04\x06\x01\x01\x01\x01\x01\x01" /* "\0x1"x6 */
|
|
"\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xfe" /* INT ~1 */
|
|
"\x04\x06\x02\x02\x02\x02\x02\x02" /* "\x02"x6 */
|
|
"\x02\x01\x02" /* INT 2 */
|
|
"\x04\x06\x03\x03\x03\x03\x03\x03" /* "\x03"x6 */
|
|
"\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xfd" /* INT ~2 */
|
|
"\x04\x06\x04\x04\x04\x04\x04\x04" /* ... */
|
|
"\x02\x01\x03"
|
|
"\x04\x06\x05\x05\x05\x05\x05\x05"
|
|
"\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xfc"
|
|
"\x04\x06\x06\x06\x06\x06\x06\x06"
|
|
"\x02\x01\x04"
|
|
"\x04\x06\x07\x07\x07\x07\x07\x07"
|
|
"\x02\x09\x00\xff\xff\xff\xff\xff\xff\xff\xfb"
|
|
"\x04\x06\x08\x08\x08\x08\x08\x08",
|
|
"seq5 1" },
|
|
};
|
|
|
|
int ret = 0, ntests = sizeof(tests) / sizeof(*tests);
|
|
TESTSeqOf5 c[2];
|
|
struct TESTSeqOf5_outer outer;
|
|
struct TESTSeqOf5_outer_inner inner;
|
|
TESTuint64 u[8];
|
|
heim_octet_string s[8];
|
|
int i;
|
|
|
|
c[0].outer = NULL;
|
|
tests[0].val = &c[0];
|
|
|
|
for (i = 0; i < 8; ++i) {
|
|
u[i] = (i&1) == 0 ? i/2+1 : ~(i/2+1);
|
|
s[i].data = memset(malloc(s[i].length = 6), i+1, 6);
|
|
}
|
|
|
|
inner.u0 = u[0]; inner.u1 = u[1]; inner.u2 = u[2]; inner.u3 = u[3];
|
|
inner.u4 = u[4]; inner.u5 = u[5]; inner.u6 = u[6]; inner.u7 = u[7];
|
|
inner.s0 = s[0]; inner.s1 = s[1]; inner.s2 = s[2]; inner.s3 = s[3];
|
|
inner.s4 = s[4]; inner.s5 = s[5]; inner.s6 = s[6]; inner.s7 = s[7];
|
|
|
|
outer.inner = inner;
|
|
c[1].outer = &outer;
|
|
tests[1].val = &c[1];
|
|
|
|
ret += generic_test (tests, ntests, sizeof(TESTSeqOf5),
|
|
(generic_encode)encode_TESTSeqOf5,
|
|
(generic_length)length_TESTSeqOf5,
|
|
(generic_decode)decode_TESTSeqOf5,
|
|
(generic_free)free_TESTSeqOf5,
|
|
cmp_test_seqof5,
|
|
NULL);
|
|
|
|
for (i = 0; i < 8; ++i)
|
|
free(s[i].data);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
cmp_default(void *a, void *b)
|
|
{
|
|
TESTDefault *aa = a;
|
|
TESTDefault *ab = b;
|
|
|
|
COMPARE_STRING(aa,ab,name);
|
|
COMPARE_INTEGER(aa,ab,version);
|
|
COMPARE_INTEGER(aa,ab,maxint);
|
|
COMPARE_INTEGER(aa,ab,works);
|
|
return 0;
|
|
}
|
|
|
|
static int
|
|
test_default(void)
|
|
{
|
|
struct test_case tests[] = {
|
|
{ NULL, 2, "\x30\x00", NULL },
|
|
{ NULL, 25,
|
|
"\x30\x17\x0c\x07\x68\x65\x69\x6d\x64\x61"
|
|
"\x6c\xa0\x03\x02\x01\x07\x02\x04\x7f\xff"
|
|
"\xff\xff\x01\x01\x00",
|
|
NULL
|
|
},
|
|
{ NULL, 10,
|
|
"\x30\x08\xa0\x03\x02\x01\x07\x01\x01\x00",
|
|
NULL
|
|
},
|
|
{ NULL, 17,
|
|
"\x30\x0f\x0c\x07\x68\x65\x69\x6d\x64\x61\x6c\x02\x04"
|
|
"\x7f\xff\xff\xff",
|
|
NULL
|
|
}
|
|
};
|
|
|
|
TESTDefault values[] = {
|
|
{ "Heimdal", 8, 9223372036854775807, 1 },
|
|
{ "heimdal", 7, 2147483647, 0 },
|
|
{ "Heimdal", 7, 9223372036854775807, 0 },
|
|
{ "heimdal", 8, 2147483647, 1 },
|
|
};
|
|
int i, ret;
|
|
int ntests = sizeof(tests) / sizeof(*tests);
|
|
|
|
for (i = 0; i < ntests; ++i) {
|
|
tests[i].val = &values[i];
|
|
if (asprintf (&tests[i].name, "TESTDefault %d", i) < 0)
|
|
errx(1, "malloc");
|
|
if (tests[i].name == NULL)
|
|
errx(1, "malloc");
|
|
}
|
|
|
|
ret = generic_test (tests, ntests, sizeof(TESTDefault),
|
|
(generic_encode)encode_TESTDefault,
|
|
(generic_length)length_TESTDefault,
|
|
(generic_decode)decode_TESTDefault,
|
|
(generic_free)free_TESTDefault,
|
|
cmp_default,
|
|
(generic_copy)copy_TESTDefault);
|
|
for (i = 0; i < ntests; ++i)
|
|
free(tests[i].name);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int
|
|
test_x690sample(void)
|
|
{
|
|
/*
|
|
* Taken from X.690, Appendix A, though sadly it's not specified whether
|
|
* it's in BER, DER, or CER, but it is clearly BER and neither DER nor CER
|
|
* because the tags of the members of the X690SamplePersonnelRecord type
|
|
* are not canonically sorted in the given sample.
|
|
*
|
|
* Our compiler does NOT canonically sort the members of SET { ... } types
|
|
* so it produces the same encoding after decoding this test vector. That
|
|
* is clearly a bug given that we aim to output DER.
|
|
*
|
|
* The template compiler doesn't even decode SET { ... } values properly
|
|
* when their members are not in the same order as defined (but the regular
|
|
* compiler does).
|
|
*/
|
|
X690SamplePersonnelRecord r;
|
|
heim_octet_string os;
|
|
unsigned char encoded_sample[] = {
|
|
0x60, 0x81, 0x85, 0x61, 0x10, 0x1a, 0x04, 0x4a, 0x6f, 0x68, 0x6e, 0x1a,
|
|
0x01, 0x50, 0x1a, 0x05, 0x53, 0x6d, 0x69, 0x74, 0x68, 0xa0, 0x0a, 0x1a,
|
|
0x08, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x42, 0x01, 0x33,
|
|
0xa1, 0x0a, 0x43, 0x08, 0x31, 0x39, 0x37, 0x31, 0x30, 0x39, 0x31, 0x37,
|
|
0xa2, 0x12, 0x61, 0x10, 0x1a, 0x04, 0x4d, 0x61, 0x72, 0x79, 0x1a, 0x01,
|
|
0x54, 0x1a, 0x05, 0x53, 0x6d, 0x69, 0x74, 0x68, 0xa3, 0x42, 0x31, 0x1f,
|
|
0x61, 0x11, 0x1a, 0x05, 0x52, 0x61, 0x6c, 0x70, 0x68, 0x1a, 0x01, 0x54,
|
|
0x1a, 0x05, 0x53, 0x6d, 0x69, 0x74, 0x68, 0xa0, 0x0a, 0x43, 0x08, 0x31,
|
|
0x39, 0x35, 0x37, 0x31, 0x31, 0x31, 0x31, 0x31, 0x1f, 0x61, 0x11, 0x1a,
|
|
0x05, 0x53, 0x75, 0x73, 0x61, 0x6e, 0x1a, 0x01, 0x42, 0x1a, 0x05, 0x53,
|
|
0x6d, 0x69, 0x74, 0x68, 0xa0, 0x0a, 0x43, 0x08, 0x31, 0x39, 0x35, 0x39,
|
|
0x30, 0x37, 0x31, 0x37
|
|
};
|
|
size_t sz = 0;
|
|
int ret;
|
|
|
|
memset(&r, 0, sizeof(r));
|
|
if (decode_X690SamplePersonnelRecord(encoded_sample, sizeof(encoded_sample), &r, &sz))
|
|
return 1;
|
|
if (sz != sizeof(encoded_sample))
|
|
return 1;
|
|
free_X690SamplePersonnelRecord(&r);
|
|
memset(&r, 0, sizeof(r));
|
|
|
|
/* We re-construct the record manually to double-check the spec */
|
|
r.name.givenName = strdup("John");
|
|
r.name.initial = strdup("P");
|
|
r.name.familyName = strdup("Smith");
|
|
r.title = strdup("Director");
|
|
r.dateOfHire = strdup("19710917");
|
|
r.number = 51;
|
|
r.nameOfSpouse.givenName = strdup("Mary");
|
|
r.nameOfSpouse.initial = strdup("T");
|
|
r.nameOfSpouse.familyName = strdup("Smith");
|
|
r.children.val = calloc(2, sizeof(r.children.val[0]));
|
|
r.children.len = 2;
|
|
r.children.val[0].name.givenName = strdup("Ralph");
|
|
r.children.val[0].name.initial = strdup("T");
|
|
r.children.val[0].name.familyName = strdup("Smith");
|
|
r.children.val[0].dateOfBirth = strdup("19571111");
|
|
r.children.val[1].name.givenName = strdup("Susan");
|
|
r.children.val[1].name.initial = strdup("B");
|
|
r.children.val[1].name.familyName = strdup("Smith");
|
|
r.children.val[1].dateOfBirth = strdup("19590717");
|
|
os.length = 0;
|
|
os.data = 0;
|
|
ASN1_MALLOC_ENCODE(X690SamplePersonnelRecord, os.data, os.length, &r, &sz,
|
|
ret);
|
|
if (ret || sz != sizeof(encoded_sample) || sz != os.length ||
|
|
memcmp(encoded_sample, os.data, sz) != 0)
|
|
return 1;
|
|
free_X690SamplePersonnelRecord(&r);
|
|
free(os.data);
|
|
return 0;
|
|
}
|
|
|
|
#if ASN1_IOS_SUPPORTED
|
|
static int
|
|
test_ios(void)
|
|
{
|
|
unsigned char encoded_sample[] = {
|
|
0x30, 0x82, 0x04, 0x8e, 0x30, 0x82, 0x03, 0x76,
|
|
0xa0, 0x03, 0x02, 0x01, 0x02, 0x02, 0x14, 0x6a,
|
|
0x05, 0x97, 0xba, 0x71, 0xd7, 0xe6, 0xd3, 0xac,
|
|
0x0e, 0xdc, 0x9e, 0xdc, 0x95, 0xa1, 0x5b, 0x99,
|
|
0x8d, 0xe4, 0x0a, 0x30, 0x0d, 0x06, 0x09, 0x2a,
|
|
0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x0b,
|
|
0x05, 0x00, 0x30, 0x55, 0x31, 0x0b, 0x30, 0x09,
|
|
0x06, 0x03, 0x55, 0x04, 0x06, 0x13, 0x02, 0x43,
|
|
0x48, 0x31, 0x1e, 0x30, 0x1c, 0x06, 0x03, 0x55,
|
|
0x04, 0x0a, 0x13, 0x15, 0x53, 0x54, 0x4d, 0x69,
|
|
0x63, 0x72, 0x6f, 0x65, 0x6c, 0x65, 0x63, 0x74,
|
|
0x72, 0x6f, 0x6e, 0x69, 0x63, 0x73, 0x20, 0x4e,
|
|
0x56, 0x31, 0x26, 0x30, 0x24, 0x06, 0x03, 0x55,
|
|
0x04, 0x03, 0x13, 0x1d, 0x53, 0x54, 0x4d, 0x20,
|
|
0x54, 0x50, 0x4d, 0x20, 0x45, 0x4b, 0x20, 0x49,
|
|
0x6e, 0x74, 0x65, 0x72, 0x6d, 0x65, 0x64, 0x69,
|
|
0x61, 0x74, 0x65, 0x20, 0x43, 0x41, 0x20, 0x30,
|
|
0x35, 0x30, 0x1e, 0x17, 0x0d, 0x31, 0x38, 0x31,
|
|
0x32, 0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30,
|
|
0x30, 0x5a, 0x17, 0x0d, 0x32, 0x38, 0x31, 0x32,
|
|
0x31, 0x34, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30,
|
|
0x5a, 0x30, 0x00, 0x30, 0x82, 0x01, 0x22, 0x30,
|
|
0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7,
|
|
0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x03, 0x82,
|
|
0x01, 0x0f, 0x00, 0x30, 0x82, 0x01, 0x0a, 0x02,
|
|
0x82, 0x01, 0x01, 0x00, 0xcc, 0x14, 0xeb, 0x27,
|
|
0xa7, 0x8c, 0xeb, 0x0e, 0xa4, 0x86, 0xfa, 0x2d,
|
|
0xf7, 0x83, 0x5f, 0x5f, 0xa8, 0xe9, 0x05, 0xb0,
|
|
0x97, 0x01, 0x2b, 0x5b, 0xde, 0x50, 0x38, 0x0c,
|
|
0x35, 0x5b, 0x1a, 0x2a, 0x72, 0x1b, 0xbc, 0x3d,
|
|
0x08, 0xdd, 0x21, 0x79, 0x6c, 0xdb, 0x23, 0x9f,
|
|
0xa9, 0x53, 0x10, 0x65, 0x1b, 0x1b, 0x56, 0xfd,
|
|
0x2c, 0xfe, 0x53, 0xc8, 0x73, 0x52, 0xeb, 0xd9,
|
|
0x96, 0xe3, 0x32, 0x56, 0x16, 0x04, 0x04, 0xce,
|
|
0x93, 0x02, 0xa0, 0x80, 0x66, 0x80, 0x1e, 0x78,
|
|
0x6a, 0x2f, 0x86, 0xe1, 0x81, 0xf9, 0x49, 0x96,
|
|
0x6f, 0x49, 0x2a, 0x85, 0xb5, 0x8e, 0xaa, 0x4a,
|
|
0x6a, 0x8c, 0xb3, 0x69, 0x75, 0x51, 0xbb, 0x23,
|
|
0x6e, 0x87, 0xcc, 0x7b, 0xf8, 0xec, 0x13, 0x47,
|
|
0x87, 0x1c, 0x91, 0xe1, 0x54, 0x37, 0xe8, 0xf2,
|
|
0x66, 0xbf, 0x1e, 0xa5, 0xeb, 0x27, 0x1f, 0xdc,
|
|
0xf3, 0x74, 0xd8, 0xb4, 0x7d, 0xf8, 0xbc, 0xe8,
|
|
0x9e, 0x1f, 0xad, 0x61, 0xc2, 0xa0, 0x88, 0xcb,
|
|
0x40, 0x36, 0xb3, 0x59, 0xcb, 0x72, 0xa2, 0x94,
|
|
0x97, 0x3f, 0xed, 0xcc, 0xf0, 0xc3, 0x40, 0xaf,
|
|
0xfd, 0x14, 0xb6, 0x4f, 0x04, 0x11, 0x65, 0x58,
|
|
0x1a, 0xca, 0x34, 0x14, 0x7c, 0x1c, 0x75, 0x61,
|
|
0x70, 0x47, 0x05, 0x8f, 0x7e, 0xd7, 0xd6, 0x03,
|
|
0xe0, 0x32, 0x50, 0x80, 0x94, 0xfa, 0x73, 0xe8,
|
|
0xb9, 0x15, 0x3d, 0xa3, 0xbf, 0x25, 0x5d, 0x2c,
|
|
0xbb, 0xc5, 0xdf, 0x30, 0x1b, 0xa8, 0xf7, 0x4d,
|
|
0x19, 0x8b, 0xeb, 0xce, 0x86, 0x04, 0x0f, 0xc1,
|
|
0xd2, 0x92, 0x7c, 0x76, 0x57, 0x41, 0x44, 0x90,
|
|
0xd8, 0x02, 0xf4, 0x82, 0xf3, 0xeb, 0xf2, 0xde,
|
|
0x35, 0xee, 0x14, 0x9a, 0x1a, 0x6d, 0xe8, 0xd1,
|
|
0x68, 0x91, 0xfb, 0xfb, 0xa0, 0x2a, 0x18, 0xaf,
|
|
0xe5, 0x9f, 0x9d, 0x6f, 0x14, 0x97, 0x44, 0xe5,
|
|
0xf0, 0xd5, 0x59, 0xb1, 0x02, 0x03, 0x01, 0x00,
|
|
0x01, 0xa3, 0x82, 0x01, 0xa9, 0x30, 0x82, 0x01,
|
|
0xa5, 0x30, 0x1f, 0x06, 0x03, 0x55, 0x1d, 0x23,
|
|
0x04, 0x18, 0x30, 0x16, 0x80, 0x14, 0x1a, 0xdb,
|
|
0x99, 0x4a, 0xb5, 0x8b, 0xe5, 0x7a, 0x0c, 0xc9,
|
|
0xb9, 0x00, 0xe7, 0x85, 0x1e, 0x1a, 0x43, 0xc0,
|
|
0x86, 0x60, 0x30, 0x42, 0x06, 0x03, 0x55, 0x1d,
|
|
0x20, 0x04, 0x3b, 0x30, 0x39, 0x30, 0x37, 0x06,
|
|
0x04, 0x55, 0x1d, 0x20, 0x00, 0x30, 0x2f, 0x30,
|
|
0x2d, 0x06, 0x08, 0x2b, 0x06, 0x01, 0x05, 0x05,
|
|
0x07, 0x02, 0x01, 0x16, 0x21, 0x68, 0x74, 0x74,
|
|
0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e,
|
|
0x73, 0x74, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x54,
|
|
0x50, 0x4d, 0x2f, 0x72, 0x65, 0x70, 0x6f, 0x73,
|
|
0x69, 0x74, 0x6f, 0x72, 0x79, 0x2f, 0x30, 0x59,
|
|
0x06, 0x03, 0x55, 0x1d, 0x11, 0x01, 0x01, 0xff,
|
|
0x04, 0x4f, 0x30, 0x4d, 0xa4, 0x4b, 0x30, 0x49,
|
|
0x31, 0x16, 0x30, 0x14, 0x06, 0x05, 0x67, 0x81,
|
|
0x05, 0x02, 0x01, 0x0c, 0x0b, 0x69, 0x64, 0x3a,
|
|
0x35, 0x33, 0x35, 0x34, 0x34, 0x44, 0x32, 0x30,
|
|
0x31, 0x17, 0x30, 0x15, 0x06, 0x05, 0x67, 0x81,
|
|
0x05, 0x02, 0x02, 0x0c, 0x0c, 0x53, 0x54, 0x33,
|
|
0x33, 0x48, 0x54, 0x50, 0x48, 0x41, 0x48, 0x43,
|
|
0x30, 0x31, 0x16, 0x30, 0x14, 0x06, 0x05, 0x67,
|
|
0x81, 0x05, 0x02, 0x03, 0x0c, 0x0b, 0x69, 0x64,
|
|
0x3a, 0x30, 0x30, 0x34, 0x39, 0x30, 0x30, 0x30,
|
|
0x38, 0x30, 0x67, 0x06, 0x03, 0x55, 0x1d, 0x09,
|
|
0x04, 0x60, 0x30, 0x5e, 0x30, 0x17, 0x06, 0x05,
|
|
0x67, 0x81, 0x05, 0x02, 0x10, 0x31, 0x0e, 0x30,
|
|
0x0c, 0x0c, 0x03, 0x32, 0x2e, 0x30, 0x02, 0x01,
|
|
0x00, 0x02, 0x02, 0x00, 0x8a, 0x30, 0x43, 0x06,
|
|
0x05, 0x67, 0x81, 0x05, 0x02, 0x12, 0x31, 0x3a,
|
|
0x30, 0x38, 0x02, 0x01, 0x00, 0x01, 0x01, 0xff,
|
|
0xa0, 0x03, 0x0a, 0x01, 0x01, 0xa1, 0x03, 0x0a,
|
|
0x01, 0x00, 0xa2, 0x03, 0x0a, 0x01, 0x00, 0xa3,
|
|
0x10, 0x30, 0x0e, 0x16, 0x03, 0x33, 0x2e, 0x31,
|
|
0x0a, 0x01, 0x04, 0x0a, 0x01, 0x02, 0x01, 0x01,
|
|
0xff, 0xa4, 0x0f, 0x30, 0x0d, 0x16, 0x05, 0x31,
|
|
0x34, 0x30, 0x2d, 0x32, 0x0a, 0x01, 0x02, 0x01,
|
|
0x01, 0x00, 0x30, 0x0e, 0x06, 0x03, 0x55, 0x1d,
|
|
0x0f, 0x01, 0x01, 0xff, 0x04, 0x04, 0x03, 0x02,
|
|
0x05, 0x20, 0x30, 0x0c, 0x06, 0x03, 0x55, 0x1d,
|
|
0x13, 0x01, 0x01, 0xff, 0x04, 0x02, 0x30, 0x00,
|
|
0x30, 0x10, 0x06, 0x03, 0x55, 0x1d, 0x25, 0x04,
|
|
0x09, 0x30, 0x07, 0x06, 0x05, 0x67, 0x81, 0x05,
|
|
0x08, 0x01, 0x30, 0x4a, 0x06, 0x08, 0x2b, 0x06,
|
|
0x01, 0x05, 0x05, 0x07, 0x01, 0x01, 0x04, 0x3e,
|
|
0x30, 0x3c, 0x30, 0x3a, 0x06, 0x08, 0x2b, 0x06,
|
|
0x01, 0x05, 0x05, 0x07, 0x30, 0x02, 0x86, 0x2e,
|
|
0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x73,
|
|
0x65, 0x63, 0x75, 0x72, 0x65, 0x2e, 0x67, 0x6c,
|
|
0x6f, 0x62, 0x61, 0x6c, 0x73, 0x69, 0x67, 0x6e,
|
|
0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x73, 0x74, 0x6d,
|
|
0x74, 0x70, 0x6d, 0x65, 0x6b, 0x69, 0x6e, 0x74,
|
|
0x30, 0x35, 0x2e, 0x63, 0x72, 0x74, 0x30, 0x0d,
|
|
0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d,
|
|
0x01, 0x01, 0x0b, 0x05, 0x00, 0x03, 0x82, 0x01,
|
|
0x01, 0x00, 0x3d, 0x4c, 0x38, 0x1e, 0x5b, 0x4f,
|
|
0x1b, 0xcb, 0xe0, 0x9c, 0x63, 0xd5, 0x2f, 0x1f,
|
|
0x04, 0x57, 0x0c, 0xae, 0xa1, 0x42, 0xfd, 0x9c,
|
|
0xd9, 0x42, 0x04, 0x3b, 0x11, 0xf8, 0xe3, 0xbd,
|
|
0xcf, 0x50, 0x00, 0x7a, 0xe1, 0x6c, 0xf8, 0x86,
|
|
0x90, 0x13, 0x04, 0x1e, 0x92, 0xcd, 0xd3, 0x28,
|
|
0x0b, 0xa4, 0xb5, 0x1f, 0xbb, 0xd4, 0x05, 0x82,
|
|
0xed, 0x75, 0x02, 0x19, 0xe2, 0x61, 0xa6, 0x95,
|
|
0x09, 0x56, 0x74, 0x85, 0x5a, 0xac, 0xeb, 0x52,
|
|
0x0a, 0xda, 0xff, 0x9e, 0x7e, 0x90, 0x84, 0x80,
|
|
0xa3, 0x9c, 0xdc, 0xf9, 0x00, 0x46, 0x2d, 0x91,
|
|
0x71, 0x96, 0x0f, 0xfe, 0x55, 0xd3, 0xac, 0x49,
|
|
0xe8, 0xc9, 0x81, 0x34, 0x1b, 0xbd, 0x2e, 0xfb,
|
|
0xcc, 0x25, 0x2a, 0x4c, 0x18, 0xa4, 0xf3, 0xb7,
|
|
0xc8, 0x4c, 0xce, 0x42, 0xce, 0x70, 0xa2, 0x08,
|
|
0xc8, 0x4d, 0x26, 0x30, 0xa7, 0xab, 0xfb, 0xe7,
|
|
0x2d, 0x62, 0x71, 0xe7, 0x5b, 0x9f, 0xf1, 0xc9,
|
|
0x71, 0xd2, 0x0e, 0xb3, 0xdb, 0xd7, 0x63, 0xf1,
|
|
0xe0, 0x4d, 0x83, 0x4e, 0xaa, 0x69, 0x2d, 0x2e,
|
|
0x40, 0x01, 0xbb, 0xf4, 0x73, 0x0a, 0x3e, 0x3f,
|
|
0xda, 0x97, 0x11, 0xae, 0x38, 0x65, 0x24, 0xd9,
|
|
0x1c, 0x63, 0xbe, 0x0e, 0x51, 0x6d, 0x00, 0xd5,
|
|
0xc6, 0x14, 0x1f, 0xcc, 0xf6, 0xc5, 0x39, 0xf3,
|
|
0x51, 0x8e, 0x18, 0x00, 0x49, 0x86, 0x5b, 0xe1,
|
|
0x6b, 0x69, 0xca, 0xe1, 0xf8, 0xcb, 0x7f, 0xdc,
|
|
0x47, 0x4b, 0x38, 0xf7, 0xee, 0x56, 0xcb, 0xe7,
|
|
0xd8, 0xa8, 0x9d, 0x9b, 0xa9, 0x9b, 0x65, 0xd5,
|
|
0x26, 0x5a, 0xef, 0x32, 0xaa, 0x62, 0x42, 0x6b,
|
|
0x10, 0xe6, 0xd7, 0x5b, 0xb8, 0x67, 0x7e, 0xc4,
|
|
0x4f, 0x75, 0x5b, 0xbc, 0x28, 0x06, 0xfd, 0x2b,
|
|
0x4e, 0x04, 0xbd, 0xf5, 0xd4, 0x42, 0x59, 0xdb,
|
|
0xea, 0xa4, 0x2b, 0x6f, 0x56, 0x3d, 0xf7, 0xaa,
|
|
0x75, 0x06,
|
|
};
|
|
char cert_json[] = {
|
|
"{\"_type\":\"Certificate\",\"tbsCertificate\":{\"_type\":\"TBSCertificate"
|
|
"\",\"_save\":\"30820376A00302010202146A0597BA71D7E6D3AC0EDC9EDC95A15"
|
|
"B998DE40A300D06092A864886F70D01010B05003055310B30090603550406130"
|
|
"24348311E301C060355040A131553544D6963726F656C656374726F6E6963732"
|
|
"04E56312630240603550403131D53544D2054504D20454B20496E7465726D656"
|
|
"469617465204341203035301E170D3138313231343030303030305A170D32383"
|
|
"13231343030303030305A300030820122300D06092A864886F70D01010105000"
|
|
"382010F003082010A0282010100CC14EB27A78CEB0EA486FA2DF7835F5FA8E90"
|
|
"5B097012B5BDE50380C355B1A2A721BBC3D08DD21796CDB239FA95310651B1B5"
|
|
"6FD2CFE53C87352EBD996E33256160404CE9302A08066801E786A2F86E181F94"
|
|
"9966F492A85B58EAA4A6A8CB3697551BB236E87CC7BF8EC1347871C91E15437E"
|
|
"8F266BF1EA5EB271FDCF374D8B47DF8BCE89E1FAD61C2A088CB4036B359CB72A"
|
|
"294973FEDCCF0C340AFFD14B64F041165581ACA34147C1C75617047058F7ED7D"
|
|
"603E032508094FA73E8B9153DA3BF255D2CBBC5DF301BA8F74D198BEBCE86040"
|
|
"FC1D2927C7657414490D802F482F3EBF2DE35EE149A1A6DE8D16891FBFBA02A1"
|
|
"8AFE59F9D6F149744E5F0D559B10203010001A38201A9308201A5301F0603551"
|
|
"D230418301680141ADB994AB58BE57A0CC9B900E7851E1A43C08660304206035"
|
|
"51D20043B303930370604551D2000302F302D06082B060105050702011621687"
|
|
"474703A2F2F7777772E73742E636F6D2F54504D2F7265706F7369746F72792F3"
|
|
"0590603551D110101FF044F304DA44B304931163014060567810502010C0B696"
|
|
"43A353335343444323031173015060567810502020C0C5354333348545048414"
|
|
"8433031163014060567810502030C0B69643A303034393030303830670603551"
|
|
"D090460305E301706056781050210310E300C0C03322E300201000202008A304"
|
|
"306056781050212313A30380201000101FFA0030A0101A1030A0100A2030A010"
|
|
"0A310300E1603332E310A01040A01020101FFA40F300D16053134302D320A010"
|
|
"2010100300E0603551D0F0101FF040403020520300C0603551D130101FF04023"
|
|
"00030100603551D250409300706056781050801304A06082B060105050701010"
|
|
"43E303C303A06082B06010505073002862E687474703A2F2F7365637572652E6"
|
|
"76C6F62616C7369676E2E636F6D2F73746D74706D656B696E7430352E637274\""
|
|
",\"version\":\"rfc3280_version_3\",\"serialNumber\":\"6A0597BA71D7E6D3A"
|
|
"C0EDC9EDC95A15B998DE40A\",\"signature\":{\"_type\":\"AlgorithmIdentifi"
|
|
"er\",\"algorithm\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\"1.2.840.1135"
|
|
"49.1.1.11\",\"components\":[1,2,840,113549,1,1,11],\"name\":\"id-pkcs1"
|
|
"-sha256WithRSAEncryption\"},\"parameters\":\"0500\"},\"issuer\":{\"_choi"
|
|
"ce\":\"rdnSequence\",\"value\":[[{\"_type\":\"AttributeTypeAndValue\",\"ty"
|
|
"pe\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\"2.5.4.6\",\"components\":[2"
|
|
",5,4,6],\"name\":\"id-at-countryName\"},\"value\":{\"_choice\":\"printabl"
|
|
"eString\",\"value\":\"CH\"}}],[{\"_type\":\"AttributeTypeAndValue\",\"type"
|
|
"\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\"2.5.4.10\",\"components\":[2,"
|
|
"5,4,10],\"name\":\"id-at-organizationName\"},\"value\":{\"_choice\":\"pri"
|
|
"ntableString\",\"value\":\"STMicroelectronics NV\"}}],[{\"_type\":\"Attr"
|
|
"ibuteTypeAndValue\",\"type\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\"2."
|
|
"5.4.3\",\"components\":[2,5,4,3],\"name\":\"id-at-commonName\"},\"value\""
|
|
":{\"_choice\":\"printableString\",\"value\":\"STM TPM EK Intermediate C"
|
|
"A 05\"}}]]},\"validity\":{\"_type\":\"Validity\",\"notBefore\":{\"_choice\""
|
|
":\"utcTime\",\"value\":\"2018-12-14T00:00:00Z\"},\"notAfter\":{\"_choice\""
|
|
":\"utcTime\",\"value\":\"2028-12-14T00:00:00Z\"}},\"subject\":{\"_choice\""
|
|
":\"rdnSequence\",\"value\":[]},\"subjectPublicKeyInfo\":{\"_type\":\"Subj"
|
|
"ectPublicKeyInfo\",\"algorithm\":{\"_type\":\"AlgorithmIdentifier\",\"al"
|
|
"gorithm\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\"1.2.840.113549.1.1."
|
|
"1\",\"components\":[1,2,840,113549,1,1,1],\"name\":\"id-pkcs1-rsaEncry"
|
|
"ption\"},\"parameters\":\"0500\"},\"subjectPublicKey\":\"2160:3082010A02"
|
|
"82010100CC14EB27A78CEB0EA486FA2DF7835F5FA8E905B097012B5BDE50380C"
|
|
"355B1A2A721BBC3D08DD21796CDB239FA95310651B1B56FD2CFE53C87352EBD9"
|
|
"96E33256160404CE9302A08066801E786A2F86E181F949966F492A85B58EAA4A"
|
|
"6A8CB3697551BB236E87CC7BF8EC1347871C91E15437E8F266BF1EA5EB271FDC"
|
|
"F374D8B47DF8BCE89E1FAD61C2A088CB4036B359CB72A294973FEDCCF0C340AF"
|
|
"FD14B64F041165581ACA34147C1C75617047058F7ED7D603E032508094FA73E8"
|
|
"B9153DA3BF255D2CBBC5DF301BA8F74D198BEBCE86040FC1D2927C7657414490"
|
|
"D802F482F3EBF2DE35EE149A1A6DE8D16891FBFBA02A18AFE59F9D6F149744E5"
|
|
"F0D559B10203010001\"},\"issuerUniqueID\":null,\"subjectUniqueID\":nul"
|
|
"l,\"extensions\":[{\"_type\":\"Extension\",\"extnID\":{\"_type\":\"OBJECT I"
|
|
"DENTIFIER\",\"oid\":\"2.5.29.35\",\"components\":[2,5,29,35],\"name\":\"id"
|
|
"-x509-ce-authorityKeyIdentifier\"},\"critical\":false,\"extnValue\":\""
|
|
"301680141ADB994AB58BE57A0CC9B900E7851E1A43C08660\",\"_extnValue_ch"
|
|
"oice\":\"ext-AuthorityKeyIdentifier\",\"_extnValue\":{\"_type\":\"Author"
|
|
"ityKeyIdentifier\",\"keyIdentifier\":\"1ADB994AB58BE57A0CC9B900E7851"
|
|
"E1A43C08660\",\"authorityCertIssuer\":null,\"authorityCertSerialNumb"
|
|
"er\":null}},{\"_type\":\"Extension\",\"extnID\":{\"_type\":\"OBJECT IDENTI"
|
|
"FIER\",\"oid\":\"2.5.29.32\",\"components\":[2,5,29,32],\"name\":\"id-x509"
|
|
"-ce-certificatePolicies\"},\"critical\":false,\"extnValue\":\"30393037"
|
|
"0604551D2000302F302D06082B060105050702011621687474703A2F2F777777"
|
|
"2E73742E636F6D2F54504D2F7265706F7369746F72792F\",\"_extnValue_choi"
|
|
"ce\":\"ext-CertificatePolicies\",\"_extnValue\":[{\"_type\":\"PolicyInfo"
|
|
"rmation\",\"policyIdentifier\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\""
|
|
"2.5.29.32.0\",\"components\":[2,5,29,32,0],\"name\":\"id-x509-ce-certi"
|
|
"ficatePolicies-anyPolicy\"},\"policyQualifiers\":[{\"_type\":\"PolicyQ"
|
|
"ualifierInfo\",\"policyQualifierId\":{\"_type\":\"OBJECT IDENTIFIER\",\""
|
|
"oid\":\"1.3.6.1.5.5.7.2.1\",\"components\":[1,3,6,1,5,5,7,2,1],\"name\""
|
|
":\"id-pkix-qt-cps\"},\"qualifier\":\"1621687474703A2F2F7777772E73742E"
|
|
"636F6D2F54504D2F7265706F7369746F72792F\"}]}]},{\"_type\":\"Extension"
|
|
"\",\"extnID\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\"2.5.29.17\",\"compo"
|
|
"nents\":[2,5,29,17],\"name\":\"id-x509-ce-subjectAltName\"},\"critical"
|
|
"\":true,\"extnValue\":\"304DA44B304931163014060567810502010C0B69643A"
|
|
"353335343444323031173015060567810502020C0C5354333348545048414843"
|
|
"3031163014060567810502030C0B69643A3030343930303038\",\"_extnValue_"
|
|
"choice\":\"ext-SubjectAltName\",\"_extnValue\":[{\"_choice\":\"directory"
|
|
"Name\",\"value\":{\"_choice\":\"rdnSequence\",\"value\":[[{\"_type\":\"Attri"
|
|
"buteTypeAndValue\",\"type\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\"2.2"
|
|
"3.133.2.1\",\"components\":[2,23,133,2,1],\"name\":\"tcg-at-tpmManufac"
|
|
"turer\"},\"value\":{\"_choice\":\"utf8String\",\"value\":\"id:53544D20\"}}]"
|
|
",[{\"_type\":\"AttributeTypeAndValue\",\"type\":{\"_type\":\"OBJECT IDENT"
|
|
"IFIER\",\"oid\":\"2.23.133.2.2\",\"components\":[2,23,133,2,2],\"name\":\""
|
|
"tcg-at-tpmModel\"},\"value\":{\"_choice\":\"utf8String\",\"value\":\"ST33H"
|
|
"TPHAHC0\"}}],[{\"_type\":\"AttributeTypeAndValue\",\"type\":{\"_type\":\"O"
|
|
"BJECT IDENTIFIER\",\"oid\":\"2.23.133.2.3\",\"components\":[2,23,133,2,"
|
|
"3],\"name\":\"tcg-at-tpmVersion\"},\"value\":{\"_choice\":\"utf8String\",\""
|
|
"value\":\"id:00490008\"}}]]}}]},{\"_type\":\"Extension\",\"extnID\":{\"_ty"
|
|
"pe\":\"OBJECT IDENTIFIER\",\"oid\":\"2.5.29.9\",\"components\":[2,5,29,9]"
|
|
",\"name\":\"id-x509-ce-subjectDirectoryAttributes\"},\"critical\":fals"
|
|
"e,\"extnValue\":\"305E301706056781050210310E300C0C03322E30020100020"
|
|
"2008A304306056781050212313A30380201000101FFA0030A0101A1030A0100A"
|
|
"2030A0100A310300E1603332E310A01040A01020101FFA40F300D16053134302"
|
|
"D320A0102010100\",\"_extnValue_choice\":\"ext-SubjectDirectoryAttrib"
|
|
"utes\",\"_extnValue\":[{\"_type\":\"AttributeSet\",\"type\":{\"_type\":\"OBJ"
|
|
"ECT IDENTIFIER\",\"oid\":\"2.23.133.2.16\",\"components\":[2,23,133,2,1"
|
|
"6],\"name\":\"tcg-at-tpmSpecification\"},\"values\":[\"300C0C03322E3002"
|
|
"01000202008A\"],\"_values_choice\":\"at-TPMSpecification\",\"_values\":"
|
|
"[{\"_type\":\"TPMSpecification\",\"family\":\"2.0\",\"level\":0,\"revision\""
|
|
":138}]},{\"_type\":\"AttributeSet\",\"type\":{\"_type\":\"OBJECT IDENTIFI"
|
|
"ER\",\"oid\":\"2.23.133.2.18\",\"components\":[2,23,133,2,18],\"name\":\"t"
|
|
"cg-at-tpmSecurityAssertions\"},\"values\":[\"30380201000101FFA0030A0"
|
|
"101A1030A0100A2030A0100A310300E1603332E310A01040A01020101FFA40F3"
|
|
"00D16053134302D320A0102010100\"],\"_values_choice\":\"at-TPMSecurity"
|
|
"Assertions\",\"_values\":[{\"_type\":\"TPMSecurityAssertions\",\"version"
|
|
"\":0,\"fieldUpgradable\":true,\"ekGenerationType\":\"ekgt-injected\",\"e"
|
|
"kGenerationLocation\":\"tpmManufacturer\",\"ekCertificateGenerationL"
|
|
"ocation\":\"tpmManufacturer\",\"ccInfo\":{\"_type\":\"CommonCriteriaMeas"
|
|
"ures\",\"version\":\"3.1\",\"assurancelevel\":\"ealevel4\",\"evaluationSta"
|
|
"tus\":\"evaluationCompleted\",\"plus\":true,\"strengthOfFunction\":null"
|
|
",\"profileOid\":null,\"profileUri\":null,\"targetOid\":null,\"targetUri"
|
|
"\":null},\"fipsLevel\":{\"_type\":\"FIPSLevel\",\"version\":\"140-2\",\"leve"
|
|
"l\":\"sllevel2\",\"plus\":false},\"iso9000Certified\":false,\"iso9000Uri"
|
|
"\":null}]}]},{\"_type\":\"Extension\",\"extnID\":{\"_type\":\"OBJECT IDENT"
|
|
"IFIER\",\"oid\":\"2.5.29.15\",\"components\":[2,5,29,15],\"name\":\"id-x50"
|
|
"9-ce-keyUsage\"},\"critical\":true,\"extnValue\":\"03020520\",\"_extnVal"
|
|
"ue_choice\":\"ext-KeyUsage\",\"_extnValue\":[\"keyEncipherment\"]},{\"_t"
|
|
"ype\":\"Extension\",\"extnID\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\"2."
|
|
"5.29.19\",\"components\":[2,5,29,19],\"name\":\"id-x509-ce-basicConstr"
|
|
"aints\"},\"critical\":true,\"extnValue\":\"3000\",\"_extnValue_choice\":\""
|
|
"ext-BasicConstraints\",\"_extnValue\":{\"_type\":\"BasicConstraints\",\""
|
|
"cA\":false,\"pathLenConstraint\":null}},{\"_type\":\"Extension\",\"extnI"
|
|
"D\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\"2.5.29.37\",\"components\":["
|
|
"2,5,29,37],\"name\":\"id-x509-ce-extKeyUsage\"},\"critical\":false,\"ex"
|
|
"tnValue\":\"300706056781050801\",\"_extnValue_choice\":\"ext-ExtKeyUsa"
|
|
"ge\",\"_extnValue\":[{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\"2.23.133.8"
|
|
".1\",\"components\":[2,23,133,8,1],\"name\":\"tcg-kp-EKCertificate\"}]}"
|
|
",{\"_type\":\"Extension\",\"extnID\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid"
|
|
"\":\"1.3.6.1.5.5.7.1.1\",\"components\":[1,3,6,1,5,5,7,1,1],\"name\":\"i"
|
|
"d-pkix-pe-authorityInfoAccess\"},\"critical\":false,\"extnValue\":\"30"
|
|
"3C303A06082B06010505073002862E687474703A2F2F7365637572652E676C6F"
|
|
"62616C7369676E2E636F6D2F73746D74706D656B696E7430352E637274\",\"_ex"
|
|
"tnValue_choice\":\"ext-AuthorityInfoAccess\",\"_extnValue\":[{\"_type\""
|
|
":\"AccessDescription\",\"accessMethod\":{\"_type\":\"OBJECT IDENTIFIER\""
|
|
",\"oid\":\"1.3.6.1.5.5.7.48.2\",\"components\":[1,3,6,1,5,5,7,48,2],\"n"
|
|
"ame\":\"id-pkix-ad-caIssuers\"},\"accessLocation\":{\"_choice\":\"unifor"
|
|
"mResourceIdentifier\",\"value\":\"http://secure.globalsign.com/stmtp"
|
|
"mekint05.crt\"}}]}]},\"signatureAlgorithm\":{\"_type\":\"AlgorithmIden"
|
|
"tifier\",\"algorithm\":{\"_type\":\"OBJECT IDENTIFIER\",\"oid\":\"1.2.840."
|
|
"113549.1.1.11\",\"components\":[1,2,840,113549,1,1,11],\"name\":\"id-p"
|
|
"kcs1-sha256WithRSAEncryption\"},\"parameters\":\"0500\"},\"signatureVa"
|
|
"lue\":\"2048:3D4C381E5B4F1BCBE09C63D52F1F04570CAEA142FD9CD942043B1"
|
|
"1F8E3BDCF50007AE16CF8869013041E92CDD3280BA4B51FBBD40582ED750219E"
|
|
"261A695095674855AACEB520ADAFF9E7E908480A39CDCF900462D9171960FFE5"
|
|
"5D3AC49E8C981341BBD2EFBCC252A4C18A4F3B7C84CCE42CE70A208C84D2630A"
|
|
"7ABFBE72D6271E75B9FF1C971D20EB3DBD763F1E04D834EAA692D2E4001BBF47"
|
|
"30A3E3FDA9711AE386524D91C63BE0E516D00D5C6141FCCF6C539F3518E18004"
|
|
"9865BE16B69CAE1F8CB7FDC474B38F7EE56CBE7D8A89D9BA99B65D5265AEF32A"
|
|
"A62426B10E6D75BB8677EC44F755BBC2806FD2B4E04BDF5D44259DBEAA42B6F5"
|
|
"63DF7AA7506\"}"
|
|
};
|
|
heim_octet_string os;
|
|
Certificate c0, c1;
|
|
size_t i, nknown, size;
|
|
char *s;
|
|
int ret;
|
|
|
|
/*
|
|
* Test automatic decoding of open types.
|
|
*
|
|
* Decode a value that has plenty of open types with values of known
|
|
* alternatives in them, then check that we got what we wanted.
|
|
*/
|
|
ret = decode_Certificate(encoded_sample, sizeof(encoded_sample),
|
|
&c0, &size);
|
|
if (ret)
|
|
return 1;
|
|
if (size != sizeof(encoded_sample))
|
|
return 1;
|
|
|
|
s = print_Certificate(&c0, 0);
|
|
if (!s)
|
|
return 1;
|
|
if (strcmp(s, cert_json))
|
|
return 1;
|
|
free(s);
|
|
|
|
ret = copy_Certificate(&c0, &c1);
|
|
if (ret)
|
|
return 1;
|
|
|
|
if (!c0.tbsCertificate.extensions || !c1.tbsCertificate.extensions)
|
|
return 1;
|
|
if (!c0.tbsCertificate.extensions->len ||
|
|
c0.tbsCertificate.extensions->len != c1.tbsCertificate.extensions->len)
|
|
return 1;
|
|
for (i = nknown = 0; i < c0.tbsCertificate.extensions->len; i++) {
|
|
if (c0.tbsCertificate.extensions->val[i]._ioschoice_extnValue.element !=
|
|
c1.tbsCertificate.extensions->val[i]._ioschoice_extnValue.element)
|
|
return 1;
|
|
if (c0.tbsCertificate.extensions->val[i]._ioschoice_extnValue.element) {
|
|
#if 0
|
|
fprintf(stderr, "extension %llu known %u\n",
|
|
(unsigned long long)i,
|
|
c0.tbsCertificate.extensions->val[i]._ioschoice_extnValue._element);
|
|
#endif
|
|
nknown++;
|
|
}
|
|
}
|
|
if (!nknown)
|
|
return 1;
|
|
|
|
|
|
/*
|
|
* Check that this round trips. But note that this attempt to encode will
|
|
* ignore the automatically decoded open type values from above because
|
|
* their encodings are still present.
|
|
*/
|
|
ASN1_MALLOC_ENCODE(Certificate, os.data, os.length, &c1, &size, ret);
|
|
if (ret)
|
|
return 1;
|
|
if (os.length != size || size != sizeof(encoded_sample))
|
|
return 1;
|
|
if (memcmp(os.data, encoded_sample, os.length))
|
|
return 1;
|
|
der_free_octet_string(&os);
|
|
|
|
/*
|
|
* Test automatic encoding of open types by clearing the encoding of one
|
|
* such open type value, forcing the encoder to encode the value from
|
|
* before.
|
|
*/
|
|
der_free_octet_string(&c0.tbsCertificate.extensions->val[0].extnValue);
|
|
der_free_oid(&c0.tbsCertificate.extensions->val[0].extnID);
|
|
|
|
ASN1_MALLOC_ENCODE(Certificate, os.data, os.length, &c0, &size, ret);
|
|
if (ret)
|
|
return 1;
|
|
if (os.length != size || size != sizeof(encoded_sample))
|
|
return 1;
|
|
if (memcmp(os.data, encoded_sample, os.length))
|
|
return 1;
|
|
der_free_octet_string(&os);
|
|
|
|
/*
|
|
* Repeat, but with the copy, as this will test that copying data
|
|
* structures with decoded open types in them also copies those.
|
|
*/
|
|
der_free_octet_string(&c1.tbsCertificate.extensions->val[0].extnValue);
|
|
der_free_oid(&c1.tbsCertificate.extensions->val[0].extnID);
|
|
|
|
ASN1_MALLOC_ENCODE(Certificate, os.data, os.length, &c1, &size, ret);
|
|
if (ret)
|
|
return 1;
|
|
if (os.length != size || size != sizeof(encoded_sample))
|
|
return 1;
|
|
if (memcmp(os.data, encoded_sample, os.length))
|
|
return 1;
|
|
der_free_octet_string(&os);
|
|
|
|
free_Certificate(&c0);
|
|
free_Certificate(&c1);
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
int ret = 0;
|
|
|
|
#define DO_ONE(t) if (t()) { fprintf(stderr, "%s() failed!\n", #t); ret++; }
|
|
DO_ONE(test_principal);
|
|
DO_ONE(test_authenticator);
|
|
DO_ONE(test_krb_error);
|
|
DO_ONE(test_Name);
|
|
DO_ONE(test_bit_string);
|
|
DO_ONE(test_bit_string_rfc1510);
|
|
DO_ONE(test_time);
|
|
DO_ONE(test_cert);
|
|
|
|
DO_ONE(check_tag_length);
|
|
DO_ONE(check_tag_length64);
|
|
DO_ONE(check_tag_length64s);
|
|
DO_ONE(test_large_tag);
|
|
DO_ONE(test_choice);
|
|
|
|
DO_ONE(test_implicit);
|
|
|
|
DO_ONE(test_taglessalloc);
|
|
DO_ONE(test_optional);
|
|
|
|
DO_ONE(check_fail_largetag);
|
|
DO_ONE(check_fail_sequence);
|
|
DO_ONE(check_fail_choice);
|
|
DO_ONE(check_fail_Ticket);
|
|
|
|
DO_ONE(check_seq);
|
|
DO_ONE(check_seq_of_size);
|
|
DO_ONE(test_SignedData);
|
|
|
|
DO_ONE(check_TESTMechTypeList);
|
|
DO_ONE(test_seq4);
|
|
DO_ONE(test_seqof5);
|
|
|
|
DO_ONE(test_x690sample);
|
|
|
|
DO_ONE(test_default);
|
|
|
|
#if ASN1_IOS_SUPPORTED
|
|
DO_ONE(test_ios);
|
|
#endif
|
|
|
|
return ret;
|
|
}
|