VirtualBox

source: vbox/trunk/src/VBox/Runtime/common/string/base64.cpp@ 16774

Last change on this file since 16774 was 16774, checked in by vboxsync, 16 years ago

RTBase64: no trailing newline.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 16.6 KB
Line 
1/* $Id: base64.cpp 16774 2009-02-15 04:23:47Z vboxsync $ */
2/** @file
3 * IPRT - Base64, MIME content transfer encoding.
4 */
5
6/*
7 * Copyright (C) 2009 Sun Microsystems, Inc.
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 *
17 * The contents of this file may alternatively be used under the terms
18 * of the Common Development and Distribution License Version 1.0
19 * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20 * VirtualBox OSE distribution, in which case the provisions of the
21 * CDDL are applicable instead of those of the GPL.
22 *
23 * You may elect to license modified versions of this file under the
24 * terms and conditions of either the GPL or the CDDL or both.
25 *
26 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
27 * Clara, CA 95054 USA or visit http://www.sun.com if you need
28 * additional information or have any questions.
29 */
30
31/*******************************************************************************
32* Header Files *
33*******************************************************************************/
34#include <iprt/base64.h>
35#include <iprt/assert.h>
36#include <iprt/err.h>
37#include <iprt/ctype.h>
38#ifdef RT_STRICT
39# include <iprt/asm.h>
40#endif
41
42
43/*******************************************************************************
44* Defined Constants And Macros *
45*******************************************************************************/
46/** The line length used for encoding. */
47#define RTBASE64_LINE_LEN 64
48
49/** @name Special g_au8CharToVal values
50 * @{ */
51#define BASE64_SPACE 0xc0
52#define BASE64_PAD 0xe0
53#define BASE64_INVALID 0xff
54/** @} */
55
56
57/*******************************************************************************
58* Global Variables *
59*******************************************************************************/
60/** Base64 character to value. (RFC 2045)
61 * ASSUMES ASCII / UTF-8. */
62static const uint8_t g_au8CharToVal[256] =
63{
64 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xff, 0xff, /* 0x00..0x0f */
65 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 0x10..0x1f */
66 0xc0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 62, 0xff, 0xff, 0xff, 63, /* 0x20..0x2f */
67 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 0xff, 0xff, 0xff, 0xe0, 0xff, 0xff, /* 0x30..0x3f */
68 0xff, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, /* 0x40..0x4f */
69 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 0xff, 0xff, 0xff, 0xff, 0xff, /* 0x50..0x5f */
70 0xff, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, /* 0x60..0x6f */
71 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 0xff, 0xff, 0xff, 0xff, 0xff, /* 0x70..0x7f */
72 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 0x80..0x8f */
73 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 0x90..0x9f */
74 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 0xa0..0xaf */
75 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 0xb0..0xbf */
76 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 0xc0..0xcf */
77 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 0xd0..0xdf */
78 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, /* 0xe0..0xef */
79 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff /* 0xf0..0xff */
80};
81
82/** Value to Base64 character. (RFC 2045) */
83static const char g_szValToChar[64+1] =
84 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
85
86
87#ifdef RT_STRICT
88/**
89 * Perform table sanity checks on the first call.
90 */
91static void rtBase64Sanity(void)
92{
93 static bool s_fSane = false;
94 if (RT_UNLIKELY(!s_fSane))
95 {
96 for (unsigned i = 0; i < 64; i++)
97 {
98 unsigned ch = g_szValToChar[i];
99 Assert(ch);
100 Assert(g_au8CharToVal[ch] == i);
101 }
102
103 for (unsigned i = 0; i < 256; i++)
104 {
105 uint8_t u8 = g_au8CharToVal[i];
106 Assert( ( u8 == BASE64_INVALID
107 && !RT_C_IS_ALNUM(i)
108 && !RT_C_IS_SPACE(i))
109 || ( u8 == BASE64_PAD
110 && i == '=')
111 || ( u8 == BASE64_SPACE
112 && RT_C_IS_SPACE(i))
113 || ( u8 < 64
114 && (unsigned)g_szValToChar[u8] == i));
115 }
116 ASMAtomicWriteBool(&s_fSane, true);
117 }
118}
119#endif /* RT_STRICT */
120
121
122/**
123 * Calculates the decoded data size for a Base64 encoded string.
124 *
125 * @returns The length in bytes. -1 if the encoding is bad.
126 *
127 * @param pszString The Base64 encoded string.
128 * @param ppszEnd If not NULL, this will point to the first char
129 * following the Base64 encoded text block. If
130 * NULL the entire string is assumed to be Base64.
131 */
132RTDECL(ssize_t) RTBase64DecodedSize(const char *pszString, char **ppszEnd)
133{
134#ifdef RT_STRICT
135 rtBase64Sanity();
136#endif
137
138 /*
139 * Walk the string until a non-encoded or non-space character is encountered.
140 */
141 uint32_t c6Bits = 0;
142 uint8_t u8 = BASE64_INVALID;
143 unsigned ch;
144 AssertCompile(sizeof(char) == sizeof(uint8_t));
145
146 while ((ch = *pszString))
147 {
148 u8 = g_au8CharToVal[ch];
149 if (u8 < 64)
150 c6Bits++;
151 else if (RT_UNLIKELY(u8 != BASE64_SPACE))
152 break;
153
154 /* advance */
155 pszString++;
156 }
157
158 /*
159 * Padding can only be found at the end and there is
160 * only 1 or 2 padding chars. Deal with it first.
161 */
162 unsigned cbPad = 0;
163 if (u8 == BASE64_PAD)
164 {
165 cbPad = 1;
166 c6Bits++;
167 pszString++;
168 while ((ch = *pszString))
169 {
170 u8 = g_au8CharToVal[ch];
171 if (u8 != BASE64_SPACE)
172 {
173 if (u8 != BASE64_PAD)
174 break;
175 c6Bits++;
176 cbPad++;
177 }
178 pszString++;
179 }
180 if (cbPad >= 3)
181 return -1;
182 }
183
184 /*
185 * Invalid char and no where to indicate where the
186 * Base64 text ends? Return failure.
187 */
188 if ( u8 == BASE64_INVALID
189 && !ppszEnd
190 && ch)
191 return -1;
192
193 /*
194 * Recalc 6-bit to 8-bit and adjust for padding.
195 */
196 size_t cb;
197 if (c6Bits * 3 / 3 == c6Bits)
198 {
199 if ((c6Bits * 3 % 4) != 0)
200 return -1;
201 cb = c6Bits * 3 / 4;
202 }
203 else
204 {
205 if ((c6Bits * (uint64_t)3 % 4) != 0)
206 return -1;
207 cb = c6Bits * (uint64_t)3 / 4;
208 }
209
210 if (cb < cbPad)
211 return -1;
212 cb -= cbPad;
213
214 if (ppszEnd)
215 *ppszEnd = (char *)pszString;
216 return cb;
217}
218
219
220/**
221 * Decodes a Base64 encoded string into the buffer supplied by the caller.
222 *
223 * @returns IPRT status code.
224 * @retval VERR_BUFFER_OVERFLOW if the buffer is too small. pcbActual will not
225 * be set, nor will ppszEnd.
226 * @retval VERR_INVALID_BASE64_ENCODING if the encoding is wrong.
227 *
228 * @param pszString The Base64 string. Whether the entire string or
229 * just the start of the string is in Base64 depends
230 * on wther ppszEnd is specified or not.
231 * @param pvData Where to store the decoded data.
232 * @param cbData The size of the output buffer that pvData points to.
233 * @param pcbActual Where to store the actual number of bytes returned.
234 * Optional.
235 * @param ppszEnd Indicats that the string may contain other stuff
236 * after the Base64 encoded data when not NULL. Will
237 * be set to point to the first char that's not part of
238 * the encoding. If NULL the entire string must be part
239 * of the Base64 encoded data.
240 */
241RTDECL(int) RTBase64Decode(const char *pszString, void *pvData, size_t cbData, size_t *pcbActual, char **ppszEnd)
242{
243#ifdef RT_STRICT
244 rtBase64Sanity();
245#endif
246
247 /*
248 * Process input in groups of 4 input / 3 output chars.
249 */
250 uint8_t u8Trio[3];
251 uint8_t *pbData = (uint8_t *)pvData;
252 uint8_t u8 = BASE64_INVALID;
253 unsigned c6Bits = 0;
254 unsigned ch;
255 AssertCompile(sizeof(char) == sizeof(uint8_t));
256
257 for (;;)
258 {
259 /* The first 6-bit group. */
260 while ((u8 = g_au8CharToVal[ch = *pszString]) == BASE64_SPACE)
261 pszString++;
262 if (u8 >= 64)
263 {
264 c6Bits = 0;
265 break;
266 }
267 u8Trio[0] = u8 << 2;
268 pszString++;
269
270 /* The second 6-bit group. */
271 while ((u8 = g_au8CharToVal[ch = *pszString]) == BASE64_SPACE)
272 pszString++;
273 if (u8 >= 64)
274 {
275 c6Bits = 1;
276 break;
277 }
278 u8Trio[0] |= u8 >> 4;
279 u8Trio[1] = u8 << 4;
280 pszString++;
281
282 /* The third 6-bit group. */
283 while ((u8 = g_au8CharToVal[ch = *pszString]) == BASE64_SPACE)
284 pszString++;
285 if (u8 >= 64)
286 {
287 c6Bits = 2;
288 break;
289 }
290 u8Trio[1] |= u8 >> 2;
291 u8Trio[2] = u8 << 6;
292 pszString++;
293
294 /* The fourth 6-bit group. */
295 while ((u8 = g_au8CharToVal[ch = *pszString]) == BASE64_SPACE)
296 pszString++;
297 if (u8 >= 64)
298 {
299 c6Bits = 3;
300 break;
301 }
302 u8Trio[2] |= u8;
303 pszString++;
304
305 /* flush the trio */
306 if (cbData < 3)
307 return VERR_BUFFER_OVERFLOW;
308 cbData -= 3;
309 pbData[0] = u8Trio[0];
310 pbData[1] = u8Trio[1];
311 pbData[2] = u8Trio[2];
312 pbData += 3;
313 }
314
315 /*
316 * Padding can only be found at the end and there is
317 * only 1 or 2 padding chars. Deal with it first.
318 */
319 unsigned cbPad = 0;
320 if (u8 == BASE64_PAD)
321 {
322 cbPad = 1;
323 pszString++;
324 while ((ch = *pszString))
325 {
326 u8 = g_au8CharToVal[ch];
327 if (u8 != BASE64_SPACE)
328 {
329 if (u8 != BASE64_PAD)
330 break;
331 cbPad++;
332 }
333 pszString++;
334 }
335 if (cbPad >= 3)
336 return VERR_INVALID_BASE64_ENCODING;
337 }
338
339 /*
340 * Invalid char and no where to indicate where the
341 * Base64 text ends? Return failure.
342 */
343 if ( u8 == BASE64_INVALID
344 && !ppszEnd
345 && ch)
346 return VERR_INVALID_BASE64_ENCODING;
347
348 /*
349 * Check padding vs. pending sextets, if anything left to do finish it off.
350 */
351 if (c6Bits || cbPad)
352 {
353 if (c6Bits + cbPad != 4)
354 return VERR_INVALID_BASE64_ENCODING;
355
356 switch (c6Bits)
357 {
358 case 1:
359 u8Trio[1] = u8Trio[2] = 0;
360 break;
361 case 2:
362 u8Trio[2] = 0;
363 break;
364 case 3:
365 default:
366 break;
367 }
368 switch (3 - cbPad)
369 {
370 case 1:
371 if (cbData < 1)
372 return VERR_BUFFER_OVERFLOW;
373 cbData--;
374 pbData[0] = u8Trio[0];
375 pbData++;
376 break;
377
378 case 2:
379 if (cbData < 2)
380 return VERR_BUFFER_OVERFLOW;
381 cbData -= 2;
382 pbData[0] = u8Trio[0];
383 pbData[1] = u8Trio[1];
384 pbData += 2;
385 break;
386
387 default:
388 break;
389 }
390 }
391
392 /*
393 * Set optional return values and return successfully.
394 */
395 if (ppszEnd)
396 *ppszEnd = (char *)pszString;
397 if (pcbActual)
398 *pcbActual = pbData - (uint8_t *)pvData;
399 return VINF_SUCCESS;
400}
401
402
403/**
404 * Calculates the length of the Base64 encoding of a given number of bytes of
405 * data.
406 *
407 * This will assume line breaks every 64 chars. A RTBase64EncodedLengthEx
408 * function can be added if closer control over the output is found to be
409 * required.
410 *
411 * @returns The Base64 string length.
412 * @param cbData The number of bytes to encode.
413 */
414RTDECL(size_t) RTBase64EncodedLength(size_t cbData)
415{
416 if (cbData * 8 / 8 != cbData)
417 {
418 AssertReturn(sizeof(size_t) == sizeof(uint64_t), ~(size_t)0);
419 uint64_t cch = cbData * (uint64_t)8;
420 while (cch % 24)
421 cch += 8;
422 cch /= 6;
423
424 cch += (cch / RTBASE64_LINE_LEN) * RTBASE64_EOL_SIZE;
425 cch -= (cch % RTBASE64_LINE_LEN) == 0;
426 return cch;
427 }
428
429 size_t cch = cbData * 8;
430 while (cch % 24)
431 cch += 8;
432 cch /= 6;
433
434 cch += (cch / RTBASE64_LINE_LEN) * RTBASE64_EOL_SIZE;
435 cch -= (cch % RTBASE64_LINE_LEN) == 0;
436 return cch;
437}
438
439
440/**
441 * Encodes the specifed data into a Base64 string, the caller supplies the
442 * output buffer.
443 *
444 * This will make the same assumptions about line breaks and EOL size as
445 * RTBase64EncodedLength() does. A RTBase64EncodeEx function can be added if
446 * more strict control over the output formatting is found necessary.
447 *
448 * @returns IRPT status code.
449 * @retval VERR_BUFFER_OVERFLOW if the output buffer is too small. The buffer
450 * may contain an invalid Base64 string.
451 *
452 * @param pvData The data to encode.
453 * @param cbData The number of bytes to encode.
454 * @param pszBuf Where to put the Base64 string.
455 * @param cbBuf The size of the output buffer, including the terminator.
456 * @param pcchActual The actual number of characters returned.
457 */
458RTDECL(int) RTBase64Encode(const void *pvData, size_t cbData, char *pszBuf, size_t cbBuf, size_t *pcchActual)
459{
460 /*
461 * Process whole "trios" of input data.
462 */
463 uint8_t u8A;
464 uint8_t u8B;
465 uint8_t u8C;
466 size_t cbLineFeed = cbBuf - RTBASE64_LINE_LEN;
467 const uint8_t *pbSrc = (const uint8_t *)pvData;
468 char *pchDst = pszBuf;
469 while (cbData >= 3)
470 {
471 if (cbBuf < 4 + 1)
472 return VERR_BUFFER_OVERFLOW;
473
474 /* encode */
475 u8A = pbSrc[0];
476 pchDst[0] = g_szValToChar[u8A >> 2];
477 u8B = pbSrc[1];
478 pchDst[1] = g_szValToChar[((u8A << 4) & 0x3f) | (u8B >> 4)];
479 u8C = pbSrc[2];
480 pchDst[2] = g_szValToChar[((u8B << 2) & 0x3f) | (u8C >> 6)];
481 pchDst[3] = g_szValToChar[u8C & 0x3f];
482
483 /* advance */
484 cbBuf -= 4;
485 pchDst += 4;
486 cbData -= 3;
487 pbSrc += 3;
488
489 /* deal out linefeeds */
490 if (cbBuf == cbLineFeed && cbData)
491 {
492 if (cbBuf < RTBASE64_EOL_SIZE + 1)
493 return VERR_BUFFER_OVERFLOW;
494 cbBuf -= RTBASE64_EOL_SIZE;
495 if (RTBASE64_EOL_SIZE == 2)
496 *pchDst++ = '\r';
497 *pchDst++ = '\n';
498 cbLineFeed = cbBuf - RTBASE64_LINE_LEN;
499 }
500 }
501
502 /*
503 * Deal with the odd bytes and string termination.
504 */
505 if (cbData)
506 {
507 if (cbBuf < 4 + 1)
508 return VERR_BUFFER_OVERFLOW;
509 switch (cbData)
510 {
511 case 1:
512 u8A = pbSrc[0];
513 pchDst[0] = g_szValToChar[u8A >> 2];
514 pchDst[1] = g_szValToChar[(u8A << 4) & 0x3f];
515 pchDst[2] = '=';
516 pchDst[3] = '=';
517 break;
518 case 2:
519 u8A = pbSrc[0];
520 pchDst[0] = g_szValToChar[u8A >> 2];
521 u8B = pbSrc[1];
522 pchDst[1] = g_szValToChar[((u8A << 4) & 0x3f) | (u8B >> 4)];
523 pchDst[2] = g_szValToChar[(u8B << 2) & 0x3f];
524 pchDst[3] = '=';
525 break;
526 }
527 pchDst += 4;
528 }
529
530 *pchDst = '\0';
531
532 if (pcchActual)
533 *pcchActual = pchDst - pszBuf;
534 return VINF_SUCCESS;
535}
536
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette