git.oblomov.eu Git - wine/blob - dlls/crypt32/tests/base64.c

   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 static BOOL (WINAPI *pCryptBinaryToStringA)(const BYTE *pbBinary,
  44  DWORD cbBinary, DWORD dwFlags, LPSTR pszString, DWORD *pcchString);
  45 static BOOL (WINAPI *pCryptStringToBinaryA)(LPCSTR pszString,
  46  DWORD cchString, DWORD dwFlags, BYTE *pbBinary, DWORD *pcbBinary,
  47  DWORD *pdwSkip, DWORD *pdwFlags);
  48
  49 struct BinTests
  50 {
  51     const BYTE *toEncode;
  52     DWORD       toEncodeLen;
  53     const char *base64;
  54 };
  55
  56 static const BYTE toEncode1[] = { 0 };
  57 static const BYTE toEncode2[] = { 1,2 };
  58 static const BYTE toEncode3[] = { 1,2,3 };
  59 static const BYTE toEncode4[] =
  60  "abcdefghijlkmnopqrstuvwxyz01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890"
  61  "abcdefghijlkmnopqrstuvwxyz01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890"
  62  "abcdefghijlkmnopqrstuvwxyz01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890";
  63
  64 static const struct BinTests tests[] = {
  65  { toEncode1, sizeof(toEncode1), "AA==\r\n", },
  66  { toEncode2, sizeof(toEncode2), "AQI=\r\n", },
  67  /* { toEncode3, sizeof(toEncode3), "AQID\r\n", },  This test fails on Vista. */
  68  { toEncode4, sizeof(toEncode4),
  69    "YWJjZGVmZ2hpamxrbW5vcHFyc3R1dnd4eXowMTIzNDU2Nzg5MEFCQ0RFRkdISUpL\r\n"
  70    "TE1OT1BRUlNUVVZXWFlaMDEyMzQ1Njc4OTBhYmNkZWZnaGlqbGttbm9wcXJzdHV2\r\n"
  71    "d3h5ejAxMjM0NTY3ODkwQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVowMTIzNDU2\r\n"
  72    "Nzg5MGFiY2RlZmdoaWpsa21ub3BxcnN0dXZ3eHl6MDEyMzQ1Njc4OTBBQkNERUZH\r\n"
  73    "SElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0NTY3ODkwAA==\r\n" },
  74 };
  75
  76 static const struct BinTests testsNoCR[] = {
  77  { toEncode1, sizeof(toEncode1), "AA==\n", },
  78  { toEncode2, sizeof(toEncode2), "AQI=\n", },
  79  /* { toEncode3, sizeof(toEncode3), "AQID\n", },  This test fails on Vista. */
  80  { toEncode4, sizeof(toEncode4),
  81    "YWJjZGVmZ2hpamxrbW5vcHFyc3R1dnd4eXowMTIzNDU2Nzg5MEFCQ0RFRkdISUpL\n"
  82    "TE1OT1BRUlNUVVZXWFlaMDEyMzQ1Njc4OTBhYmNkZWZnaGlqbGttbm9wcXJzdHV2\n"
  83    "d3h5ejAxMjM0NTY3ODkwQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVowMTIzNDU2\n"
  84    "Nzg5MGFiY2RlZmdoaWpsa21ub3BxcnN0dXZ3eHl6MDEyMzQ1Njc4OTBBQkNERUZH\n"
  85    "SElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0NTY3ODkwAA==\n" },
  86 };
  87
  88 static void encodeAndCompareBase64_A(const BYTE *toEncode, DWORD toEncodeLen,
  89  DWORD format, const char *expected, const char *header, const char *trailer)
  90 {
  91     DWORD strLen = 0;
  92     LPSTR str = NULL;
  93     BOOL ret;
  94
  95     ret = pCryptBinaryToStringA(toEncode, toEncodeLen, format, NULL, &strLen);
  96     ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError());
  97     str = HeapAlloc(GetProcessHeap(), 0, strLen);
  98     if (str)
  99     {
 100         DWORD strLen2 = strLen;
 101         LPCSTR ptr = str;
 102
 103         ret = pCryptBinaryToStringA(toEncode, toEncodeLen, format, str,
 104          &strLen2);
 105         ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError());
 106         ok(strLen2 == strLen - 1, "Expected length %d, got %d\n",
 107          strLen - 1, strLen);
 108         if (header)
 109         {
 110             ok(!strncmp(header, ptr, strlen(header)),
 111              "Expected header %s, got %s\n", header, ptr);
 112             ptr += strlen(header);
 113         }
 114         ok(!strncmp(expected, ptr, strlen(expected)),
 115          "Expected %s, got %s\n", expected, ptr);
 116         ptr += strlen(expected);
 117         if (trailer)
 118         {
 119             ok(!strncmp(trailer, ptr, strlen(trailer)),
 120              "Expected trailer %s, got %s\n", trailer, ptr);
 121             ptr += strlen(trailer);
 122         }
 123         HeapFree(GetProcessHeap(), 0, str);
 124     }
 125 }
 126
 127 static void testBinaryToStringA(void)
 128 {
 129     BOOL ret;
 130     DWORD strLen = 0, i;
 131
 132     ret = pCryptBinaryToStringA(NULL, 0, 0, NULL, NULL);
 133     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 134      "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 135     ret = pCryptBinaryToStringA(NULL, 0, 0, NULL, &strLen);
 136     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 137      "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 138     for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
 139     {
 140         DWORD strLen = 0;
 141         LPSTR str = NULL;
 142         BOOL ret;
 143
 144         ret = pCryptBinaryToStringA(tests[i].toEncode, tests[i].toEncodeLen,
 145          CRYPT_STRING_BINARY, NULL, &strLen);
 146         ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError());
 147         str = HeapAlloc(GetProcessHeap(), 0, strLen);
 148         if (str)
 149         {
 150             DWORD strLen2 = strLen;
 151
 152             ret = pCryptBinaryToStringA(tests[i].toEncode, tests[i].toEncodeLen,
 153              CRYPT_STRING_BINARY, str, &strLen2);
 154             ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError());
 155             ok(strLen == strLen2, "Expected length %d, got %d\n", strLen,
 156              strLen2);
 157             ok(!memcmp(str, tests[i].toEncode, tests[i].toEncodeLen),
 158              "Unexpected value\n");
 159             HeapFree(GetProcessHeap(), 0, str);
 160         }
 161         encodeAndCompareBase64_A(tests[i].toEncode, tests[i].toEncodeLen,
 162          CRYPT_STRING_BASE64, tests[i].base64, NULL, NULL);
 163         encodeAndCompareBase64_A(tests[i].toEncode, tests[i].toEncodeLen,
 164          CRYPT_STRING_BASE64HEADER, tests[i].base64, CERT_HEADER,
 165          CERT_TRAILER);
 166         encodeAndCompareBase64_A(tests[i].toEncode, tests[i].toEncodeLen,
 167          CRYPT_STRING_BASE64REQUESTHEADER, tests[i].base64,
 168          CERT_REQUEST_HEADER, CERT_REQUEST_TRAILER);
 169         encodeAndCompareBase64_A(tests[i].toEncode, tests[i].toEncodeLen,
 170          CRYPT_STRING_BASE64X509CRLHEADER, tests[i].base64, X509_HEADER,
 171          X509_TRAILER);
 172     }
 173     for (i = 0; i < sizeof(testsNoCR) / sizeof(testsNoCR[0]); i++)
 174     {
 175         DWORD strLen = 0;
 176         LPSTR str = NULL;
 177         BOOL ret;
 178
 179         ret = pCryptBinaryToStringA(testsNoCR[i].toEncode,
 180          testsNoCR[i].toEncodeLen, CRYPT_STRING_BINARY | CRYPT_STRING_NOCR,
 181          NULL, &strLen);
 182         ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError());
 183         str = HeapAlloc(GetProcessHeap(), 0, strLen);
 184         if (str)
 185         {
 186             DWORD strLen2 = strLen;
 187
 188             ret = pCryptBinaryToStringA(testsNoCR[i].toEncode,
 189              testsNoCR[i].toEncodeLen, CRYPT_STRING_BINARY | CRYPT_STRING_NOCR,
 190              str, &strLen2);
 191             ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError());
 192             ok(strLen == strLen2, "Expected length %d, got %d\n", strLen,
 193              strLen2);
 194             ok(!memcmp(str, testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen),
 195              "Unexpected value\n");
 196             HeapFree(GetProcessHeap(), 0, str);
 197         }
 198         encodeAndCompareBase64_A(testsNoCR[i].toEncode,
 199          testsNoCR[i].toEncodeLen, CRYPT_STRING_BASE64 | CRYPT_STRING_NOCR,
 200          testsNoCR[i].base64, NULL, NULL);
 201         encodeAndCompareBase64_A(testsNoCR[i].toEncode,
 202          testsNoCR[i].toEncodeLen,
 203          CRYPT_STRING_BASE64HEADER | CRYPT_STRING_NOCR, testsNoCR[i].base64,
 204          CERT_HEADER_NOCR, CERT_TRAILER_NOCR);
 205         encodeAndCompareBase64_A(testsNoCR[i].toEncode,
 206          testsNoCR[i].toEncodeLen,
 207          CRYPT_STRING_BASE64REQUESTHEADER | CRYPT_STRING_NOCR,
 208          testsNoCR[i].base64, CERT_REQUEST_HEADER_NOCR,
 209          CERT_REQUEST_TRAILER_NOCR);
 210         encodeAndCompareBase64_A(testsNoCR[i].toEncode,
 211          testsNoCR[i].toEncodeLen,
 212          CRYPT_STRING_BASE64X509CRLHEADER | CRYPT_STRING_NOCR,
 213          testsNoCR[i].base64, X509_HEADER_NOCR, X509_TRAILER_NOCR);
 214     }
 215 }
 216
 217 static void decodeAndCompareBase64_A(LPCSTR toDecode, LPCSTR header,
 218  LPCSTR trailer, DWORD useFormat, DWORD expectedFormat, const BYTE *expected,
 219  DWORD expectedLen)
 220 {
 221     static const char garbage[] = "garbage\r\n";
 222     LPSTR str;
 223     DWORD len = strlen(toDecode) + strlen(garbage) + 1;
 224
 225     if (header)
 226         len += strlen(header);
 227     if (trailer)
 228         len += strlen(trailer);
 229     str = HeapAlloc(GetProcessHeap(), 0, len);
 230     if (str)
 231     {
 232         LPBYTE buf;
 233         DWORD bufLen = 0;
 234         BOOL ret;
 235
 236         if (header)
 237             strcpy(str, header);
 238         else
 239             *str = 0;
 240         strcat(str, toDecode);
 241         if (trailer)
 242             strcat(str, trailer);
 243         ret = pCryptStringToBinaryA(str, 0, useFormat, NULL, &bufLen, NULL,
 244          NULL);
 245         ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError());
 246         buf = HeapAlloc(GetProcessHeap(), 0, bufLen);
 247         if (buf)
 248         {
 249             DWORD skipped, usedFormat;
 250
 251             /* check as normal, make sure last two parameters are optional */
 252             ret = pCryptStringToBinaryA(str, 0, useFormat, buf, &bufLen, NULL,
 253              NULL);
 254             ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError());
 255             ok(bufLen == expectedLen,
 256              "Expected length %d, got %d\n", expectedLen, bufLen);
 257             ok(!memcmp(buf, expected, bufLen), "Unexpected value\n");
 258             /* check last two params */
 259             ret = pCryptStringToBinaryA(str, 0, useFormat, buf, &bufLen,
 260              &skipped, &usedFormat);
 261             ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError());
 262             ok(skipped == 0, "Expected skipped 0, got %d\n", skipped);
 263             ok(usedFormat == expectedFormat, "Expected format %d, got %d\n",
 264              expectedFormat, usedFormat);
 265             HeapFree(GetProcessHeap(), 0, buf);
 266         }
 267
 268         /* Check again, but with garbage up front */
 269         strcpy(str, garbage);
 270         if (header)
 271             strcat(str, header);
 272         strcat(str, toDecode);
 273         if (trailer)
 274             strcat(str, trailer);
 275         ret = pCryptStringToBinaryA(str, 0, useFormat, NULL, &bufLen, NULL,
 276          NULL);
 277         /* expect failure with no header, and success with one */
 278         if (header)
 279             ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError());
 280         else
 281             ok(!ret && GetLastError() == ERROR_INVALID_DATA,
 282              "Expected !ret and last error ERROR_INVALID_DATA, got ret=%d, error=%d\n", ret, GetLastError());
 283         if (ret)
 284         {
 285             buf = HeapAlloc(GetProcessHeap(), 0, bufLen);
 286             if (buf)
 287             {
 288                 DWORD skipped, usedFormat;
 289
 290                 ret = pCryptStringToBinaryA(str, 0, useFormat, buf, &bufLen,
 291                  &skipped, &usedFormat);
 292                 ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError());
 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 static const 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 = (void *)GetProcAddress(lib, "CryptBinaryToStringA");
 445     pCryptStringToBinaryA = (void *)GetProcAddress(lib, "CryptStringToBinaryA");
 446
 447     if (pCryptBinaryToStringA)
 448         testBinaryToStringA();
 449     else
 450         win_skip("CryptBinaryToStringA is not available\n");
 451
 452     if (pCryptStringToBinaryA)
 453         testStringToBinaryA();
 454     else
 455         win_skip("CryptStringToBinaryA is not available\n");
 456 }