~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~ [ freetext search ] ~ [ file search ] ~

Wine Cross Reference
wine/dlls/crypt32/tests/ctl.c

Version: ~ [ wine-1.1.33 ] ~ [ wine-1.1.32 ] ~ [ wine-1.1.31 ] ~ [ wine-1.1.30 ] ~ [ wine-1.1.29 ] ~ [ wine-1.1.28 ] ~ [ wine-1.1.27 ] ~ [ wine-1.1.26 ] ~ [ wine-1.1.25 ] ~ [ wine-1.1.24 ] ~ [ wine-1.1.23 ] ~ [ wine-1.1.22 ] ~ [ wine-1.1.21 ] ~ [ wine-1.1.20 ] ~ [ wine-1.1.19 ] ~ [ wine-1.1.18 ] ~ [ wine-1.1.17 ] ~ [ wine-1.1.16 ] ~ [ wine-1.1.15 ] ~ [ wine-1.1.14 ] ~ [ wine-1.1.13 ] ~ [ wine-1.1.12 ] ~ [ wine-1.1.11 ] ~ [ wine-1.1.10 ] ~ [ wine-1.1.9 ] ~ [ wine-1.1.8 ] ~ [ wine-1.1.7 ] ~ [ wine-1.0.1 ] ~ [ wine-1.1.6 ] ~ [ wine-1.1.5 ] ~ [ wine-1.1.4 ] ~ [ wine-1.1.3 ] ~ [ wine-1.1.2 ] ~ [ wine-1.1.1 ] ~ [ wine-1.1.0 ] ~ [ wine-1.0 ] ~ 
  1 /*
  2  * crypt32 CTL functions tests
  3  *
  4  * Copyright 2008 Juan Lang
  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 
 21 #include <assert.h>
 22 #include <stdio.h>
 23 #include <stdarg.h>
 24 #include <windef.h>
 25 #include <winbase.h>
 26 #include <winerror.h>
 27 #include <wincrypt.h>
 28 
 29 #include "wine/test.h"
 30 
 31 static const BYTE emptyCTL[] = {
 32 0x30,0x17,0x30,0x00,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,
 33 0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x02,0x06,0x00 };
 34 static const BYTE ctlWithOneEntry[] = {
 35 0x30,0x2a,0x30,0x00,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,
 36 0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x02,0x06,0x00,0x30,0x11,0x30,0x0f,0x04,
 37 0x01,0x01,0x31,0x0a,0x30,0x08,0x06,0x02,0x2a,0x03,0x31,0x02,0x30,0x00 };
 38 static const BYTE signedCTL[] = {
 39 0x30,0x81,0xc7,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,0xa0,
 40 0x81,0xb9,0x30,0x81,0xb6,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,
 41 0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x28,0x06,0x09,0x2a,0x86,
 42 0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x1b,0x04,0x19,0x30,0x17,0x30,0x00,
 43 0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,
 44 0x30,0x5a,0x30,0x02,0x06,0x00,0x31,0x77,0x30,0x75,0x02,0x01,0x01,0x30,0x1a,
 45 0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,
 46 0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,
 47 0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,
 48 0x00,0x04,0x40,0xca,0xd8,0x32,0xd1,0xbd,0x97,0x61,0x54,0xd6,0x80,0xcf,0x0d,
 49 0xbd,0xa2,0x42,0xc7,0xca,0x37,0x91,0x7d,0x9d,0xac,0x8c,0xdf,0x05,0x8a,0x39,
 50 0xc6,0x07,0xc1,0x37,0xe6,0xb9,0xd1,0x0d,0x26,0xec,0xa5,0xb0,0x8a,0x51,0x26,
 51 0x2b,0x4f,0x73,0x44,0x86,0x83,0x5e,0x2b,0x6e,0xcc,0xf8,0x1b,0x85,0x53,0xe9,
 52 0x7a,0x80,0x8f,0x6b,0x42,0x19,0x93 };
 53 static const BYTE signedCTLWithSubjectAlgorithm[] = {
 54 0x30,0x81,0xd1,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,0xa0,
 55 0x81,0xc3,0x30,0x81,0xc0,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,0x2a,
 56 0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x32,0x06,0x09,0x2a,0x86,
 57 0x48,0x86,0xf7,0x0d,0x01,0x07,0x01,0xa0,0x25,0x04,0x23,0x30,0x21,0x30,0x00,
 58 0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,
 59 0x30,0x5a,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,
 60 0x00,0x31,0x77,0x30,0x75,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,
 61 0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,
 62 0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,
 63 0x0d,0x02,0x05,0x05,0x00,0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x40,0xca,0x7a,
 64 0xfa,0xbf,0x44,0x36,0xfd,0xb2,0x84,0x70,0x0f,0xf5,0x66,0xcb,0x68,0xdb,0x45,
 65 0x74,0xa1,0xed,0xe3,0x30,0x4a,0x11,0xd2,0x7b,0xf5,0xa9,0x68,0x8d,0x36,0xe8,
 66 0x79,0xff,0xa2,0xf2,0x4c,0x8a,0xa9,0x65,0x03,0xf8,0x77,0xa5,0x01,0xd3,0x46,
 67 0x8a,0xcc,0x93,0x36,0x30,0xe1,0xa4,0x47,0x70,0x3d,0xb3,0x97,0xfc,0x6d,0x24,
 68 0xe9,0xf9 };
 69 static const BYTE signedCTLWithCTLInnerContent[] = {
 70 0x30,0x82,0x01,0x0f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,
 71 0xa0,0x82,0x01,0x00,0x30,0x81,0xfd,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,
 72 0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x30,0x06,0x09,
 73 0x2b,0x06,0x01,0x04,0x01,0x82,0x37,0x0a,0x01,0xa0,0x23,0x30,0x21,0x30,0x00,
 74 0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,
 75 0x30,0x5a,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,
 76 0x00,0x31,0x81,0xb5,0x30,0x81,0xb2,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,
 77 0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,
 78 0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,
 79 0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0xa0,0x3b,0x30,0x18,0x06,0x09,0x2a,0x86,
 80 0x48,0x86,0xf7,0x0d,0x01,0x09,0x03,0x31,0x0b,0x06,0x09,0x2b,0x06,0x01,0x04,
 81 0x01,0x82,0x37,0x0a,0x01,0x30,0x1f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,
 82 0x01,0x09,0x04,0x31,0x12,0x04,0x10,0x54,0x71,0xbc,0xe1,0x56,0x31,0xa2,0xf9,
 83 0x65,0x70,0x34,0xf8,0xe2,0xe9,0xb4,0xf4,0x30,0x04,0x06,0x00,0x05,0x00,0x04,
 84 0x40,0x2f,0x1b,0x9f,0x5a,0x4a,0x15,0x73,0xfa,0xb1,0x93,0x3d,0x09,0x52,0xdf,
 85 0x6b,0x98,0x4b,0x13,0x5e,0xe7,0xbf,0x65,0xf4,0x9c,0xc2,0xb1,0x77,0x09,0xb1,
 86 0x66,0x4d,0x72,0x0d,0xb1,0x1a,0x50,0x20,0xe0,0x57,0xa2,0x39,0xc7,0xcd,0x7f,
 87 0x8e,0xe7,0x5f,0x76,0x2b,0xd1,0x6a,0x82,0xb3,0x30,0x25,0x61,0xf6,0x25,0x23,
 88 0x57,0x6c,0x0b,0x47,0xb8 };
 89 static const BYTE signedCTLWithCTLInnerContentAndBadSig[] = {
 90 0x30,0x82,0x01,0x0f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,
 91 0xa0,0x82,0x01,0x00,0x30,0x81,0xfd,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,
 92 0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x30,0x06,0x09,
 93 0x2b,0x06,0x01,0x04,0x01,0x82,0x37,0x0a,0x01,0xa0,0x23,0x30,0x21,0x30,0x00,
 94 0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,
 95 0x30,0x5a,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,
 96 0x00,0x31,0x81,0xb5,0x30,0x81,0xb2,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,
 97 0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,
 98 0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,
 99 0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0xa0,0x3b,0x30,0x18,0x06,0x09,0x2a,0x86,
100 0x48,0x86,0xf7,0x0d,0x01,0x09,0x03,0x31,0x0b,0x06,0x09,0x2b,0x06,0x01,0x04,
101 0x01,0x82,0x37,0x0a,0x01,0x30,0x1f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,
102 0x01,0x09,0x04,0x31,0x12,0x04,0x10,0x54,0x71,0xbc,0xe1,0x56,0x31,0xa2,0xf9,
103 0x65,0x70,0x34,0xf8,0xe2,0xe9,0xb4,0xf4,0x30,0x04,0x06,0x00,0x05,0x00,0x04,
104 0x40,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
105 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
106 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
107 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
108 0xff,0xff,0xff,0xff,0xff };
109 
110 static void testCreateCTL(void)
111 {
112     PCCTL_CONTEXT ctl;
113 
114     SetLastError(0xdeadbeef);
115     ctl = CertCreateCTLContext(0, NULL, 0);
116     ok(!ctl && GetLastError() == E_INVALIDARG,
117      "expected E_INVALIDARG, got %08x\n", GetLastError());
118     SetLastError(0xdeadbeef);
119     ctl = CertCreateCTLContext(X509_ASN_ENCODING, NULL, 0);
120     ok(!ctl &&
121      (GetLastError() == ERROR_INVALID_DATA ||
122       GetLastError() == OSS_MORE_INPUT), /* win9x */
123      "expected ERROR_INVALID_DATA, got %d (0x%08x)\n", GetLastError(),
124      GetLastError());
125     /* An empty CTL can't be created.. */
126     SetLastError(0xdeadbeef);
127     ctl = CertCreateCTLContext(X509_ASN_ENCODING, emptyCTL, sizeof(emptyCTL));
128     ok(!ctl &&
129      (GetLastError() == ERROR_INVALID_DATA ||
130       GetLastError() == OSS_DATA_ERROR), /* win9x */
131      "expected ERROR_INVALID_DATA, got %d (0x%08x)\n", GetLastError(),
132      GetLastError());
133     /* Nor can any of these "signed" CTLs whose inner content OID isn't
134      * szOID_CTL.
135      */
136     SetLastError(0xdeadbeef);
137     ctl = CertCreateCTLContext(X509_ASN_ENCODING, signedCTL, sizeof(signedCTL));
138     ok(!ctl &&
139      (GetLastError() == ERROR_INVALID_DATA ||
140       GetLastError() == CRYPT_E_UNEXPECTED_MSG_TYPE /* win9x */ ||
141       GetLastError() == ERROR_SUCCESS /* some win98 */),
142      "expected ERROR_INVALID_DATA, CRYPT_E_UNEXPECTED_MSG_TYPE, or ERROR_SUCCESS, got %d (0x%08x)\n", GetLastError(),
143      GetLastError());
144     SetLastError(0xdeadbeef);
145     ctl = CertCreateCTLContext(X509_ASN_ENCODING, ctlWithOneEntry,
146      sizeof(ctlWithOneEntry));
147     ok(!ctl &&
148      (GetLastError() == ERROR_INVALID_DATA ||
149       GetLastError() == CRYPT_E_UNEXPECTED_MSG_TYPE /* win9x */ ||
150       GetLastError() == OSS_DATA_ERROR /* some win98 */ ||
151       GetLastError() == ERROR_SUCCESS /* some win98 */),
152      "expected ERROR_INVALID_DATA, CRYPT_E_UNEXPECTED_MSG_TYPE, OSS_DATA_ERROR, or ERROR_SUCCESS, got %d (0x%08x)\n", GetLastError(),
153      GetLastError());
154     SetLastError(0xdeadbeef);
155     ctl = CertCreateCTLContext(X509_ASN_ENCODING,
156      signedCTLWithSubjectAlgorithm, sizeof(signedCTLWithSubjectAlgorithm));
157     ok(!ctl &&
158      (GetLastError() == ERROR_INVALID_DATA ||
159       GetLastError() == CRYPT_E_UNEXPECTED_MSG_TYPE /* win9x */ ||
160       GetLastError() == ERROR_SUCCESS /* some win98 */),
161      "expected ERROR_INVALID_DATA, got %d (0x%08x)\n", GetLastError(),
162      GetLastError());
163     /* This signed CTL with the appropriate inner content type can be decoded.
164      */
165     ctl = CertCreateCTLContext(X509_ASN_ENCODING,
166      signedCTLWithCTLInnerContent, sizeof(signedCTLWithCTLInnerContent));
167     ok(ctl != NULL, "CertCreateCTLContext failed: %08x\n", GetLastError());
168     if (ctl)
169     {
170         /* Even though the CTL was decoded with X509_ASN_ENCODING, the
171          * message encoding type is included in the CTL's encoding type.
172          */
173         ok(ctl->dwMsgAndCertEncodingType ==
174          (X509_ASN_ENCODING | PKCS_7_ASN_ENCODING),
175          "expected X509_ASN_ENCODING | PKCS_7_ASN_ENCODING, got %08x\n",
176          ctl->dwMsgAndCertEncodingType);
177         CertFreeCTLContext(ctl);
178     }
179     /* This CTL with a bad signature can also be decoded, so the sig isn't
180      * checked when loading the CTL.
181      */
182     ctl = CertCreateCTLContext(X509_ASN_ENCODING,
183      signedCTLWithCTLInnerContentAndBadSig,
184      sizeof(signedCTLWithCTLInnerContentAndBadSig));
185     ok(ctl != NULL, "CertCreateCTLContext failed: %08x\n", GetLastError());
186     if (ctl)
187         CertFreeCTLContext(ctl);
188 }
189 
190 static void testDupCTL(void)
191 {
192     PCCTL_CONTEXT context, dupContext;
193 
194     context = CertDuplicateCTLContext(NULL);
195     ok(context == NULL, "expected NULL\n");
196     context = CertCreateCTLContext(X509_ASN_ENCODING,
197      signedCTLWithCTLInnerContent, sizeof(signedCTLWithCTLInnerContent));
198     dupContext = CertDuplicateCTLContext(context);
199     ok(dupContext != NULL, "expected a context\n");
200     ok(dupContext == context, "expected identical context addresses\n");
201     CertFreeCTLContext(dupContext);
202     CertFreeCTLContext(context);
203 }
204 
205 static void checkHash(const BYTE *data, DWORD dataLen, ALG_ID algID,
206  PCCTL_CONTEXT context, DWORD propID)
207 {
208     BYTE hash[20] = { 0 }, hashProperty[20];
209     BOOL ret;
210     DWORD size;
211 
212     memset(hash, 0, sizeof(hash));
213     memset(hashProperty, 0, sizeof(hashProperty));
214     size = sizeof(hash);
215     ret = CryptHashCertificate(0, algID, 0, data, dataLen, hash, &size);
216     ret = CertGetCTLContextProperty(context, propID, hashProperty, &size);
217     ok(ret, "CertGetCTLContextProperty failed: %08x\n", GetLastError());
218     if (ret)
219         ok(!memcmp(hash, hashProperty, size),
220          "Unexpected hash for property %d\n", propID);
221 }
222 
223 static void testCTLProperties(void)
224 {
225     PCCTL_CONTEXT ctl;
226     BOOL ret;
227     DWORD propID, numProps, access, size;
228 
229     ctl = CertCreateCTLContext(X509_ASN_ENCODING,
230      signedCTLWithCTLInnerContent, sizeof(signedCTLWithCTLInnerContent));
231     if (!ctl)
232     {
233         skip("CertCreateCTLContext failed: %08x\n", GetLastError());
234         return;
235     }
236 
237     /* No properties as yet */
238     propID = 0;
239     numProps = 0;
240     do {
241         propID = CertEnumCTLContextProperties(ctl, propID);
242         if (propID)
243             numProps++;
244     } while (propID != 0);
245     ok(numProps == 0, "Expected 0 properties, got %d\n", numProps);
246 
247     /* An implicit property */
248     ret = CertGetCTLContextProperty(ctl, CERT_ACCESS_STATE_PROP_ID, NULL,
249      &size);
250     ok(ret || broken(GetLastError() == CRYPT_E_NOT_FOUND /* some win98 */),
251      "CertGetCTLContextProperty failed: %08x\n", GetLastError());
252     ret = CertGetCTLContextProperty(ctl, CERT_ACCESS_STATE_PROP_ID, &access,
253      &size);
254     ok(ret || broken(GetLastError() == CRYPT_E_NOT_FOUND /* some win98 */),
255      "CertGetCTLContextProperty failed: %08x\n", GetLastError());
256     if (ret)
257         ok(!(access & CERT_ACCESS_STATE_WRITE_PERSIST_FLAG),
258          "Didn't expect a persisted cert\n");
259 
260     checkHash(signedCTLWithCTLInnerContent,
261      sizeof(signedCTLWithCTLInnerContent), CALG_SHA1, ctl, CERT_HASH_PROP_ID);
262 
263     /* Now that the hash property is set, we should get one property when
264      * enumerating.
265      */
266     propID = 0;
267     numProps = 0;
268     do {
269         propID = CertEnumCTLContextProperties(ctl, propID);
270         if (propID)
271             numProps++;
272     } while (propID != 0);
273     ok(numProps == 1, "Expected 1 properties, got %d\n", numProps);
274 
275     checkHash(signedCTLWithCTLInnerContent,
276      sizeof(signedCTLWithCTLInnerContent), CALG_MD5, ctl,
277      CERT_MD5_HASH_PROP_ID);
278 
279     CertFreeCTLContext(ctl);
280 }
281 
282 static const BYTE signedCTLWithUsage[] = {
283 0x30,0x82,0x01,0x0f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,
284 0xa0,0x82,0x01,0x00,0x30,0x81,0xfd,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,
285 0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x30,0x06,0x09,
286 0x2b,0x06,0x01,0x04,0x01,0x82,0x37,0x0a,0x01,0xa0,0x23,0x30,0x21,0x30,0x0a,
287 0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x18,0x0f,0x31,0x36,0x30,
288 0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,0x30,0x30,0x30,0x5a,0x30,0x02,0x06,
289 0x00,0x31,0x81,0xb5,0x30,0x81,0xb2,0x02,0x01,0x01,0x30,0x1a,0x30,0x15,0x31,
290 0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,
291 0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,
292 0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0xa0,0x3b,0x30,0x18,0x06,0x09,0x2a,0x86,
293 0x48,0x86,0xf7,0x0d,0x01,0x09,0x03,0x31,0x0b,0x06,0x09,0x2b,0x06,0x01,0x04,
294 0x01,0x82,0x37,0x0a,0x01,0x30,0x1f,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,
295 0x01,0x09,0x04,0x31,0x12,0x04,0x10,0xc4,0x3e,0x7e,0xc8,0xf9,0x85,0xf3,0x27,
296 0x7d,0xc0,0x38,0xb2,0x7f,0xc7,0x76,0x85,0x30,0x04,0x06,0x00,0x05,0x00,0x04,
297 0x40,0x90,0x33,0x1b,0xb4,0x88,0x35,0xe6,0xf7,0x7f,0x93,0x05,0xc9,0x1a,0x0e,
298 0x8f,0x21,0xc0,0xaa,0xb3,0xab,0x3e,0x4a,0xa6,0x63,0x74,0xfd,0xef,0x11,0xbd,
299 0x67,0x3a,0x1b,0x07,0x4b,0x88,0x59,0x31,0xd5,0x08,0xf9,0x09,0x2f,0x0b,0x85,
300 0x62,0x5a,0x67,0x3b,0x62,0x7e,0x81,0x31,0xea,0xa4,0x36,0x5f,0x9a,0x92,0xb6,
301 0x66,0xa5,0x00,0x60,0x96 };
302 static const BYTE signedCTLWithListID1[] = {
303 0x30,0x82,0x01,0x07,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,
304 0xa0,0x81,0xf9,0x30,0x81,0xf6,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,
305 0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x29,0x06,0x09,0x2b,
306 0x06,0x01,0x04,0x01,0x82,0x37,0x0a,0x01,0xa0,0x1c,0x30,0x1a,0x30,0x00,0x04,
307 0x01,0x01,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,
308 0x30,0x30,0x30,0x5a,0x30,0x02,0x06,0x00,0x31,0x81,0xb5,0x30,0x81,0xb2,0x02,
309 0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,
310 0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,
311 0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0xa0,
312 0x3b,0x30,0x18,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x09,0x03,0x31,
313 0x0b,0x06,0x09,0x2b,0x06,0x01,0x04,0x01,0x82,0x37,0x0a,0x01,0x30,0x1f,0x06,
314 0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x09,0x04,0x31,0x12,0x04,0x10,0xbc,
315 0x13,0xde,0x17,0xc7,0x7c,0x67,0x5b,0xf9,0xa9,0x7c,0xb0,0xd9,0xf2,0x84,0xd5,
316 0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x40,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
317 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
318 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
319 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
320 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff };
321 static const BYTE signedCTLWithListID2[] = {
322 0x30,0x82,0x01,0x07,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x07,0x02,
323 0xa0,0x81,0xf9,0x30,0x81,0xf6,0x02,0x01,0x01,0x31,0x0e,0x30,0x0c,0x06,0x08,
324 0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0x30,0x29,0x06,0x09,0x2b,
325 0x06,0x01,0x04,0x01,0x82,0x37,0x0a,0x01,0xa0,0x1c,0x30,0x1a,0x30,0x00,0x04,
326 0x01,0x02,0x18,0x0f,0x31,0x36,0x30,0x31,0x30,0x31,0x30,0x31,0x30,0x30,0x30,
327 0x30,0x30,0x30,0x5a,0x30,0x02,0x06,0x00,0x31,0x81,0xb5,0x30,0x81,0xb2,0x02,
328 0x01,0x01,0x30,0x1a,0x30,0x15,0x31,0x13,0x30,0x11,0x06,0x03,0x55,0x04,0x03,
329 0x13,0x0a,0x4a,0x75,0x61,0x6e,0x20,0x4c,0x61,0x6e,0x67,0x00,0x02,0x01,0x01,
330 0x30,0x0c,0x06,0x08,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x02,0x05,0x05,0x00,0xa0,
331 0x3b,0x30,0x18,0x06,0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x09,0x03,0x31,
332 0x0b,0x06,0x09,0x2b,0x06,0x01,0x04,0x01,0x82,0x37,0x0a,0x01,0x30,0x1f,0x06,
333 0x09,0x2a,0x86,0x48,0x86,0xf7,0x0d,0x01,0x09,0x04,0x31,0x12,0x04,0x10,0x60,
334 0x6b,0x10,0xb6,0xb8,0x74,0xb8,0xf3,0x79,0xd5,0x42,0x15,0x4a,0x60,0x93,0x1f,
335 0x30,0x04,0x06,0x00,0x05,0x00,0x04,0x40,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
336 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
337 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
338 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
339 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff };
340 
341 static void testAddCTLToStore(void)
342 {
343     HCERTSTORE store;
344     BOOL ret;
345     DWORD numCTLs, expectedCTLs;
346     PCCTL_CONTEXT ctl;
347 
348     store = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
349      CERT_STORE_CREATE_NEW_FLAG, NULL);
350     /* Add two CTLs */
351     ret = CertAddEncodedCTLToStore(store, X509_ASN_ENCODING,
352      signedCTLWithCTLInnerContent, sizeof(signedCTLWithCTLInnerContent),
353      CERT_STORE_ADD_ALWAYS, NULL);
354     ok(ret, "CertAddEncodedCTLToStore failed: %08x\n", GetLastError());
355     ret = CertAddEncodedCTLToStore(store, X509_ASN_ENCODING,
356      signedCTLWithCTLInnerContentAndBadSig,
357      sizeof(signedCTLWithCTLInnerContentAndBadSig), CERT_STORE_ADD_ALWAYS,
358      NULL);
359     ok(ret, "CertAddEncodedCTLToStore failed: %08x\n", GetLastError());
360     /* Check that two exist */
361     numCTLs = 0;
362     ctl = NULL;
363     do {
364         ctl = CertEnumCTLsInStore(store, ctl);
365         if (ctl)
366             numCTLs++;
367     } while (ctl);
368     ok(numCTLs == 2, "expected 2 CTLs, got %d\n", numCTLs);
369     CertCloseStore(store, 0);
370 
371     store = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
372      CERT_STORE_CREATE_NEW_FLAG, NULL);
373     /* Add the two CTLs again.  They're identical except for the signature.. */
374     ret = CertAddEncodedCTLToStore(store, X509_ASN_ENCODING,
375      signedCTLWithCTLInnerContent, sizeof(signedCTLWithCTLInnerContent),
376      CERT_STORE_ADD_NEW, NULL);
377     ok(ret, "CertAddEncodedCTLToStore failed: %08x\n", GetLastError());
378     /* so adding the second CTL fails. */
379     SetLastError(0xdeadbeef);
380     ret = CertAddEncodedCTLToStore(store, X509_ASN_ENCODING,
381      signedCTLWithCTLInnerContentAndBadSig,
382      sizeof(signedCTLWithCTLInnerContentAndBadSig), CERT_STORE_ADD_NEW,
383      NULL);
384     if (ret)
385     {
386         /* win9x */
387         ok(GetLastError() == CRYPT_E_NOT_FOUND ||
388            GetLastError() == OSS_DATA_ERROR /* some win98 */,
389            "Expected CRYPT_E_NOT_FOUND, got %08x\n", GetLastError());
390     }
391     else
392     {
393         ok(!ret && (GetLastError() == CRYPT_E_EXISTS ||
394            GetLastError() == OSS_DATA_ERROR),
395            "expected CRYPT_E_EXISTS or OSS_DATA_ERROR, got %d %08x\n", ret,
396            GetLastError());
397     }
398     CertCloseStore(store, 0);
399 
400     store = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
401      CERT_STORE_CREATE_NEW_FLAG, NULL);
402     /* Add two CTLs.  These two have different usages, so they're considered
403      * different.
404      */
405     ret = CertAddEncodedCTLToStore(store, X509_ASN_ENCODING,
406      signedCTLWithCTLInnerContent, sizeof(signedCTLWithCTLInnerContent),
407      CERT_STORE_ADD_NEW, NULL);
408     ok(ret, "CertAddEncodedCTLToStore failed: %08x\n", GetLastError());
409     expectedCTLs = 1;
410     ret = CertAddEncodedCTLToStore(store, X509_ASN_ENCODING,
411      signedCTLWithUsage, sizeof(signedCTLWithUsage), CERT_STORE_ADD_NEW,
412      NULL);
413     ok(ret || broken(GetLastError() == OSS_DATA_ERROR /* some win98 */),
414        "CertAddEncodedCTLToStore failed: %08x\n", GetLastError());
415     if (ret)
416         expectedCTLs++;
417     /* Check that two exist */
418     numCTLs = 0;
419     ctl = NULL;
420     do {
421         ctl = CertEnumCTLsInStore(store, ctl);
422         if (ctl)
423             numCTLs++;
424     } while (ctl);
425     ok(numCTLs == expectedCTLs, "expected %d CTLs, got %d\n", expectedCTLs,
426        numCTLs);
427     CertCloseStore(store, 0);
428 
429     store = CertOpenStore(CERT_STORE_PROV_MEMORY, 0, 0,
430      CERT_STORE_CREATE_NEW_FLAG, NULL);
431     /* Add two CTLs.  Now they have the same (empty) usages and different list
432      * IDs, so they're different.
433      */
434     ret = CertAddEncodedCTLToStore(store, X509_ASN_ENCODING,
435      signedCTLWithListID1, sizeof(signedCTLWithListID1), CERT_STORE_ADD_NEW,
436      NULL);
437     if (!ret)
438     {
439         skip("adding a CTL with an empty usage not supported\n");
440         return;
441     }
442     ok(ret, "CertAddEncodedCTLToStore failed: %08x\n", GetLastError());
443     ret = CertAddEncodedCTLToStore(store, X509_ASN_ENCODING,
444      signedCTLWithListID2, sizeof(signedCTLWithListID2), CERT_STORE_ADD_NEW,
445      NULL);
446     ok(ret, "CertAddEncodedCTLToStore failed: %08x\n", GetLastError());
447     /* Check that two exist */
448     numCTLs = 0;
449     ctl = NULL;
450     do {
451         ctl = CertEnumCTLsInStore(store, ctl);
452         if (ctl)
453             numCTLs++;
454     } while (ctl);
455     ok(numCTLs == 2, "expected 2 CTLs, got %d\n", numCTLs);
456     CertCloseStore(store, 0);
457 }
458 
459 START_TEST(ctl)
460 {
461     testCreateCTL();
462     testDupCTL();
463     testCTLProperties();
464     testAddCTLToStore();
465 }
466
~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~ [ freetext search ] ~ [ file search ] ~
This page was automatically generated by the LXR engine.
Visit the LXR main site for more information.