From 9879a47f9dc00ba74486b1d6935aed5034d36288 Mon Sep 17 00:00:00 2001 From: Juan Lang Date: Fri, 2 Jun 2006 07:02:27 -0700 Subject: [PATCH] crypt32: Add name value tests. Add tests for name values, and move tests for different string encodings to there. --- dlls/crypt32/tests/encode.c | 212 ++++++++++++++++++------------------ 1 file changed, 109 insertions(+), 103 deletions(-) diff --git a/dlls/crypt32/tests/encode.c b/dlls/crypt32/tests/encode.c index 3be938afd10..d5258c16a7a 100644 --- a/dlls/crypt32/tests/encode.c +++ b/dlls/crypt32/tests/encode.c @@ -602,57 +602,8 @@ static void test_decodeFiletime(DWORD dwEncoding) } } -struct EncodedName -{ - CERT_RDN_ATTR attr; - const BYTE *encoded; -}; - static const char commonName[] = "Juan Lang"; static const char surName[] = "Lang"; -static const char bogusIA5[] = "\x80"; -static const char bogusPrintable[] = "~"; -static const char bogusNumeric[] = "A"; -static const unsigned char bin39[] = { - 0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,'J','u','a','n',' ','L','a','n','g',0}; -static const unsigned char bin40[] = { - 0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x16,0x0a,'J','u','a','n',' ','L','a','n','g',0}; -static const unsigned char bin41[] = { - 0x30,0x10,0x31,0x0e,0x30,0x0c,0x06,0x03,0x55,0x04,0x04,0x16,0x05,'L','a','n','g',0}; -static const unsigned char bin42[] = { - 0x30,0x12,0x31,0x10,0x30,0x0e,0x06,0x00,0x13,0x0a,'J','u','a','n',' ','L','a','n','g',0}; -static const unsigned char bin43[] = { - 0x30,0x0d,0x31,0x0b,0x30,0x09,0x06,0x03,0x55,0x04,0x03,0x16,0x02,0x80,0}; -static const unsigned char bin44[] = { - 0x30,0x0d,0x31,0x0b,0x30,0x09,0x06,0x03,0x55,0x04,0x03,0x13,0x02,0x7e,0}; -static const unsigned char bin45[] = { - 0x30,0x0d,0x31,0x0b,0x30,0x09,0x06,0x03,0x55,0x04,0x03,0x12,0x02,0x41,0}; -static const struct EncodedName names[] = { - { { szOID_COMMON_NAME, CERT_RDN_PRINTABLE_STRING, - { sizeof(commonName), (BYTE *)commonName } }, bin39 }, - { { szOID_COMMON_NAME, CERT_RDN_IA5_STRING, - { sizeof(commonName), (BYTE *)commonName } }, bin40 }, - { { szOID_SUR_NAME, CERT_RDN_IA5_STRING, - { sizeof(surName), (BYTE *)surName } }, bin41 }, - { { NULL, CERT_RDN_PRINTABLE_STRING, - { sizeof(commonName), (BYTE *)commonName } }, bin42 }, -/* The following test isn't a very good one, because it doesn't encode any - * Japanese characters. I'm leaving it out for now. - { { szOID_COMMON_NAME, CERT_RDN_T61_STRING, - { sizeof(commonName), (BYTE *)commonName } }, - "\x30\x15\x31\x13\x30\x11\x06\x03\x55\x04\x03\x14\x0aJuan Lang" }, - */ - /* The following tests succeed under Windows, but really should fail, - * they contain characters that are illegal for the encoding. I'm - * including them to justify my lazy encoding. - */ - { { szOID_COMMON_NAME, CERT_RDN_IA5_STRING, - { sizeof(bogusIA5), (BYTE *)bogusIA5 } }, bin43 }, - { { szOID_COMMON_NAME, CERT_RDN_PRINTABLE_STRING, - { sizeof(bogusPrintable), (BYTE *)bogusPrintable } }, bin44 }, - { { szOID_COMMON_NAME, CERT_RDN_NUMERIC_STRING, - { sizeof(bogusNumeric), (BYTE *)bogusNumeric } }, bin45 }, -}; static const BYTE emptySequence[] = { 0x30, 0 }; static const BYTE emptyRDNs[] = { 0x30, 0x02, 0x31, 0 }; @@ -715,7 +666,7 @@ static void test_encodeName(DWORD dwEncoding) CERT_RDN rdn; CERT_NAME_INFO info; BYTE *buf = NULL; - DWORD size = 0, i; + DWORD size = 0; BOOL ret; /* Test with NULL pvStructInfo */ @@ -802,22 +753,6 @@ static void test_encodeName(DWORD dwEncoding) CRYPT_ENCODE_ALLOC_FLAG, NULL, (BYTE *)&buf, &size); ok(!ret && GetLastError() == E_INVALIDARG, "Expected E_INVALIDARG, got %08lx\n", GetLastError()); - for (i = 0; i < sizeof(names) / sizeof(names[0]); i++) - { - rdn.cRDNAttr = 1; - rdn.rgRDNAttr = (CERT_RDN_ATTR *)&names[i].attr; - ret = CryptEncodeObjectEx(dwEncoding, X509_NAME, &info, - CRYPT_ENCODE_ALLOC_FLAG, NULL, (BYTE *)&buf, &size); - ok(ret, "CryptEncodeObjectEx failed: %08lx\n", GetLastError()); - if (buf) - { - ok(size == names[i].encoded[1] + 2, "Expected size %d, got %ld\n", - names[i].encoded[1] + 2, size); - ok(!memcmp(buf, names[i].encoded, names[i].encoded[1] + 2), - "Got unexpected encoding\n"); - LocalFree(buf); - } - } /* Test a more complex name */ rdn.cRDNAttr = sizeof(rdnAttrs) / sizeof(rdnAttrs[0]); rdn.rgRDNAttr = (PCERT_RDN_ATTR)rdnAttrs; @@ -837,6 +772,20 @@ static void test_encodeName(DWORD dwEncoding) } } +static void compareNameValues(const CERT_NAME_VALUE *expected, + const CERT_NAME_VALUE *got) +{ + ok(got->dwValueType == expected->dwValueType, + "Expected string type %ld, got %ld\n", expected->dwValueType, + got->dwValueType); + ok(got->Value.cbData == expected->Value.cbData, + "Unexpected data size, got %ld, expected %ld\n", got->Value.cbData, + expected->Value.cbData); + if (got->Value.cbData && got->Value.pbData) + ok(!memcmp(got->Value.pbData, expected->Value.pbData, + min(got->Value.cbData, expected->Value.cbData)), "Unexpected value\n"); +} + static void compareRDNAttrs(const CERT_RDN_ATTR *expected, const CERT_RDN_ATTR *got) { @@ -851,15 +800,8 @@ static void compareRDNAttrs(const CERT_RDN_ATTR *expected, expected->pszObjId); } } - ok(got->dwValueType == expected->dwValueType, - "Expected string type %ld, got %ld\n", expected->dwValueType, - got->dwValueType); - ok(got->Value.cbData == expected->Value.cbData, - "Unexpected data size, got %ld, expected %ld\n", got->Value.cbData, - expected->Value.cbData); - if (got->Value.cbData && got->Value.pbData) - ok(!memcmp(got->Value.pbData, expected->Value.pbData, - min(got->Value.cbData, expected->Value.cbData)), "Unexpected value\n"); + compareNameValues((const CERT_NAME_VALUE *)&expected->dwValueType, + (const CERT_NAME_VALUE *)&got->dwValueType); } static void compareRDNs(const CERT_RDN *expected, const CERT_RDN *got) @@ -891,34 +833,12 @@ static void compareNames(const CERT_NAME_INFO *expected, static void test_decodeName(DWORD dwEncoding) { - int i; BYTE *buf = NULL; DWORD bufSize = 0; BOOL ret; CERT_RDN rdn; CERT_NAME_INFO info = { 1, &rdn }; - for (i = 0; i < sizeof(names) / sizeof(names[0]); i++) - { - /* When the output buffer is NULL, this always succeeds */ - SetLastError(0xdeadbeef); - ret = CryptDecodeObjectEx(dwEncoding, X509_NAME, names[i].encoded, - names[i].encoded[1] + 2, 0, NULL, NULL, &bufSize); - ok(ret && GetLastError() == NOERROR, - "Expected success and NOERROR, got %08lx\n", GetLastError()); - ret = CryptDecodeObjectEx(dwEncoding, X509_NAME, names[i].encoded, - names[i].encoded[1] + 2, - CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_SHARE_OID_STRING_FLAG, NULL, - (BYTE *)&buf, &bufSize); - ok(ret, "CryptDecodeObjectEx failed: %08lx\n", GetLastError()); - rdn.cRDNAttr = 1; - rdn.rgRDNAttr = (CERT_RDN_ATTR *)&names[i].attr; - if (buf) - { - compareNames(&info, (CERT_NAME_INFO *)buf); - LocalFree(buf); - } - } /* test empty name */ bufSize = 0; ret = CryptDecodeObjectEx(dwEncoding, X509_NAME, emptySequence, @@ -990,6 +910,90 @@ static void test_decodeName(DWORD dwEncoding) } } +struct EncodedNameValue +{ + CERT_NAME_VALUE value; + const BYTE *encoded; +}; + +static const char bogusIA5[] = "\x80"; +static const char bogusPrintable[] = "~"; +static const char bogusNumeric[] = "A"; +static const char bogusT61[] = "\xff"; +static const BYTE bin39[] = { 0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e, + 0x67,0x00 }; +static const BYTE bin40[] = { 0x16,0x05,0x4c,0x61,0x6e,0x67,0x00 }; +static const BYTE bin41[] = { 0x14,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e, + 0x67,0x00 }; +static const BYTE bin42[] = { 0x16,0x02,0x80,0x00 }; +static const BYTE bin43[] = { 0x13,0x02,0x7e,0x00 }; +static const BYTE bin44[] = { 0x12,0x02,0x41,0x00 }; +static const BYTE bin45[] = { 0x14,0x02,0xff,0x00 }; + +struct EncodedNameValue nameValues[] = { + { { CERT_RDN_PRINTABLE_STRING, { sizeof(commonName), (BYTE *)commonName } }, + bin39 }, + { { CERT_RDN_IA5_STRING, { sizeof(surName), (BYTE *)surName } }, bin40 }, + { { CERT_RDN_T61_STRING, { sizeof(commonName), (BYTE *)commonName } }, bin41 }, + /* The following tests succeed under Windows, but really should fail, + * they contain characters that are illegal for the encoding. I'm + * including them to justify my lazy encoding. + */ + { { CERT_RDN_IA5_STRING, { sizeof(bogusIA5), (BYTE *)bogusIA5 } }, bin42 }, + { { CERT_RDN_PRINTABLE_STRING, { sizeof(bogusPrintable), + (BYTE *)bogusPrintable } }, bin43 }, + { { CERT_RDN_NUMERIC_STRING, { sizeof(bogusNumeric), (BYTE *)bogusNumeric } }, + bin44 }, + { { CERT_RDN_T61_STRING, { sizeof(bogusT61), (BYTE *)bogusT61 } }, bin45 }, +}; + + +static void test_encodeNameValue(DWORD dwEncoding) +{ + BYTE *buf = NULL; + DWORD size = 0, i; + BOOL ret; + + for (i = 0; i < sizeof(nameValues) / sizeof(nameValues[0]); i++) + { + ret = CryptEncodeObjectEx(dwEncoding, X509_NAME_VALUE, + &nameValues[i].value, CRYPT_ENCODE_ALLOC_FLAG, NULL, (BYTE *)&buf, + &size); + ok(ret, "CryptEncodeObjectEx failed: %08lx\n", GetLastError()); + if (buf) + { + ok(size == nameValues[i].encoded[1] + 2, + "Expected size %d, got %ld\n", nameValues[i].encoded[1] + 2, size); + ok(!memcmp(buf, nameValues[i].encoded, size), + "Got unexpected encoding\n"); + LocalFree(buf); + } + } +} + +static void test_decodeNameValue(DWORD dwEncoding) +{ + int i; + BYTE *buf = NULL; + DWORD bufSize = 0; + BOOL ret; + + for (i = 0; i < sizeof(nameValues) / sizeof(nameValues[0]); i++) + { + ret = CryptDecodeObjectEx(dwEncoding, X509_NAME_VALUE, + nameValues[i].encoded, nameValues[i].encoded[1] + 2, + CRYPT_DECODE_ALLOC_FLAG | CRYPT_DECODE_SHARE_OID_STRING_FLAG, NULL, + (BYTE *)&buf, &bufSize); + ok(ret, "CryptDecodeObjectEx failed: %08lx\n", GetLastError()); + if (buf) + { + compareNameValues(&nameValues[i].value, + (const CERT_NAME_VALUE *)buf); + LocalFree(buf); + } + } +} + static const BYTE emptyURL[] = { 0x30, 0x02, 0x86, 0x00 }; static const WCHAR url[] = { 'h','t','t','p',':','/','/','w','i','n','e', 'h','q','.','o','r','g',0 }; @@ -1495,6 +1499,8 @@ static void test_encodeBasicConstraints(DWORD dwEncoding) } static const unsigned char bin63[] = { 0x30,0x06,0x01,0x01,0x01,0x02,0x01,0x01 }; +static const unsigned char encodedCommonName[] = { + 0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,'J','u','a','n',' ','L','a','n','g',0}; static void test_decodeBasicConstraints(DWORD dwEncoding) { @@ -1547,8 +1553,8 @@ static void test_decodeBasicConstraints(DWORD dwEncoding) } /* Check with a non-basic constraints value */ ret = CryptDecodeObjectEx(dwEncoding, X509_BASIC_CONSTRAINTS2, - names[0].encoded, names[0].encoded[1] + 2, CRYPT_DECODE_ALLOC_FLAG, NULL, - (BYTE *)&buf, &bufSize); + (LPBYTE)encodedCommonName, encodedCommonName[1] + 2, + CRYPT_DECODE_ALLOC_FLAG, NULL, (BYTE *)&buf, &bufSize); ok(!ret && GetLastError() == CRYPT_E_ASN1_CORRUPT, "Expected CRYPT_E_ASN1_CORRUPT, got %08lx\n", GetLastError()); /* Now check with the more complex CERT_BASIC_CONSTRAINTS_INFO */ @@ -2164,10 +2170,6 @@ static const BYTE bigCert[] = { 0x30, 0x7a, 0x02, 0x01, 0x01, 0x30, 0x02, 0x06, 0x00, 0xa3, 0x16, 0x30, 0x14, 0x30, 0x12, 0x06, 0x03, 0x55, 0x1d, 0x13, 0x01, 0x01, 0xff, 0x04, 0x08, 0x30, 0x06, 0x01, 0x01, 0xff, 0x02, 0x01, 0x01 }; -/* This is the encoded form of the printable string "Juan Lang" */ -static const BYTE encodedCommonName[] = { 0x30, 0x15, 0x31, 0x13, 0x30, 0x11, - 0x06, 0x03, 0x55, 0x04, 0x03, 0x13, 0x0a, 0x4a, 0x75, 0x61, 0x6e, 0x20, 0x4c, - 0x61, 0x6e, 0x67, 0x00 }; static const BYTE serialNum[] = { 0x01 }; static void test_encodeCertToBeSigned(DWORD dwEncoding) @@ -3202,6 +3204,10 @@ START_TEST(encode) test_decodeFiletime(encodings[i]); test_encodeName(encodings[i]); test_decodeName(encodings[i]); + todo_wine { + test_encodeNameValue(encodings[i]); + test_decodeNameValue(encodings[i]); + } test_encodeAltName(encodings[i]); test_decodeAltName(encodings[i]); test_encodeOctets(encodings[i]);