source: trunk/src/crypt32/tests/str.c@ 21311

Last change on this file since 21311 was 21311, checked in by vladest, 16 years ago

Added CRYPT32 and MSCMS APIs support
File size: 29.4 KB
Line 
1/*
2 * Unit test suite for crypt32.dll's Cert*ToStr and CertStrToName functions.
3 *
4 * Copyright 2006 Juan Lang, Aric Stewart for CodeWeavers
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20#include <stdio.h>
21#include <stdarg.h>
22#include <windef.h>
23#include <winbase.h>
24#include <winerror.h>
25#include <wincrypt.h>
26
27#include "wine/test.h"
28
29/*#define DUMP_STRINGS*/
30#ifdef DUMP_STRINGS
31#include "wine/debug.h"
32#endif
33
34typedef struct _CertRDNAttrEncoding {
35 LPCSTR pszObjId;
36 DWORD dwValueType;
37 CERT_RDN_VALUE_BLOB Value;
38 LPCSTR str;
39} CertRDNAttrEncoding, *PCertRDNAttrEncoding;
40
41typedef struct _CertRDNAttrEncodingW {
42 LPCSTR pszObjId;
43 DWORD dwValueType;
44 CERT_RDN_VALUE_BLOB Value;
45 LPCWSTR str;
46} CertRDNAttrEncodingW, *PCertRDNAttrEncodingW;
47
48static BYTE bin1[] = { 0x55, 0x53 };
49static BYTE bin2[] = { 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74,
50 0x61 };
51static BYTE bin3[] = { 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x61, 0x70, 0x6f,
52 0x6c, 0x69, 0x73 };
53static BYTE bin4[] = { 0x43, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x61, 0x76,
54 0x65, 0x72, 0x73 };
55static BYTE bin5[] = { 0x57, 0x69, 0x6e, 0x65, 0x20, 0x44, 0x65, 0x76,
56 0x65, 0x6c, 0x6f, 0x70, 0x6d, 0x65, 0x6e, 0x74 };
57static BYTE bin6[] = { 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x68, 0x6f, 0x73,
58 0x74 };
59static BYTE bin7[] = { 0x61, 0x72, 0x69, 0x63, 0x40, 0x63, 0x6f, 0x64,
60 0x65, 0x77, 0x65, 0x61, 0x76, 0x65, 0x72, 0x73, 0x2e, 0x63, 0x6f, 0x6d };
61
62static const BYTE cert[] =
63{0x30,0x82,0x2,0xbb,0x30,0x82,0x2,0x24,0x2,0x9,0x0,0xe3,0x5a,0x10,0xf1,0xfc,
64 0x4b,0xf3,0xa2,0x30,0xd,0x6,0x9,0x2a,0x86,0x48,0x86,0xf7,0xd,0x1,0x1,0x4,0x5,
65 0x0,0x30,0x81,0xa1,0x31,0xb,0x30,0x9,0x6,0x3,0x55,0x4,0x6,0x13,0x2,0x55,0x53,
66 0x31,0x12,0x30,0x10,0x6,0x3,0x55,0x4,0x8,0x13,0x9,0x4d,0x69,0x6e,0x6e,0x65,
67 0x73,0x6f,0x74,0x61,0x31,0x14,0x30,0x12,0x6,0x3,0x55,0x4,0x7,0x13,0xb,0x4d,
68 0x69,0x6e,0x6e,0x65,0x61,0x70,0x6f,0x6c,0x69,0x73,0x31,0x14,0x30,0x12,0x6,0x3,
69 0x55,0x4,0xa,0x13,0xb,0x43,0x6f,0x64,0x65,0x57,0x65,0x61,0x76,0x65,0x72,0x73,
70 0x31,0x19,0x30,0x17,0x6,0x3,0x55,0x4,0xb,0x13,0x10,0x57,0x69,0x6e,0x65,0x20,
71 0x44,0x65,0x76,0x65,0x6c,0x6f,0x70,0x6d,0x65,0x6e,0x74,0x31,0x12,0x30,0x10,
72 0x6,0x3,0x55,0x4,0x3,0x13,0x9,0x6c,0x6f,0x63,0x61,0x6c,0x68,0x6f,0x73,0x74,
73 0x31,0x23,0x30,0x21,0x6,0x9,0x2a,0x86,0x48,0x86,0xf7,0xd,0x1,0x9,0x1,0x16,
74 0x14,0x61,0x72,0x69,0x63,0x40,0x63,0x6f,0x64,0x65,0x77,0x65,0x61,0x76,0x65,
75 0x72,0x73,0x2e,0x63,0x6f,0x6d,0x30,0x1e,0x17,0xd,0x30,0x36,0x30,0x31,0x32,
76 0x35,0x31,0x33,0x35,0x37,0x32,0x34,0x5a,0x17,0xd,0x30,0x36,0x30,0x32,0x32,
77 0x34,0x31,0x33,0x35,0x37,0x32,0x34,0x5a,0x30,0x81,0xa1,0x31,0xb,0x30,0x9,0x6,
78 0x3,0x55,0x4,0x6,0x13,0x2,0x55,0x53,0x31,0x12,0x30,0x10,0x6,0x3,0x55,0x4,0x8,
79 0x13,0x9,0x4d,0x69,0x6e,0x6e,0x65,0x73,0x6f,0x74,0x61,0x31,0x14,0x30,0x12,0x6,
80 0x3,0x55,0x4,0x7,0x13,0xb,0x4d,0x69,0x6e,0x6e,0x65,0x61,0x70,0x6f,0x6c,0x69,
81 0x73,0x31,0x14,0x30,0x12,0x6,0x3,0x55,0x4,0xa,0x13,0xb,0x43,0x6f,0x64,0x65,
82 0x57,0x65,0x61,0x76,0x65,0x72,0x73,0x31,0x19,0x30,0x17,0x6,0x3,0x55,0x4,0xb,
83 0x13,0x10,0x57,0x69,0x6e,0x65,0x20,0x44,0x65,0x76,0x65,0x6c,0x6f,0x70,0x6d,
84 0x65,0x6e,0x74,0x31,0x12,0x30,0x10,0x6,0x3,0x55,0x4,0x3,0x13,0x9,0x6c,0x6f,
85 0x63,0x61,0x6c,0x68,0x6f,0x73,0x74,0x31,0x23,0x30,0x21,0x6,0x9,0x2a,0x86,0x48,
86 0x86,0xf7,0xd,0x1,0x9,0x1,0x16,0x14,0x61,0x72,0x69,0x63,0x40,0x63,0x6f,0x64,
87 0x65,0x77,0x65,0x61,0x76,0x65,0x72,0x73,0x2e,0x63,0x6f,0x6d,0x30,0x81,0x9f,
88 0x30,0xd,0x6,0x9,0x2a,0x86,0x48,0x86,0xf7,0xd,0x1,0x1,0x1,0x5,0x0,0x3,0x81,
89 0x8d,0x0,0x30,0x81,0x89,0x2,0x81,0x81,0x0,0x9b,0xb5,0x8f,0xaf,0xfb,0x9a,0xaf,
90 0xdc,0xa2,0x4d,0xb1,0xc8,0x72,0x44,0xef,0x79,0x7f,0x28,0xb6,0xfe,0x50,0xdc,
91 0x8a,0xf7,0x11,0x2f,0x90,0x70,0xed,0xa4,0xa9,0xd,0xbf,0x82,0x3e,0x56,0xd8,
92 0x36,0xb6,0x9,0x52,0x83,0xab,0x65,0x95,0x0,0xe2,0xea,0x3c,0x4f,0x85,0xb8,0xc,
93 0x41,0x42,0x77,0x5c,0x9d,0x44,0xeb,0xcf,0x7d,0x60,0x64,0x7a,0x6c,0x4c,0xac,
94 0x4a,0x9a,0x23,0x25,0x15,0xd7,0x92,0xb4,0x10,0xe7,0x95,0xad,0x4b,0x93,0xda,
95 0x6a,0x76,0xe0,0xa5,0xd2,0x13,0x8,0x12,0x30,0x68,0xde,0xb9,0x5b,0x6e,0x2a,
96 0x97,0x43,0xaa,0x7b,0x22,0x33,0x34,0xb1,0xca,0x5d,0x19,0xd8,0x42,0x26,0x45,
97 0xc6,0xe9,0x1d,0xee,0x7,0xc2,0x27,0x95,0x87,0xd8,0x12,0xec,0x4b,0x16,0x9f,0x2,
98 0x3,0x1,0x0,0x1,0x30,0xd,0x6,0x9,0x2a,0x86,0x48,0x86,0xf7,0xd,0x1,0x1,0x4,0x5,
99 0x0,0x3,0x81,0x81,0x0,0x96,0xf9,0xf6,0x6a,0x3d,0xd9,0xca,0x6e,0xd5,0x76,0x73,
100 0xab,0x75,0xc1,0xcc,0x98,0x44,0xc3,0xa9,0x90,0x68,0x88,0x76,0xb9,0xeb,0xb6,
101 0xbe,0x60,0x62,0xb9,0x67,0x1e,0xcc,0xf4,0xe1,0xe7,0x6c,0xc8,0x67,0x3f,0x1d,
102 0xf3,0x68,0x86,0x30,0xee,0xaa,0x92,0x61,0x37,0xd7,0x82,0x90,0x28,0xaa,0x7a,
103 0x18,0x88,0x60,0x14,0x88,0x75,0xc0,0x4a,0x4e,0x7d,0x48,0xe7,0x3,0xa6,0xfd,
104 0xd7,0xce,0x3c,0xe5,0x9b,0xaf,0x2f,0xdc,0xbb,0x7c,0xbd,0x20,0x49,0xd9,0x68,
105 0x37,0xeb,0x5d,0xbb,0xe2,0x6d,0x66,0xe3,0x11,0xc1,0xa7,0x88,0x49,0xc6,0x6f,
106 0x65,0xd3,0xce,0xae,0x26,0x19,0x3,0x2e,0x4f,0x78,0xa5,0xa,0x97,0x7e,0x4f,0xc4,
107 0x91,0x8a,0xf8,0x5,0xef,0x5b,0x3b,0x49,0xbf,0x5f,0x2b};
108
109static char issuerStr[] =
110 "US, Minnesota, Minneapolis, CodeWeavers, Wine Development, localhost, aric@codeweavers.com";
111static char issuerStrSemicolon[] =
112 "US; Minnesota; Minneapolis; CodeWeavers; Wine Development; localhost; aric@codeweavers.com";
113static char issuerStrCRLF[] =
114 "US\r\nMinnesota\r\nMinneapolis\r\nCodeWeavers\r\nWine Development\r\nlocalhost\r\naric@codeweavers.com";
115static char subjectStr[] =
116 "2.5.4.6=US, 2.5.4.8=Minnesota, 2.5.4.7=Minneapolis, 2.5.4.10=CodeWeavers, 2.5.4.11=Wine Development, 2.5.4.3=localhost, 1.2.840.113549.1.9.1=aric@codeweavers.com";
117static char subjectStrSemicolon[] =
118 "2.5.4.6=US; 2.5.4.8=Minnesota; 2.5.4.7=Minneapolis; 2.5.4.10=CodeWeavers; 2.5.4.11=Wine Development; 2.5.4.3=localhost; 1.2.840.113549.1.9.1=aric@codeweavers.com";
119static char subjectStrCRLF[] =
120 "2.5.4.6=US\r\n2.5.4.8=Minnesota\r\n2.5.4.7=Minneapolis\r\n2.5.4.10=CodeWeavers\r\n2.5.4.11=Wine Development\r\n2.5.4.3=localhost\r\n1.2.840.113549.1.9.1=aric@codeweavers.com";
121static char x500SubjectStr[] = "C=US, S=Minnesota, L=Minneapolis, O=CodeWeavers, OU=Wine Development, CN=localhost, E=aric@codeweavers.com";
122static char x500SubjectStrSemicolonReverse[] = "E=aric@codeweavers.com; CN=localhost; OU=Wine Development; O=CodeWeavers; L=Minneapolis; S=Minnesota; C=US";
123static WCHAR issuerStrW[] = {
124 'U','S',',',' ','M','i','n','n','e','s','o','t','a',',',' ','M','i','n','n',
125 'e','a','p','o','l','i','s',',',' ','C','o','d','e','W','e','a','v','e','r',
126 's',',',' ','W','i','n','e',' ','D','e','v','e','l','o','p','m','e','n','t',
127 ',',' ','l','o','c','a','l','h','o','s','t',',',' ','a','r','i','c','@','c',
128 'o','d','e','w','e','a','v','e','r','s','.','c','o','m',0 };
129static WCHAR issuerStrSemicolonW[] = {
130 'U','S',';',' ','M','i','n','n','e','s','o','t','a',';',' ','M','i','n','n',
131 'e','a','p','o','l','i','s',';',' ','C','o','d','e','W','e','a','v','e','r',
132 's',';',' ','W','i','n','e',' ','D','e','v','e','l','o','p','m','e','n','t',
133 ';',' ','l','o','c','a','l','h','o','s','t',';',' ','a','r','i','c','@','c',
134 'o','d','e','w','e','a','v','e','r','s','.','c','o','m',0 };
135static WCHAR issuerStrCRLFW[] = {
136 'U','S','\r','\n','M','i','n','n','e','s','o','t','a','\r','\n','M','i','n',
137 'n','e','a','p','o','l','i','s','\r','\n','C','o','d','e','W','e','a','v','e',
138 'r','s','\r','\n','W','i','n','e',' ','D','e','v','e','l','o','p','m','e','n',
139 't','\r','\n','l','o','c','a','l','h','o','s','t','\r','\n','a','r','i','c',
140 '@','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m',0 };
141static WCHAR subjectStrW[] = {
142 '2','.','5','.','4','.','6','=','U','S',',',' ','2','.','5','.','4','.','8',
143 '=','M','i','n','n','e','s','o','t','a',',',' ','2','.','5','.','4','.','7',
144 '=','M','i','n','n','e','a','p','o','l','i','s',',',' ','2','.','5','.','4',
145 '.','1','0','=','C','o','d','e','W','e','a','v','e','r','s',',',' ','2','.',
146 '5','.','4','.','1','1','=','W','i','n','e',' ','D','e','v','e','l','o','p',
147 'm','e','n','t',',',' ','2','.','5','.','4','.','3','=','l','o','c','a','l',
148 'h','o','s','t',',',' ','1','.','2','.','8','4','0','.','1','1','3','5','4',
149 '9','.','1','.','9','.','1','=','a','r','i','c','@','c','o','d','e','w','e',
150 'a','v','e','r','s','.','c','o','m',0 };
151static WCHAR subjectStrSemicolonW[] = {
152 '2','.','5','.','4','.','6','=','U','S',';',' ','2','.','5','.','4','.','8',
153 '=','M','i','n','n','e','s','o','t','a',';',' ','2','.','5','.','4','.','7',
154 '=','M','i','n','n','e','a','p','o','l','i','s',';',' ','2','.','5','.','4',
155 '.','1','0','=','C','o','d','e','W','e','a','v','e','r','s',';',' ','2','.',
156 '5','.','4','.','1','1','=','W','i','n','e',' ','D','e','v','e','l','o','p',
157 'm','e','n','t',';',' ','2','.','5','.','4','.','3','=','l','o','c','a','l',
158 'h','o','s','t',';',' ','1','.','2','.','8','4','0','.','1','1','3','5','4',
159 '9','.','1','.','9','.','1','=','a','r','i','c','@','c','o','d','e','w','e',
160 'a','v','e','r','s','.','c','o','m',0 };
161static WCHAR subjectStrCRLFW[] = {
162 '2','.','5','.','4','.','6','=','U','S','\r','\n','2','.','5','.','4','.','8',
163 '=','M','i','n','n','e','s','o','t','a','\r','\n','2','.','5','.','4','.','7',
164 '=','M','i','n','n','e','a','p','o','l','i','s','\r','\n','2','.','5','.','4',
165 '.','1','0','=','C','o','d','e','W','e','a','v','e','r','s','\r','\n','2','.',
166 '5','.','4','.','1','1','=','W','i','n','e',' ','D','e','v','e','l','o','p',
167 'm','e','n','t','\r','\n','2','.','5','.','4','.','3','=','l','o','c','a','l',
168 'h','o','s','t','\r','\n','1','.','2','.','8','4','0','.','1','1','3','5','4',
169 '9','.','1','.','9','.','1','=','a','r','i','c','@','c','o','d','e','w','e',
170 'a','v','e','r','s','.','c','o','m',0 };
171static WCHAR x500SubjectStrSemicolonReverseW[] = {
172 'E','=','a','r','i','c','@','c','o','d','e','w','e','a','v','e','r','s','.','c',
173 'o','m',';',' ','C','N','=','l','o','c','a','l','h','o','s','t',';',' ','O','U',
174 '=','W','i','n','e',' ','D','e','v','e','l','o','p','m','e','n','t',';',' ','O',
175 '=','C','o','d','e','W','e','a','v','e','r','s',';',' ','L','=','M','i','n','n',
176 'e','a','p','o','l','i','s',';',' ','S','=','M','i','n','n','e','s','o','t','a',
177 ';',' ','C','=','U','S',0 };
178
179typedef BOOL (WINAPI *CryptDecodeObjectFunc)(DWORD, LPCSTR, const BYTE *,
180 DWORD, DWORD, void *, DWORD *);
181typedef DWORD (WINAPI *CertNameToStrAFunc)(DWORD,LPVOID,DWORD,LPSTR,DWORD);
182typedef DWORD (WINAPI *CertNameToStrWFunc)(DWORD,LPVOID,DWORD,LPWSTR,DWORD);
183typedef DWORD (WINAPI *CertRDNValueToStrAFunc)(DWORD, PCERT_RDN_VALUE_BLOB,
184 LPSTR, DWORD);
185typedef DWORD (WINAPI *CertRDNValueToStrWFunc)(DWORD, PCERT_RDN_VALUE_BLOB,
186 LPWSTR, DWORD);
187typedef BOOL (WINAPI *CertStrToNameAFunc)(DWORD dwCertEncodingType,
188 LPCSTR pszX500, DWORD dwStrType, void *pvReserved, BYTE *pbEncoded,
189 DWORD *pcbEncoded, LPCSTR *ppszError);
190typedef BOOL (WINAPI *CertStrToNameWFunc)(DWORD dwCertEncodingType,
191 LPCWSTR pszX500, DWORD dwStrType, void *pvReserved, BYTE *pbEncoded,
192 DWORD *pcbEncoded, LPCWSTR *ppszError);
193
194HMODULE dll;
195static CertNameToStrAFunc pCertNameToStrA;
196static CertNameToStrWFunc pCertNameToStrW;
197static CryptDecodeObjectFunc pCryptDecodeObject;
198static CertRDNValueToStrAFunc pCertRDNValueToStrA;
199static CertRDNValueToStrWFunc pCertRDNValueToStrW;
200static CertStrToNameAFunc pCertStrToNameA;
201static CertStrToNameWFunc pCertStrToNameW;
202
203static void test_CertRDNValueToStrA(void)
204{
205 CertRDNAttrEncoding attrs[] = {
206 { "2.5.4.6", CERT_RDN_PRINTABLE_STRING,
207 { sizeof(bin1), (PBYTE)bin1 }, "US" },
208 { "2.5.4.8", CERT_RDN_PRINTABLE_STRING,
209 { sizeof(bin2), (PBYTE)bin2 }, "Minnesota" },
210 { "2.5.4.7", CERT_RDN_PRINTABLE_STRING,
211 { sizeof(bin3), (PBYTE)bin3 }, "Minneapolis" },
212 { "2.5.4.10", CERT_RDN_PRINTABLE_STRING,
213 { sizeof(bin4), (PBYTE)bin4 }, "CodeWeavers" },
214 { "2.5.4.11", CERT_RDN_PRINTABLE_STRING,
215 { sizeof(bin5), (PBYTE)bin5 }, "Wine Development" },
216 { "2.5.4.3", CERT_RDN_PRINTABLE_STRING,
217 { sizeof(bin6), (PBYTE)bin6 }, "localhost" },
218 { "1.2.840.113549.1.9.1", CERT_RDN_IA5_STRING,
219 { sizeof(bin7), (PBYTE)bin7 }, "aric@codeweavers.com" },
220 };
221 DWORD i, ret;
222 char buffer[2000];
223 CERT_RDN_VALUE_BLOB blob = { 0, NULL };
224
225 if (!pCertRDNValueToStrA) return;
226
227 /* This crashes
228 ret = pCertRDNValueToStrA(0, NULL, NULL, 0);
229 */
230 /* With empty input, it generates the empty string */
231 SetLastError(0xdeadbeef);
232 ret = pCertRDNValueToStrA(0, &blob, NULL, 0);
233 ok(ret == 1 && GetLastError() == 0xdeadbeef, "Expected empty string\n");
234 ret = pCertRDNValueToStrA(0, &blob, buffer, sizeof(buffer));
235 ok(ret == 1 && GetLastError() == 0xdeadbeef, "Expected empty string\n");
236 ok(!buffer[0], "Expected empty string\n");
237
238 for (i = 0; i < sizeof(attrs) / sizeof(attrs[0]); i++)
239 {
240 ret = pCertRDNValueToStrA(attrs[i].dwValueType, &attrs[i].Value,
241 buffer, sizeof(buffer));
242 ok(ret == strlen(attrs[i].str) + 1, "Expected length %d, got %d\n",
243 lstrlenA(attrs[i].str) + 1, ret);
244 ok(!strcmp(buffer, attrs[i].str), "Expected %s, got %s\n", attrs[i].str,
245 buffer);
246 }
247}
248
249static void test_CertRDNValueToStrW(void)
250{
251 static const WCHAR usW[] = { 'U','S',0 };
252 static const WCHAR minnesotaW[] = { 'M','i','n','n','e','s','o','t','a',0 };
253 static const WCHAR minneapolisW[] = { 'M','i','n','n','e','a','p','o','l',
254 'i','s',0 };
255 static const WCHAR codeweaversW[] = { 'C','o','d','e','W','e','a','v','e',
256 'r','s',0 };
257 static const WCHAR wineDevW[] = { 'W','i','n','e',' ','D','e','v','e','l',
258 'o','p','m','e','n','t',0 };
259 static const WCHAR localhostW[] = { 'l','o','c','a','l','h','o','s','t',0 };
260 static const WCHAR aricW[] = { 'a','r','i','c','@','c','o','d','e','w','e',
261 'a','v','e','r','s','.','c','o','m',0 };
262 CertRDNAttrEncodingW attrs[] = {
263 { "2.5.4.6", CERT_RDN_PRINTABLE_STRING,
264 { sizeof(bin1), (PBYTE)bin1 }, usW },
265 { "2.5.4.8", CERT_RDN_PRINTABLE_STRING,
266 { sizeof(bin2), (PBYTE)bin2 }, minnesotaW },
267 { "2.5.4.7", CERT_RDN_PRINTABLE_STRING,
268 { sizeof(bin3), (PBYTE)bin3 }, minneapolisW },
269 { "2.5.4.10", CERT_RDN_PRINTABLE_STRING,
270 { sizeof(bin4), (PBYTE)bin4 }, codeweaversW },
271 { "2.5.4.11", CERT_RDN_PRINTABLE_STRING,
272 { sizeof(bin5), (PBYTE)bin5 }, wineDevW },
273 { "2.5.4.3", CERT_RDN_PRINTABLE_STRING,
274 { sizeof(bin6), (PBYTE)bin6 }, localhostW },
275 { "1.2.840.113549.1.9.1", CERT_RDN_IA5_STRING,
276 { sizeof(bin7), (PBYTE)bin7 }, aricW },
277 };
278 DWORD i, ret;
279 WCHAR buffer[2000];
280 CERT_RDN_VALUE_BLOB blob = { 0, NULL };
281
282 if (!pCertRDNValueToStrW)
283 {
284 skip("CertRDNValueToStrW is not available\n");
285 return;
286 }
287
288 /* This crashes
289 ret = pCertRDNValueToStrW(0, NULL, NULL, 0);
290 */
291 /* With empty input, it generates the empty string */
292 SetLastError(0xdeadbeef);
293 ret = pCertRDNValueToStrW(0, &blob, NULL, 0);
294 ok(ret == 1 && GetLastError() == 0xdeadbeef, "Expected empty string\n");
295 ret = pCertRDNValueToStrW(0, &blob, buffer,
296 sizeof(buffer) / sizeof(buffer[0]));
297 ok(ret == 1 && GetLastError() == 0xdeadbeef, "Expected empty string\n");
298 ok(!buffer[0], "Expected empty string\n");
299
300 for (i = 0; i < sizeof(attrs) / sizeof(attrs[0]); i++)
301 {
302 ret = pCertRDNValueToStrW(attrs[i].dwValueType, &attrs[i].Value,
303 buffer, sizeof(buffer) / sizeof(buffer[0]));
304 ok(ret == lstrlenW(attrs[i].str) + 1, "Expected length %d, got %d\n",
305 lstrlenW(attrs[i].str) + 1, ret);
306 ok(!lstrcmpW(buffer, attrs[i].str), "Unexpected value\n");
307#ifdef DUMP_STRINGS
308 trace("Expected %s, got %s\n",
309 wine_dbgstr_w(attrs[i].str), wine_dbgstr_w(buffer));
310#endif
311 }
312}
313
314static void test_NameToStrConversionA(PCERT_NAME_BLOB pName, DWORD dwStrType,
315 LPCSTR expected)
316{
317 char buffer[2000] = { 0 };
318 DWORD i;
319
320 i = pCertNameToStrA(X509_ASN_ENCODING, pName, dwStrType, NULL, 0);
321 ok(i == strlen(expected) + 1, "Expected %d chars, got %d\n",
322 lstrlenA(expected) + 1, i);
323 i = pCertNameToStrA(X509_ASN_ENCODING,pName, dwStrType, buffer,
324 sizeof(buffer));
325 ok(i == strlen(expected) + 1, "Expected %d chars, got %d\n",
326 lstrlenA(expected) + 1, i);
327 ok(!strcmp(buffer, expected), "Expected %s, got %s\n", expected, buffer);
328}
329
330static void test_CertNameToStrA(void)
331{
332 PCCERT_CONTEXT context;
333
334 if (!pCertNameToStrA)
335 {
336 skip("CertNameToStrA is not available\n");
337 return;
338 }
339
340 context = CertCreateCertificateContext(X509_ASN_ENCODING, cert,
341 sizeof(cert));
342 ok(context != NULL, "CertCreateCertificateContext failed: %08x\n",
343 GetLastError());
344 if (context)
345 {
346 DWORD ret;
347
348 /* This crashes
349 ret = pCertNameToStrA(0, NULL, 0, NULL, 0);
350 */
351 /* Test with a bogus encoding type */
352 SetLastError(0xdeadbeef);
353 ret = pCertNameToStrA(0, &context->pCertInfo->Issuer, 0, NULL, 0);
354 ok(ret == 1 && GetLastError() == ERROR_FILE_NOT_FOUND,
355 "Expected retval 1 and ERROR_FILE_NOT_FOUND, got %d - %08x\n",
356 ret, GetLastError());
357 SetLastError(0xdeadbeef);
358 ret = pCertNameToStrA(X509_ASN_ENCODING, &context->pCertInfo->Issuer,
359 0, NULL, 0);
360 ok(ret && GetLastError() == ERROR_SUCCESS,
361 "Expected positive return and ERROR_SUCCESS, got %d - %08x\n",
362 ret, GetLastError());
363
364 test_NameToStrConversionA(&context->pCertInfo->Issuer,
365 CERT_SIMPLE_NAME_STR, issuerStr);
366 test_NameToStrConversionA(&context->pCertInfo->Issuer,
367 CERT_SIMPLE_NAME_STR | CERT_NAME_STR_SEMICOLON_FLAG,
368 issuerStrSemicolon);
369 test_NameToStrConversionA(&context->pCertInfo->Issuer,
370 CERT_SIMPLE_NAME_STR | CERT_NAME_STR_CRLF_FLAG,
371 issuerStrCRLF);
372 test_NameToStrConversionA(&context->pCertInfo->Subject,
373 CERT_OID_NAME_STR, subjectStr);
374 test_NameToStrConversionA(&context->pCertInfo->Subject,
375 CERT_OID_NAME_STR | CERT_NAME_STR_SEMICOLON_FLAG,
376 subjectStrSemicolon);
377 test_NameToStrConversionA(&context->pCertInfo->Subject,
378 CERT_OID_NAME_STR | CERT_NAME_STR_CRLF_FLAG,
379 subjectStrCRLF);
380 test_NameToStrConversionA(&context->pCertInfo->Subject,
381 CERT_X500_NAME_STR, x500SubjectStr);
382 test_NameToStrConversionA(&context->pCertInfo->Subject,
383 CERT_X500_NAME_STR | CERT_NAME_STR_SEMICOLON_FLAG | CERT_NAME_STR_REVERSE_FLAG, x500SubjectStrSemicolonReverse);
384
385 CertFreeCertificateContext(context);
386 }
387}
388
389static void test_NameToStrConversionW(PCERT_NAME_BLOB pName, DWORD dwStrType,
390 LPCWSTR expected)
391{
392 WCHAR buffer[2000] = { 0 };
393 DWORD i;
394
395 i = pCertNameToStrW(X509_ASN_ENCODING,pName, dwStrType, NULL, 0);
396 ok(i == lstrlenW(expected) + 1, "Expected %d chars, got %d\n",
397 lstrlenW(expected) + 1, i);
398 i = pCertNameToStrW(X509_ASN_ENCODING,pName, dwStrType, buffer,
399 sizeof(buffer) / sizeof(buffer[0]));
400 ok(i == lstrlenW(expected) + 1, "Expected %d chars, got %d\n",
401 lstrlenW(expected) + 1, i);
402 ok(!lstrcmpW(buffer, expected), "Unexpected value\n");
403#ifdef DUMP_STRINGS
404 trace("Expected %s, got %s\n",
405 wine_dbgstr_w(expected), wine_dbgstr_w(buffer));
406#endif
407}
408
409static void test_CertNameToStrW(void)
410{
411 PCCERT_CONTEXT context;
412
413 if (!pCertNameToStrW)
414 {
415 skip("CertNameToStrW is not available\n");
416 return;
417 }
418
419 context = CertCreateCertificateContext(X509_ASN_ENCODING, cert,
420 sizeof(cert));
421 ok(context != NULL, "CertCreateCertificateContext failed: %08x\n",
422 GetLastError());
423 if (context)
424 {
425 DWORD ret;
426
427 /* This crashes
428 ret = pCertNameToStrW(0, NULL, 0, NULL, 0);
429 */
430 /* Test with a bogus encoding type */
431 SetLastError(0xdeadbeef);
432 ret = pCertNameToStrW(0, &context->pCertInfo->Issuer, 0, NULL, 0);
433 ok(ret == 1 && GetLastError() == ERROR_FILE_NOT_FOUND,
434 "Expected retval 1 and ERROR_FILE_NOT_FOUND, got %d - %08x\n",
435 ret, GetLastError());
436 SetLastError(0xdeadbeef);
437 ret = pCertNameToStrW(X509_ASN_ENCODING, &context->pCertInfo->Issuer,
438 0, NULL, 0);
439 ok(ret && GetLastError() == ERROR_SUCCESS,
440 "Expected positive return and ERROR_SUCCESS, got %d - %08x\n",
441 ret, GetLastError());
442
443 test_NameToStrConversionW(&context->pCertInfo->Issuer,
444 CERT_SIMPLE_NAME_STR, issuerStrW);
445 test_NameToStrConversionW(&context->pCertInfo->Issuer,
446 CERT_SIMPLE_NAME_STR | CERT_NAME_STR_SEMICOLON_FLAG,
447 issuerStrSemicolonW);
448 test_NameToStrConversionW(&context->pCertInfo->Issuer,
449 CERT_SIMPLE_NAME_STR | CERT_NAME_STR_CRLF_FLAG,
450 issuerStrCRLFW);
451 test_NameToStrConversionW(&context->pCertInfo->Subject,
452 CERT_OID_NAME_STR, subjectStrW);
453 test_NameToStrConversionW(&context->pCertInfo->Subject,
454 CERT_OID_NAME_STR | CERT_NAME_STR_SEMICOLON_FLAG,
455 subjectStrSemicolonW);
456 test_NameToStrConversionW(&context->pCertInfo->Subject,
457 CERT_OID_NAME_STR | CERT_NAME_STR_CRLF_FLAG,
458 subjectStrCRLFW);
459 test_NameToStrConversionW(&context->pCertInfo->Subject,
460 CERT_X500_NAME_STR | CERT_NAME_STR_SEMICOLON_FLAG | CERT_NAME_STR_REVERSE_FLAG, x500SubjectStrSemicolonReverseW);
461
462 CertFreeCertificateContext(context);
463 }
464}
465
466struct StrToNameA
467{
468 LPCSTR x500;
469 DWORD encodedSize;
470 const BYTE *encoded;
471};
472
473const BYTE encodedSimpleCN[] = {
4740x30,0x0c,0x31,0x0a,0x30,0x08,0x06,0x03,0x55,0x04,0x03,0x13,0x01,0x31 };
475static const BYTE encodedSingleQuotedCN[] = { 0x30,0x0e,0x31,0x0c,0x30,0x0a,
476 0x06,0x03,0x55,0x04,0x03,0x13,0x03,0x27,0x31,0x27 };
477static const BYTE encodedSpacedCN[] = { 0x30,0x0e,0x31,0x0c,0x30,0x0a,0x06,0x03,
478 0x55,0x04,0x03,0x13,0x03,0x20,0x31,0x20 };
479static const BYTE encodedQuotedCN[] = { 0x30,0x11,0x31,0x0f,0x30,0x0d,0x06,0x03,
480 0x55, 0x04,0x03,0x1e,0x06,0x00,0x22,0x00,0x31,0x00,0x22, };
481static const BYTE encodedMultipleAttrCN[] = { 0x30,0x0e,0x31,0x0c,0x30,0x0a,
482 0x06,0x03,0x55,0x04,0x03,0x13,0x03,0x31,0x2b,0x32 };
483
484struct StrToNameA namesA[] = {
485 { "CN=1", sizeof(encodedSimpleCN), encodedSimpleCN },
486 { "CN=\"1\"", sizeof(encodedSimpleCN), encodedSimpleCN },
487 { "CN = \"1\"", sizeof(encodedSimpleCN), encodedSimpleCN },
488 { "CN='1'", sizeof(encodedSingleQuotedCN), encodedSingleQuotedCN },
489 { "CN=\" 1 \"", sizeof(encodedSpacedCN), encodedSpacedCN },
490 { "CN=\"\"\"1\"\"\"", sizeof(encodedQuotedCN), encodedQuotedCN },
491 { "CN=\"1+2\"", sizeof(encodedMultipleAttrCN), encodedMultipleAttrCN },
492};
493
494static void test_CertStrToNameA(void)
495{
496 BOOL ret;
497 DWORD size, i;
498 BYTE buf[100];
499
500 if (!pCertStrToNameA)
501 {
502 skip("CertStrToNameA is not available\n");
503 return;
504 }
505
506 /* Crash
507 ret = pCertStrToNameA(0, NULL, 0, NULL, NULL, NULL, NULL);
508 */
509 ret = pCertStrToNameA(0, NULL, 0, NULL, NULL, &size, NULL);
510 ok(!ret, "Expected failure\n");
511 ret = pCertStrToNameA(0, "bogus", 0, NULL, NULL, &size, NULL);
512 ok(!ret && GetLastError() == CRYPT_E_INVALID_X500_STRING,
513 "Expected CRYPT_E_INVALID_X500_STRING, got %08x\n", GetLastError());
514 ret = pCertStrToNameA(0, "foo=1", 0, NULL, NULL, &size, NULL);
515 ok(!ret && GetLastError() == CRYPT_E_INVALID_X500_STRING,
516 "Expected CRYPT_E_INVALID_X500_STRING, got %08x\n", GetLastError());
517 ret = pCertStrToNameA(0, "CN=1", 0, NULL, NULL, &size, NULL);
518 ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND,
519 "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
520 ret = pCertStrToNameA(X509_ASN_ENCODING, "CN=1", 0, NULL, NULL, &size, NULL);
521 ok(ret, "CertStrToNameA failed: %08x\n", GetLastError());
522 size = sizeof(buf);
523 ret = pCertStrToNameA(X509_ASN_ENCODING, "CN=\"\"1\"\"", 0, NULL, buf, &size,
524 NULL);
525 ok(!ret && GetLastError() == CRYPT_E_INVALID_X500_STRING,
526 "Expected CRYPT_E_INVALID_X500_STRING, got %08x\n", GetLastError());
527 ret = pCertStrToNameA(X509_ASN_ENCODING, "CN=1+2", 0, NULL, buf,
528 &size, NULL);
529 todo_wine ok(!ret && GetLastError() == CRYPT_E_INVALID_X500_STRING,
530 "Expected CRYPT_E_INVALID_X500_STRING, got %08x\n", GetLastError());
531 for (i = 0; i < sizeof(namesA) / sizeof(namesA[0]); i++)
532 {
533 size = sizeof(buf);
534 ret = pCertStrToNameA(X509_ASN_ENCODING, namesA[i].x500, 0, NULL, buf,
535 &size, NULL);
536 ok(ret, "CertStrToNameA failed on string %s: %08x\n", namesA[i].x500,
537 GetLastError());
538 ok(size == namesA[i].encodedSize,
539 "Expected size %d, got %d\n", namesA[i].encodedSize, size);
540 if (ret)
541 ok(!memcmp(buf, namesA[i].encoded, namesA[i].encodedSize),
542 "Unexpected value for string %s\n", namesA[i].x500);
543 }
544}
545
546struct StrToNameW
547{
548 LPCWSTR x500;
549 DWORD encodedSize;
550 const BYTE *encoded;
551};
552
553static const WCHAR badlyQuotedCN_W[] = { 'C','N','=','"','"','1','"','"',0 };
554static const WCHAR simpleCN_W[] = { 'C','N','=','1',0 };
555static const WCHAR simpleCN2_W[] = { 'C','N','=','"','1','"',0 };
556static const WCHAR simpleCN3_W[] = { 'C','N',' ','=',' ','"','1','"',0 };
557static const WCHAR singledQuotedCN_W[] = { 'C','N','=','\'','1','\'',0 };
558static const WCHAR spacedCN_W[] = { 'C','N','=','"',' ','1',' ','"',0 };
559static const WCHAR quotedCN_W[] = { 'C','N','=','"','"','"','1','"','"','"',0 };
560static const WCHAR multipleAttrCN_W[] = { 'C','N','=','"','1','+','2','"',0 };
561static const WCHAR japaneseCN_W[] = { 'C','N','=',0x226f,0x575b,0 };
562static const BYTE encodedJapaneseCN[] = { 0x30,0x0f,0x31,0x0d,0x30,0x0b,0x06,
563 0x03,0x55,0x04,0x03,0x1e,0x04,0x22,0x6f,0x57,0x5b };
564
565struct StrToNameW namesW[] = {
566 { simpleCN_W, sizeof(encodedSimpleCN), encodedSimpleCN },
567 { simpleCN2_W, sizeof(encodedSimpleCN), encodedSimpleCN },
568 { simpleCN3_W, sizeof(encodedSimpleCN), encodedSimpleCN },
569 { singledQuotedCN_W, sizeof(encodedSingleQuotedCN), encodedSingleQuotedCN },
570 { spacedCN_W, sizeof(encodedSpacedCN), encodedSpacedCN },
571 { quotedCN_W, sizeof(encodedQuotedCN), encodedQuotedCN },
572 { multipleAttrCN_W, sizeof(encodedMultipleAttrCN), encodedMultipleAttrCN },
573 { japaneseCN_W, sizeof(encodedJapaneseCN), encodedJapaneseCN },
574};
575
576static void test_CertStrToNameW(void)
577{
578 static const WCHAR bogusW[] = { 'b','o','g','u','s',0 };
579 static const WCHAR fooW[] = { 'f','o','o','=','1',0 };
580 BOOL ret;
581 DWORD size, i;
582 LPCWSTR errorPtr;
583 BYTE buf[100];
584
585 if (!pCertStrToNameW)
586 {
587 skip("CertStrToNameW is not available\n");
588 return;
589 }
590
591 /* Crash
592 ret = pCertStrToNameW(0, NULL, 0, NULL, NULL, NULL, NULL);
593 */
594 ret = pCertStrToNameW(0, NULL, 0, NULL, NULL, &size, NULL);
595 ok(!ret, "Expected failure\n");
596 ret = pCertStrToNameW(0, bogusW, 0, NULL, NULL, &size, NULL);
597 ok(!ret && GetLastError() == CRYPT_E_INVALID_X500_STRING,
598 "Expected CRYPT_E_INVALID_X500_STRING, got %08x\n", GetLastError());
599 ret = pCertStrToNameW(0, fooW, 0, NULL, NULL, &size, NULL);
600 ok(!ret && GetLastError() == CRYPT_E_INVALID_X500_STRING,
601 "Expected CRYPT_E_INVALID_X500_STRING, got %08x\n", GetLastError());
602 ret = pCertStrToNameW(0, simpleCN_W, 0, NULL, NULL, &size, NULL);
603 ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND,
604 "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
605 ret = pCertStrToNameW(X509_ASN_ENCODING, simpleCN_W, 0, NULL, NULL, &size,
606 NULL);
607 ok(ret, "CertStrToNameW failed: %08x\n", GetLastError());
608 size = sizeof(buf);
609 ret = pCertStrToNameW(X509_ASN_ENCODING, badlyQuotedCN_W, 0, NULL, buf,
610 &size, NULL);
611 ok(!ret && GetLastError() == CRYPT_E_INVALID_X500_STRING,
612 "Expected CRYPT_E_INVALID_X500_STRING, got %08x\n", GetLastError());
613 ret = pCertStrToNameW(X509_ASN_ENCODING, badlyQuotedCN_W, 0, NULL, buf,
614 &size, &errorPtr);
615 ok(!ret && GetLastError() == CRYPT_E_INVALID_X500_STRING,
616 "Expected CRYPT_E_INVALID_X500_STRING, got %08x\n", GetLastError());
617 ok(errorPtr && *errorPtr == '1', "Expected first error character was 1\n");
618 for (i = 0; i < sizeof(namesW) / sizeof(namesW[0]); i++)
619 {
620 size = sizeof(buf);
621 ret = pCertStrToNameW(X509_ASN_ENCODING, namesW[i].x500, 0, NULL, buf,
622 &size, NULL);
623 ok(ret, "Index %d: CertStrToNameW failed: %08x\n", i, GetLastError());
624 ok(size == namesW[i].encodedSize,
625 "Index %d: expected size %d, got %d\n", i, namesW[i].encodedSize,
626 size);
627 if (ret)
628 ok(!memcmp(buf, namesW[i].encoded, size),
629 "Index %d: unexpected value\n", i);
630 }
631}
632
633START_TEST(str)
634{
635 dll = GetModuleHandleA("Crypt32.dll");
636
637 pCertNameToStrA = (CertNameToStrAFunc)GetProcAddress(dll,"CertNameToStrA");
638 pCertNameToStrW = (CertNameToStrWFunc)GetProcAddress(dll,"CertNameToStrW");
639 pCertRDNValueToStrA = (CertRDNValueToStrAFunc)GetProcAddress(dll,
640 "CertRDNValueToStrA");
641 pCertRDNValueToStrW = (CertRDNValueToStrWFunc)GetProcAddress(dll,
642 "CertRDNValueToStrW");
643 pCryptDecodeObject = (CryptDecodeObjectFunc)GetProcAddress(dll,
644 "CryptDecodeObject");
645 pCertStrToNameA = (CertStrToNameAFunc)GetProcAddress(dll,"CertStrToNameA");
646 pCertStrToNameW = (CertStrToNameWFunc)GetProcAddress(dll,"CertStrToNameW");
647
648 test_CertRDNValueToStrA();
649 test_CertRDNValueToStrW();
650 test_CertNameToStrA();
651 test_CertNameToStrW();
652 test_CertStrToNameA();
653 test_CertStrToNameW();
654}
Note: See TracBrowser for help on using the repository browser.