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 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
29 WINE_DEFAULT_DEBUG_CHANNEL(crypt);
30
31 #define CERT_HEADER "-----BEGIN CERTIFICATE-----"
32 #define CERT_TRAILER "-----END CERTIFICATE-----"
33 #define CERT_REQUEST_HEADER "-----BEGIN NEW CERTIFICATE REQUEST-----"
34 #define CERT_REQUEST_TRAILER "-----END NEW CERTIFICATE REQUEST-----"
35 #define X509_HEADER "-----BEGIN X509 CRL-----"
36 #define X509_TRAILER "-----END X509 CRL-----"
37
38 static const char b64[] =
39 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
40
41 typedef BOOL (*BinaryToStringAFunc)(const BYTE *pbBinary,
42 DWORD cbBinary, DWORD dwFlags, LPSTR pszString, DWORD *pcchString);
43
44 static BOOL EncodeBinaryToBinaryA(const BYTE *pbBinary,
45 DWORD cbBinary, DWORD dwFlags, LPSTR pszString, DWORD *pcchString)
46 {
47 BOOL ret = TRUE;
48
49 if (*pcchString < cbBinary)
50 {
51 if (!pszString)
52 *pcchString = cbBinary;
53 else
54 {
55 SetLastError(ERROR_INSUFFICIENT_BUFFER);
56 *pcchString = cbBinary;
57 ret = FALSE;
58 }
59 }
60 else
61 {
62 if (cbBinary)
63 memcpy(pszString, pbBinary, cbBinary);
64 *pcchString = cbBinary;
65 }
66 return ret;
67 }
68
69 static LONG encodeBase64A(const BYTE *in_buf, int in_len, LPCSTR sep,
70 char* out_buf, DWORD *out_len)
71 {
72 int div, i;
73 const BYTE *d = in_buf;
74 int bytes = (in_len*8 + 5)/6, pad_bytes = (bytes % 4) ? 4 - (bytes % 4) : 0;
75 DWORD needed;
76 LPSTR ptr;
77
78 TRACE("bytes is %d, pad bytes is %d\n", bytes, pad_bytes);
79 needed = bytes + pad_bytes + 1;
80 needed += (needed / 64 + 1) * strlen(sep);
81
82 if (needed > *out_len)
83 {
84 *out_len = needed;
85 return ERROR_INSUFFICIENT_BUFFER;
86 }
87 else
88 *out_len = needed;
89
90 /* Three bytes of input give 4 chars of output */
91 div = in_len / 3;
92
93 ptr = out_buf;
94 i = 0;
95 while (div > 0)
96 {
97 if (i && i % 64 == 0)
98 {
99 strcpy(ptr, sep);
100 ptr += strlen(sep);
101 }
102 /* first char is the first 6 bits of the first byte*/
103 *ptr++ = b64[ ( d[0] >> 2) & 0x3f ];
104 /* second char is the last 2 bits of the first byte and the first 4
105 * bits of the second byte */
106 *ptr++ = b64[ ((d[0] << 4) & 0x30) | (d[1] >> 4 & 0x0f)];
107 /* third char is the last 4 bits of the second byte and the first 2
108 * bits of the third byte */
109 *ptr++ = b64[ ((d[1] << 2) & 0x3c) | (d[2] >> 6 & 0x03)];
110 /* fourth char is the remaining 6 bits of the third byte */
111 *ptr++ = b64[ d[2] & 0x3f];
112 i += 4;
113 d += 3;
114 div--;
115 }
116
117 switch(pad_bytes)
118 {
119 case 1:
120 /* first char is the first 6 bits of the first byte*/
121 *ptr++ = b64[ ( d[0] >> 2) & 0x3f ];
122 /* second char is the last 2 bits of the first byte and the first 4
123 * bits of the second byte */
124 *ptr++ = b64[ ((d[0] << 4) & 0x30) | (d[1] >> 4 & 0x0f)];
125 /* third char is the last 4 bits of the second byte padded with
126 * two zeroes */
127 *ptr++ = b64[ ((d[1] << 2) & 0x3c) ];
128 /* fourth char is a = to indicate one byte of padding */
129 *ptr++ = '=';
130 break;
131 case 2:
132 /* first char is the first 6 bits of the first byte*/
133 *ptr++ = b64[ ( d[0] >> 2) & 0x3f ];
134 /* second char is the last 2 bits of the first byte padded with
135 * four zeroes*/
136 *ptr++ = b64[ ((d[0] << 4) & 0x30)];
137 /* third char is = to indicate padding */
138 *ptr++ = '=';
139 /* fourth char is = to indicate padding */
140 *ptr++ = '=';
141 break;
142 }
143 strcpy(ptr, sep);
144
145 return ERROR_SUCCESS;
146 }
147
148 static BOOL BinaryToBase64A(const BYTE *pbBinary,
149 DWORD cbBinary, DWORD dwFlags, LPSTR pszString, DWORD *pcchString)
150 {
151 static const char crlf[] = "\r\n", lf[] = "\n";
152 BOOL ret = TRUE;
153 LPCSTR header = NULL, trailer = NULL, sep = NULL;
154 DWORD charsNeeded;
155
156 if (dwFlags & CRYPT_STRING_NOCR)
157 sep = lf;
158 else
159 sep = crlf;
160 switch (dwFlags & 0x7fffffff)
161 {
162 case CRYPT_STRING_BASE64:
163 /* no header or footer */
164 break;
165 case CRYPT_STRING_BASE64HEADER:
166 header = CERT_HEADER;
167 trailer = CERT_TRAILER;
168 break;
169 case CRYPT_STRING_BASE64REQUESTHEADER:
170 header = CERT_REQUEST_HEADER;
171 trailer = CERT_REQUEST_TRAILER;
172 break;
173 case CRYPT_STRING_BASE64X509CRLHEADER:
174 header = X509_HEADER;
175 trailer = X509_TRAILER;
176 break;
177 }
178
179 charsNeeded = 0;
180 encodeBase64A(pbBinary, cbBinary, sep, NULL, &charsNeeded);
181 charsNeeded += strlen(sep);
182 if (header)
183 charsNeeded += strlen(header) + strlen(sep);
184 if (trailer)
185 charsNeeded += strlen(trailer) + strlen(sep);
186 if (charsNeeded <= *pcchString)
187 {
188 LPSTR ptr = pszString;
189 DWORD size = charsNeeded;
190
191 if (header)
192 {
193 strcpy(ptr, header);
194 ptr += strlen(ptr);
195 strcpy(ptr, sep);
196 ptr += strlen(sep);
197 }
198 encodeBase64A(pbBinary, cbBinary, sep, ptr, &size);
199 ptr += size - 1;
200 if (trailer)
201 {
202 strcpy(ptr, trailer);
203 ptr += strlen(ptr);
204 strcpy(ptr, sep);
205 ptr += strlen(sep);
206 }
207 *pcchString = charsNeeded - 1;
208 }
209 else if (pszString)
210 {
211 *pcchString = charsNeeded;
212 SetLastError(ERROR_INSUFFICIENT_BUFFER);
213 ret = FALSE;
214 }
215 else
216 *pcchString = charsNeeded;
217 return ret;
218 }
219
220 BOOL WINAPI CryptBinaryToStringA(const BYTE *pbBinary,
221 DWORD cbBinary, DWORD dwFlags, LPSTR pszString, DWORD *pcchString)
222 {
223 BinaryToStringAFunc encoder = NULL;
224
225 TRACE("(%p, %d, %08x, %p, %p)\n", pbBinary, cbBinary, dwFlags, pszString,
226 pcchString);
227
228 if (!pbBinary)
229 {
230 SetLastError(ERROR_INVALID_PARAMETER);
231 return FALSE;
232 }
233 if (!pcchString)
234 {
235 SetLastError(ERROR_INVALID_PARAMETER);
236 return FALSE;
237 }
238
239 switch (dwFlags & 0x7fffffff)
240 {
241 case CRYPT_STRING_BINARY:
242 encoder = EncodeBinaryToBinaryA;
243 break;
244 case CRYPT_STRING_BASE64:
245 case CRYPT_STRING_BASE64HEADER:
246 case CRYPT_STRING_BASE64REQUESTHEADER:
247 case CRYPT_STRING_BASE64X509CRLHEADER:
248 encoder = BinaryToBase64A;
249 break;
250 case CRYPT_STRING_HEX:
251 case CRYPT_STRING_HEXASCII:
252 case CRYPT_STRING_HEXADDR:
253 case CRYPT_STRING_HEXASCIIADDR:
254 FIXME("Unimplemented type %d\n", dwFlags & 0x7fffffff);
255 /* fall through */
256 default:
257 SetLastError(ERROR_INVALID_PARAMETER);
258 return FALSE;
259 }
260 return encoder(pbBinary, cbBinary, dwFlags, pszString, pcchString);
261 }
262
263 static inline BYTE decodeBase64Byte(char c)
264 {
265 BYTE ret;
266
267 if (c >= 'A' && c <= 'Z')
268 ret = c - 'A';
269 else if (c >= 'a' && c <= 'z')
270 ret = c - 'a' + 26;
271 else if (c >= '' && c <= '9')
272 ret = c - '' + 52;
273 else if (c == '+')
274 ret = 62;
275 else if (c == '/')
276 ret = 63;
277 else
278 ret = 64;
279 return ret;
280 }
281
282 static LONG decodeBase64Block(const char *in_buf, int in_len,
283 const char **nextBlock, PBYTE out_buf, DWORD *out_len)
284 {
285 int len = in_len, i;
286 const char *d = in_buf;
287 int ip0, ip1, ip2, ip3;
288
289 if (len < 4)
290 return ERROR_INVALID_DATA;
291
292 i = 0;
293 if (d[2] == '=')
294 {
295 if ((ip0 = decodeBase64Byte(d[0])) > 63)
296 return ERROR_INVALID_DATA;
297 if ((ip1 = decodeBase64Byte(d[1])) > 63)
298 return ERROR_INVALID_DATA;
299
300 if (out_buf)
301 out_buf[i] = (ip0 << 2) | (ip1 >> 4);
302 i++;
303 }
304 else if (d[3] == '=')
305 {
306 if ((ip0 = decodeBase64Byte(d[0])) > 63)
307 return ERROR_INVALID_DATA;
308 if ((ip1 = decodeBase64Byte(d[1])) > 63)
309 return ERROR_INVALID_DATA;
310 if ((ip2 = decodeBase64Byte(d[2])) > 63)
311 return ERROR_INVALID_DATA;
312
313 if (out_buf)
314 {
315 out_buf[i + 0] = (ip0 << 2) | (ip1 >> 4);
316 out_buf[i + 1] = (ip1 << 4) | (ip2 >> 2);
317 }
318 i += 2;
319 }
320 else
321 {
322 if ((ip0 = decodeBase64Byte(d[0])) > 63)
323 return ERROR_INVALID_DATA;
324 if ((ip1 = decodeBase64Byte(d[1])) > 63)
325 return ERROR_INVALID_DATA;
326 if ((ip2 = decodeBase64Byte(d[2])) > 63)
327 return ERROR_INVALID_DATA;
328 if ((ip3 = decodeBase64Byte(d[3])) > 63)
329 return ERROR_INVALID_DATA;
330
331 if (out_buf)
332 {
333 out_buf[i + 0] = (ip0 << 2) | (ip1 >> 4);
334 out_buf[i + 1] = (ip1 << 4) | (ip2 >> 2);
335 out_buf[i + 2] = (ip2 << 6) | ip3;
336 }
337 i += 3;
338 }
339 if (len >= 6 && d[4] == '\r' && d[5] == '\n')
340 *nextBlock = d + 6;
341 else if (len >= 5 && d[4] == '\n')
342 *nextBlock = d + 5;
343 else if (len >= 4 && d[4])
344 *nextBlock = d + 4;
345 else
346 *nextBlock = NULL;
347 *out_len = i;
348 return ERROR_SUCCESS;
349 }
350
351 /* Unlike CryptStringToBinaryA, cchString is guaranteed to be the length of the
352 * string to convert.
353 */
354 typedef LONG (*StringToBinaryAFunc)(LPCSTR pszString, DWORD cchString,
355 BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags);
356
357 static LONG Base64ToBinaryA(LPCSTR pszString, DWORD cchString,
358 BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags)
359 {
360 LONG ret = ERROR_SUCCESS;
361 const char *nextBlock;
362 DWORD outLen = 0;
363
364 nextBlock = pszString;
365 while (nextBlock && !ret)
366 {
367 DWORD len = 0;
368
369 ret = decodeBase64Block(nextBlock, cchString - (nextBlock - pszString),
370 &nextBlock, pbBinary ? pbBinary + outLen : NULL, &len);
371 if (!ret)
372 outLen += len;
373 if (cchString - (nextBlock - pszString) <= 0)
374 nextBlock = NULL;
375 }
376 *pcbBinary = outLen;
377 if (!ret)
378 {
379 if (pdwSkip)
380 *pdwSkip = 0;
381 if (pdwFlags)
382 *pdwFlags = CRYPT_STRING_BASE64;
383 }
384 else if (ret == ERROR_INSUFFICIENT_BUFFER)
385 {
386 if (!pbBinary)
387 ret = ERROR_SUCCESS;
388 }
389 return ret;
390 }
391
392 static LONG Base64WithHeaderAndTrailerToBinaryA(LPCSTR pszString,
393 DWORD cchString, LPCSTR header, LPCSTR trailer, BYTE *pbBinary,
394 DWORD *pcbBinary, DWORD *pdwSkip)
395 {
396 LONG ret;
397 LPCSTR ptr;
398
399 if (cchString > strlen(header) + strlen(trailer)
400 && (ptr = strstr(pszString, header)) != NULL)
401 {
402 LPCSTR trailerSpot = pszString + cchString - strlen(trailer);
403
404 if (pszString[cchString - 1] == '\n')
405 {
406 cchString--;
407 trailerSpot--;
408 }
409 if (pszString[cchString - 1] == '\r')
410 {
411 cchString--;
412 trailerSpot--;
413 }
414 if (!strncmp(trailerSpot, trailer, strlen(trailer)))
415 {
416 if (pdwSkip)
417 *pdwSkip = ptr - pszString;
418 ptr += strlen(header);
419 if (*ptr == '\r') ptr++;
420 if (*ptr == '\n') ptr++;
421 cchString -= ptr - pszString + strlen(trailer);
422 ret = Base64ToBinaryA(ptr, cchString, pbBinary, pcbBinary, NULL,
423 NULL);
424 }
425 else
426 ret = ERROR_INVALID_DATA;
427 }
428 else
429 ret = ERROR_INVALID_DATA;
430 return ret;
431 }
432
433 static LONG Base64HeaderToBinaryA(LPCSTR pszString, DWORD cchString,
434 BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags)
435 {
436 LONG ret = Base64WithHeaderAndTrailerToBinaryA(pszString, cchString,
437 CERT_HEADER, CERT_TRAILER, pbBinary, pcbBinary, pdwSkip);
438
439 if (!ret && pdwFlags)
440 *pdwFlags = CRYPT_STRING_BASE64HEADER;
441 return ret;
442 }
443
444 static LONG Base64RequestHeaderToBinaryA(LPCSTR pszString, DWORD cchString,
445 BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags)
446 {
447 LONG ret = Base64WithHeaderAndTrailerToBinaryA(pszString, cchString,
448 CERT_REQUEST_HEADER, CERT_REQUEST_TRAILER, pbBinary, pcbBinary, pdwSkip);
449
450 if (!ret && pdwFlags)
451 *pdwFlags = CRYPT_STRING_BASE64REQUESTHEADER;
452 return ret;
453 }
454
455 static LONG Base64X509HeaderToBinaryA(LPCSTR pszString, DWORD cchString,
456 BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags)
457 {
458 LONG ret = Base64WithHeaderAndTrailerToBinaryA(pszString, cchString,
459 X509_HEADER, X509_TRAILER, pbBinary, pcbBinary, pdwSkip);
460
461 if (!ret && pdwFlags)
462 *pdwFlags = CRYPT_STRING_BASE64X509CRLHEADER;
463 return ret;
464 }
465
466 static LONG Base64AnyToBinaryA(LPCSTR pszString, DWORD cchString,
467 BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags)
468 {
469 LONG ret;
470
471 ret = Base64HeaderToBinaryA(pszString, cchString, pbBinary, pcbBinary,
472 pdwSkip, pdwFlags);
473 if (ret == ERROR_INVALID_DATA)
474 ret = Base64ToBinaryA(pszString, cchString, pbBinary, pcbBinary,
475 pdwSkip, pdwFlags);
476 return ret;
477 }
478
479 static LONG DecodeBinaryToBinaryA(LPCSTR pszString, DWORD cchString,
480 BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags)
481 {
482 LONG ret = ERROR_SUCCESS;
483
484 if (*pcbBinary < cchString)
485 {
486 if (!pbBinary)
487 *pcbBinary = cchString;
488 else
489 {
490 ret = ERROR_INSUFFICIENT_BUFFER;
491 *pcbBinary = cchString;
492 }
493 }
494 else
495 {
496 if (cchString)
497 memcpy(pbBinary, pszString, cchString);
498 *pcbBinary = cchString;
499 }
500 return ret;
501 }
502
503 static LONG DecodeAnyA(LPCSTR pszString, DWORD cchString,
504 BYTE *pbBinary, DWORD *pcbBinary, DWORD *pdwSkip, DWORD *pdwFlags)
505 {
506 LONG ret;
507
508 ret = Base64HeaderToBinaryA(pszString, cchString, pbBinary, pcbBinary,
509 pdwSkip, pdwFlags);
510 if (ret == ERROR_INVALID_DATA)
511 ret = Base64ToBinaryA(pszString, cchString, pbBinary, pcbBinary,
512 pdwSkip, pdwFlags);
513 if (ret == ERROR_INVALID_DATA)
514 ret = DecodeBinaryToBinaryA(pszString, cchString, pbBinary, pcbBinary,
515 pdwSkip, pdwFlags);
516 return ret;
517 }
518
519 BOOL WINAPI CryptStringToBinaryA(LPCSTR pszString,
520 DWORD cchString, DWORD dwFlags, BYTE *pbBinary, DWORD *pcbBinary,
521 DWORD *pdwSkip, DWORD *pdwFlags)
522 {
523 StringToBinaryAFunc decoder;
524 LONG ret;
525
526 TRACE("(%s, %d, %08x, %p, %p, %p, %p)\n", debugstr_a(pszString),
527 cchString, dwFlags, pbBinary, pcbBinary, pdwSkip, pdwFlags);
528
529 if (!pszString)
530 {
531 SetLastError(ERROR_INVALID_PARAMETER);
532 return FALSE;
533 }
534 /* Only the bottom byte contains valid types */
535 if (dwFlags & 0xfffffff0)
536 {
537 SetLastError(ERROR_INVALID_DATA);
538 return FALSE;
539 }
540 switch (dwFlags)
541 {
542 case CRYPT_STRING_BASE64_ANY:
543 decoder = Base64AnyToBinaryA;
544 break;
545 case CRYPT_STRING_BASE64:
546 decoder = Base64ToBinaryA;
547 break;
548 case CRYPT_STRING_BASE64HEADER:
549 decoder = Base64HeaderToBinaryA;
550 break;
551 case CRYPT_STRING_BASE64REQUESTHEADER:
552 decoder = Base64RequestHeaderToBinaryA;
553 break;
554 case CRYPT_STRING_BASE64X509CRLHEADER:
555 decoder = Base64X509HeaderToBinaryA;
556 break;
557 case CRYPT_STRING_BINARY:
558 decoder = DecodeBinaryToBinaryA;
559 break;
560 case CRYPT_STRING_ANY:
561 decoder = DecodeAnyA;
562 break;
563 case CRYPT_STRING_HEX:
564 case CRYPT_STRING_HEXASCII:
565 case CRYPT_STRING_HEXADDR:
566 case CRYPT_STRING_HEXASCIIADDR:
567 FIXME("Unimplemented type %d\n", dwFlags & 0x7fffffff);
568 /* fall through */
569 default:
570 SetLastError(ERROR_INVALID_PARAMETER);
571 return FALSE;
572 }
573 if (!cchString)
574 cchString = strlen(pszString);
575 ret = decoder(pszString, cchString, pbBinary, pcbBinary, pdwSkip, pdwFlags);
576 if (ret)
577 SetLastError(ret);
578 return (ret == ERROR_SUCCESS) ? TRUE : FALSE;
579 }
580
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.