ReactOS  0.4.15-dev-1039-gb9754fa
str.c
Go to the documentation of this file.
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 typedef struct _CertRDNAttrEncoding {
30  LPCSTR pszObjId;
31  DWORD dwValueType;
32  CERT_RDN_VALUE_BLOB Value;
33  LPCSTR str;
34  BOOL todo;
35 } CertRDNAttrEncoding, *PCertRDNAttrEncoding;
36 
37 typedef struct _CertRDNAttrEncodingW {
38  LPCSTR pszObjId;
39  DWORD dwValueType;
40  CERT_RDN_VALUE_BLOB Value;
41  LPCWSTR str;
42  BOOL todo;
43 } CertRDNAttrEncodingW, *PCertRDNAttrEncodingW;
44 
45 static BYTE bin1[] = { 0x55, 0x53 };
46 static BYTE bin2[] = { 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x73, 0x6f, 0x74,
47  0x61 };
48 static BYTE bin3[] = { 0x4d, 0x69, 0x6e, 0x6e, 0x65, 0x61, 0x70, 0x6f,
49  0x6c, 0x69, 0x73 };
50 static BYTE bin4[] = { 0x43, 0x6f, 0x64, 0x65, 0x57, 0x65, 0x61, 0x76,
51  0x65, 0x72, 0x73 };
52 static BYTE bin5[] = { 0x57, 0x69, 0x6e, 0x65, 0x20, 0x44, 0x65, 0x76,
53  0x65, 0x6c, 0x6f, 0x70, 0x6d, 0x65, 0x6e, 0x74 };
54 static BYTE bin6[] = { 0x6c, 0x6f, 0x63, 0x61, 0x6c, 0x68, 0x6f, 0x73,
55  0x74 };
56 static BYTE bin7[] = { 0x61, 0x72, 0x69, 0x63, 0x40, 0x63, 0x6f, 0x64,
57  0x65, 0x77, 0x65, 0x61, 0x76, 0x65, 0x72, 0x73, 0x2e, 0x63, 0x6f, 0x6d };
58 static BYTE bin8[] = {
59 0x65,0x00,0x50,0x00,0x4b,0x00,0x49,0x00,0x20,0x00,0x52,0x00,0x6f,0x00,0x6f,
60 0x00,0x74,0x00,0x20,0x00,0x43,0x00,0x65,0x00,0x72,0x00,0x74,0x00,0x69,0x00,
61 0x66,0x00,0x69,0x00,0x63,0x00,0x61,0x00,0x74,0x00,0x69,0x00,0x6f,0x00,0x6e,
62 0x00,0x20,0x00,0x41,0x00,0x75,0x00,0x74,0x00,0x68,0x00,0x6f,0x00,0x72,0x00,
63 0x69,0x00,0x74,0x00,0x79,0x00 };
64 static BYTE bin9[] = { 0x61, 0x62, 0x63, 0x22, 0x64, 0x65, 0x66 };
65 static BYTE bin10[] = { 0x61, 0x62, 0x63, 0x27, 0x64, 0x65, 0x66 };
66 static BYTE bin11[] = { 0x61, 0x62, 0x63, 0x2c, 0x20, 0x64, 0x65, 0x66 };
67 static BYTE bin12[] = { 0x20, 0x61, 0x62, 0x63, 0x20 };
68 static BYTE bin13[] = { 0x22, 0x64, 0x65, 0x66, 0x22 };
69 static BYTE bin14[] = { 0x31, 0x3b, 0x33 };
70 
71 static const BYTE cert[] =
72 {0x30,0x82,0x2,0xbb,0x30,0x82,0x2,0x24,0x2,0x9,0x0,0xe3,0x5a,0x10,0xf1,0xfc,
73  0x4b,0xf3,0xa2,0x30,0xd,0x6,0x9,0x2a,0x86,0x48,0x86,0xf7,0xd,0x1,0x1,0x4,0x5,
74  0x0,0x30,0x81,0xa1,0x31,0xb,0x30,0x9,0x6,0x3,0x55,0x4,0x6,0x13,0x2,0x55,0x53,
75  0x31,0x12,0x30,0x10,0x6,0x3,0x55,0x4,0x8,0x13,0x9,0x4d,0x69,0x6e,0x6e,0x65,
76  0x73,0x6f,0x74,0x61,0x31,0x14,0x30,0x12,0x6,0x3,0x55,0x4,0x7,0x13,0xb,0x4d,
77  0x69,0x6e,0x6e,0x65,0x61,0x70,0x6f,0x6c,0x69,0x73,0x31,0x14,0x30,0x12,0x6,0x3,
78  0x55,0x4,0xa,0x13,0xb,0x43,0x6f,0x64,0x65,0x57,0x65,0x61,0x76,0x65,0x72,0x73,
79  0x31,0x19,0x30,0x17,0x6,0x3,0x55,0x4,0xb,0x13,0x10,0x57,0x69,0x6e,0x65,0x20,
80  0x44,0x65,0x76,0x65,0x6c,0x6f,0x70,0x6d,0x65,0x6e,0x74,0x31,0x12,0x30,0x10,
81  0x6,0x3,0x55,0x4,0x3,0x13,0x9,0x6c,0x6f,0x63,0x61,0x6c,0x68,0x6f,0x73,0x74,
82  0x31,0x23,0x30,0x21,0x6,0x9,0x2a,0x86,0x48,0x86,0xf7,0xd,0x1,0x9,0x1,0x16,
83  0x14,0x61,0x72,0x69,0x63,0x40,0x63,0x6f,0x64,0x65,0x77,0x65,0x61,0x76,0x65,
84  0x72,0x73,0x2e,0x63,0x6f,0x6d,0x30,0x1e,0x17,0xd,0x30,0x36,0x30,0x31,0x32,
85  0x35,0x31,0x33,0x35,0x37,0x32,0x34,0x5a,0x17,0xd,0x30,0x36,0x30,0x32,0x32,
86  0x34,0x31,0x33,0x35,0x37,0x32,0x34,0x5a,0x30,0x81,0xa1,0x31,0xb,0x30,0x9,0x6,
87  0x3,0x55,0x4,0x6,0x13,0x2,0x55,0x53,0x31,0x12,0x30,0x10,0x6,0x3,0x55,0x4,0x8,
88  0x13,0x9,0x4d,0x69,0x6e,0x6e,0x65,0x73,0x6f,0x74,0x61,0x31,0x14,0x30,0x12,0x6,
89  0x3,0x55,0x4,0x7,0x13,0xb,0x4d,0x69,0x6e,0x6e,0x65,0x61,0x70,0x6f,0x6c,0x69,
90  0x73,0x31,0x14,0x30,0x12,0x6,0x3,0x55,0x4,0xa,0x13,0xb,0x43,0x6f,0x64,0x65,
91  0x57,0x65,0x61,0x76,0x65,0x72,0x73,0x31,0x19,0x30,0x17,0x6,0x3,0x55,0x4,0xb,
92  0x13,0x10,0x57,0x69,0x6e,0x65,0x20,0x44,0x65,0x76,0x65,0x6c,0x6f,0x70,0x6d,
93  0x65,0x6e,0x74,0x31,0x12,0x30,0x10,0x6,0x3,0x55,0x4,0x3,0x13,0x9,0x6c,0x6f,
94  0x63,0x61,0x6c,0x68,0x6f,0x73,0x74,0x31,0x23,0x30,0x21,0x6,0x9,0x2a,0x86,0x48,
95  0x86,0xf7,0xd,0x1,0x9,0x1,0x16,0x14,0x61,0x72,0x69,0x63,0x40,0x63,0x6f,0x64,
96  0x65,0x77,0x65,0x61,0x76,0x65,0x72,0x73,0x2e,0x63,0x6f,0x6d,0x30,0x81,0x9f,
97  0x30,0xd,0x6,0x9,0x2a,0x86,0x48,0x86,0xf7,0xd,0x1,0x1,0x1,0x5,0x0,0x3,0x81,
98  0x8d,0x0,0x30,0x81,0x89,0x2,0x81,0x81,0x0,0x9b,0xb5,0x8f,0xaf,0xfb,0x9a,0xaf,
99  0xdc,0xa2,0x4d,0xb1,0xc8,0x72,0x44,0xef,0x79,0x7f,0x28,0xb6,0xfe,0x50,0xdc,
100  0x8a,0xf7,0x11,0x2f,0x90,0x70,0xed,0xa4,0xa9,0xd,0xbf,0x82,0x3e,0x56,0xd8,
101  0x36,0xb6,0x9,0x52,0x83,0xab,0x65,0x95,0x0,0xe2,0xea,0x3c,0x4f,0x85,0xb8,0xc,
102  0x41,0x42,0x77,0x5c,0x9d,0x44,0xeb,0xcf,0x7d,0x60,0x64,0x7a,0x6c,0x4c,0xac,
103  0x4a,0x9a,0x23,0x25,0x15,0xd7,0x92,0xb4,0x10,0xe7,0x95,0xad,0x4b,0x93,0xda,
104  0x6a,0x76,0xe0,0xa5,0xd2,0x13,0x8,0x12,0x30,0x68,0xde,0xb9,0x5b,0x6e,0x2a,
105  0x97,0x43,0xaa,0x7b,0x22,0x33,0x34,0xb1,0xca,0x5d,0x19,0xd8,0x42,0x26,0x45,
106  0xc6,0xe9,0x1d,0xee,0x7,0xc2,0x27,0x95,0x87,0xd8,0x12,0xec,0x4b,0x16,0x9f,0x2,
107  0x3,0x1,0x0,0x1,0x30,0xd,0x6,0x9,0x2a,0x86,0x48,0x86,0xf7,0xd,0x1,0x1,0x4,0x5,
108  0x0,0x3,0x81,0x81,0x0,0x96,0xf9,0xf6,0x6a,0x3d,0xd9,0xca,0x6e,0xd5,0x76,0x73,
109  0xab,0x75,0xc1,0xcc,0x98,0x44,0xc3,0xa9,0x90,0x68,0x88,0x76,0xb9,0xeb,0xb6,
110  0xbe,0x60,0x62,0xb9,0x67,0x1e,0xcc,0xf4,0xe1,0xe7,0x6c,0xc8,0x67,0x3f,0x1d,
111  0xf3,0x68,0x86,0x30,0xee,0xaa,0x92,0x61,0x37,0xd7,0x82,0x90,0x28,0xaa,0x7a,
112  0x18,0x88,0x60,0x14,0x88,0x75,0xc0,0x4a,0x4e,0x7d,0x48,0xe7,0x3,0xa6,0xfd,
113  0xd7,0xce,0x3c,0xe5,0x9b,0xaf,0x2f,0xdc,0xbb,0x7c,0xbd,0x20,0x49,0xd9,0x68,
114  0x37,0xeb,0x5d,0xbb,0xe2,0x6d,0x66,0xe3,0x11,0xc1,0xa7,0x88,0x49,0xc6,0x6f,
115  0x65,0xd3,0xce,0xae,0x26,0x19,0x3,0x2e,0x4f,0x78,0xa5,0xa,0x97,0x7e,0x4f,0xc4,
116  0x91,0x8a,0xf8,0x5,0xef,0x5b,0x3b,0x49,0xbf,0x5f,0x2b};
117 
118 static char issuerStr[] =
119  "US, Minnesota, Minneapolis, CodeWeavers, Wine Development, localhost, aric@codeweavers.com";
120 static char issuerStrSemicolon[] =
121  "US; Minnesota; Minneapolis; CodeWeavers; Wine Development; localhost; aric@codeweavers.com";
122 static char issuerStrCRLF[] =
123  "US\r\nMinnesota\r\nMinneapolis\r\nCodeWeavers\r\nWine Development\r\nlocalhost\r\naric@codeweavers.com";
124 static char subjectStr[] =
125  "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";
126 static char subjectStrSemicolon[] =
127  "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";
128 static char subjectStrCRLF[] =
129  "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";
130 static char x500SubjectStr[] = "C=US, S=Minnesota, L=Minneapolis, O=CodeWeavers, OU=Wine Development, CN=localhost, E=aric@codeweavers.com";
131 static char x500SubjectStrSemicolonReverse[] = "E=aric@codeweavers.com; CN=localhost; OU=Wine Development; O=CodeWeavers; L=Minneapolis; S=Minnesota; C=US";
132 static WCHAR issuerStrW[] = {
133  'U','S',',',' ','M','i','n','n','e','s','o','t','a',',',' ','M','i','n','n',
134  'e','a','p','o','l','i','s',',',' ','C','o','d','e','W','e','a','v','e','r',
135  's',',',' ','W','i','n','e',' ','D','e','v','e','l','o','p','m','e','n','t',
136  ',',' ','l','o','c','a','l','h','o','s','t',',',' ','a','r','i','c','@','c',
137  'o','d','e','w','e','a','v','e','r','s','.','c','o','m',0 };
138 static WCHAR issuerStrSemicolonW[] = {
139  'U','S',';',' ','M','i','n','n','e','s','o','t','a',';',' ','M','i','n','n',
140  'e','a','p','o','l','i','s',';',' ','C','o','d','e','W','e','a','v','e','r',
141  's',';',' ','W','i','n','e',' ','D','e','v','e','l','o','p','m','e','n','t',
142  ';',' ','l','o','c','a','l','h','o','s','t',';',' ','a','r','i','c','@','c',
143  'o','d','e','w','e','a','v','e','r','s','.','c','o','m',0 };
144 static WCHAR issuerStrCRLFW[] = {
145  'U','S','\r','\n','M','i','n','n','e','s','o','t','a','\r','\n','M','i','n',
146  'n','e','a','p','o','l','i','s','\r','\n','C','o','d','e','W','e','a','v','e',
147  'r','s','\r','\n','W','i','n','e',' ','D','e','v','e','l','o','p','m','e','n',
148  't','\r','\n','l','o','c','a','l','h','o','s','t','\r','\n','a','r','i','c',
149  '@','c','o','d','e','w','e','a','v','e','r','s','.','c','o','m',0 };
150 static WCHAR subjectStrW[] = {
151  '2','.','5','.','4','.','6','=','U','S',',',' ','2','.','5','.','4','.','8',
152  '=','M','i','n','n','e','s','o','t','a',',',' ','2','.','5','.','4','.','7',
153  '=','M','i','n','n','e','a','p','o','l','i','s',',',' ','2','.','5','.','4',
154  '.','1','0','=','C','o','d','e','W','e','a','v','e','r','s',',',' ','2','.',
155  '5','.','4','.','1','1','=','W','i','n','e',' ','D','e','v','e','l','o','p',
156  'm','e','n','t',',',' ','2','.','5','.','4','.','3','=','l','o','c','a','l',
157  'h','o','s','t',',',' ','1','.','2','.','8','4','0','.','1','1','3','5','4',
158  '9','.','1','.','9','.','1','=','a','r','i','c','@','c','o','d','e','w','e',
159  'a','v','e','r','s','.','c','o','m',0 };
160 static WCHAR subjectStrSemicolonW[] = {
161  '2','.','5','.','4','.','6','=','U','S',';',' ','2','.','5','.','4','.','8',
162  '=','M','i','n','n','e','s','o','t','a',';',' ','2','.','5','.','4','.','7',
163  '=','M','i','n','n','e','a','p','o','l','i','s',';',' ','2','.','5','.','4',
164  '.','1','0','=','C','o','d','e','W','e','a','v','e','r','s',';',' ','2','.',
165  '5','.','4','.','1','1','=','W','i','n','e',' ','D','e','v','e','l','o','p',
166  'm','e','n','t',';',' ','2','.','5','.','4','.','3','=','l','o','c','a','l',
167  'h','o','s','t',';',' ','1','.','2','.','8','4','0','.','1','1','3','5','4',
168  '9','.','1','.','9','.','1','=','a','r','i','c','@','c','o','d','e','w','e',
169  'a','v','e','r','s','.','c','o','m',0 };
170 static WCHAR subjectStrCRLFW[] = {
171  '2','.','5','.','4','.','6','=','U','S','\r','\n','2','.','5','.','4','.','8',
172  '=','M','i','n','n','e','s','o','t','a','\r','\n','2','.','5','.','4','.','7',
173  '=','M','i','n','n','e','a','p','o','l','i','s','\r','\n','2','.','5','.','4',
174  '.','1','0','=','C','o','d','e','W','e','a','v','e','r','s','\r','\n','2','.',
175  '5','.','4','.','1','1','=','W','i','n','e',' ','D','e','v','e','l','o','p',
176  'm','e','n','t','\r','\n','2','.','5','.','4','.','3','=','l','o','c','a','l',
177  'h','o','s','t','\r','\n','1','.','2','.','8','4','0','.','1','1','3','5','4',
178  '9','.','1','.','9','.','1','=','a','r','i','c','@','c','o','d','e','w','e',
179  'a','v','e','r','s','.','c','o','m',0 };
180 static WCHAR x500SubjectStrSemicolonReverseW[] = {
181  'E','=','a','r','i','c','@','c','o','d','e','w','e','a','v','e','r','s','.','c',
182  'o','m',';',' ','C','N','=','l','o','c','a','l','h','o','s','t',';',' ','O','U',
183  '=','W','i','n','e',' ','D','e','v','e','l','o','p','m','e','n','t',';',' ','O',
184  '=','C','o','d','e','W','e','a','v','e','r','s',';',' ','L','=','M','i','n','n',
185  'e','a','p','o','l','i','s',';',' ','S','=','M','i','n','n','e','s','o','t','a',
186  ';',' ','C','=','U','S',0 };
187 
188 static HMODULE dll;
189 static DWORD (WINAPI *pCertNameToStrA)(DWORD,LPVOID,DWORD,LPSTR,DWORD);
190 static DWORD (WINAPI *pCertNameToStrW)(DWORD,LPVOID,DWORD,LPWSTR,DWORD);
191 static DWORD (WINAPI *pCertRDNValueToStrA)(DWORD, PCERT_RDN_VALUE_BLOB,
192  LPSTR, DWORD);
193 static DWORD (WINAPI *pCertRDNValueToStrW)(DWORD, PCERT_RDN_VALUE_BLOB,
194  LPWSTR, DWORD);
195 static BOOL (WINAPI *pCertStrToNameA)(DWORD dwCertEncodingType,
196  LPCSTR pszX500, DWORD dwStrType, void *pvReserved, BYTE *pbEncoded,
197  DWORD *pcbEncoded, LPCSTR *ppszError);
198 static BOOL (WINAPI *pCertStrToNameW)(DWORD dwCertEncodingType,
199  LPCWSTR pszX500, DWORD dwStrType, void *pvReserved, BYTE *pbEncoded,
200  DWORD *pcbEncoded, LPCWSTR *ppszError);
201 static DWORD (WINAPI *pCertGetNameStringA)(PCCERT_CONTEXT cert, DWORD type,
202  DWORD flags, void *typePara, LPSTR str, DWORD cch);
203 
204 
205 static void test_CertRDNValueToStrA(void)
206 {
207  CertRDNAttrEncoding attrs[] = {
208  { "2.5.4.6", CERT_RDN_PRINTABLE_STRING,
209  { sizeof(bin1), bin1 }, "US", FALSE },
210  { "2.5.4.8", CERT_RDN_PRINTABLE_STRING,
211  { sizeof(bin2), bin2 }, "Minnesota", FALSE },
212  { "2.5.4.7", CERT_RDN_PRINTABLE_STRING,
213  { sizeof(bin3), bin3 }, "Minneapolis", FALSE },
214  { "2.5.4.10", CERT_RDN_PRINTABLE_STRING,
215  { sizeof(bin4), bin4 }, "CodeWeavers", FALSE },
216  { "2.5.4.11", CERT_RDN_PRINTABLE_STRING,
217  { sizeof(bin5), bin5 }, "Wine Development", FALSE },
218  { "2.5.4.3", CERT_RDN_PRINTABLE_STRING,
219  { sizeof(bin6), bin6 }, "localhost", FALSE },
220  { "1.2.840.113549.1.9.1", CERT_RDN_IA5_STRING,
221  { sizeof(bin7), bin7 }, "aric@codeweavers.com", FALSE },
222  { "0", CERT_RDN_PRINTABLE_STRING,
223  { sizeof(bin9), bin9 }, "abc\"def", FALSE },
224  { "0", CERT_RDN_PRINTABLE_STRING,
225  { sizeof(bin10), bin10 }, "abc'def", FALSE },
226  { "0", CERT_RDN_PRINTABLE_STRING,
227  { sizeof(bin11), bin11 }, "abc, def", FALSE },
228  { "0", CERT_RDN_PRINTABLE_STRING,
229  { sizeof(bin12), bin12 }, " abc ", FALSE },
230  { "0", CERT_RDN_PRINTABLE_STRING,
231  { sizeof(bin13), bin13 }, "\"def\"", FALSE },
232  { "0", CERT_RDN_PRINTABLE_STRING,
233  { sizeof(bin14), bin14 }, "1;3", FALSE },
234  };
235  DWORD i, ret;
236  char buffer[2000];
237  CERT_RDN_VALUE_BLOB blob = { 0, NULL };
238  static const char ePKI[] = "ePKI Root Certification Authority";
239 
240  if (!pCertRDNValueToStrA) return;
241 
242  /* This crashes
243  ret = pCertRDNValueToStrA(0, NULL, NULL, 0);
244  */
245  /* With empty input, it generates the empty string */
246  SetLastError(0xdeadbeef);
247  ret = pCertRDNValueToStrA(0, &blob, NULL, 0);
248  ok(ret == 1 && GetLastError() == 0xdeadbeef, "Expected empty string\n");
249  ret = pCertRDNValueToStrA(0, &blob, buffer, sizeof(buffer));
250  ok(ret == 1 && GetLastError() == 0xdeadbeef, "Expected empty string\n");
251  ok(!buffer[0], "Expected empty string\n");
252 
253  for (i = 0; i < ARRAY_SIZE(attrs); i++)
254  {
255  ret = pCertRDNValueToStrA(attrs[i].dwValueType, &attrs[i].Value,
256  buffer, sizeof(buffer));
257  todo_wine_if (attrs[i].todo)
258  {
259  ok(ret == strlen(attrs[i].str) + 1, "Expected length %d, got %d\n",
260  lstrlenA(attrs[i].str) + 1, ret);
261  ok(!strcmp(buffer, attrs[i].str), "Expected %s, got %s\n",
262  attrs[i].str, buffer);
263  }
264  }
265  blob.pbData = bin8;
266  blob.cbData = sizeof(bin8);
267  ret = pCertRDNValueToStrA(CERT_RDN_UTF8_STRING, &blob, buffer,
268  sizeof(buffer));
269  ok(ret == strlen(ePKI) + 1 || broken(ret != strlen(ePKI) + 1),
270  "Expected length %d, got %d\n", lstrlenA(ePKI), ret);
271  if (ret == strlen(ePKI) + 1)
272  ok(!strcmp(buffer, ePKI), "Expected %s, got %s\n", ePKI, buffer);
273 }
274 
275 static void test_CertRDNValueToStrW(void)
276 {
277  static const WCHAR usW[] = { 'U','S',0 };
278  static const WCHAR minnesotaW[] = { 'M','i','n','n','e','s','o','t','a',0 };
279  static const WCHAR minneapolisW[] = { 'M','i','n','n','e','a','p','o','l',
280  'i','s',0 };
281  static const WCHAR codeweaversW[] = { 'C','o','d','e','W','e','a','v','e',
282  'r','s',0 };
283  static const WCHAR wineDevW[] = { 'W','i','n','e',' ','D','e','v','e','l',
284  'o','p','m','e','n','t',0 };
285  static const WCHAR localhostW[] = { 'l','o','c','a','l','h','o','s','t',0 };
286  static const WCHAR aricW[] = { 'a','r','i','c','@','c','o','d','e','w','e',
287  'a','v','e','r','s','.','c','o','m',0 };
288  static const WCHAR ePKIW[] = { 'e','P','K','I',' ','R','o','o','t',' ',
289  'C','e','r','t','i','f','i','c','a','t','i','o','n',' ','A','u','t','h',
290  'o','r','i','t','y',0 };
291  static const WCHAR embeddedDoubleQuoteW[] = { 'a','b','c','"','d','e','f',
292  0 };
293  static const WCHAR embeddedSingleQuoteW[] = { 'a','b','c','\'','d','e','f',
294  0 };
295  static const WCHAR embeddedCommaW[] = { 'a','b','c',',',' ','d','e','f',0 };
296  static const WCHAR trailingAndEndingSpaceW[] = { ' ','a','b','c',' ',0 };
297  static const WCHAR enclosingQuotesW[] = { '"','d','e','f','"',0 };
298  static const WCHAR embeddedSemiW[] = { '1',';','3',0 };
299  CertRDNAttrEncodingW attrs[] = {
300  { "2.5.4.6", CERT_RDN_PRINTABLE_STRING,
301  { sizeof(bin1), bin1 }, usW, FALSE },
302  { "2.5.4.8", CERT_RDN_PRINTABLE_STRING,
303  { sizeof(bin2), bin2 }, minnesotaW, FALSE },
304  { "2.5.4.7", CERT_RDN_PRINTABLE_STRING,
305  { sizeof(bin3), bin3 }, minneapolisW, FALSE },
306  { "2.5.4.10", CERT_RDN_PRINTABLE_STRING,
307  { sizeof(bin4), bin4 }, codeweaversW, FALSE },
308  { "2.5.4.11", CERT_RDN_PRINTABLE_STRING,
309  { sizeof(bin5), bin5 }, wineDevW, FALSE },
310  { "2.5.4.3", CERT_RDN_PRINTABLE_STRING,
311  { sizeof(bin6), bin6 }, localhostW, FALSE },
312  { "1.2.840.113549.1.9.1", CERT_RDN_IA5_STRING,
313  { sizeof(bin7), bin7 }, aricW, FALSE },
314  { "0", CERT_RDN_PRINTABLE_STRING,
315  { sizeof(bin9), bin9 }, embeddedDoubleQuoteW, FALSE },
316  { "0", CERT_RDN_PRINTABLE_STRING,
317  { sizeof(bin10), bin10 }, embeddedSingleQuoteW, FALSE },
318  { "0", CERT_RDN_PRINTABLE_STRING,
319  { sizeof(bin11), bin11 }, embeddedCommaW, FALSE },
320  { "0", CERT_RDN_PRINTABLE_STRING,
321  { sizeof(bin12), bin12 }, trailingAndEndingSpaceW, FALSE },
322  { "0", CERT_RDN_PRINTABLE_STRING,
323  { sizeof(bin13), bin13 }, enclosingQuotesW, FALSE },
324  { "0", CERT_RDN_PRINTABLE_STRING,
325  { sizeof(bin14), bin14 }, embeddedSemiW, FALSE },
326  };
327  DWORD i, ret;
328  WCHAR buffer[2000];
329  CERT_RDN_VALUE_BLOB blob = { 0, NULL };
330 
331  if (!pCertRDNValueToStrW)
332  {
333  win_skip("CertRDNValueToStrW is not available\n");
334  return;
335  }
336 
337  /* This crashes
338  ret = pCertRDNValueToStrW(0, NULL, NULL, 0);
339  */
340  /* With empty input, it generates the empty string */
341  SetLastError(0xdeadbeef);
342  ret = pCertRDNValueToStrW(0, &blob, NULL, 0);
343  ok(ret == 1 && GetLastError() == 0xdeadbeef, "Expected empty string\n");
344  ret = pCertRDNValueToStrW(0, &blob, buffer, ARRAY_SIZE(buffer));
345  ok(ret == 1 && GetLastError() == 0xdeadbeef, "Expected empty string\n");
346  ok(!buffer[0], "Expected empty string\n");
347 
348  for (i = 0; i < ARRAY_SIZE(attrs); i++)
349  {
350  ret = pCertRDNValueToStrW(attrs[i].dwValueType, &attrs[i].Value, buffer, ARRAY_SIZE(buffer));
351  todo_wine_if (attrs[i].todo)
352  {
353  ok(ret == lstrlenW(attrs[i].str) + 1,
354  "Expected length %d, got %d\n", lstrlenW(attrs[i].str) + 1, ret);
355  ok(!lstrcmpW(buffer, attrs[i].str), "Expected %s, got %s\n",
356  wine_dbgstr_w(attrs[i].str), wine_dbgstr_w(buffer));
357  }
358  }
359  blob.pbData = bin8;
360  blob.cbData = sizeof(bin8);
361  ret = pCertRDNValueToStrW(CERT_RDN_UTF8_STRING, &blob, buffer,
362  sizeof(buffer));
363  ok(ret == lstrlenW(ePKIW) + 1 || broken(ret != lstrlenW(ePKIW) + 1),
364  "Expected length %d, got %d\n", lstrlenW(ePKIW), ret);
365  if (ret == lstrlenW(ePKIW) + 1)
366  ok(!lstrcmpW(buffer, ePKIW), "Expected %s, got %s\n",
367  wine_dbgstr_w(ePKIW), wine_dbgstr_w(buffer));
368 }
369 
370 static void test_NameToStrConversionA(PCERT_NAME_BLOB pName, DWORD dwStrType,
371  LPCSTR expected, BOOL todo)
372 {
373  char buffer[2000] = { 0 };
374  DWORD i;
375 
376  i = pCertNameToStrA(X509_ASN_ENCODING, pName, dwStrType, NULL, 0);
377  todo_wine_if (todo)
378  ok(i == strlen(expected) + 1, "Expected %d chars, got %d\n",
379  lstrlenA(expected) + 1, i);
380  i = pCertNameToStrA(X509_ASN_ENCODING,pName, dwStrType, buffer,
381  sizeof(buffer));
382  todo_wine_if (todo)
383  ok(i == strlen(expected) + 1, "Expected %d chars, got %d\n",
384  lstrlenA(expected) + 1, i);
385  todo_wine_if (todo)
386  ok(!strcmp(buffer, expected), "Expected %s, got %s\n", expected,
387  buffer);
388 }
389 
390 static BYTE encodedSimpleCN[] = {
391 0x30,0x0c,0x31,0x0a,0x30,0x08,0x06,0x03,0x55,0x04,0x03,0x13,0x01,0x31 };
392 static BYTE encodedSingleQuotedCN[] = { 0x30,0x0e,0x31,0x0c,0x30,0x0a,
393  0x06,0x03,0x55,0x04,0x03,0x13,0x03,0x27,0x31,0x27 };
394 static BYTE encodedSpacedCN[] = { 0x30,0x0e,0x31,0x0c,0x30,0x0a,0x06,0x03,
395  0x55,0x04,0x03,0x13,0x03,0x20,0x31,0x20 };
396 static BYTE encodedQuotedCN[] = { 0x30,0x11,0x31,0x0f,0x30,0x0d,0x06,0x03,
397  0x55, 0x04,0x03,0x1e,0x06,0x00,0x22,0x00,0x31,0x00,0x22, };
398 static BYTE encodedMultipleAttrCN[] = { 0x30,0x0e,0x31,0x0c,0x30,0x0a,
399  0x06,0x03,0x55,0x04,0x03,0x13,0x03,0x31,0x2b,0x32 };
400 static BYTE encodedCommaCN[] = {
401 0x30,0x0e,0x31,0x0c,0x30,0x0a,0x06,0x03,0x55,0x04,0x03,0x13,0x03,0x61,0x2c,
402 0x62 };
403 static BYTE encodedEqualCN[] = {
404 0x30,0x0e,0x31,0x0c,0x30,0x0a,0x06,0x03,0x55,0x04,0x03,0x13,0x03,0x61,0x3d,
405 0x62 };
406 static BYTE encodedLessThanCN[] = {
407 0x30,0x0d,0x31,0x0b,0x30,0x09,0x06,0x03,0x55,0x04,0x03,0x1e,0x02,0x00,0x3c
408 };
409 static BYTE encodedGreaterThanCN[] = {
410 0x30,0x0d,0x31,0x0b,0x30,0x09,0x06,0x03,0x55,0x04,0x03,0x1e,0x02,0x00,0x3e
411 };
412 static BYTE encodedHashCN[] = {
413 0x30,0x0d,0x31,0x0b,0x30,0x09,0x06,0x03,0x55,0x04,0x03,0x1e,0x02,0x00,0x23
414 };
415 static BYTE encodedSemiCN[] = {
416 0x30,0x0d,0x31,0x0b,0x30,0x09,0x06,0x03,0x55,0x04,0x03,0x1e,0x02,0x00,0x3b
417 };
418 static BYTE encodedNewlineCN[] = {
419 0x30,0x11,0x31,0x0f,0x30,0x0d,0x06,0x03,0x55,0x04,0x03,0x1e,0x06,0x00,0x61,
420 0x00,0x0a,0x00,0x62 };
421 static BYTE encodedDummyCN[] = {
422 0x30,0x1F,0x31,0x0E,0x30,0x0C,0x06,0x03,0x55,0x04,0x03,0x13,0x05,0x64,0x75,
423 0x6D,0x6D,0x79,0x31,0x0D,0x30,0x0B,0x06,0x03,0x55,0x04,0x0C,0x13,0x04,0x74,
424 0x65,0x73,0x74 };
425 static BYTE encodedFields[] = {
426 0x30,0x2F,0x31,0x12,0x30,0x10,0x06,0x03,0x55,0x04,0x03,0x13,0x09,0x57,0x69,
427 0x6E,0x65,0x20,0x54,0x65,0x73,0x74,0x31,0x0C,0x30,0x0A,0x06,0x03,0x55,0x04,
428 0x0C,0x13,0x03,0x31,0x32,0x33,0x31,0x0B,0x30,0x09,0x06,0x03,0x55,0x04,0x06,
429 0x13,0x02,0x42,0x52 };
430 
431 static void test_CertNameToStrA(void)
432 {
433  PCCERT_CONTEXT context;
434  CERT_NAME_BLOB blob;
435 
436  if (!pCertNameToStrA)
437  {
438  win_skip("CertNameToStrA is not available\n");
439  return;
440  }
441 
442  context = CertCreateCertificateContext(X509_ASN_ENCODING, cert,
443  sizeof(cert));
444  ok(context != NULL, "CertCreateCertificateContext failed: %08x\n",
445  GetLastError());
446  if (context)
447  {
448  DWORD ret;
449 
450  /* This crashes
451  ret = pCertNameToStrA(0, NULL, 0, NULL, 0);
452  */
453  /* Test with a bogus encoding type */
454  SetLastError(0xdeadbeef);
455  ret = pCertNameToStrA(0, &context->pCertInfo->Issuer, 0, NULL, 0);
456  ok(ret == 1 && GetLastError() == ERROR_FILE_NOT_FOUND,
457  "Expected retval 1 and ERROR_FILE_NOT_FOUND, got %d - %08x\n",
458  ret, GetLastError());
459  SetLastError(0xdeadbeef);
460  ret = pCertNameToStrA(X509_ASN_ENCODING, &context->pCertInfo->Issuer,
461  0, NULL, 0);
462  ok(ret && GetLastError() == ERROR_SUCCESS,
463  "Expected positive return and ERROR_SUCCESS, got %d - %08x\n",
464  ret, GetLastError());
465 
466  test_NameToStrConversionA(&context->pCertInfo->Issuer,
467  CERT_SIMPLE_NAME_STR, issuerStr, FALSE);
468  test_NameToStrConversionA(&context->pCertInfo->Issuer,
469  CERT_SIMPLE_NAME_STR | CERT_NAME_STR_SEMICOLON_FLAG,
470  issuerStrSemicolon, FALSE);
471  test_NameToStrConversionA(&context->pCertInfo->Issuer,
472  CERT_SIMPLE_NAME_STR | CERT_NAME_STR_CRLF_FLAG,
473  issuerStrCRLF, FALSE);
474  test_NameToStrConversionA(&context->pCertInfo->Subject,
475  CERT_OID_NAME_STR, subjectStr, FALSE);
476  test_NameToStrConversionA(&context->pCertInfo->Subject,
477  CERT_OID_NAME_STR | CERT_NAME_STR_SEMICOLON_FLAG,
478  subjectStrSemicolon, FALSE);
479  test_NameToStrConversionA(&context->pCertInfo->Subject,
480  CERT_OID_NAME_STR | CERT_NAME_STR_CRLF_FLAG,
481  subjectStrCRLF, FALSE);
482  test_NameToStrConversionA(&context->pCertInfo->Subject,
483  CERT_X500_NAME_STR, x500SubjectStr, FALSE);
484  test_NameToStrConversionA(&context->pCertInfo->Subject,
485  CERT_X500_NAME_STR | CERT_NAME_STR_SEMICOLON_FLAG | CERT_NAME_STR_REVERSE_FLAG,
486  x500SubjectStrSemicolonReverse, FALSE);
487 
488  CertFreeCertificateContext(context);
489  }
490  blob.pbData = encodedSimpleCN;
491  blob.cbData = sizeof(encodedSimpleCN);
492  test_NameToStrConversionA(&blob, CERT_X500_NAME_STR, "CN=1", FALSE);
493  blob.pbData = encodedSingleQuotedCN;
494  blob.cbData = sizeof(encodedSingleQuotedCN);
495  test_NameToStrConversionA(&blob, CERT_X500_NAME_STR, "CN='1'", FALSE);
496  test_NameToStrConversionA(&blob, CERT_SIMPLE_NAME_STR, "'1'", FALSE);
497  blob.pbData = encodedSpacedCN;
498  blob.cbData = sizeof(encodedSpacedCN);
499  test_NameToStrConversionA(&blob, CERT_X500_NAME_STR, "CN=\" 1 \"", FALSE);
500  test_NameToStrConversionA(&blob, CERT_SIMPLE_NAME_STR, "\" 1 \"", FALSE);
501  blob.pbData = encodedQuotedCN;
502  blob.cbData = sizeof(encodedQuotedCN);
503  test_NameToStrConversionA(&blob, CERT_X500_NAME_STR, "CN=\"\"\"1\"\"\"",
504  FALSE);
505  test_NameToStrConversionA(&blob, CERT_SIMPLE_NAME_STR, "\"\"\"1\"\"\"",
506  FALSE);
507  blob.pbData = encodedMultipleAttrCN;
508  blob.cbData = sizeof(encodedMultipleAttrCN);
509  test_NameToStrConversionA(&blob, CERT_X500_NAME_STR, "CN=\"1+2\"", FALSE);
510  test_NameToStrConversionA(&blob, CERT_SIMPLE_NAME_STR, "\"1+2\"", FALSE);
511  blob.pbData = encodedCommaCN;
512  blob.cbData = sizeof(encodedCommaCN);
513  test_NameToStrConversionA(&blob, CERT_X500_NAME_STR, "CN=\"a,b\"", FALSE);
514  test_NameToStrConversionA(&blob, CERT_SIMPLE_NAME_STR, "\"a,b\"", FALSE);
515  blob.pbData = encodedEqualCN;
516  blob.cbData = sizeof(encodedEqualCN);
517  test_NameToStrConversionA(&blob, CERT_X500_NAME_STR, "CN=\"a=b\"", FALSE);
518  test_NameToStrConversionA(&blob, CERT_SIMPLE_NAME_STR, "\"a=b\"", FALSE);
519  blob.pbData = encodedLessThanCN;
520  blob.cbData = sizeof(encodedLessThanCN);
521  test_NameToStrConversionA(&blob, CERT_X500_NAME_STR, "CN=\"<\"", FALSE);
522  test_NameToStrConversionA(&blob, CERT_SIMPLE_NAME_STR, "\"<\"", FALSE);
523  blob.pbData = encodedGreaterThanCN;
524  blob.cbData = sizeof(encodedGreaterThanCN);
525  test_NameToStrConversionA(&blob, CERT_X500_NAME_STR, "CN=\">\"", FALSE);
526  test_NameToStrConversionA(&blob, CERT_SIMPLE_NAME_STR, "\">\"", FALSE);
527  blob.pbData = encodedHashCN;
528  blob.cbData = sizeof(encodedHashCN);
529  test_NameToStrConversionA(&blob, CERT_X500_NAME_STR, "CN=\"#\"", FALSE);
530  test_NameToStrConversionA(&blob, CERT_SIMPLE_NAME_STR, "\"#\"", FALSE);
531  blob.pbData = encodedSemiCN;
532  blob.cbData = sizeof(encodedSemiCN);
533  test_NameToStrConversionA(&blob, CERT_X500_NAME_STR, "CN=\";\"", FALSE);
534  test_NameToStrConversionA(&blob, CERT_SIMPLE_NAME_STR, "\";\"", FALSE);
535  blob.pbData = encodedNewlineCN;
536  blob.cbData = sizeof(encodedNewlineCN);
537  test_NameToStrConversionA(&blob, CERT_X500_NAME_STR, "CN=\"a\nb\"", FALSE);
538  test_NameToStrConversionA(&blob, CERT_SIMPLE_NAME_STR, "\"a\nb\"", FALSE);
539 }
540 
541 static void test_NameToStrConversionW(PCERT_NAME_BLOB pName, DWORD dwStrType,
542  LPCWSTR expected, BOOL todo)
543 {
544  WCHAR buffer[2000] = { 0 };
545  DWORD i;
546 
547  i = pCertNameToStrW(X509_ASN_ENCODING,pName, dwStrType, NULL, 0);
548  todo_wine_if (todo)
549  ok(i == lstrlenW(expected) + 1, "Expected %d chars, got %d\n",
550  lstrlenW(expected) + 1, i);
551  i = pCertNameToStrW(X509_ASN_ENCODING,pName, dwStrType, buffer, ARRAY_SIZE(buffer));
552  todo_wine_if (todo)
553  ok(i == lstrlenW(expected) + 1, "Expected %d chars, got %d\n",
554  lstrlenW(expected) + 1, i);
555  todo_wine_if (todo)
556  ok(!lstrcmpW(buffer, expected), "Expected %s, got %s\n",
557  wine_dbgstr_w(expected), wine_dbgstr_w(buffer));
558 }
559 
560 static const WCHAR simpleCN_W[] = { 'C','N','=','1',0 };
561 static const WCHAR singledQuotedCN_W[] = { 'C','N','=','\'','1','\'',0 };
562 static const WCHAR simpleSingleQuotedCN_W[] = { '\'','1','\'',0 };
563 static const WCHAR spacedCN_W[] = { 'C','N','=','"',' ','1',' ','"',0 };
564 static const WCHAR simpleSpacedCN_W[] = { '"',' ','1',' ','"',0 };
565 static const WCHAR quotedCN_W[] = { 'C','N','=','"','"','"','1','"','"','"',0 };
566 static const WCHAR simpleQuotedCN_W[] = { '"','"','"','1','"','"','"',0 };
567 static const WCHAR multipleAttrCN_W[] = { 'C','N','=','"','1','+','2','"',0 };
568 static const WCHAR simpleMultipleAttrCN_W[] = { '"','1','+','2','"',0 };
569 static const WCHAR commaCN_W[] = { 'C','N','=','"','a',',','b','"',0 };
570 static const WCHAR simpleCommaCN_W[] = { '"','a',',','b','"',0 };
571 static const WCHAR equalCN_W[] = { 'C','N','=','"','a','=','b','"',0 };
572 static const WCHAR simpleEqualCN_W[] = { '"','a','=','b','"',0 };
573 static const WCHAR lessThanCN_W[] = { 'C','N','=','"','<','"',0 };
574 static const WCHAR simpleLessThanCN_W[] = { '"','<','"',0 };
575 static const WCHAR greaterThanCN_W[] = { 'C','N','=','"','>','"',0 };
576 static const WCHAR simpleGreaterThanCN_W[] = { '"','>','"',0 };
577 static const WCHAR hashCN_W[] = { 'C','N','=','"','#','"',0 };
578 static const WCHAR simpleHashCN_W[] = { '"','#','"',0 };
579 static const WCHAR semiCN_W[] = { 'C','N','=','"',';','"',0 };
580 static const WCHAR simpleSemiCN_W[] = { '"',';','"',0 };
581 static const WCHAR newlineCN_W[] = { 'C','N','=','"','a','\n','b','"',0 };
582 static const WCHAR simpleNewlineCN_W[] = { '"','a','\n','b','"',0 };
583 
584 static void test_CertNameToStrW(void)
585 {
586  PCCERT_CONTEXT context;
587  CERT_NAME_BLOB blob;
588 
589  if (!pCertNameToStrW)
590  {
591  win_skip("CertNameToStrW is not available\n");
592  return;
593  }
594 
595  context = CertCreateCertificateContext(X509_ASN_ENCODING, cert,
596  sizeof(cert));
597  ok(context != NULL, "CertCreateCertificateContext failed: %08x\n",
598  GetLastError());
599  if (context)
600  {
601  DWORD ret;
602 
603  /* This crashes
604  ret = pCertNameToStrW(0, NULL, 0, NULL, 0);
605  */
606  /* Test with a bogus encoding type */
607  SetLastError(0xdeadbeef);
608  ret = pCertNameToStrW(0, &context->pCertInfo->Issuer, 0, NULL, 0);
609  ok(ret == 1 && GetLastError() == ERROR_FILE_NOT_FOUND,
610  "Expected retval 1 and ERROR_FILE_NOT_FOUND, got %d - %08x\n",
611  ret, GetLastError());
612  SetLastError(0xdeadbeef);
613  ret = pCertNameToStrW(X509_ASN_ENCODING, &context->pCertInfo->Issuer,
614  0, NULL, 0);
615  ok(ret && GetLastError() == ERROR_SUCCESS,
616  "Expected positive return and ERROR_SUCCESS, got %d - %08x\n",
617  ret, GetLastError());
618 
619  test_NameToStrConversionW(&context->pCertInfo->Issuer,
620  CERT_SIMPLE_NAME_STR, issuerStrW, FALSE);
621  test_NameToStrConversionW(&context->pCertInfo->Issuer,
622  CERT_SIMPLE_NAME_STR | CERT_NAME_STR_SEMICOLON_FLAG,
623  issuerStrSemicolonW, FALSE);
624  test_NameToStrConversionW(&context->pCertInfo->Issuer,
625  CERT_SIMPLE_NAME_STR | CERT_NAME_STR_CRLF_FLAG,
626  issuerStrCRLFW, FALSE);
627  test_NameToStrConversionW(&context->pCertInfo->Subject,
628  CERT_OID_NAME_STR, subjectStrW, FALSE);
629  test_NameToStrConversionW(&context->pCertInfo->Subject,
630  CERT_OID_NAME_STR | CERT_NAME_STR_SEMICOLON_FLAG,
631  subjectStrSemicolonW, FALSE);
632  test_NameToStrConversionW(&context->pCertInfo->Subject,
633  CERT_OID_NAME_STR | CERT_NAME_STR_CRLF_FLAG,
634  subjectStrCRLFW, FALSE);
635  test_NameToStrConversionW(&context->pCertInfo->Subject,
636  CERT_X500_NAME_STR | CERT_NAME_STR_SEMICOLON_FLAG | CERT_NAME_STR_REVERSE_FLAG,
637  x500SubjectStrSemicolonReverseW, FALSE);
638 
639  CertFreeCertificateContext(context);
640  }
641  blob.pbData = encodedSimpleCN;
642  blob.cbData = sizeof(encodedSimpleCN);
643  test_NameToStrConversionW(&blob, CERT_X500_NAME_STR, simpleCN_W, FALSE);
644  blob.pbData = encodedSingleQuotedCN;
645  blob.cbData = sizeof(encodedSingleQuotedCN);
646  test_NameToStrConversionW(&blob, CERT_X500_NAME_STR, singledQuotedCN_W,
647  FALSE);
648  test_NameToStrConversionW(&blob, CERT_SIMPLE_NAME_STR,
649  simpleSingleQuotedCN_W, FALSE);
650  blob.pbData = encodedSpacedCN;
651  blob.cbData = sizeof(encodedSpacedCN);
652  test_NameToStrConversionW(&blob, CERT_X500_NAME_STR, spacedCN_W, FALSE);
653  test_NameToStrConversionW(&blob, CERT_SIMPLE_NAME_STR, simpleSpacedCN_W,
654  FALSE);
655  blob.pbData = encodedQuotedCN;
656  blob.cbData = sizeof(encodedQuotedCN);
657  test_NameToStrConversionW(&blob, CERT_X500_NAME_STR, quotedCN_W,
658  FALSE);
659  test_NameToStrConversionW(&blob, CERT_SIMPLE_NAME_STR, simpleQuotedCN_W,
660  FALSE);
661  blob.pbData = encodedMultipleAttrCN;
662  blob.cbData = sizeof(encodedMultipleAttrCN);
663  test_NameToStrConversionW(&blob, CERT_X500_NAME_STR, multipleAttrCN_W,
664  FALSE);
665  test_NameToStrConversionW(&blob, CERT_SIMPLE_NAME_STR,
666  simpleMultipleAttrCN_W, FALSE);
667  blob.pbData = encodedCommaCN;
668  blob.cbData = sizeof(encodedCommaCN);
669  test_NameToStrConversionW(&blob, CERT_X500_NAME_STR, commaCN_W, FALSE);
670  test_NameToStrConversionW(&blob, CERT_SIMPLE_NAME_STR, simpleCommaCN_W,
671  FALSE);
672  blob.pbData = encodedEqualCN;
673  blob.cbData = sizeof(encodedEqualCN);
674  test_NameToStrConversionW(&blob, CERT_X500_NAME_STR, equalCN_W, FALSE);
675  test_NameToStrConversionW(&blob, CERT_SIMPLE_NAME_STR, simpleEqualCN_W,
676  FALSE);
677  blob.pbData = encodedLessThanCN;
678  blob.cbData = sizeof(encodedLessThanCN);
679  test_NameToStrConversionW(&blob, CERT_X500_NAME_STR, lessThanCN_W, FALSE);
680  test_NameToStrConversionW(&blob, CERT_SIMPLE_NAME_STR, simpleLessThanCN_W,
681  FALSE);
682  blob.pbData = encodedGreaterThanCN;
683  blob.cbData = sizeof(encodedGreaterThanCN);
684  test_NameToStrConversionW(&blob, CERT_X500_NAME_STR, greaterThanCN_W,
685  FALSE);
686  test_NameToStrConversionW(&blob, CERT_SIMPLE_NAME_STR,
687  simpleGreaterThanCN_W, FALSE);
688  blob.pbData = encodedHashCN;
689  blob.cbData = sizeof(encodedHashCN);
690  test_NameToStrConversionW(&blob, CERT_X500_NAME_STR, hashCN_W, FALSE);
691  test_NameToStrConversionW(&blob, CERT_SIMPLE_NAME_STR, simpleHashCN_W,
692  FALSE);
693  blob.pbData = encodedSemiCN;
694  blob.cbData = sizeof(encodedSemiCN);
695  test_NameToStrConversionW(&blob, CERT_X500_NAME_STR, semiCN_W, FALSE);
696  test_NameToStrConversionW(&blob, CERT_SIMPLE_NAME_STR, simpleSemiCN_W,
697  FALSE);
698  blob.pbData = encodedNewlineCN;
699  blob.cbData = sizeof(encodedNewlineCN);
700  test_NameToStrConversionW(&blob, CERT_X500_NAME_STR, newlineCN_W, FALSE);
701  test_NameToStrConversionW(&blob, CERT_SIMPLE_NAME_STR, simpleNewlineCN_W,
702  FALSE);
703 }
704 
705 struct StrToNameA
706 {
707  LPCSTR x500;
708  DWORD encodedSize;
709  const BYTE *encoded;
710 };
711 
712 static const struct StrToNameA namesA[] = {
713  { "CN=1", sizeof(encodedSimpleCN), encodedSimpleCN },
714  { "CN=\"1\"", sizeof(encodedSimpleCN), encodedSimpleCN },
715  { "CN = \"1\"", sizeof(encodedSimpleCN), encodedSimpleCN },
716  { "CN='1'", sizeof(encodedSingleQuotedCN), encodedSingleQuotedCN },
717  { "CN=\" 1 \"", sizeof(encodedSpacedCN), encodedSpacedCN },
718  { "CN=\"\"\"1\"\"\"", sizeof(encodedQuotedCN), encodedQuotedCN },
719  { "CN=\"1+2\"", sizeof(encodedMultipleAttrCN), encodedMultipleAttrCN },
720  { "CN=\"a,b\"", sizeof(encodedCommaCN), encodedCommaCN },
721  { "CN=\"a=b\"", sizeof(encodedEqualCN), encodedEqualCN },
722  { "CN=\"<\"", sizeof(encodedLessThanCN), encodedLessThanCN },
723  { "CN=\">\"", sizeof(encodedGreaterThanCN), encodedGreaterThanCN },
724  { "CN=\"#\"", sizeof(encodedHashCN), encodedHashCN },
725  { "CN=\";\"", sizeof(encodedSemiCN), encodedSemiCN },
726  { "CN=dummy,T=test", sizeof(encodedDummyCN), encodedDummyCN },
727  { " CN = Wine Test,T = 123, C = BR", sizeof(encodedFields), encodedFields },
728 };
729 
730 static void test_CertStrToNameA(void)
731 {
732  BOOL ret;
733  DWORD size, i;
734  BYTE buf[100];
735 
736  if (!pCertStrToNameA)
737  {
738  win_skip("CertStrToNameA is not available\n");
739  return;
740  }
741 
742  /* Crash
743  ret = pCertStrToNameA(0, NULL, 0, NULL, NULL, NULL, NULL);
744  */
745  ret = pCertStrToNameA(0, NULL, 0, NULL, NULL, &size, NULL);
746  ok(!ret, "Expected failure\n");
747  ret = pCertStrToNameA(0, "bogus", 0, NULL, NULL, &size, NULL);
748  ok(!ret && GetLastError() == CRYPT_E_INVALID_X500_STRING,
749  "Expected CRYPT_E_INVALID_X500_STRING, got %08x\n", GetLastError());
750  ret = pCertStrToNameA(0, "foo=1", 0, NULL, NULL, &size, NULL);
751  ok(!ret && GetLastError() == CRYPT_E_INVALID_X500_STRING,
752  "Expected CRYPT_E_INVALID_X500_STRING, got %08x\n", GetLastError());
753  ret = pCertStrToNameA(0, "CN=1", 0, NULL, NULL, &size, NULL);
754  ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND,
755  "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
756  ret = pCertStrToNameA(X509_ASN_ENCODING, "CN=1", 0, NULL, NULL, &size, NULL);
757  ok(ret, "CertStrToNameA failed: %08x\n", GetLastError());
758  size = sizeof(buf);
759  ret = pCertStrToNameA(X509_ASN_ENCODING, "CN=\"\"1\"\"", 0, NULL, buf, &size,
760  NULL);
761  ok(!ret && GetLastError() == CRYPT_E_INVALID_X500_STRING,
762  "Expected CRYPT_E_INVALID_X500_STRING, got %08x\n", GetLastError());
763  ret = pCertStrToNameA(X509_ASN_ENCODING, "CN=1+2", 0, NULL, buf,
764  &size, NULL);
765  ok(!ret && GetLastError() == CRYPT_E_INVALID_X500_STRING,
766  "Expected CRYPT_E_INVALID_X500_STRING, got %08x\n", GetLastError());
767  ret = pCertStrToNameA(X509_ASN_ENCODING, "CN=1+2", CERT_NAME_STR_NO_PLUS_FLAG, NULL, buf,
768  &size, NULL);
769  ok(ret && GetLastError() == ERROR_SUCCESS,
770  "Expected ERROR_SUCCESS, got %08x\n", GetLastError());
771  ret = pCertStrToNameA(X509_ASN_ENCODING, "CN=1,2", CERT_NAME_STR_NO_QUOTING_FLAG, NULL, buf,
772  &size, NULL);
773  ok(!ret && GetLastError() == CRYPT_E_INVALID_X500_STRING,
774  "Expected CRYPT_E_INVALID_X500_STRING, got %08x\n", GetLastError());
775  ret = pCertStrToNameA(X509_ASN_ENCODING, "CN=\"1,2;3,4\"", CERT_NAME_STR_NO_QUOTING_FLAG, NULL, buf,
776  &size, NULL);
777  ok(!ret && GetLastError() == CRYPT_E_INVALID_X500_STRING,
778  "Expected CRYPT_E_INVALID_X500_STRING, got %08x\n", GetLastError());
779  ret = pCertStrToNameA(X509_ASN_ENCODING, "CN=abc", 0, NULL, buf,
780  &size, NULL);
781  ok(ret && GetLastError() == ERROR_SUCCESS,
782  "Expected ERROR_SUCCESS, got %08x\n", GetLastError());
783  ret = pCertStrToNameA(X509_ASN_ENCODING, "CN=abc", CERT_NAME_STR_NO_QUOTING_FLAG, NULL, buf,
784  &size, NULL);
785  ok(ret && GetLastError() == ERROR_SUCCESS,
786  "Expected ERROR_SUCCESS, got %08x\n", GetLastError());
787  ret = pCertStrToNameA(X509_ASN_ENCODING, "CN=\"abc\"", 0, NULL, buf,
788  &size, NULL);
789  ok(ret && GetLastError() == ERROR_SUCCESS,
790  "Expected ERROR_SUCCESS, got %08x\n", GetLastError());
791  ret = pCertStrToNameA(X509_ASN_ENCODING, "CN=\"abc\"", CERT_NAME_STR_NO_QUOTING_FLAG, NULL, buf,
792  &size, NULL);
793  ok(!ret && GetLastError() == ERROR_MORE_DATA,
794  "Expected ERROR_MORE_DATA, got %08x\n", GetLastError());
795  for (i = 0; i < ARRAY_SIZE(namesA); i++)
796  {
797  size = sizeof(buf);
798  ret = pCertStrToNameA(X509_ASN_ENCODING, namesA[i].x500, 0, NULL, buf,
799  &size, NULL);
800  ok(ret, "CertStrToNameA failed on string %s: %08x\n", namesA[i].x500,
801  GetLastError());
802  ok(size == namesA[i].encodedSize,
803  "Expected size %d, got %d\n", namesA[i].encodedSize, size);
804  if (ret)
805  ok(!memcmp(buf, namesA[i].encoded, namesA[i].encodedSize),
806  "Unexpected value for string %s\n", namesA[i].x500);
807  }
808 }
809 
810 struct StrToNameW
811 {
812  LPCWSTR x500;
813  DWORD encodedSize;
814  const BYTE *encoded;
815 };
816 
817 static const WCHAR badlyQuotedCN_W[] = { 'C','N','=','"','"','1','"','"',0 };
818 static const WCHAR simpleCN2_W[] = { 'C','N','=','"','1','"',0 };
819 static const WCHAR simpleCN3_W[] = { 'C','N',' ','=',' ','"','1','"',0 };
820 static const WCHAR japaneseCN_W[] = { 'C','N','=',0x226f,0x575b,0 };
821 static const WCHAR dummyCN_W[] = { 'C','N','=','d','u','m','m','y',',','T','=','t','e','s','t',0 };
822 static const WCHAR encodedFields_W[] = { ' ','C','N',' ','=',' ',' ',' ','W','i','n','e',' ','T',
823  'e','s','t',',','T',' ','=',' ','1','2','3',',',' ','C',
824  ' ','=',' ','B','R',0 };
825 static const BYTE encodedJapaneseCN[] = { 0x30,0x0f,0x31,0x0d,0x30,0x0b,0x06,
826  0x03,0x55,0x04,0x03,0x1e,0x04,0x22,0x6f,0x57,0x5b };
827 
828 static const struct StrToNameW namesW[] = {
829  { simpleCN_W, sizeof(encodedSimpleCN), encodedSimpleCN },
830  { simpleCN2_W, sizeof(encodedSimpleCN), encodedSimpleCN },
831  { simpleCN3_W, sizeof(encodedSimpleCN), encodedSimpleCN },
832  { singledQuotedCN_W, sizeof(encodedSingleQuotedCN), encodedSingleQuotedCN },
833  { spacedCN_W, sizeof(encodedSpacedCN), encodedSpacedCN },
834  { quotedCN_W, sizeof(encodedQuotedCN), encodedQuotedCN },
835  { multipleAttrCN_W, sizeof(encodedMultipleAttrCN), encodedMultipleAttrCN },
836  { japaneseCN_W, sizeof(encodedJapaneseCN), encodedJapaneseCN },
837  { commaCN_W, sizeof(encodedCommaCN), encodedCommaCN },
838  { equalCN_W, sizeof(encodedEqualCN), encodedEqualCN },
839  { lessThanCN_W, sizeof(encodedLessThanCN), encodedLessThanCN },
840  { greaterThanCN_W, sizeof(encodedGreaterThanCN), encodedGreaterThanCN },
841  { hashCN_W, sizeof(encodedHashCN), encodedHashCN },
842  { semiCN_W, sizeof(encodedSemiCN), encodedSemiCN },
843  { dummyCN_W, sizeof(encodedDummyCN), encodedDummyCN },
844  { encodedFields_W, sizeof(encodedFields), encodedFields },
845 };
846 
847 static void test_CertStrToNameW(void)
848 {
849  static const WCHAR bogusW[] = { 'b','o','g','u','s',0 };
850  static const WCHAR fooW[] = { 'f','o','o','=','1',0 };
851  BOOL ret;
852  DWORD size, i;
853  LPCWSTR errorPtr;
854  BYTE buf[100];
855 
856  if (!pCertStrToNameW)
857  {
858  win_skip("CertStrToNameW is not available\n");
859  return;
860  }
861 
862  /* Crash
863  ret = pCertStrToNameW(0, NULL, 0, NULL, NULL, NULL, NULL);
864  */
865  ret = pCertStrToNameW(0, NULL, 0, NULL, NULL, &size, NULL);
866  ok(!ret, "Expected failure\n");
867  ret = pCertStrToNameW(0, bogusW, 0, NULL, NULL, &size, NULL);
868  ok(!ret && GetLastError() == CRYPT_E_INVALID_X500_STRING,
869  "Expected CRYPT_E_INVALID_X500_STRING, got %08x\n", GetLastError());
870  ret = pCertStrToNameW(0, fooW, 0, NULL, NULL, &size, NULL);
871  ok(!ret && GetLastError() == CRYPT_E_INVALID_X500_STRING,
872  "Expected CRYPT_E_INVALID_X500_STRING, got %08x\n", GetLastError());
873  ret = pCertStrToNameW(0, simpleCN_W, 0, NULL, NULL, &size, NULL);
874  ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND,
875  "Expected ERROR_FILE_NOT_FOUND, got %08x\n", GetLastError());
876  ret = pCertStrToNameW(X509_ASN_ENCODING, simpleCN_W, 0, NULL, NULL, &size,
877  NULL);
878  ok(ret, "CertStrToNameW failed: %08x\n", GetLastError());
879  size = sizeof(buf);
880  ret = pCertStrToNameW(X509_ASN_ENCODING, badlyQuotedCN_W, 0, NULL, buf,
881  &size, NULL);
882  ok(!ret && GetLastError() == CRYPT_E_INVALID_X500_STRING,
883  "Expected CRYPT_E_INVALID_X500_STRING, got %08x\n", GetLastError());
884  ret = pCertStrToNameW(X509_ASN_ENCODING, badlyQuotedCN_W, 0, NULL, buf,
885  &size, &errorPtr);
886  ok(!ret && GetLastError() == CRYPT_E_INVALID_X500_STRING,
887  "Expected CRYPT_E_INVALID_X500_STRING, got %08x\n", GetLastError());
888  ok(errorPtr && *errorPtr == '1', "Expected first error character was 1\n");
889  for (i = 0; i < ARRAY_SIZE(namesW); i++)
890  {
891  size = sizeof(buf);
892  ret = pCertStrToNameW(X509_ASN_ENCODING, namesW[i].x500, 0, NULL, buf,
893  &size, NULL);
894  ok(ret, "Index %d: CertStrToNameW failed: %08x\n", i, GetLastError());
895  ok(size == namesW[i].encodedSize,
896  "Index %d: expected size %d, got %d\n", i, namesW[i].encodedSize,
897  size);
898  if (ret)
899  ok(!memcmp(buf, namesW[i].encoded, size),
900  "Index %d: unexpected value for string %s\n", i, wine_dbgstr_w(namesW[i].x500));
901  }
902 }
903 
904 static void test_CertGetNameStringA(void)
905 {
906  PCCERT_CONTEXT context;
907 
908  if (!pCertGetNameStringA)
909  {
910  win_skip("CertGetNameStringA is not available\n");
911  return;
912  }
913 
914  context = CertCreateCertificateContext(X509_ASN_ENCODING, cert,
915  sizeof(cert));
916  ok(context != NULL, "CertCreateCertificateContext failed: %08x\n",
917  GetLastError());
918  if (context)
919  {
920  static const char aric[] = "aric@codeweavers.com";
921  static const char localhost[] = "localhost";
922  DWORD len, type;
923  LPSTR str;
924 
925  /* Bad string types/types missing from the cert */
926  len = pCertGetNameStringA(NULL, 0, 0, NULL, NULL, 0);
927  ok(len == 1, "expected 1, got %d\n", len);
928  len = pCertGetNameStringA(context, 0, 0, NULL, NULL, 0);
929  ok(len == 1, "expected 1, got %d\n", len);
930  len = pCertGetNameStringA(context, CERT_NAME_URL_TYPE, 0, NULL, NULL,
931  0);
932  ok(len == 1, "expected 1, got %d\n", len);
933 
934  len = pCertGetNameStringA(context, CERT_NAME_EMAIL_TYPE, 0, NULL, NULL,
935  0);
936  ok(len == strlen(aric) + 1, "unexpected length %d\n", len);
937  str = HeapAlloc(GetProcessHeap(), 0, len);
938  if (str)
939  {
940  len = pCertGetNameStringA(context, CERT_NAME_EMAIL_TYPE, 0, NULL,
941  str, len);
942  ok(!strcmp(str, aric), "unexpected value %s\n", str);
943  HeapFree(GetProcessHeap(), 0, str);
944  }
945 
946  len = pCertGetNameStringA(context, CERT_NAME_RDN_TYPE, 0, NULL, NULL,
947  0);
948  ok(len == strlen(issuerStr) + 1, "unexpected length %d\n", len);
949  str = HeapAlloc(GetProcessHeap(), 0, len);
950  if (str)
951  {
952  len = pCertGetNameStringA(context, CERT_NAME_RDN_TYPE, 0, NULL,
953  str, len);
954  ok(!strcmp(str, issuerStr), "unexpected value %s\n", str);
955  HeapFree(GetProcessHeap(), 0, str);
956  }
957  type = 0;
958  len = pCertGetNameStringA(context, CERT_NAME_RDN_TYPE, 0, &type, NULL,
959  0);
960  ok(len == strlen(issuerStr) + 1, "unexpected length %d\n", len);
961  str = HeapAlloc(GetProcessHeap(), 0, len);
962  if (str)
963  {
964  len = pCertGetNameStringA(context, CERT_NAME_RDN_TYPE, 0, &type,
965  str, len);
966  ok(!strcmp(str, issuerStr), "unexpected value %s\n", str);
967  HeapFree(GetProcessHeap(), 0, str);
968  }
969  type = CERT_OID_NAME_STR;
970  len = pCertGetNameStringA(context, CERT_NAME_RDN_TYPE, 0, &type, NULL,
971  0);
972  ok(len == strlen(subjectStr) + 1, "unexpected length %d\n", len);
973  str = HeapAlloc(GetProcessHeap(), 0, len);
974  if (str)
975  {
976  len = pCertGetNameStringA(context, CERT_NAME_RDN_TYPE, 0, &type,
977  str, len);
978  ok(!strcmp(str, subjectStr), "unexpected value %s\n", str);
979  HeapFree(GetProcessHeap(), 0, str);
980  }
981 
982  len = pCertGetNameStringA(context, CERT_NAME_ATTR_TYPE, 0, NULL, NULL,
983  0);
984  ok(len == strlen(aric) + 1, "unexpected length %d\n", len);
985  str = HeapAlloc(GetProcessHeap(), 0, len);
986  if (str)
987  {
988  len = pCertGetNameStringA(context, CERT_NAME_ATTR_TYPE, 0, NULL,
989  str, len);
990  ok(!strcmp(str, aric), "unexpected value %s\n", str);
991  HeapFree(GetProcessHeap(), 0, str);
992  }
993  len = pCertGetNameStringA(context, CERT_NAME_ATTR_TYPE, 0,
994  (void *)szOID_RSA_emailAddr, NULL, 0);
995  ok(len == strlen(aric) + 1, "unexpected length %d\n", len);
996  str = HeapAlloc(GetProcessHeap(), 0, len);
997  if (str)
998  {
999  len = pCertGetNameStringA(context, CERT_NAME_ATTR_TYPE, 0,
1000  (void *)szOID_RSA_emailAddr, str, len);
1001  ok(!strcmp(str, aric), "unexpected value %s\n", str);
1002  HeapFree(GetProcessHeap(), 0, str);
1003  }
1004  len = pCertGetNameStringA(context, CERT_NAME_ATTR_TYPE, 0,
1005  (void *)szOID_COMMON_NAME, NULL, 0);
1006  ok(len == strlen(localhost) + 1, "unexpected length %d\n", len);
1007  str = HeapAlloc(GetProcessHeap(), 0, len);
1008  if (str)
1009  {
1010  len = pCertGetNameStringA(context, CERT_NAME_ATTR_TYPE, 0,
1011  (void *)szOID_COMMON_NAME, str, len);
1012  ok(!strcmp(str, localhost), "unexpected value %s\n", str);
1013  HeapFree(GetProcessHeap(), 0, str);
1014  }
1015 
1016  len = pCertGetNameStringA(context, CERT_NAME_SIMPLE_DISPLAY_TYPE, 0,
1017  NULL, NULL, 0);
1018  ok(len == strlen(localhost) + 1, "unexpected length %d\n", len);
1019  str = HeapAlloc(GetProcessHeap(), 0, len);
1020  if (str)
1021  {
1022  len = pCertGetNameStringA(context, CERT_NAME_SIMPLE_DISPLAY_TYPE,
1023  0, NULL, str, len);
1024  ok(!strcmp(str, localhost), "unexpected value %s\n", str);
1025  HeapFree(GetProcessHeap(), 0, str);
1026  }
1027 
1028  len = pCertGetNameStringA(context, CERT_NAME_FRIENDLY_DISPLAY_TYPE, 0,
1029  NULL, NULL, 0);
1030  ok(len == strlen(localhost) + 1, "unexpected length %d\n", len);
1031  str = HeapAlloc(GetProcessHeap(), 0, len);
1032  if (str)
1033  {
1034  len = pCertGetNameStringA(context, CERT_NAME_FRIENDLY_DISPLAY_TYPE,
1035  0, NULL, str, len);
1036  ok(!strcmp(str, localhost), "unexpected value %s\n", str);
1037  HeapFree(GetProcessHeap(), 0, str);
1038  }
1039 
1040  len = pCertGetNameStringA(context, CERT_NAME_DNS_TYPE, 0, NULL, NULL,
1041  0);
1042  ok(len == strlen(localhost) + 1 || broken(len == 1) /* NT4 */,
1043  "unexpected length %d\n", len);
1044  if (len > 1)
1045  {
1046  str = HeapAlloc(GetProcessHeap(), 0, len);
1047  if (str)
1048  {
1049  len = pCertGetNameStringA(context, CERT_NAME_DNS_TYPE, 0, NULL,
1050  str, len);
1051  ok(!strcmp(str, localhost), "unexpected value %s\n", str);
1052  HeapFree(GetProcessHeap(), 0, str);
1053  }
1054  }
1055 
1056  CertFreeCertificateContext(context);
1057  }
1058 }
1059 
1060 START_TEST(str)
1061 {
1062  dll = GetModuleHandleA("Crypt32.dll");
1063 
1064  pCertNameToStrA = (void*)GetProcAddress(dll,"CertNameToStrA");
1065  pCertNameToStrW = (void*)GetProcAddress(dll,"CertNameToStrW");
1066  pCertRDNValueToStrA = (void*)GetProcAddress(dll, "CertRDNValueToStrA");
1067  pCertRDNValueToStrW = (void*)GetProcAddress(dll, "CertRDNValueToStrW");
1068  pCertStrToNameA = (void*)GetProcAddress(dll,"CertStrToNameA");
1069  pCertStrToNameW = (void*)GetProcAddress(dll,"CertStrToNameW");
1070  pCertGetNameStringA = (void*)GetProcAddress(dll, "CertGetNameStringA");
1071 
1072  test_CertRDNValueToStrA();
1073  test_CertRDNValueToStrW();
1074  test_CertNameToStrA();
1075  test_CertNameToStrW();
1076  test_CertStrToNameA();
1077  test_CertStrToNameW();
1078  test_CertGetNameStringA();
1079 }
bin4
static BYTE bin4[]
Definition: str.c:50
CERT_NAME_FRIENDLY_DISPLAY_TYPE
#define CERT_NAME_FRIENDLY_DISPLAY_TYPE
Definition: wincrypt.h:3501
equalCN_W
static const WCHAR equalCN_W[]
Definition: str.c:571
encodedNewlineCN
static BYTE encodedNewlineCN[]
Definition: str.c:418
CERT_NAME_STR_SEMICOLON_FLAG
#define CERT_NAME_STR_SEMICOLON_FLAG
Definition: wincrypt.h:3487
CERT_X500_NAME_STR
#define CERT_X500_NAME_STR
Definition: wincrypt.h:3486
aric
static const BYTE aric[]
Definition: encode.c:700
localhostW
static const WCHAR localhostW[]
Definition: notification.c:35
issuerStrCRLFW
static WCHAR issuerStrCRLFW[]
Definition: str.c:144
test_CertNameToStrA
static void test_CertNameToStrA(void)
Definition: str.c:431
_CertRDNAttrEncoding::str
LPCSTR str
Definition: str.c:33
memcmp
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
_CertRDNAttrEncodingW::todo
BOOL todo
Definition: str.c:42
CERT_NAME_ATTR_TYPE
#define CERT_NAME_ATTR_TYPE
Definition: wincrypt.h:3499
ERROR_SUCCESS
#define ERROR_SUCCESS
Definition: deptool.c:10
bin10
static BYTE bin10[]
Definition: str.c:65
LPCWSTR
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
blob
Definition: image.c:133
issuerStrSemicolonW
static WCHAR issuerStrSemicolonW[]
Definition: str.c:138
context
Definition: http.c:7094
strlen
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
StrToNameA::x500
LPCSTR x500
Definition: str.c:707
hashCN_W
static const WCHAR hashCN_W[]
Definition: str.c:577
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
_CertRDNAttrEncoding
Definition: str.c:29
wine_dbgstr_w
char * wine_dbgstr_w(const wchar_t *wstr)
Definition: atltest.h:87
encodedSingleQuotedCN
static BYTE encodedSingleQuotedCN[]
Definition: str.c:392
lstrcmpW
int WINAPI lstrcmpW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:170
CertFreeCertificateContext
BOOL WINAPI CertFreeCertificateContext(PCCERT_CONTEXT pCertContext)
Definition: cert.c:371
CERT_RDN_IA5_STRING
#define CERT_RDN_IA5_STRING
Definition: wincrypt.h:2784
encodedDummyCN
static BYTE encodedDummyCN[]
Definition: str.c:421
issuerStr
static char issuerStr[]
Definition: str.c:118
cert
static const BYTE cert[]
Definition: str.c:71
_CertRDNAttrEncoding::Value
CERT_RDN_VALUE_BLOB Value
Definition: str.c:32
todo
BOOL todo
Definition: filedlg.c:313
StrToNameW::x500
LPCWSTR x500
Definition: str.c:812
localhost
static const BYTE localhost[]
Definition: encode.c:1442
_CertRDNAttrEncodingW::pszObjId
LPCSTR pszObjId
Definition: str.c:38
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
x500SubjectStrSemicolonReverse
static char x500SubjectStrSemicolonReverse[]
Definition: str.c:131
GetLastError
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
greaterThanCN_W
static const WCHAR greaterThanCN_W[]
Definition: str.c:575
buffer
GLuint buffer
Definition: glext.h:5915
bin8
static BYTE bin8[]
Definition: str.c:58
encodedSimpleCN
static BYTE encodedSimpleCN[]
Definition: str.c:390
issuerStrSemicolon
static char issuerStrSemicolon[]
Definition: str.c:120
szOID_COMMON_NAME
#define szOID_COMMON_NAME
Definition: wincrypt.h:3134
CERT_NAME_SIMPLE_DISPLAY_TYPE
#define CERT_NAME_SIMPLE_DISPLAY_TYPE
Definition: wincrypt.h:3500
LPSTR
char * LPSTR
Definition: xmlstorage.h:182
lstrlenW
#define lstrlenW
Definition: compat.h:498
simpleHashCN_W
static const WCHAR simpleHashCN_W[]
Definition: str.c:578
issuerStrCRLF
static char issuerStrCRLF[]
Definition: str.c:122
BOOL
static BOOL(WINAPI *pCertStrToNameA)(DWORD dwCertEncodingType
Value
IN UCHAR Value
Definition: halp.h:394
_CERT_CONTEXT
Definition: wincrypt.h:478
encodedCommaCN
static BYTE encodedCommaCN[]
Definition: str.c:400
encodedEqualCN
static BYTE encodedEqualCN[]
Definition: str.c:403
test_CertNameToStrW
static void test_CertNameToStrW(void)
Definition: str.c:584
simpleQuotedCN_W
static const WCHAR simpleQuotedCN_W[]
Definition: str.c:566
type
static DWORD type
Definition: str.c:201
dll
static HMODULE dll
Definition: str.c:188
CertRDNAttrEncoding
struct _CertRDNAttrEncoding CertRDNAttrEncoding
CRYPT_E_INVALID_X500_STRING
#define CRYPT_E_INVALID_X500_STRING
Definition: winerror.h:3027
CERT_NAME_STR_NO_QUOTING_FLAG
#define CERT_NAME_STR_NO_QUOTING_FLAG
Definition: wincrypt.h:3489
X509_ASN_ENCODING
#define X509_ASN_ENCODING
Definition: wincrypt.h:2297
issuerStrW
static WCHAR issuerStrW[]
Definition: str.c:132
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
StrToNameW::encodedSize
DWORD encodedSize
Definition: str.c:813
FALSE
#define FALSE
Definition: types.h:117
_CertRDNAttrEncoding::pszObjId
LPCSTR pszObjId
Definition: str.c:30
encodedSemiCN
static BYTE encodedSemiCN[]
Definition: str.c:415
test_NameToStrConversionA
static void test_NameToStrConversionA(PCERT_NAME_BLOB pName, DWORD dwStrType, LPCSTR expected, BOOL todo)
Definition: str.c:370
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
DWORD
static DWORD
Definition: str.c:189
blob
const DWORD * blob
Definition: effect.c:999
CERT_OID_NAME_STR
#define CERT_OID_NAME_STR
Definition: wincrypt.h:3485
bin13
static BYTE bin13[]
Definition: str.c:68
commaCN_W
static const WCHAR commaCN_W[]
Definition: str.c:569
pszX500
static LPCSTR pszX500
Definition: str.c:196
test_CertRDNValueToStrA
static void test_CertRDNValueToStrA(void)
Definition: str.c:205
bin5
static BYTE bin5[]
Definition: str.c:52
PCertRDNAttrEncodingW
struct _CertRDNAttrEncodingW * PCertRDNAttrEncodingW
test_CertGetNameStringA
static void test_CertGetNameStringA(void)
Definition: str.c:904
dummyCN_W
static const WCHAR dummyCN_W[]
Definition: str.c:821
ppszError
static LPCSTR DWORD void BYTE DWORD LPCSTR * ppszError
Definition: str.c:196
cch
static DWORD DWORD void LPSTR DWORD cch
Definition: str.c:201
CERT_NAME_EMAIL_TYPE
#define CERT_NAME_EMAIL_TYPE
Definition: wincrypt.h:3497
NULL
smooth NULL
Definition: ftsmooth.c:416
encodedFields_W
static const WCHAR encodedFields_W[]
Definition: str.c:822
bin14
static BYTE bin14[]
Definition: str.c:69
subjectStrW
static WCHAR subjectStrW[]
Definition: str.c:150
quotedCN_W
static const WCHAR quotedCN_W[]
Definition: str.c:565
multipleAttrCN_W
static const WCHAR multipleAttrCN_W[]
Definition: str.c:567
CERT_NAME_URL_TYPE
#define CERT_NAME_URL_TYPE
Definition: wincrypt.h:3503
CERT_NAME_STR_CRLF_FLAG
#define CERT_NAME_STR_CRLF_FLAG
Definition: wincrypt.h:3490
subjectStrSemicolonW
static WCHAR subjectStrSemicolonW[]
Definition: str.c:160
LPCSTR
const char * LPCSTR
Definition: xmlstorage.h:183
test_CertStrToNameW
static void test_CertStrToNameW(void)
Definition: str.c:847
LPSTR
static LPSTR
Definition: str.c:189
ERROR_FILE_NOT_FOUND
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
japaneseCN_W
static const WCHAR japaneseCN_W[]
Definition: str.c:820
todo_wine_if
#define todo_wine_if(is_todo)
Definition: test.h:163
bin3
static BYTE bin3[]
Definition: str.c:48
CERT_NAME_STR_NO_PLUS_FLAG
#define CERT_NAME_STR_NO_PLUS_FLAG
Definition: wincrypt.h:3488
_CRYPTOAPI_BLOB
Definition: wincrypt.h:101
pName
static LPSTR pName
Definition: security.c:75
_CertRDNAttrEncodingW::Value
CERT_RDN_VALUE_BLOB Value
Definition: str.c:40
size
GLsizeiptr size
Definition: glext.h:5919
dwStrType
static LPCSTR DWORD dwStrType
Definition: str.c:196
namesW
static const struct StrToNameW namesW[]
Definition: str.c:828
GetProcessHeap
#define GetProcessHeap()
Definition: compat.h:484
HeapAlloc
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
str
static DWORD DWORD void LPSTR str
Definition: str.c:201
encodedGreaterThanCN
static BYTE encodedGreaterThanCN[]
Definition: str.c:409
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180
pbEncoded
static LPCSTR DWORD void BYTE * pbEncoded
Definition: str.c:196
pvReserved
static LPCSTR DWORD void * pvReserved
Definition: str.c:196
x500SubjectStrSemicolonReverseW
static WCHAR x500SubjectStrSemicolonReverseW[]
Definition: str.c:180
StrToNameA::encoded
const BYTE * encoded
Definition: str.c:709
WINAPI
#define WINAPI
Definition: msvc.h:6
StrToNameA::encodedSize
DWORD encodedSize
Definition: str.c:708
subjectStrCRLF
static char subjectStrCRLF[]
Definition: str.c:128
typePara
static DWORD DWORD void * typePara
Definition: str.c:201
fooW
static const WCHAR fooW[]
Definition: locale.c:44
bin7
static BYTE bin7[]
Definition: str.c:56
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
SetLastError
#define SetLastError(x)
Definition: compat.h:500
CERT_RDN_UTF8_STRING
#define CERT_RDN_UTF8_STRING
Definition: wincrypt.h:2793
bin12
static BYTE bin12[]
Definition: str.c:67
simpleSemiCN_W
static const WCHAR simpleSemiCN_W[]
Definition: str.c:580
CERT_NAME_RDN_TYPE
#define CERT_NAME_RDN_TYPE
Definition: wincrypt.h:3498
badlyQuotedCN_W
static const WCHAR badlyQuotedCN_W[]
Definition: str.c:817
START_TEST
START_TEST(str)
Definition: str.c:1060
simpleNewlineCN_W
static const WCHAR simpleNewlineCN_W[]
Definition: str.c:582
bin6
static BYTE bin6[]
Definition: str.c:54
PCertRDNAttrEncoding
struct _CertRDNAttrEncoding * PCertRDNAttrEncoding
bin9
static BYTE bin9[]
Definition: str.c:64
_CertRDNAttrEncoding::dwValueType
DWORD dwValueType
Definition: str.c:31
ret
int ret
Definition: wcstombs-tests.c:31
simpleMultipleAttrCN_W
static const WCHAR simpleMultipleAttrCN_W[]
Definition: str.c:568
test_NameToStrConversionW
static void test_NameToStrConversionW(PCERT_NAME_BLOB pName, DWORD dwStrType, LPCWSTR expected, BOOL todo)
Definition: str.c:541
CertCreateCertificateContext
PCCERT_CONTEXT WINAPI CertCreateCertificateContext(DWORD dwCertEncodingType, const BYTE *pbCertEncoded, DWORD cbCertEncoded)
Definition: cert.c:316
encodedHashCN
static BYTE encodedHashCN[]
Definition: str.c:412
lessThanCN_W
static const WCHAR lessThanCN_W[]
Definition: str.c:573
bin2
static BYTE bin2[]
Definition: str.c:46
encodedLessThanCN
static BYTE encodedLessThanCN[]
Definition: str.c:406
len
GLenum GLsizei len
Definition: glext.h:6722
GetModuleHandleA
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:812
spacedCN_W
static const WCHAR spacedCN_W[]
Definition: str.c:563
ERROR_MORE_DATA
#define ERROR_MORE_DATA
Definition: dderror.h:13
BYTE
unsigned char BYTE
Definition: xxhash.c:193
test_CertRDNValueToStrW
static void test_CertRDNValueToStrW(void)
Definition: str.c:275
CERT_NAME_STR_REVERSE_FLAG
#define CERT_NAME_STR_REVERSE_FLAG
Definition: wincrypt.h:3492
broken
#define broken(x)
Definition: _sntprintf.h:21
dwCertEncodingType
_In_ DWORD dwCertEncodingType
Definition: wincrypt.h:5037
simpleCN_W
static const WCHAR simpleCN_W[]
Definition: str.c:560
_CertRDNAttrEncoding::todo
BOOL todo
Definition: str.c:34
simpleCommaCN_W
static const WCHAR simpleCommaCN_W[]
Definition: str.c:570
subjectStrSemicolon
static char subjectStrSemicolon[]
Definition: str.c:126
flags
static DWORD DWORD flags
Definition: str.c:201
namesA
static const struct StrToNameA namesA[]
Definition: str.c:712
lstrlenA
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
pcbEncoded
static LPCSTR DWORD void BYTE DWORD * pcbEncoded
Definition: str.c:196
ARRAY_SIZE
#define ARRAY_SIZE(a)
Definition: main.h:24
x500SubjectStr
static char x500SubjectStr[]
Definition: str.c:130
ok
#define ok(value,...)
Definition: atltest.h:57
encodedFields
static BYTE encodedFields[]
Definition: str.c:425
StrToNameW::encoded
const BYTE * encoded
Definition: str.c:814
simpleSpacedCN_W
static const WCHAR simpleSpacedCN_W[]
Definition: str.c:564
simpleSingleQuotedCN_W
static const WCHAR simpleSingleQuotedCN_W[]
Definition: str.c:562
szOID_RSA_emailAddr
#define szOID_RSA_emailAddr
Definition: wincrypt.h:3035
bin1
static BYTE bin1[]
Definition: str.c:45
CertRDNAttrEncodingW
struct _CertRDNAttrEncodingW CertRDNAttrEncodingW
_CertRDNAttrEncodingW::str
LPCWSTR str
Definition: str.c:41
test_CertStrToNameA
static void test_CertStrToNameA(void)
Definition: str.c:730
semiCN_W
static const WCHAR semiCN_W[]
Definition: str.c:579
simpleEqualCN_W
static const WCHAR simpleEqualCN_W[]
Definition: str.c:572
newlineCN_W
static const WCHAR newlineCN_W[]
Definition: str.c:581
CERT_SIMPLE_NAME_STR
#define CERT_SIMPLE_NAME_STR
Definition: wincrypt.h:3484
LPWSTR
static LPWSTR
Definition: str.c:190
PCERT_RDN_VALUE_BLOB
static PCERT_RDN_VALUE_BLOB
Definition: str.c:191
strcmp
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
GetProcAddress
#define GetProcAddress(x, y)
Definition: compat.h:501
CERT_NAME_DNS_TYPE
#define CERT_NAME_DNS_TYPE
Definition: wincrypt.h:3502
simpleCN2_W
static const WCHAR simpleCN2_W[]
Definition: str.c:818
bin11
static BYTE bin11[]
Definition: str.c:66
_CertRDNAttrEncodingW
Definition: str.c:37
subjectStr
static char subjectStr[]
Definition: str.c:124
simpleCN3_W
static const WCHAR simpleCN3_W[]
Definition: str.c:819
encodedMultipleAttrCN
static BYTE encodedMultipleAttrCN[]
Definition: str.c:398
win_skip
#define win_skip
Definition: test.h:149
HeapFree
#define HeapFree(x, y, z)
Definition: compat.h:483
encodedJapaneseCN
static const BYTE encodedJapaneseCN[]
Definition: str.c:825
CERT_RDN_PRINTABLE_STRING
#define CERT_RDN_PRINTABLE_STRING
Definition: wincrypt.h:2780
subjectStrCRLFW
static WCHAR subjectStrCRLFW[]
Definition: str.c:170
expected
BOOL expected
Definition: store.c:2063
LPVOID
static LPVOID
Definition: str.c:189
encodedSpacedCN
static BYTE encodedSpacedCN[]
Definition: str.c:394
simpleLessThanCN_W
static const WCHAR simpleLessThanCN_W[]
Definition: str.c:574
encodedQuotedCN
static BYTE encodedQuotedCN[]
Definition: str.c:396
singledQuotedCN_W
static const WCHAR singledQuotedCN_W[]
Definition: str.c:561
simpleGreaterThanCN_W
static const WCHAR simpleGreaterThanCN_W[]
Definition: str.c:576
_CertRDNAttrEncodingW::dwValueType
DWORD dwValueType
Definition: str.c:39