1 /*
2 * Unit test suite for crypt32.dll's CryptStringToBinary and CryptBinaryToString
3 * functions.
4 *
5 * Copyright 2006 Juan Lang
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21 #include <stdio.h>
22 #include <stdarg.h>
23 #include <windef.h>
24 #include <winbase.h>
25 #include <winerror.h>
26 #include <wincrypt.h>
27
28 #include "wine/test.h"
29
30 #define CERT_HEADER "-----BEGIN CERTIFICATE-----\r\n"
31 #define CERT_TRAILER "-----END CERTIFICATE-----\r\n"
32 #define CERT_REQUEST_HEADER "-----BEGIN NEW CERTIFICATE REQUEST-----\r\n"
33 #define CERT_REQUEST_TRAILER "-----END NEW CERTIFICATE REQUEST-----\r\n"
34 #define X509_HEADER "-----BEGIN X509 CRL-----\r\n"
35 #define X509_TRAILER "-----END X509 CRL-----\r\n"
36 #define CERT_HEADER_NOCR "-----BEGIN CERTIFICATE-----\n"
37 #define CERT_TRAILER_NOCR "-----END CERTIFICATE-----\n"
38 #define CERT_REQUEST_HEADER_NOCR "-----BEGIN NEW CERTIFICATE REQUEST-----\n"
39 #define CERT_REQUEST_TRAILER_NOCR "-----END NEW CERTIFICATE REQUEST-----\n"
40 #define X509_HEADER_NOCR "-----BEGIN X509 CRL-----\n"
41 #define X509_TRAILER_NOCR "-----END X509 CRL-----\n"
42
43 typedef BOOL (WINAPI *CryptBinaryToStringAFunc)(const BYTE *pbBinary,
44 DWORD cbBinary, DWORD dwFlags, LPSTR pszString, DWORD *pcchString);
45 typedef BOOL (WINAPI *CryptStringToBinaryAFunc)(LPCSTR pszString,
46 DWORD cchString, DWORD dwFlags, BYTE *pbBinary, DWORD *pcbBinary,
47 DWORD *pdwSkip, DWORD *pdwFlags);
48
49 CryptBinaryToStringAFunc pCryptBinaryToStringA;
50 CryptStringToBinaryAFunc pCryptStringToBinaryA;
51
52 struct BinTests
53 {
54 const BYTE *toEncode;
55 DWORD toEncodeLen;
56 const char *base64;
57 };
58
59 static const BYTE toEncode1[] = { 0 };
60 static const BYTE toEncode2[] = { 1,2 };
61 static const BYTE toEncode3[] = { 1,2,3 };
62 static const BYTE toEncode4[] =
63 "abcdefghijlkmnopqrstuvwxyz01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890"
64 "abcdefghijlkmnopqrstuvwxyz01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890"
65 "abcdefghijlkmnopqrstuvwxyz01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890";
66
67 struct BinTests tests[] = {
68 { toEncode1, sizeof(toEncode1), "AA==\r\n", },
69 { toEncode2, sizeof(toEncode2), "AQI=\r\n", },
70 /* { toEncode3, sizeof(toEncode3), "AQID\r\n", }, This test fails on Vista. */
71 { toEncode4, sizeof(toEncode4),
72 "YWJjZGVmZ2hpamxrbW5vcHFyc3R1dnd4eXowMTIzNDU2Nzg5MEFCQ0RFRkdISUpL\r\n"
73 "TE1OT1BRUlNUVVZXWFlaMDEyMzQ1Njc4OTBhYmNkZWZnaGlqbGttbm9wcXJzdHV2\r\n"
74 "d3h5ejAxMjM0NTY3ODkwQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVowMTIzNDU2\r\n"
75 "Nzg5MGFiY2RlZmdoaWpsa21ub3BxcnN0dXZ3eHl6MDEyMzQ1Njc4OTBBQkNERUZH\r\n"
76 "SElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0NTY3ODkwAA==\r\n" },
77 };
78
79 struct BinTests testsNoCR[] = {
80 { toEncode1, sizeof(toEncode1), "AA==\n", },
81 { toEncode2, sizeof(toEncode2), "AQI=\n", },
82 /* { toEncode3, sizeof(toEncode3), "AQID\n", }, This test fails on Vista. */
83 { toEncode4, sizeof(toEncode4),
84 "YWJjZGVmZ2hpamxrbW5vcHFyc3R1dnd4eXowMTIzNDU2Nzg5MEFCQ0RFRkdISUpL\n"
85 "TE1OT1BRUlNUVVZXWFlaMDEyMzQ1Njc4OTBhYmNkZWZnaGlqbGttbm9wcXJzdHV2\n"
86 "d3h5ejAxMjM0NTY3ODkwQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVowMTIzNDU2\n"
87 "Nzg5MGFiY2RlZmdoaWpsa21ub3BxcnN0dXZ3eHl6MDEyMzQ1Njc4OTBBQkNERUZH\n"
88 "SElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0NTY3ODkwAA==\n" },
89 };
90
91 static void encodeAndCompareBase64_A(const BYTE *toEncode, DWORD toEncodeLen,
92 DWORD format, const char *expected, const char *header, const char *trailer)
93 {
94 DWORD strLen = 0;
95 LPSTR str = NULL;
96 BOOL ret;
97
98 ret = pCryptBinaryToStringA(toEncode, toEncodeLen, format, NULL, &strLen);
99 ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError());
100 str = HeapAlloc(GetProcessHeap(), 0, strLen);
101 if (str)
102 {
103 DWORD strLen2 = strLen;
104 LPCSTR ptr = str;
105
106 ret = pCryptBinaryToStringA(toEncode, toEncodeLen, format, str,
107 &strLen2);
108 ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError());
109 ok(strLen2 == strLen - 1, "Expected length %d, got %d\n",
110 strLen - 1, strLen);
111 if (header)
112 {
113 ok(!strncmp(header, ptr, strlen(header)),
114 "Expected header %s, got %s\n", header, ptr);
115 ptr += strlen(header);
116 }
117 ok(!strncmp(expected, ptr, strlen(expected)),
118 "Expected %s, got %s\n", expected, ptr);
119 ptr += strlen(expected);
120 if (trailer)
121 {
122 ok(!strncmp(trailer, ptr, strlen(trailer)),
123 "Expected trailer %s, got %s\n", trailer, ptr);
124 ptr += strlen(trailer);
125 }
126 HeapFree(GetProcessHeap(), 0, str);
127 }
128 }
129
130 static void testBinaryToStringA(void)
131 {
132 BOOL ret;
133 DWORD strLen = 0, i;
134
135 ret = pCryptBinaryToStringA(NULL, 0, 0, NULL, NULL);
136 ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
137 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
138 ret = pCryptBinaryToStringA(NULL, 0, 0, NULL, &strLen);
139 ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
140 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
141 for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
142 {
143 DWORD strLen = 0;
144 LPSTR str = NULL;
145 BOOL ret;
146
147 ret = pCryptBinaryToStringA(tests[i].toEncode, tests[i].toEncodeLen,
148 CRYPT_STRING_BINARY, NULL, &strLen);
149 ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError());
150 str = HeapAlloc(GetProcessHeap(), 0, strLen);
151 if (str)
152 {
153 DWORD strLen2 = strLen;
154
155 ret = pCryptBinaryToStringA(tests[i].toEncode, tests[i].toEncodeLen,
156 CRYPT_STRING_BINARY, str, &strLen2);
157 ok(strLen == strLen2, "Expected length %d, got %d\n", strLen,
158 strLen2);
159 ok(!memcmp(str, tests[i].toEncode, tests[i].toEncodeLen),
160 "Unexpected value\n");
161 HeapFree(GetProcessHeap(), 0, str);
162 }
163 encodeAndCompareBase64_A(tests[i].toEncode, tests[i].toEncodeLen,
164 CRYPT_STRING_BASE64, tests[i].base64, NULL, NULL);
165 encodeAndCompareBase64_A(tests[i].toEncode, tests[i].toEncodeLen,
166 CRYPT_STRING_BASE64HEADER, tests[i].base64, CERT_HEADER,
167 CERT_TRAILER);
168 encodeAndCompareBase64_A(tests[i].toEncode, tests[i].toEncodeLen,
169 CRYPT_STRING_BASE64REQUESTHEADER, tests[i].base64,
170 CERT_REQUEST_HEADER, CERT_REQUEST_TRAILER);
171 encodeAndCompareBase64_A(tests[i].toEncode, tests[i].toEncodeLen,
172 CRYPT_STRING_BASE64X509CRLHEADER, tests[i].base64, X509_HEADER,
173 X509_TRAILER);
174 }
175 for (i = 0; i < sizeof(testsNoCR) / sizeof(testsNoCR[0]); i++)
176 {
177 DWORD strLen = 0;
178 LPSTR str = NULL;
179 BOOL ret;
180
181 ret = pCryptBinaryToStringA(testsNoCR[i].toEncode,
182 testsNoCR[i].toEncodeLen, CRYPT_STRING_BINARY | CRYPT_STRING_NOCR,
183 NULL, &strLen);
184 ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError());
185 str = HeapAlloc(GetProcessHeap(), 0, strLen);
186 if (str)
187 {
188 DWORD strLen2 = strLen;
189
190 ret = pCryptBinaryToStringA(testsNoCR[i].toEncode,
191 testsNoCR[i].toEncodeLen, CRYPT_STRING_BINARY | CRYPT_STRING_NOCR,
192 str, &strLen2);
193 ok(strLen == strLen2, "Expected length %d, got %d\n", strLen,
194 strLen2);
195 ok(!memcmp(str, testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen),
196 "Unexpected value\n");
197 HeapFree(GetProcessHeap(), 0, str);
198 }
199 encodeAndCompareBase64_A(testsNoCR[i].toEncode,
200 testsNoCR[i].toEncodeLen, CRYPT_STRING_BASE64 | CRYPT_STRING_NOCR,
201 testsNoCR[i].base64, NULL, NULL);
202 encodeAndCompareBase64_A(testsNoCR[i].toEncode,
203 testsNoCR[i].toEncodeLen,
204 CRYPT_STRING_BASE64HEADER | CRYPT_STRING_NOCR, testsNoCR[i].base64,
205 CERT_HEADER_NOCR, CERT_TRAILER_NOCR);
206 encodeAndCompareBase64_A(testsNoCR[i].toEncode,
207 testsNoCR[i].toEncodeLen,
208 CRYPT_STRING_BASE64REQUESTHEADER | CRYPT_STRING_NOCR,
209 testsNoCR[i].base64, CERT_REQUEST_HEADER_NOCR,
210 CERT_REQUEST_TRAILER_NOCR);
211 encodeAndCompareBase64_A(testsNoCR[i].toEncode,
212 testsNoCR[i].toEncodeLen,
213 CRYPT_STRING_BASE64X509CRLHEADER | CRYPT_STRING_NOCR,
214 testsNoCR[i].base64, X509_HEADER_NOCR, X509_TRAILER_NOCR);
215 }
216 }
217
218 static void decodeAndCompareBase64_A(LPCSTR toDecode, LPCSTR header,
219 LPCSTR trailer, DWORD useFormat, DWORD expectedFormat, const BYTE *expected,
220 DWORD expectedLen)
221 {
222 static const char garbage[] = "garbage\r\n";
223 LPSTR str;
224 DWORD len = strlen(toDecode) + strlen(garbage) + 1;
225
226 if (header)
227 len += strlen(header);
228 if (trailer)
229 len += strlen(trailer);
230 str = HeapAlloc(GetProcessHeap(), 0, len);
231 if (str)
232 {
233 LPBYTE buf;
234 DWORD bufLen = 0;
235 BOOL ret;
236
237 if (header)
238 strcpy(str, header);
239 else
240 *str = 0;
241 strcat(str, toDecode);
242 if (trailer)
243 strcat(str, trailer);
244 ret = pCryptStringToBinaryA(str, 0, useFormat, NULL, &bufLen, NULL,
245 NULL);
246 ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError());
247 buf = HeapAlloc(GetProcessHeap(), 0, bufLen);
248 if (buf)
249 {
250 DWORD skipped, usedFormat;
251
252 /* check as normal, make sure last two parameters are optional */
253 ret = pCryptStringToBinaryA(str, 0, useFormat, buf, &bufLen, NULL,
254 NULL);
255 ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError());
256 ok(bufLen == expectedLen,
257 "Expected length %d, got %d\n", expectedLen, bufLen);
258 ok(!memcmp(buf, expected, bufLen), "Unexpected value\n");
259 /* check last two params */
260 ret = pCryptStringToBinaryA(str, 0, useFormat, buf, &bufLen,
261 &skipped, &usedFormat);
262 ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError());
263 ok(skipped == 0, "Expected skipped 0, got %d\n", skipped);
264 ok(usedFormat == expectedFormat, "Expected format %d, got %d\n",
265 expectedFormat, usedFormat);
266 HeapFree(GetProcessHeap(), 0, buf);
267 }
268
269 /* Check again, but with garbage up front */
270 strcpy(str, garbage);
271 if (header)
272 strcat(str, header);
273 strcat(str, toDecode);
274 if (trailer)
275 strcat(str, trailer);
276 ret = pCryptStringToBinaryA(str, 0, useFormat, NULL, &bufLen, NULL,
277 NULL);
278 /* expect failure with no header, and success with one */
279 if (header)
280 ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError());
281 else
282 ok(!ret && GetLastError() == ERROR_INVALID_DATA,
283 "Expected !ret and last error ERROR_INVALID_DATA, got ret=%d, error=%d\n", ret, GetLastError());
284 if (ret)
285 {
286 buf = HeapAlloc(GetProcessHeap(), 0, bufLen);
287 if (buf)
288 {
289 DWORD skipped, usedFormat;
290
291 ret = pCryptStringToBinaryA(str, 0, useFormat, buf, &bufLen,
292 &skipped, &usedFormat);
293 ok(skipped == strlen(garbage),
294 "Expected %d characters of \"%s\" skipped when trying format %08x, got %d (used format is %08x)\n",
295 lstrlenA(garbage), str, useFormat, skipped, usedFormat);
296 HeapFree(GetProcessHeap(), 0, buf);
297 }
298 }
299 HeapFree(GetProcessHeap(), 0, str);
300 }
301 }
302
303 struct BadString
304 {
305 const char *str;
306 DWORD format;
307 };
308
309 struct BadString badStrings[] = {
310 { "A\r\nA\r\n=\r\n=\r\n", CRYPT_STRING_BASE64 },
311 { "AA\r\n=\r\n=\r\n", CRYPT_STRING_BASE64 },
312 { "AA=\r\n=\r\n", CRYPT_STRING_BASE64 },
313 { "-----BEGIN X509 CRL-----\r\nAA==\r\n", CRYPT_STRING_BASE64X509CRLHEADER },
314 };
315
316 static void testStringToBinaryA(void)
317 {
318 BOOL ret;
319 DWORD bufLen = 0, i;
320
321 ret = pCryptStringToBinaryA(NULL, 0, 0, NULL, NULL, NULL, NULL);
322 ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
323 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
324 ret = pCryptStringToBinaryA(NULL, 0, 0, NULL, &bufLen, NULL, NULL);
325 ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
326 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
327 /* Bogus format */
328 ret = pCryptStringToBinaryA(tests[0].base64, 0, 0, NULL, &bufLen, NULL,
329 NULL);
330 ok(!ret && GetLastError() == ERROR_INVALID_DATA,
331 "Expected ERROR_INVALID_DATA, got %d\n", GetLastError());
332 /* Decoding doesn't expect the NOCR flag to be specified */
333 ret = pCryptStringToBinaryA(tests[0].base64, 1,
334 CRYPT_STRING_BASE64 | CRYPT_STRING_NOCR, NULL, &bufLen, NULL, NULL);
335 ok(!ret && GetLastError() == ERROR_INVALID_DATA,
336 "Expected ERROR_INVALID_DATA, got %d\n", GetLastError());
337 /* Bad strings */
338 for (i = 0; i < sizeof(badStrings) / sizeof(badStrings[0]); i++)
339 {
340 bufLen = 0;
341 ret = pCryptStringToBinaryA(badStrings[i].str, 0, badStrings[i].format,
342 NULL, &bufLen, NULL, NULL);
343 ok(!ret && GetLastError() == ERROR_INVALID_DATA,
344 "Expected ERROR_INVALID_DATA, got %d\n", GetLastError());
345 }
346 /* Good strings */
347 for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
348 {
349 bufLen = 0;
350 /* Bogus length--oddly enough, that succeeds, even though it's not
351 * properly padded.
352 */
353 ret = pCryptStringToBinaryA(tests[i].base64, 1, CRYPT_STRING_BASE64,
354 NULL, &bufLen, NULL, NULL);
355 todo_wine ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError());
356 /* Check with the precise format */
357 decodeAndCompareBase64_A(tests[i].base64, NULL, NULL,
358 CRYPT_STRING_BASE64, CRYPT_STRING_BASE64, tests[i].toEncode,
359 tests[i].toEncodeLen);
360 decodeAndCompareBase64_A(tests[i].base64, CERT_HEADER, CERT_TRAILER,
361 CRYPT_STRING_BASE64HEADER, CRYPT_STRING_BASE64HEADER,
362 tests[i].toEncode, tests[i].toEncodeLen);
363 decodeAndCompareBase64_A(tests[i].base64, CERT_REQUEST_HEADER,
364 CERT_REQUEST_TRAILER, CRYPT_STRING_BASE64REQUESTHEADER,
365 CRYPT_STRING_BASE64REQUESTHEADER, tests[i].toEncode,
366 tests[i].toEncodeLen);
367 decodeAndCompareBase64_A(tests[i].base64, X509_HEADER, X509_TRAILER,
368 CRYPT_STRING_BASE64X509CRLHEADER, CRYPT_STRING_BASE64X509CRLHEADER,
369 tests[i].toEncode, tests[i].toEncodeLen);
370 /* And check with the "any" formats */
371 decodeAndCompareBase64_A(tests[i].base64, NULL, NULL,
372 CRYPT_STRING_BASE64_ANY, CRYPT_STRING_BASE64, tests[i].toEncode,
373 tests[i].toEncodeLen);
374 /* Don't check with no header and the string_any format, that'll
375 * always succeed.
376 */
377 decodeAndCompareBase64_A(tests[i].base64, CERT_HEADER, CERT_TRAILER,
378 CRYPT_STRING_BASE64_ANY, CRYPT_STRING_BASE64HEADER, tests[i].toEncode,
379 tests[i].toEncodeLen);
380 decodeAndCompareBase64_A(tests[i].base64, CERT_HEADER, CERT_TRAILER,
381 CRYPT_STRING_ANY, CRYPT_STRING_BASE64HEADER, tests[i].toEncode,
382 tests[i].toEncodeLen);
383 /* oddly, these seem to decode using the wrong format
384 decodeAndCompareBase64_A(tests[i].base64, CERT_REQUEST_HEADER,
385 CERT_REQUEST_TRAILER, CRYPT_STRING_BASE64_ANY,
386 CRYPT_STRING_BASE64REQUESTHEADER, tests[i].toEncode,
387 tests[i].toEncodeLen);
388 decodeAndCompareBase64_A(tests[i].base64, CERT_REQUEST_HEADER,
389 CERT_REQUEST_TRAILER, CRYPT_STRING_ANY,
390 CRYPT_STRING_BASE64REQUESTHEADER, tests[i].toEncode,
391 tests[i].toEncodeLen);
392 decodeAndCompareBase64_A(tests[i].base64, X509_HEADER, X509_TRAILER,
393 CRYPT_STRING_BASE64_ANY, CRYPT_STRING_BASE64X509CRLHEADER,
394 tests[i].toEncode, tests[i].toEncodeLen);
395 decodeAndCompareBase64_A(tests[i].base64, X509_HEADER, X509_TRAILER,
396 CRYPT_STRING_ANY, CRYPT_STRING_BASE64X509CRLHEADER, tests[i].toEncode,
397 tests[i].toEncodeLen);
398 */
399 }
400 /* And again, with no CR--decoding handles this automatically */
401 for (i = 0; i < sizeof(testsNoCR) / sizeof(testsNoCR[0]); i++)
402 {
403 bufLen = 0;
404 /* Bogus length--oddly enough, that succeeds, even though it's not
405 * properly padded.
406 */
407 ret = pCryptStringToBinaryA(testsNoCR[i].base64, 1, CRYPT_STRING_BASE64,
408 NULL, &bufLen, NULL, NULL);
409 todo_wine ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError());
410 /* Check with the precise format */
411 decodeAndCompareBase64_A(testsNoCR[i].base64, NULL, NULL,
412 CRYPT_STRING_BASE64, CRYPT_STRING_BASE64, testsNoCR[i].toEncode,
413 testsNoCR[i].toEncodeLen);
414 decodeAndCompareBase64_A(testsNoCR[i].base64, CERT_HEADER, CERT_TRAILER,
415 CRYPT_STRING_BASE64HEADER, CRYPT_STRING_BASE64HEADER,
416 testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen);
417 decodeAndCompareBase64_A(testsNoCR[i].base64, CERT_REQUEST_HEADER,
418 CERT_REQUEST_TRAILER, CRYPT_STRING_BASE64REQUESTHEADER,
419 CRYPT_STRING_BASE64REQUESTHEADER, testsNoCR[i].toEncode,
420 testsNoCR[i].toEncodeLen);
421 decodeAndCompareBase64_A(testsNoCR[i].base64, X509_HEADER, X509_TRAILER,
422 CRYPT_STRING_BASE64X509CRLHEADER, CRYPT_STRING_BASE64X509CRLHEADER,
423 testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen);
424 /* And check with the "any" formats */
425 decodeAndCompareBase64_A(testsNoCR[i].base64, NULL, NULL,
426 CRYPT_STRING_BASE64_ANY, CRYPT_STRING_BASE64, testsNoCR[i].toEncode,
427 testsNoCR[i].toEncodeLen);
428 /* Don't check with no header and the string_any format, that'll
429 * always succeed.
430 */
431 decodeAndCompareBase64_A(testsNoCR[i].base64, CERT_HEADER, CERT_TRAILER,
432 CRYPT_STRING_BASE64_ANY, CRYPT_STRING_BASE64HEADER,
433 testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen);
434 decodeAndCompareBase64_A(testsNoCR[i].base64, CERT_HEADER, CERT_TRAILER,
435 CRYPT_STRING_ANY, CRYPT_STRING_BASE64HEADER, testsNoCR[i].toEncode,
436 testsNoCR[i].toEncodeLen);
437 }
438 }
439
440 START_TEST(base64)
441 {
442 HMODULE lib = GetModuleHandleA("crypt32");
443
444 pCryptBinaryToStringA = (CryptBinaryToStringAFunc)GetProcAddress(lib,
445 "CryptBinaryToStringA");
446 pCryptStringToBinaryA = (CryptStringToBinaryAFunc)GetProcAddress(lib,
447 "CryptStringToBinaryA");
448
449 if (pCryptBinaryToStringA)
450 testBinaryToStringA();
451 else
452 skip("CryptBinaryToStringA is not available\n");
453
454 if (pCryptStringToBinaryA)
455 testStringToBinaryA();
456 else
457 skip("CryptStringToBinaryA is not available\n");
458 }
459
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.