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

   1 /*
   2  * base64 encoder/decoder
   3  *
   4  * Copyright 2005 by Kai Blin
   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
  22 #include <stdarg.h>
  23 #include "windef.h"
  24 #include "winbase.h"
  25 #include "winerror.h"
  26 #include "wincrypt.h"
  27 #include "wine/debug.h"
  28 #include "wine/unicode.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
  31
  32 #define CERT_HEADER          "-----BEGIN CERTIFICATE-----"
  33 #define CERT_TRAILER         "-----END CERTIFICATE-----"
  34 #define CERT_REQUEST_HEADER  "-----BEGIN NEW CERTIFICATE REQUEST-----"
  35 #define CERT_REQUEST_TRAILER "-----END NEW CERTIFICATE REQUEST-----"
  36 #define X509_HEADER          "-----BEGIN X509 CRL-----"
  37 #define X509_TRAILER         "-----END X509 CRL-----"
  38
  39 static const WCHAR CERT_HEADER_W[] = {
  40 '-','-','-','-','-','B','E','G','I','N',' ','C','E','R','T','I','F','I','C',
  41 'A','T','E','-','-','-','-','-',0 };
  42 static const WCHAR CERT_TRAILER_W[] = {
  43 '-','-','-','-','-','E','N','D',' ','C','E','R','T','I','F','I','C','A','T',
  44 'E','-','-','-','-','-',0 };
  45 static const WCHAR CERT_REQUEST_HEADER_W[] = {
  46 '-','-','-','-','-','B','E','G','I','N',' ','N','E','W',' ','C','E','R','T',
  47 'I','F','I','C','A','T','E','R','E','Q','U','E','S','T','-','-','-','-','-',0 };
  48 static const WCHAR CERT_REQUEST_TRAILER_W[] = {
  49 '-','-','-','-','-','E','N','D',' ','N','E','W',' ','C','E','R','T','I','F',
  50 'I','C','A','T','E','R','E','Q','U','E','S','T','-','-','-','-','-',0 };
  51 static const WCHAR X509_HEADER_W[] = {
  52 '-','-','-','-','-','B','E','G','I','N',' ','X','5','0','9',' ','C','R','L',
  53 '-','-','-','-','-',0 };
  54 static const WCHAR X509_TRAILER_W[] = {
  55 '-','-','-','-','-','E','N','D',' ','X','5','0','9',' ','C','R','L','-','-',
  56 '-','-','-',0 };
  57
  58 static const char b64[] =
  59 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
  60
  61 typedef BOOL (*BinaryToStringAFunc)(const BYTE *pbBinary,
  62  DWORD cbBinary, DWORD dwFlags, LPSTR pszString, DWORD *pcchString);
  63 typedef BOOL (*BinaryToStringWFunc)(const BYTE *pbBinary,
  64  DWORD cbBinary, DWORD dwFlags, LPWSTR pszString, DWORD *pcchString);
  65
  66 static BOOL EncodeBinaryToBinaryA(const BYTE *pbBinary,
  67  DWORD cbBinary, DWORD dwFlags, LPSTR pszString, DWORD *pcchString)
  68 {
  69     BOOL ret = TRUE;
  70
  71     if (*pcchString < cbBinary)
  72     {
  73         if (!pszString)
  74             *pcchString = cbBinary;
  75         else
  76         {
  77             SetLastError(ERROR_INSUFFICIENT_BUFFER);
  78             *pcchString = cbBinary;
  79             ret = FALSE;
  80         }
  81     }
  82     else
  83     {
  84         if (cbBinary)
  85             memcpy(pszString, pbBinary, cbBinary);
  86         *pcchString = cbBinary;
  87     }
  88     return ret;
  89 }
  90
  91 static LONG encodeBase64A(const BYTE *in_buf, int in_len, LPCSTR sep,
  92  char* out_buf, DWORD *out_len)
  93 {
  94     int div, i;
  95     const BYTE *d = in_buf;
  96     int bytes = (in_len*8 + 5)/6, pad_bytes = (bytes % 4) ? 4 - (bytes % 4) : 0;
  97     DWORD needed;
  98     LPSTR ptr;
  99
 100     TRACE("bytes is %d, pad bytes is %d\n", bytes, pad_bytes);
 101     needed = bytes + pad_bytes + 1;
 102     needed += (needed / 64 + 1) * strlen(sep);
 103
 104     if (needed > *out_len)
 105     {
 106         *out_len = needed;
 107         return ERROR_INSUFFICIENT_BUFFER;
 108     }
 109     else
 110         *out_len = needed;
 111
 112     /* Three bytes of input give 4 chars of output */
 113     div = in_len / 3;
 114
 115     ptr = out_buf;
 116     i = 0;
 117     while (div > 0)
 118     {
 119         if (i && i % 64 == 0)
 120         {
 121             strcpy(ptr, sep);
 122             ptr += strlen(sep);
 123         }
 124         /* first char is the first 6 bits of the first byte*/
 125         *ptr++ = b64[ ( d[0] >> 2) & 0x3f ];
 126         /* second char is the last 2 bits of the first byte and the first 4
 127          * bits of the second byte */
 128         *ptr++ = b64[ ((d[0] << 4) & 0x30) | (d[1] >> 4 & 0x0f)];
 129         /* third char is the last 4 bits of the second byte and the first 2
 130          * bits of the third byte */
 131         *ptr++ = b64[ ((d[1] << 2) & 0x3c) | (d[2] >> 6 & 0x03)];
 132         /* fourth char is the remaining 6 bits of the third byte */
 133         *ptr++ = b64[   d[2]       & 0x3f];
 134         i += 4;
 135         d += 3;
 136         div--;
 137     }
 138
 139     switch(pad_bytes)
 140     {
 141         case 1:
 142             /* first char is the first 6 bits of the first byte*/
 143             *ptr++ = b64[ ( d[0] >> 2) & 0x3f ];
 144             /* second char is the last 2 bits of the first byte and the first 4
 145              * bits of the second byte */
 146             *ptr++ = b64[ ((d[0] << 4) & 0x30) | (d[1] >> 4 & 0x0f)];
 147             /* third char is the last 4 bits of the second byte padded with
 148              * two zeroes */
 149             *ptr++ = b64[ ((d[1] << 2) & 0x3c) ];
 150             /* fourth char is a = to indicate one byte of padding */
 151             *ptr++ = '=';
 152             break;
 153         case 2:
 154             /* first char is the first 6 bits of the first byte*/
 155             *ptr++ = b64[ ( d[0] >> 2) & 0x3f ];
 156             /* second char is the last 2 bits of the first byte padded with
 157              * four zeroes*/
 158             *ptr++ = b64[ ((d[0] << 4) & 0x30)];
 159             /* third char is = to indicate padding */
 160             *ptr++ = '=';
 161             /* fourth char is = to indicate padding */
 162             *ptr++ = '=';
 163             break;
 164     }
 165     strcpy(ptr, sep);
 166
 167     return ERROR_SUCCESS;
 168 }
 169
 170 static BOOL BinaryToBase64A(const BYTE *pbBinary,
 171  DWORD cbBinary, DWORD dwFlags, LPSTR pszString, DWORD *pcchString)
 172 {
 173     static const char crlf[] = "\r\n", lf[] = "\n";
 174     BOOL ret = TRUE;
 175     LPCSTR header = NULL, trailer = NULL, sep;
 176     DWORD charsNeeded;
 177
 178     if (dwFlags & CRYPT_STRING_NOCR)
 179         sep = lf;
 180     else if (dwFlags & CRYPT_STRING_NOCRLF)
 181         sep = "";
 182     else
 183         sep = crlf;
 184     switch (dwFlags & 0x0fffffff)
 185     {
 186     case CRYPT_STRING_BASE64:
 187         /* no header or footer */
 188         break;
 189     case CRYPT_STRING_BASE64HEADER:
 190         header = CERT_HEADER;
 191         trailer = CERT_TRAILER;
 192         break;
 193     case CRYPT_STRING_BASE64REQUESTHEADER:
 194         header = CERT_REQUEST_HEADER;
 195         trailer = CERT_REQUEST_TRAILER;
 196         break;
 197     case CRYPT_STRING_BASE64X509CRLHEADER:
 198         header = X509_HEADER;
 199         trailer = X509_TRAILER;
 200         break;
 201     }
 202
 203     charsNeeded = 0;
 204     encodeBase64A(pbBinary, cbBinary, sep, NULL, &charsNeeded);
 205     if (header)
 206         charsNeeded += strlen(header) + strlen(sep);
 207     if (trailer)
 208         charsNeeded += strlen(trailer) + strlen(sep);
 209     if (charsNeeded <= *pcchString)
 210     {
 211         LPSTR ptr = pszString;
 212         DWORD size = charsNeeded;
 213
 214         if (header)
 215         {
 216             strcpy(ptr, header);
 217             ptr += strlen(ptr);
 218             strcpy(ptr, sep);
 219             ptr += strlen(sep);
 220         }
 221         encodeBase64A(pbBinary, cbBinary, sep, ptr, &size);
 222         ptr += size - 1;
 223         if (trailer)
 224         {
 225             strcpy(ptr, trailer);
 226             ptr += strlen(ptr);
 227             strcpy(ptr, sep);
 228             ptr += strlen(sep);
 229         }
 230         *pcchString = charsNeeded - 1;
 231     }
 232     else if (pszString)
 233     {
 234         *pcchString = charsNeeded;
 235         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 236         ret = FALSE;
 237     }
 238     else
 239         *pcchString = charsNeeded;
 240     return ret;
 241 }
 242
 243 BOOL WINAPI CryptBinaryToStringA(const BYTE *pbBinary,
 244  DWORD cbBinary, DWORD dwFlags, LPSTR pszString, DWORD *pcchString)
 245 {
 246     BinaryToStringAFunc encoder = NULL;
 247
 248     TRACE("(%p, %d, %08x, %p, %p)\n", pbBinary, cbBinary, dwFlags, pszString,
 249      pcchString);
 250
 251     if (!pbBinary)
 252     {
 253         SetLastError(ERROR_INVALID_PARAMETER);
 254         return FALSE;
 255     }
 256     if (!pcchString)
 257     {
 258         SetLastError(ERROR_INVALID_PARAMETER);
 259         return FALSE;
 260     }
 261
 262     switch (dwFlags & 0x0fffffff)
 263     {
 264     case CRYPT_STRING_BINARY:
 265         encoder = EncodeBinaryToBinaryA;
 266         break;
 267     case CRYPT_STRING_BASE64:
 268     case CRYPT_STRING_BASE64HEADER:
 269     case CRYPT_STRING_BASE64REQUESTHEADER:
 270     case CRYPT_STRING_BASE64X509CRLHEADER:
 271         encoder = BinaryToBase64A;
 272         break;
 273     case CRYPT_STRING_HEX:
 274     case CRYPT_STRING_HEXASCII:
 275     case CRYPT_STRING_HEXADDR:
 276     case CRYPT_STRING_HEXASCIIADDR:
 277         FIXME("Unimplemented type %d\n", dwFlags & 0x0fffffff);
 278         /* fall through */
 279     default:
 280         SetLastError(ERROR_INVALID_PARAMETER);
 281         return FALSE;
 282     }
 283     return encoder(pbBinary, cbBinary, dwFlags, pszString, pcchString);
 284 }
 285
 286 static LONG encodeBase64W(const BYTE *in_buf, int in_len, LPCWSTR sep,
 287  WCHAR* out_buf, DWORD *out_len)
 288 {
 289     int div, i;
 290     const BYTE *d = in_buf;
 291     int bytes = (in_len*8 + 5)/6, pad_bytes = (bytes % 4) ? 4 - (bytes % 4) : 0;
 292     DWORD needed;
 293     LPWSTR ptr;
 294
 295     TRACE("bytes is %d, pad bytes is %d\n", bytes, pad_bytes);
 296     needed = bytes + pad_bytes + 1;
 297     needed += (needed / 64 + 1) * strlenW(sep);
 298
 299     if (needed > *out_len)
 300     {
 301         *out_len = needed;
 302         return ERROR_INSUFFICIENT_BUFFER;
 303     }
 304     else
 305         *out_len = needed;
 306
 307     /* Three bytes of input give 4 chars of output */
 308     div = in_len / 3;
 309
 310     ptr = out_buf;
 311     i = 0;
 312     while (div > 0)
 313     {
 314         if (i && i % 64 == 0)
 315         {
 316             strcpyW(ptr, sep);
 317             ptr += strlenW(sep);
 318         }
 319         /* first char is the first 6 bits of the first byte*/
 320         *ptr++ = b64[ ( d[0] >> 2) & 0x3f ];
 321         /* second char is the last 2 bits of the first byte and the first 4
 322          * bits of the second byte */
 323         *ptr++ = b64[ ((d[0] << 4) & 0x30) | (d[1] >> 4 & 0x0f)];
 324         /* third char is the last 4 bits of the second byte and the first 2
 325          * bits of the third byte */
 326         *ptr++ = b64[ ((d[1] << 2) & 0x3c) | (d[2] >> 6 & 0x03)];
 327         /* fourth char is the remaining 6 bits of the third byte */
 328         *ptr++ = b64[   d[2]       & 0x3f];
 329         i += 4;
 330         d += 3;
 331         div--;
 332     }
 333
 334     switch(pad_bytes)
 335     {
 336         case 1:
 337             /* first char is the first 6 bits of the first byte*/
 338             *ptr++ = b64[ ( d[0] >> 2) & 0x3f ];
 339             /* second char is the last 2 bits of the first byte and the first 4
 340              * bits of the second byte */
 341             *ptr++ = b64[ ((d[0] << 4) & 0x30) | (d[1] >> 4 & 0x0f)];
 342             /* third char is the last 4 bits of the second byte padded with
 343              * two zeroes */
 344             *ptr++ = b64[ ((d[1] << 2) & 0x3c) ];
 345             /* fourth char is a = to indicate one byte of padding */
 346             *ptr++ = '=';
 347             break;
 348         case 2:
 349             /* first char is the first 6 bits of the first byte*/
 350             *ptr++ = b64[ ( d[0] >> 2) & 0x3f ];
 351             /* second char is the last 2 bits of the first byte padded with
 352              * four zeroes*/
 353             *ptr++ = b64[ ((d[0] << 4) & 0x30)];
 354             /* third char is = to indicate padding */
 355             *ptr++ = '=';
 356             /* fourth char is = to indicate padding */
 357             *ptr++ = '=';
 358             break;
 359     }
 360     strcpyW(ptr, sep);
 361
 362     return ERROR_SUCCESS;
 363 }
 364
 365 static BOOL BinaryToBase64W(const BYTE *pbBinary,
 366  DWORD cbBinary, DWORD dwFlags, LPWSTR pszString, DWORD *pcchString)
 367 {
 368     static const WCHAR crlf[] = { '\r','\n',0 }, lf[] = { '\n',0 }, empty[] = {0};
 369     BOOL ret = TRUE;
 370     LPCWSTR header = NULL, trailer = NULL, sep;
 371     DWORD charsNeeded;
 372
 373     if (dwFlags & CRYPT_STRING_NOCR)
 374         sep = lf;
 375     else if (dwFlags & CRYPT_STRING_NOCRLF)
 376         sep = empty;
 377     else
 378         sep = crlf;
 379     switch (dwFlags & 0x0fffffff)
 380     {
 381     case CRYPT_STRING_BASE64:
 382         /* no header or footer */
 383         break;
 384     case CRYPT_STRING_BASE64HEADER:
 385         header = CERT_HEADER_W;
 386         trailer = CERT_TRAILER_W;
 387         break;
 388     case CRYPT_STRING_BASE64REQUESTHEADER:
 389         header = CERT_REQUEST_HEADER_W;
 390         trailer = CERT_REQUEST_TRAILER_W;
 391         break;
 392     case CRYPT_STRING_BASE64X509CRLHEADER:
 393         header = X509_HEADER_W;
 394         trailer = X509_TRAILER_W;
 395         break;
 396     }
 397
 398     charsNeeded = 0;
 399     encodeBase64W(pbBinary, cbBinary, sep, NULL, &charsNeeded);
 400     if (header)
 401         charsNeeded += strlenW(header) + strlenW(sep);
 402     if (trailer)
 403         charsNeeded += strlenW(trailer) + strlenW(sep);
 404     if (charsNeeded <= *pcchString)
 405     {
 406         LPWSTR ptr = pszString;
 407         DWORD size = charsNeeded;
 408
 409         if (header)
 410         {
 411             strcpyW(ptr, header);
 412             ptr += strlenW(ptr);
 413             strcpyW(ptr, sep);
 414             ptr += strlenW(sep);
 415         }
 416         encodeBase64W(pbBinary, cbBinary, sep, ptr, &size);
 417         ptr += size - 1;
 418         if (trailer)
 419         {
 420             strcpyW(ptr, trailer);
 421             ptr += strlenW(ptr);
 422             strcpyW(ptr, sep);
 423             ptr += strlenW(sep);
 424         }
 425         *pcchString = charsNeeded - 1;
 426     }
 427     else if (pszString)
 428     {
 429         *pcchString = charsNeeded;
 430         SetLastError(ERROR_INSUFFICIENT_BUFFER);
 431         ret = FALSE;
 432     }
 433     else
 434         *pcchString = charsNeeded;
 435     return ret;
 436 }
 437
 438 BOOL WINAPI CryptBinaryToStringW(const BYTE *pbBinary,
 439  DWORD cbBinary, DWORD dwFlags, LPWSTR pszString, DWORD *pcchString)
 440 {
 441     BinaryToStringWFunc encoder = NULL;
 442
 443     TRACE("(%p, %d, %08x, %p, %p)\n", pbBinary, cbBinary, dwFlags, pszString,
 444      pcchString);
 445
 446     if (!pbBinary)
 447     {
 448         SetLastError(ERROR_INVALID_PARAMETER);
 449         return FALSE;
 450     }
 451     if (!pcchString)
 452     {
 453         SetLastError(ERROR_INVALID_PARAMETER);
 454         return FALSE;
 455     }
 456
 457     switch (dwFlags & 0x0fffffff)
 458     {
 459     case CRYPT_STRING_BASE64:
 460     case CRYPT_STRING_BASE64HEADER:
 461     case CRYPT_STRING_BASE64REQUESTHEADER:
 462     case CRYPT_STRING_BASE64X509CRLHEADER:
 463         encoder = BinaryToBase64W;
 464         break;
 465     case CRYPT_STRING_BINARY:
 466     case CRYPT_STRING_HEX:
 467     case CRYPT_STRING_HEXASCII:
 468     case CRYPT_STRING_HEXADDR:
 469     case CRYPT_STRING_HEXASCIIADDR:
 470         FIXME("Unimplemented type %d\n", dwFlags & 0x0fffffff);
 471         /* fall through */
 472     default:
 473         SetLastError(ERROR_INVALID_PARAMETER);
 474         return FALSE;
 475     }
 476     return encoder(pbBinary, cbBinary, dwFlags, pszString, pcchString);
 477 }
 478
 479 static inline BYTE decodeBase64Byte(int c)
 480 {
 481     BYTE ret;
 482
 483     if (c >= 'A' && c <= 'Z')
 484         ret = c - 'A';
 485     else if (c >= 'a' && c <= 'z')
 486         ret = c - 'a' + 26;
 487     else if (c >= '0' && c <= '9')
 488         ret = c - '0' + 52;
 489     else if (c == '+')
 490         ret = 62;
 491     else if (c == '/')
 492         ret = 63;
 493     else
 494         ret = 64;
 495     return ret;
 496 }
 497
 498 static LONG decodeBase64Block(const char *in_buf, int in_len,
 499  const char **nextBlock, PBYTE out_buf, DWORD *out_len)
 500 {
 501     int len = in_len, i;
 502     const char *d = in_buf;
 503     int  ip0, ip1, ip2, ip3;
 504
 505     if (len < 4)
 506         return ERROR_INVALID_DATA;
 507
 508     i = 0;
 509     if (d[2] == '=')
 510     {
 511         if ((ip0 = decodeBase64Byte(d[0])) > 63)
 512             return ERROR_INVALID_DATA;
 513         if ((ip1 = decodeBase64Byte(d[1])) > 63)
 514             return ERROR_INVALID_DATA;
 515
 516         if (out_buf)
 517             out_buf[i] = (ip0 << 2) | (ip1 >> 4);
 518         i++;
 519     }
 520     else if (d[3] == '=')
 521     {
 522         if ((ip0 = decodeBase64Byte(d[0])) > 63)
 523             return ERROR_INVALID_DATA;
 524         if ((ip1 = decodeBase64Byte(d[1])) > 63)
 525             return ERROR_INVALID_DATA;
 526         if ((ip2 = decodeBase64Byte(d[2])) > 63)
 527             return ERROR_INVALID_DATA;
 528
 529         if (out_buf)
 530         {
 531             out_buf[i + 0] = (ip0 << 2) | (ip1 >> 4);
 532             out_buf[i + 1] = (ip1 << 4) | (ip2 >> 2);
 533         }
 534         i += 2;
 535     }
 536     else
 537     {
 538         if ((ip0 = decodeBase64Byte(d[0])) > 63)
 539             return ERROR_INVALID_DATA;
 540         if ((ip1 = decodeBase64Byte(d[1])) > 63)
 541             return ERROR_INVALID_DATA;
 542         if ((ip2 = decodeBase64Byte(d[2])) > 63)
 543             return ERROR_INVALID_DATA;
 544         if ((ip3 = decodeBase64Byte(d[3])) > 63)
 545             return ERROR_INVALID_DATA;
 546
 547         if (out_buf)
 548         {
 549             out_buf[i + 0] = (ip0 << 2) | (ip1 >> 4);
 550             out_buf[i + 1] = (ip1 << 4) | (ip2 >> 2);
 551             out_buf[i + 2] = (ip2 << 6) |  ip3;
 552         }
 553         i += 3;
 554     }
 555     if (len >= 6 && d[4] == '\r' && d[5] == '\n')
 556         *nextBlock = d + 6;
 557     else if (len >= 5 && d[4] == '\n')
 558         *nextBlock = d + 5;
 559     else if (len >= 4 && d[4])
 560         *nextBlock = d + 4;
 561     else
 562         *nextBlock = NULL;
 563     *out_len = i;
 564     return ERROR_SUCCESS;
 565 }
 566
 567 /* Unlike CryptStringToBinaryA, cchString is guaranteed to be the length of the
 568  * string to convert.
 569  */
 570 typedef LONG (*StringToBinaryAFunc)(LPCSTR pszString, DWORD cchString,
 571  BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags);
 572
 573 static LONG Base64ToBinaryA(LPCSTR pszString, DWORD cchString,
 574  BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags)
 575 {
 576     LONG ret = ERROR_SUCCESS;
 577     const char *nextBlock;
 578     DWORD outLen = 0;
 579
 580     nextBlock = pszString;
 581     while (nextBlock && !ret)
 582     {
 583         DWORD len = 0;
 584
 585         ret = decodeBase64Block(nextBlock, cchString - (nextBlock - pszString),
 586          &nextBlock, pbBinary ? pbBinary + outLen : NULL, &len);
 587         if (!ret)
 588             outLen += len;
 589         if (cchString - (nextBlock - pszString) <= 0)
 590             nextBlock = NULL;
 591     }
 592     *pcbBinary = outLen;
 593     if (!ret)
 594     {
 595         if (pdwSkip)
 596             *pdwSkip = 0;
 597         if (pdwFlags)
 598             *pdwFlags = CRYPT_STRING_BASE64;
 599     }
 600     else if (ret == ERROR_INSUFFICIENT_BUFFER)
 601     {
 602         if (!pbBinary)
 603             ret = ERROR_SUCCESS;
 604     }
 605     return ret;
 606 }
 607
 608 static LONG Base64WithHeaderAndTrailerToBinaryA(LPCSTR pszString,
 609  DWORD cchString, LPCSTR header, LPCSTR trailer, BYTE *pbBinary,
 610  DWORD *pcbBinary, DWORD *pdwSkip)
 611 {
 612     LONG ret;
 613     LPCSTR ptr;
 614
 615     if (cchString > strlen(header) + strlen(trailer)
 616      && (ptr = strstr(pszString, header)) != NULL)
 617     {
 618         LPCSTR trailerSpot = pszString + cchString - strlen(trailer);
 619
 620         if (pszString[cchString - 1] == '\n')
 621         {
 622             cchString--;
 623             trailerSpot--;
 624         }
 625         if (pszString[cchString - 1] == '\r')
 626         {
 627             cchString--;
 628             trailerSpot--;
 629         }
 630         if (!strncmp(trailerSpot, trailer, strlen(trailer)))
 631         {
 632             if (pdwSkip)
 633                 *pdwSkip = ptr - pszString;
 634             ptr += strlen(header);
 635             if (*ptr == '\r') ptr++;
 636             if (*ptr == '\n') ptr++;
 637             cchString -= ptr - pszString + strlen(trailer);
 638             ret = Base64ToBinaryA(ptr, cchString, pbBinary, pcbBinary, NULL,
 639              NULL);
 640         }
 641         else
 642             ret = ERROR_INVALID_DATA;
 643     }
 644     else
 645         ret = ERROR_INVALID_DATA;
 646     return ret;
 647 }
 648
 649 static LONG Base64HeaderToBinaryA(LPCSTR pszString, DWORD cchString,
 650  BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags)
 651 {
 652     LONG ret = Base64WithHeaderAndTrailerToBinaryA(pszString, cchString,
 653      CERT_HEADER, CERT_TRAILER, pbBinary, pcbBinary, pdwSkip);
 654
 655     if (!ret && pdwFlags)
 656         *pdwFlags = CRYPT_STRING_BASE64HEADER;
 657     return ret;
 658 }
 659
 660 static LONG Base64RequestHeaderToBinaryA(LPCSTR pszString, DWORD cchString,
 661  BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags)
 662 {
 663     LONG ret = Base64WithHeaderAndTrailerToBinaryA(pszString, cchString,
 664      CERT_REQUEST_HEADER, CERT_REQUEST_TRAILER, pbBinary, pcbBinary, pdwSkip);
 665
 666     if (!ret && pdwFlags)
 667         *pdwFlags = CRYPT_STRING_BASE64REQUESTHEADER;
 668     return ret;
 669 }
 670
 671 static LONG Base64X509HeaderToBinaryA(LPCSTR pszString, DWORD cchString,
 672  BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags)
 673 {
 674     LONG ret = Base64WithHeaderAndTrailerToBinaryA(pszString, cchString,
 675      X509_HEADER, X509_TRAILER, pbBinary, pcbBinary, pdwSkip);
 676
 677     if (!ret && pdwFlags)
 678         *pdwFlags = CRYPT_STRING_BASE64X509CRLHEADER;
 679     return ret;
 680 }
 681
 682 static LONG Base64AnyToBinaryA(LPCSTR pszString, DWORD cchString,
 683  BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags)
 684 {
 685     LONG ret;
 686
 687     ret = Base64HeaderToBinaryA(pszString, cchString, pbBinary, pcbBinary,
 688      pdwSkip, pdwFlags);
 689     if (ret == ERROR_INVALID_DATA)
 690         ret = Base64ToBinaryA(pszString, cchString, pbBinary, pcbBinary,
 691          pdwSkip, pdwFlags);
 692     return ret;
 693 }
 694
 695 static LONG DecodeBinaryToBinaryA(LPCSTR pszString, DWORD cchString,
 696  BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags)
 697 {
 698     LONG ret = ERROR_SUCCESS;
 699
 700     if (*pcbBinary < cchString)
 701     {
 702         if (!pbBinary)
 703             *pcbBinary = cchString;
 704         else
 705         {
 706             ret = ERROR_INSUFFICIENT_BUFFER;
 707             *pcbBinary = cchString;
 708         }
 709     }
 710     else
 711     {
 712         if (cchString)
 713             memcpy(pbBinary, pszString, cchString);
 714         *pcbBinary = cchString;
 715     }
 716     return ret;
 717 }
 718
 719 static LONG DecodeAnyA(LPCSTR pszString, DWORD cchString,
 720  BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags)
 721 {
 722     LONG ret;
 723
 724     ret = Base64HeaderToBinaryA(pszString, cchString, pbBinary, pcbBinary,
 725      pdwSkip, pdwFlags);
 726     if (ret == ERROR_INVALID_DATA)
 727         ret = Base64ToBinaryA(pszString, cchString, pbBinary, pcbBinary,
 728          pdwSkip, pdwFlags);
 729     if (ret == ERROR_INVALID_DATA)
 730         ret = DecodeBinaryToBinaryA(pszString, cchString, pbBinary, pcbBinary,
 731          pdwSkip, pdwFlags);
 732     return ret;
 733 }
 734
 735 BOOL WINAPI CryptStringToBinaryA(LPCSTR pszString,
 736  DWORD cchString, DWORD dwFlags, BYTE *pbBinary, DWORD *pcbBinary,
 737  DWORD *pdwSkip, DWORD *pdwFlags)
 738 {
 739     StringToBinaryAFunc decoder;
 740     LONG ret;
 741
 742     TRACE("(%s, %d, %08x, %p, %p, %p, %p)\n", debugstr_a(pszString),
 743      cchString, dwFlags, pbBinary, pcbBinary, pdwSkip, pdwFlags);
 744
 745     if (!pszString)
 746     {
 747         SetLastError(ERROR_INVALID_PARAMETER);
 748         return FALSE;
 749     }
 750     /* Only the bottom byte contains valid types */
 751     if (dwFlags & 0xfffffff0)
 752     {
 753         SetLastError(ERROR_INVALID_DATA);
 754         return FALSE;
 755     }
 756     switch (dwFlags)
 757     {
 758     case CRYPT_STRING_BASE64_ANY:
 759         decoder = Base64AnyToBinaryA;
 760         break;
 761     case CRYPT_STRING_BASE64:
 762         decoder = Base64ToBinaryA;
 763         break;
 764     case CRYPT_STRING_BASE64HEADER:
 765         decoder = Base64HeaderToBinaryA;
 766         break;
 767     case CRYPT_STRING_BASE64REQUESTHEADER:
 768         decoder = Base64RequestHeaderToBinaryA;
 769         break;
 770     case CRYPT_STRING_BASE64X509CRLHEADER:
 771         decoder = Base64X509HeaderToBinaryA;
 772         break;
 773     case CRYPT_STRING_BINARY:
 774         decoder = DecodeBinaryToBinaryA;
 775         break;
 776     case CRYPT_STRING_ANY:
 777         decoder = DecodeAnyA;
 778         break;
 779     case CRYPT_STRING_HEX:
 780     case CRYPT_STRING_HEXASCII:
 781     case CRYPT_STRING_HEXADDR:
 782     case CRYPT_STRING_HEXASCIIADDR:
 783         FIXME("Unimplemented type %d\n", dwFlags & 0x7fffffff);
 784         /* fall through */
 785     default:
 786         SetLastError(ERROR_INVALID_PARAMETER);
 787         return FALSE;
 788     }
 789     if (!cchString)
 790         cchString = strlen(pszString);
 791     ret = decoder(pszString, cchString, pbBinary, pcbBinary, pdwSkip, pdwFlags);
 792     if (ret)
 793         SetLastError(ret);
 794     return (ret == ERROR_SUCCESS) ? TRUE : FALSE;
 795 }
 796
 797 static LONG decodeBase64BlockW(const WCHAR *in_buf, int in_len,
 798  const WCHAR **nextBlock, PBYTE out_buf, DWORD *out_len)
 799 {
 800     int len = in_len, i;
 801     const WCHAR *d = in_buf;
 802     int  ip0, ip1, ip2, ip3;
 803
 804     if (len < 4)
 805         return ERROR_INVALID_DATA;
 806
 807     i = 0;
 808     if (d[2] == '=')
 809     {
 810         if ((ip0 = decodeBase64Byte(d[0])) > 63)
 811             return ERROR_INVALID_DATA;
 812         if ((ip1 = decodeBase64Byte(d[1])) > 63)
 813             return ERROR_INVALID_DATA;
 814
 815         if (out_buf)
 816             out_buf[i] = (ip0 << 2) | (ip1 >> 4);
 817         i++;
 818     }
 819     else if (d[3] == '=')
 820     {
 821         if ((ip0 = decodeBase64Byte(d[0])) > 63)
 822             return ERROR_INVALID_DATA;
 823         if ((ip1 = decodeBase64Byte(d[1])) > 63)
 824             return ERROR_INVALID_DATA;
 825         if ((ip2 = decodeBase64Byte(d[2])) > 63)
 826             return ERROR_INVALID_DATA;
 827
 828         if (out_buf)
 829         {
 830             out_buf[i + 0] = (ip0 << 2) | (ip1 >> 4);
 831             out_buf[i + 1] = (ip1 << 4) | (ip2 >> 2);
 832         }
 833         i += 2;
 834     }
 835     else
 836     {
 837         if ((ip0 = decodeBase64Byte(d[0])) > 63)
 838             return ERROR_INVALID_DATA;
 839         if ((ip1 = decodeBase64Byte(d[1])) > 63)
 840             return ERROR_INVALID_DATA;
 841         if ((ip2 = decodeBase64Byte(d[2])) > 63)
 842             return ERROR_INVALID_DATA;
 843         if ((ip3 = decodeBase64Byte(d[3])) > 63)
 844             return ERROR_INVALID_DATA;
 845
 846         if (out_buf)
 847         {
 848             out_buf[i + 0] = (ip0 << 2) | (ip1 >> 4);
 849             out_buf[i + 1] = (ip1 << 4) | (ip2 >> 2);
 850             out_buf[i + 2] = (ip2 << 6) |  ip3;
 851         }
 852         i += 3;
 853     }
 854     if (len >= 6 && d[4] == '\r' && d[5] == '\n')
 855         *nextBlock = d + 6;
 856     else if (len >= 5 && d[4] == '\n')
 857         *nextBlock = d + 5;
 858     else if (len >= 4 && d[4])
 859         *nextBlock = d + 4;
 860     else
 861         *nextBlock = NULL;
 862     *out_len = i;
 863     return ERROR_SUCCESS;
 864 }
 865
 866 /* Unlike CryptStringToBinaryW, cchString is guaranteed to be the length of the
 867  * string to convert.
 868  */
 869 typedef LONG (*StringToBinaryWFunc)(LPCWSTR pszString, DWORD cchString,
 870  BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags);
 871
 872 static LONG Base64ToBinaryW(LPCWSTR pszString, DWORD cchString,
 873  BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags)
 874 {
 875     LONG ret = ERROR_SUCCESS;
 876     const WCHAR *nextBlock;
 877     DWORD outLen = 0;
 878
 879     nextBlock = pszString;
 880     while (nextBlock && !ret)
 881     {
 882         DWORD len = 0;
 883
 884         ret = decodeBase64BlockW(nextBlock, cchString - (nextBlock - pszString),
 885          &nextBlock, pbBinary ? pbBinary + outLen : NULL, &len);
 886         if (!ret)
 887             outLen += len;
 888         if (cchString - (nextBlock - pszString) <= 0)
 889             nextBlock = NULL;
 890     }
 891     *pcbBinary = outLen;
 892     if (!ret)
 893     {
 894         if (pdwSkip)
 895             *pdwSkip = 0;
 896         if (pdwFlags)
 897             *pdwFlags = CRYPT_STRING_BASE64;
 898     }
 899     else if (ret == ERROR_INSUFFICIENT_BUFFER)
 900     {
 901         if (!pbBinary)
 902             ret = ERROR_SUCCESS;
 903     }
 904     return ret;
 905 }
 906
 907 static LONG Base64WithHeaderAndTrailerToBinaryW(LPCWSTR pszString,
 908  DWORD cchString, LPCWSTR header, LPCWSTR trailer, BYTE *pbBinary,
 909  DWORD *pcbBinary, DWORD *pdwSkip)
 910 {
 911     LONG ret;
 912     LPCWSTR ptr;
 913
 914     if (cchString > strlenW(header) + strlenW(trailer)
 915      && (ptr = strstrW(pszString, header)) != NULL)
 916     {
 917         LPCWSTR trailerSpot = pszString + cchString - strlenW(trailer);
 918
 919         if (pszString[cchString - 1] == '\n')
 920         {
 921             cchString--;
 922             trailerSpot--;
 923         }
 924         if (pszString[cchString - 1] == '\r')
 925         {
 926             cchString--;
 927             trailerSpot--;
 928         }
 929         if (!strncmpW(trailerSpot, trailer, strlenW(trailer)))
 930         {
 931             if (pdwSkip)
 932                 *pdwSkip = ptr - pszString;
 933             ptr += strlenW(header);
 934             if (*ptr == '\r') ptr++;
 935             if (*ptr == '\n') ptr++;
 936             cchString -= ptr - pszString + strlenW(trailer);
 937             ret = Base64ToBinaryW(ptr, cchString, pbBinary, pcbBinary, NULL,
 938              NULL);
 939         }
 940         else
 941             ret = ERROR_INVALID_DATA;
 942     }
 943     else
 944         ret = ERROR_INVALID_DATA;
 945     return ret;
 946 }
 947
 948 static LONG Base64HeaderToBinaryW(LPCWSTR pszString, DWORD cchString,
 949  BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags)
 950 {
 951     LONG ret = Base64WithHeaderAndTrailerToBinaryW(pszString, cchString,
 952      CERT_HEADER_W, CERT_TRAILER_W, pbBinary, pcbBinary, pdwSkip);
 953
 954     if (!ret && pdwFlags)
 955         *pdwFlags = CRYPT_STRING_BASE64HEADER;
 956     return ret;
 957 }
 958
 959 static LONG Base64RequestHeaderToBinaryW(LPCWSTR pszString, DWORD cchString,
 960  BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags)
 961 {
 962     LONG ret = Base64WithHeaderAndTrailerToBinaryW(pszString, cchString,
 963      CERT_REQUEST_HEADER_W, CERT_REQUEST_TRAILER_W, pbBinary, pcbBinary,
 964      pdwSkip);
 965
 966     if (!ret && pdwFlags)
 967         *pdwFlags = CRYPT_STRING_BASE64REQUESTHEADER;
 968     return ret;
 969 }
 970
 971 static LONG Base64X509HeaderToBinaryW(LPCWSTR pszString, DWORD cchString,
 972  BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags)
 973 {
 974     LONG ret = Base64WithHeaderAndTrailerToBinaryW(pszString, cchString,
 975      X509_HEADER_W, X509_TRAILER_W, pbBinary, pcbBinary, pdwSkip);
 976
 977     if (!ret && pdwFlags)
 978         *pdwFlags = CRYPT_STRING_BASE64X509CRLHEADER;
 979     return ret;
 980 }
 981
 982 static LONG Base64AnyToBinaryW(LPCWSTR pszString, DWORD cchString,
 983  BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags)
 984 {
 985     LONG ret;
 986
 987     ret = Base64HeaderToBinaryW(pszString, cchString, pbBinary, pcbBinary,
 988      pdwSkip, pdwFlags);
 989     if (ret == ERROR_INVALID_DATA)
 990         ret = Base64ToBinaryW(pszString, cchString, pbBinary, pcbBinary,
 991          pdwSkip, pdwFlags);
 992     return ret;
 993 }
 994
 995 static LONG DecodeBinaryToBinaryW(LPCWSTR pszString, DWORD cchString,
 996  BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags)
 997 {
 998     LONG ret = ERROR_SUCCESS;
 999
1000     if (*pcbBinary < cchString)
1001     {
1002         if (!pbBinary)
1003             *pcbBinary = cchString;
1004         else
1005         {
1006             ret = ERROR_INSUFFICIENT_BUFFER;
1007             *pcbBinary = cchString;
1008         }
1009     }
1010     else
1011     {
1012         if (cchString)
1013             memcpy(pbBinary, pszString, cchString * sizeof(WCHAR));
1014         *pcbBinary = cchString * sizeof(WCHAR);
1015     }
1016     return ret;
1017 }
1018
1019 static LONG DecodeAnyW(LPCWSTR pszString, DWORD cchString,
1020  BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags)
1021 {
1022     LONG ret;
1023
1024     ret = Base64HeaderToBinaryW(pszString, cchString, pbBinary, pcbBinary,
1025      pdwSkip, pdwFlags);
1026     if (ret == ERROR_INVALID_DATA)
1027         ret = Base64ToBinaryW(pszString, cchString, pbBinary, pcbBinary,
1028          pdwSkip, pdwFlags);
1029     if (ret == ERROR_INVALID_DATA)
1030         ret = DecodeBinaryToBinaryW(pszString, cchString, pbBinary, pcbBinary,
1031          pdwSkip, pdwFlags);
1032     return ret;
1033 }
1034
1035 BOOL WINAPI CryptStringToBinaryW(LPCWSTR pszString,
1036  DWORD cchString, DWORD dwFlags, BYTE *pbBinary, DWORD *pcbBinary,
1037  DWORD *pdwSkip, DWORD *pdwFlags)
1038 {
1039     StringToBinaryWFunc decoder;
1040     LONG ret;
1041
1042     TRACE("(%s, %d, %08x, %p, %p, %p, %p)\n", debugstr_w(pszString),
1043      cchString, dwFlags, pbBinary, pcbBinary, pdwSkip, pdwFlags);
1044
1045     if (!pszString)
1046     {
1047         SetLastError(ERROR_INVALID_PARAMETER);
1048         return FALSE;
1049     }
1050     /* Only the bottom byte contains valid types */
1051     if (dwFlags & 0xfffffff0)
1052     {
1053         SetLastError(ERROR_INVALID_DATA);
1054         return FALSE;
1055     }
1056     switch (dwFlags)
1057     {
1058     case CRYPT_STRING_BASE64_ANY:
1059         decoder = Base64AnyToBinaryW;
1060         break;
1061     case CRYPT_STRING_BASE64:
1062         decoder = Base64ToBinaryW;
1063         break;
1064     case CRYPT_STRING_BASE64HEADER:
1065         decoder = Base64HeaderToBinaryW;
1066         break;
1067     case CRYPT_STRING_BASE64REQUESTHEADER:
1068         decoder = Base64RequestHeaderToBinaryW;
1069         break;
1070     case CRYPT_STRING_BASE64X509CRLHEADER:
1071         decoder = Base64X509HeaderToBinaryW;
1072         break;
1073     case CRYPT_STRING_BINARY:
1074         decoder = DecodeBinaryToBinaryW;
1075         break;
1076     case CRYPT_STRING_ANY:
1077         decoder = DecodeAnyW;
1078         break;
1079     case CRYPT_STRING_HEX:
1080     case CRYPT_STRING_HEXASCII:
1081     case CRYPT_STRING_HEXADDR:
1082     case CRYPT_STRING_HEXASCIIADDR:
1083         FIXME("Unimplemented type %d\n", dwFlags & 0x7fffffff);
1084         /* fall through */
1085     default:
1086         SetLastError(ERROR_INVALID_PARAMETER);
1087         return FALSE;
1088     }
1089     if (!cchString)
1090         cchString = strlenW(pszString);
1091     ret = decoder(pszString, cchString, pbBinary, pcbBinary, pdwSkip, pdwFlags);
1092     if (ret)
1093         SetLastError(ret);
1094     return (ret == ERROR_SUCCESS) ? TRUE : FALSE;
1095 }