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 ALT_CERT_HEADER           "-----BEGIN This is some arbitrary text that goes on and on-----\r\n"
  32 #define CERT_TRAILER              "-----END CERTIFICATE-----\r\n"
  33 #define ALT_CERT_TRAILER          "-----END More arbitrary text------\r\n"
  34 #define CERT_REQUEST_HEADER       "-----BEGIN NEW CERTIFICATE REQUEST-----\r\n"
  35 #define CERT_REQUEST_TRAILER      "-----END NEW CERTIFICATE REQUEST-----\r\n"
  36 #define X509_HEADER               "-----BEGIN X509 CRL-----\r\n"
  37 #define X509_TRAILER              "-----END X509 CRL-----\r\n"
  38 #define CERT_HEADER_NOCR          "-----BEGIN CERTIFICATE-----\n"
  39 #define CERT_TRAILER_NOCR         "-----END CERTIFICATE-----\n"
  40 #define CERT_REQUEST_HEADER_NOCR  "-----BEGIN NEW CERTIFICATE REQUEST-----\n"
  41 #define CERT_REQUEST_TRAILER_NOCR "-----END NEW CERTIFICATE REQUEST-----\n"
  42 #define X509_HEADER_NOCR          "-----BEGIN X509 CRL-----\n"
  43 #define X509_TRAILER_NOCR         "-----END X509 CRL-----\n"
  44
  45 static BOOL (WINAPI *pCryptBinaryToStringA)(const BYTE *pbBinary,
  46  DWORD cbBinary, DWORD dwFlags, LPSTR pszString, DWORD *pcchString);
  47 static BOOL (WINAPI *pCryptStringToBinaryA)(LPCSTR pszString,
  48  DWORD cchString, DWORD dwFlags, BYTE *pbBinary, DWORD *pcbBinary,
  49  DWORD *pdwSkip, DWORD *pdwFlags);
  50
  51 struct BinTests
  52 {
  53     const BYTE *toEncode;
  54     DWORD       toEncodeLen;
  55     const char *base64;
  56 };
  57
  58 static const BYTE toEncode1[] = { 0 };
  59 static const BYTE toEncode2[] = { 1,2 };
  60 static const BYTE toEncode3[] = { 1,2,3 };
  61 static const BYTE toEncode4[] =
  62  "abcdefghijlkmnopqrstuvwxyz01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890"
  63  "abcdefghijlkmnopqrstuvwxyz01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890"
  64  "abcdefghijlkmnopqrstuvwxyz01234567890ABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890";
  65
  66 static const struct BinTests tests[] = {
  67  { toEncode1, sizeof(toEncode1), "AA==\r\n", },
  68  { toEncode2, sizeof(toEncode2), "AQI=\r\n", },
  69  /* { toEncode3, sizeof(toEncode3), "AQID\r\n", },  This test fails on Vista. */
  70  { toEncode4, sizeof(toEncode4),
  71    "YWJjZGVmZ2hpamxrbW5vcHFyc3R1dnd4eXowMTIzNDU2Nzg5MEFCQ0RFRkdISUpL\r\n"
  72    "TE1OT1BRUlNUVVZXWFlaMDEyMzQ1Njc4OTBhYmNkZWZnaGlqbGttbm9wcXJzdHV2\r\n"
  73    "d3h5ejAxMjM0NTY3ODkwQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVowMTIzNDU2\r\n"
  74    "Nzg5MGFiY2RlZmdoaWpsa21ub3BxcnN0dXZ3eHl6MDEyMzQ1Njc4OTBBQkNERUZH\r\n"
  75    "SElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0NTY3ODkwAA==\r\n" },
  76 };
  77
  78 static const struct BinTests testsNoCR[] = {
  79  { toEncode1, sizeof(toEncode1), "AA==\n", },
  80  { toEncode2, sizeof(toEncode2), "AQI=\n", },
  81  /* { toEncode3, sizeof(toEncode3), "AQID\n", },  This test fails on Vista. */
  82  { toEncode4, sizeof(toEncode4),
  83    "YWJjZGVmZ2hpamxrbW5vcHFyc3R1dnd4eXowMTIzNDU2Nzg5MEFCQ0RFRkdISUpL\n"
  84    "TE1OT1BRUlNUVVZXWFlaMDEyMzQ1Njc4OTBhYmNkZWZnaGlqbGttbm9wcXJzdHV2\n"
  85    "d3h5ejAxMjM0NTY3ODkwQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVowMTIzNDU2\n"
  86    "Nzg5MGFiY2RlZmdoaWpsa21ub3BxcnN0dXZ3eHl6MDEyMzQ1Njc4OTBBQkNERUZH\n"
  87    "SElKS0xNTk9QUVJTVFVWV1hZWjAxMjM0NTY3ODkwAA==\n" },
  88 };
  89
  90 static void encodeAndCompareBase64_A(const BYTE *toEncode, DWORD toEncodeLen,
  91  DWORD format, const char *expected, const char *header, const char *trailer)
  92 {
  93     DWORD strLen = 0;
  94     LPSTR str = NULL;
  95     BOOL ret;
  96
  97     ret = pCryptBinaryToStringA(toEncode, toEncodeLen, format, NULL, &strLen);
  98     ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError());
  99     str = HeapAlloc(GetProcessHeap(), 0, strLen);
 100     if (str)
 101     {
 102         DWORD strLen2 = strLen;
 103         LPCSTR ptr = str;
 104
 105         ret = pCryptBinaryToStringA(toEncode, toEncodeLen, format, str,
 106          &strLen2);
 107         ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError());
 108         ok(strLen2 == strLen - 1, "Expected length %d, got %d\n",
 109          strLen - 1, strLen);
 110         if (header)
 111         {
 112             ok(!strncmp(header, ptr, strlen(header)),
 113              "Expected header %s, got %s\n", header, ptr);
 114             ptr += strlen(header);
 115         }
 116         ok(!strncmp(expected, ptr, strlen(expected)),
 117          "Expected %s, got %s\n", expected, ptr);
 118         ptr += strlen(expected);
 119         if (trailer)
 120         {
 121             ok(!strncmp(trailer, ptr, strlen(trailer)),
 122              "Expected trailer %s, got %s\n", trailer, ptr);
 123             ptr += strlen(trailer);
 124         }
 125         HeapFree(GetProcessHeap(), 0, str);
 126     }
 127 }
 128
 129 static void testBinaryToStringA(void)
 130 {
 131     BOOL ret;
 132     DWORD strLen = 0, i;
 133
 134     ret = pCryptBinaryToStringA(NULL, 0, 0, NULL, NULL);
 135     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 136      "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 137     ret = pCryptBinaryToStringA(NULL, 0, 0, NULL, &strLen);
 138     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 139      "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 140     for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
 141     {
 142         DWORD strLen = 0;
 143         LPSTR str = NULL;
 144         BOOL ret;
 145
 146         ret = pCryptBinaryToStringA(tests[i].toEncode, tests[i].toEncodeLen,
 147          CRYPT_STRING_BINARY, NULL, &strLen);
 148         ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError());
 149         str = HeapAlloc(GetProcessHeap(), 0, strLen);
 150         if (str)
 151         {
 152             DWORD strLen2 = strLen;
 153
 154             ret = pCryptBinaryToStringA(tests[i].toEncode, tests[i].toEncodeLen,
 155              CRYPT_STRING_BINARY, str, &strLen2);
 156             ok(ret, "CryptBinaryToStringA failed: %d\n", GetLastError());
 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(ret, "CryptBinaryToStringA failed: %d\n", GetLastError());
 194             ok(strLen == strLen2, "Expected length %d, got %d\n", strLen,
 195              strLen2);
 196             ok(!memcmp(str, testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen),
 197              "Unexpected value\n");
 198             HeapFree(GetProcessHeap(), 0, str);
 199         }
 200         encodeAndCompareBase64_A(testsNoCR[i].toEncode,
 201          testsNoCR[i].toEncodeLen, CRYPT_STRING_BASE64 | CRYPT_STRING_NOCR,
 202          testsNoCR[i].base64, NULL, NULL);
 203         encodeAndCompareBase64_A(testsNoCR[i].toEncode,
 204          testsNoCR[i].toEncodeLen,
 205          CRYPT_STRING_BASE64HEADER | CRYPT_STRING_NOCR, testsNoCR[i].base64,
 206          CERT_HEADER_NOCR, CERT_TRAILER_NOCR);
 207         encodeAndCompareBase64_A(testsNoCR[i].toEncode,
 208          testsNoCR[i].toEncodeLen,
 209          CRYPT_STRING_BASE64REQUESTHEADER | CRYPT_STRING_NOCR,
 210          testsNoCR[i].base64, CERT_REQUEST_HEADER_NOCR,
 211          CERT_REQUEST_TRAILER_NOCR);
 212         encodeAndCompareBase64_A(testsNoCR[i].toEncode,
 213          testsNoCR[i].toEncodeLen,
 214          CRYPT_STRING_BASE64X509CRLHEADER | CRYPT_STRING_NOCR,
 215          testsNoCR[i].base64, X509_HEADER_NOCR, X509_TRAILER_NOCR);
 216     }
 217 }
 218
 219 static void decodeAndCompareBase64_A(LPCSTR toDecode, LPCSTR header,
 220  LPCSTR trailer, DWORD useFormat, DWORD expectedFormat, const BYTE *expected,
 221  DWORD expectedLen)
 222 {
 223     static const char garbage[] = "garbage\r\n";
 224     LPSTR str;
 225     DWORD len = strlen(toDecode) + strlen(garbage) + 1;
 226
 227     if (header)
 228         len += strlen(header);
 229     if (trailer)
 230         len += strlen(trailer);
 231     str = HeapAlloc(GetProcessHeap(), 0, len);
 232     if (str)
 233     {
 234         LPBYTE buf;
 235         DWORD bufLen = 0;
 236         BOOL ret;
 237
 238         if (header)
 239             strcpy(str, header);
 240         else
 241             *str = 0;
 242         strcat(str, toDecode);
 243         if (trailer)
 244             strcat(str, trailer);
 245         ret = pCryptStringToBinaryA(str, 0, useFormat, NULL, &bufLen, NULL,
 246          NULL);
 247         ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError());
 248         buf = HeapAlloc(GetProcessHeap(), 0, bufLen);
 249         if (buf)
 250         {
 251             DWORD skipped, usedFormat;
 252
 253             /* check as normal, make sure last two parameters are optional */
 254             ret = pCryptStringToBinaryA(str, 0, useFormat, buf, &bufLen, NULL,
 255              NULL);
 256             ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError());
 257             ok(bufLen == expectedLen,
 258              "Expected length %d, got %d\n", expectedLen, bufLen);
 259             ok(!memcmp(buf, expected, bufLen), "Unexpected value\n");
 260             /* check last two params */
 261             ret = pCryptStringToBinaryA(str, 0, useFormat, buf, &bufLen,
 262              &skipped, &usedFormat);
 263             ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError());
 264             ok(skipped == 0, "Expected skipped 0, got %d\n", skipped);
 265             ok(usedFormat == expectedFormat, "Expected format %d, got %d\n",
 266              expectedFormat, usedFormat);
 267             HeapFree(GetProcessHeap(), 0, buf);
 268         }
 269
 270         /* Check again, but with garbage up front */
 271         strcpy(str, garbage);
 272         if (header)
 273             strcat(str, header);
 274         strcat(str, toDecode);
 275         if (trailer)
 276             strcat(str, trailer);
 277         ret = pCryptStringToBinaryA(str, 0, useFormat, NULL, &bufLen, NULL,
 278          NULL);
 279         /* expect failure with no header, and success with one */
 280         if (header)
 281             ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError());
 282         else
 283             ok(!ret && GetLastError() == ERROR_INVALID_DATA,
 284              "Expected !ret and last error ERROR_INVALID_DATA, got ret=%d, error=%d\n", ret, GetLastError());
 285         if (ret)
 286         {
 287             buf = HeapAlloc(GetProcessHeap(), 0, bufLen);
 288             if (buf)
 289             {
 290                 DWORD skipped, usedFormat;
 291
 292                 ret = pCryptStringToBinaryA(str, 0, useFormat, buf, &bufLen,
 293                  &skipped, &usedFormat);
 294                 ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError());
 295                 ok(skipped == strlen(garbage),
 296                  "Expected %d characters of \"%s\" skipped when trying format %08x, got %d (used format is %08x)\n",
 297                  lstrlenA(garbage), str, useFormat, skipped, usedFormat);
 298                 HeapFree(GetProcessHeap(), 0, buf);
 299             }
 300         }
 301         HeapFree(GetProcessHeap(), 0, str);
 302     }
 303 }
 304
 305 struct BadString
 306 {
 307     const char *str;
 308     DWORD       format;
 309 };
 310
 311 static const struct BadString badStrings[] = {
 312  { "A\r\nA\r\n=\r\n=\r\n", CRYPT_STRING_BASE64 },
 313  { "AA\r\n=\r\n=\r\n", CRYPT_STRING_BASE64 },
 314  { "AA=\r\n=\r\n", CRYPT_STRING_BASE64 },
 315  { "-----BEGIN X509 CRL-----\r\nAA==\r\n", CRYPT_STRING_BASE64X509CRLHEADER },
 316 };
 317
 318 static void testStringToBinaryA(void)
 319 {
 320     BOOL ret;
 321     DWORD bufLen = 0, i;
 322
 323     ret = pCryptStringToBinaryA(NULL, 0, 0, NULL, NULL, NULL, NULL);
 324     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 325      "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 326     ret = pCryptStringToBinaryA(NULL, 0, 0, NULL, &bufLen, NULL, NULL);
 327     ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER,
 328      "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 329     /* Bogus format */
 330     ret = pCryptStringToBinaryA(tests[0].base64, 0, 0, NULL, &bufLen, NULL,
 331      NULL);
 332     ok(!ret && GetLastError() == ERROR_INVALID_DATA,
 333      "Expected ERROR_INVALID_DATA, got %d\n", GetLastError());
 334     /* Decoding doesn't expect the NOCR flag to be specified */
 335     ret = pCryptStringToBinaryA(tests[0].base64, 1,
 336      CRYPT_STRING_BASE64 | CRYPT_STRING_NOCR, NULL, &bufLen, NULL, NULL);
 337     ok(!ret && GetLastError() == ERROR_INVALID_DATA,
 338      "Expected ERROR_INVALID_DATA, got %d\n", GetLastError());
 339     /* Bad strings */
 340     for (i = 0; i < sizeof(badStrings) / sizeof(badStrings[0]); i++)
 341     {
 342         bufLen = 0;
 343         ret = pCryptStringToBinaryA(badStrings[i].str, 0, badStrings[i].format,
 344          NULL, &bufLen, NULL, NULL);
 345         ok(!ret && GetLastError() == ERROR_INVALID_DATA,
 346          "Expected ERROR_INVALID_DATA, got %d\n", GetLastError());
 347     }
 348     /* Good strings */
 349     for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++)
 350     {
 351         bufLen = 0;
 352         /* Bogus length--oddly enough, that succeeds, even though it's not
 353          * properly padded.
 354          */
 355         ret = pCryptStringToBinaryA(tests[i].base64, 1, CRYPT_STRING_BASE64,
 356          NULL, &bufLen, NULL, NULL);
 357         todo_wine ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError());
 358         /* Check with the precise format */
 359         decodeAndCompareBase64_A(tests[i].base64, NULL, NULL,
 360          CRYPT_STRING_BASE64, CRYPT_STRING_BASE64, tests[i].toEncode,
 361          tests[i].toEncodeLen);
 362         decodeAndCompareBase64_A(tests[i].base64, CERT_HEADER, CERT_TRAILER,
 363          CRYPT_STRING_BASE64HEADER, CRYPT_STRING_BASE64HEADER,
 364          tests[i].toEncode, tests[i].toEncodeLen);
 365         decodeAndCompareBase64_A(tests[i].base64, ALT_CERT_HEADER, ALT_CERT_TRAILER,
 366          CRYPT_STRING_BASE64HEADER, CRYPT_STRING_BASE64HEADER,
 367          tests[i].toEncode, tests[i].toEncodeLen);
 368         decodeAndCompareBase64_A(tests[i].base64, CERT_REQUEST_HEADER,
 369          CERT_REQUEST_TRAILER, CRYPT_STRING_BASE64REQUESTHEADER,
 370          CRYPT_STRING_BASE64REQUESTHEADER, tests[i].toEncode,
 371          tests[i].toEncodeLen);
 372         decodeAndCompareBase64_A(tests[i].base64, X509_HEADER, X509_TRAILER,
 373          CRYPT_STRING_BASE64X509CRLHEADER, CRYPT_STRING_BASE64X509CRLHEADER,
 374          tests[i].toEncode, tests[i].toEncodeLen);
 375         /* And check with the "any" formats */
 376         decodeAndCompareBase64_A(tests[i].base64, NULL, NULL,
 377          CRYPT_STRING_BASE64_ANY, CRYPT_STRING_BASE64, tests[i].toEncode,
 378          tests[i].toEncodeLen);
 379         /* Don't check with no header and the string_any format, that'll
 380          * always succeed.
 381          */
 382         decodeAndCompareBase64_A(tests[i].base64, CERT_HEADER, CERT_TRAILER,
 383          CRYPT_STRING_BASE64_ANY, CRYPT_STRING_BASE64HEADER, tests[i].toEncode,
 384          tests[i].toEncodeLen);
 385         decodeAndCompareBase64_A(tests[i].base64, CERT_HEADER, CERT_TRAILER,
 386          CRYPT_STRING_ANY, CRYPT_STRING_BASE64HEADER, tests[i].toEncode,
 387          tests[i].toEncodeLen);
 388         /* oddly, these seem to decode using the wrong format
 389         decodeAndCompareBase64_A(tests[i].base64, CERT_REQUEST_HEADER,
 390          CERT_REQUEST_TRAILER, CRYPT_STRING_BASE64_ANY,
 391          CRYPT_STRING_BASE64REQUESTHEADER, tests[i].toEncode,
 392          tests[i].toEncodeLen);
 393         decodeAndCompareBase64_A(tests[i].base64, CERT_REQUEST_HEADER,
 394          CERT_REQUEST_TRAILER, CRYPT_STRING_ANY,
 395          CRYPT_STRING_BASE64REQUESTHEADER, tests[i].toEncode,
 396          tests[i].toEncodeLen);
 397         decodeAndCompareBase64_A(tests[i].base64, X509_HEADER, X509_TRAILER,
 398          CRYPT_STRING_BASE64_ANY, CRYPT_STRING_BASE64X509CRLHEADER,
 399          tests[i].toEncode, tests[i].toEncodeLen);
 400         decodeAndCompareBase64_A(tests[i].base64, X509_HEADER, X509_TRAILER,
 401          CRYPT_STRING_ANY, CRYPT_STRING_BASE64X509CRLHEADER, tests[i].toEncode,
 402          tests[i].toEncodeLen);
 403          */
 404     }
 405     /* And again, with no CR--decoding handles this automatically */
 406     for (i = 0; i < sizeof(testsNoCR) / sizeof(testsNoCR[0]); i++)
 407     {
 408         bufLen = 0;
 409         /* Bogus length--oddly enough, that succeeds, even though it's not
 410          * properly padded.
 411          */
 412         ret = pCryptStringToBinaryA(testsNoCR[i].base64, 1, CRYPT_STRING_BASE64,
 413          NULL, &bufLen, NULL, NULL);
 414         todo_wine ok(ret, "CryptStringToBinaryA failed: %d\n", GetLastError());
 415         /* Check with the precise format */
 416         decodeAndCompareBase64_A(testsNoCR[i].base64, NULL, NULL,
 417          CRYPT_STRING_BASE64, CRYPT_STRING_BASE64, testsNoCR[i].toEncode,
 418          testsNoCR[i].toEncodeLen);
 419         decodeAndCompareBase64_A(testsNoCR[i].base64, CERT_HEADER, CERT_TRAILER,
 420          CRYPT_STRING_BASE64HEADER, CRYPT_STRING_BASE64HEADER,
 421          testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen);
 422         decodeAndCompareBase64_A(testsNoCR[i].base64, CERT_REQUEST_HEADER,
 423          CERT_REQUEST_TRAILER, CRYPT_STRING_BASE64REQUESTHEADER,
 424          CRYPT_STRING_BASE64REQUESTHEADER, testsNoCR[i].toEncode,
 425          testsNoCR[i].toEncodeLen);
 426         decodeAndCompareBase64_A(testsNoCR[i].base64, X509_HEADER, X509_TRAILER,
 427          CRYPT_STRING_BASE64X509CRLHEADER, CRYPT_STRING_BASE64X509CRLHEADER,
 428          testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen);
 429         /* And check with the "any" formats */
 430         decodeAndCompareBase64_A(testsNoCR[i].base64, NULL, NULL,
 431          CRYPT_STRING_BASE64_ANY, CRYPT_STRING_BASE64, testsNoCR[i].toEncode,
 432          testsNoCR[i].toEncodeLen);
 433         /* Don't check with no header and the string_any format, that'll
 434          * always succeed.
 435          */
 436         decodeAndCompareBase64_A(testsNoCR[i].base64, CERT_HEADER, CERT_TRAILER,
 437          CRYPT_STRING_BASE64_ANY, CRYPT_STRING_BASE64HEADER,
 438          testsNoCR[i].toEncode, testsNoCR[i].toEncodeLen);
 439         decodeAndCompareBase64_A(testsNoCR[i].base64, CERT_HEADER, CERT_TRAILER,
 440          CRYPT_STRING_ANY, CRYPT_STRING_BASE64HEADER, testsNoCR[i].toEncode,
 441          testsNoCR[i].toEncodeLen);
 442     }
 443 }
 444
 445 START_TEST(base64)
 446 {
 447     HMODULE lib = GetModuleHandleA("crypt32");
 448
 449     pCryptBinaryToStringA = (void *)GetProcAddress(lib, "CryptBinaryToStringA");
 450     pCryptStringToBinaryA = (void *)GetProcAddress(lib, "CryptStringToBinaryA");
 451
 452     if (pCryptBinaryToStringA)
 453         testBinaryToStringA();
 454     else
 455         win_skip("CryptBinaryToStringA is not available\n");
 456
 457     if (pCryptStringToBinaryA)
 458         testStringToBinaryA();
 459     else
 460         win_skip("CryptStringToBinaryA is not available\n");
 461 }