?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
taskkill: Add Lithuanian translation.
[wine.git] / dlls / crypt32 / base64.c
blob7a23dd9a11183393cc0cef24bcdeff86a18e7517
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 }
Windows API implementation