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