]>
src.bluestatic.org Git - macgdbp.git/blob - modp_b64/modp_b64.cc
1 /* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 4 -*- */
2 /* vi: set expandtab shiftwidth=4 tabstop=4: */
6 * MODP_B64 - High performance base64 encoder/decoder
7 * Version 1.3 -- 17-Mar-2006
8 * http://modp.com/release/base64
10 * Copyright © 2005, 2006 Nick Galbreath -- nickg [at] modp [dot] com
11 * All rights reserved.
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions are
17 * Redistributions of source code must retain the above copyright
18 * notice, this list of conditions and the following disclaimer.
20 * Redistributions in binary form must reproduce the above copyright
21 * notice, this list of conditions and the following disclaimer in the
22 * documentation and/or other materials provided with the distribution.
24 * Neither the name of the modp.com nor the names of its
25 * contributors may be used to endorse or promote products derived from
26 * this software without specific prior written permission.
28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
29 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
30 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
31 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
32 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
33 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
34 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
35 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
36 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
37 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
38 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
40 * This is the standard "new" BSD license:
41 * http://www.opensource.org/licenses/bsd-license.php
49 * If you are ripping this out of the library, comment out the next
50 * line and uncomment the next lines as approrpiate
54 /* if on motoral, sun, ibm; uncomment this */
55 /* #define WORDS_BIGENDIAN 1 */
56 /* else for Intel, Amd; uncomment this */
57 /* #undef WORDS_BIGENDIAN */
59 #include "modp_b64_data.h"
61 #define BADCHAR 0x01FFFFFF
64 * you can control if we use padding by commenting out this
65 * next line. However, I highly recommend you use padding and not
66 * using it should only be for compatability with a 3rd party.
67 * Also, 'no padding' is not tested!
72 * if we aren't doing padding
73 * set the pad character to NULL
80 int modp_b64_encode(char* dest
, const char* str
, int len
)
83 uint8_t* p
= (uint8_t*) dest
;
85 /* unsigned here is important! */
88 for (i
= 0; i
< len
- 2; i
+= 3) {
89 t1
= str
[i
]; t2
= str
[i
+1]; t3
= str
[i
+2];
91 *p
++ = e1
[((t1
& 0x03) << 4) | ((t2
>> 4) & 0x0F)];
92 *p
++ = e1
[((t2
& 0x0F) << 2) | ((t3
>> 6) & 0x03)];
102 *p
++ = e1
[(t1
& 0x03) << 4];
106 default: /* case 2 */
107 t1
= str
[i
]; t2
= str
[i
+1];
109 *p
++ = e1
[((t1
& 0x03) << 4) | ((t2
>> 4) & 0x0F)];
110 *p
++ = e2
[(t2
& 0x0F) << 2];
115 return p
- (uint8_t*)dest
;
118 #ifdef WORDS_BIGENDIAN /* BIG ENDIAN -- SUN / IBM / MOTOROLA */
119 int modp_b64_decode(char* dest
, const char* src
, int len
)
121 if (len
== 0) return 0;
124 /* if padding is used, then the message must be at least
125 4 chars and be a multiple of 4.
126 there can be at most 2 pad chars at the end */
127 if (len
< 4 || (len
% 4 != 0)) return -1;
128 if (src
[len
-1] == CHARPAD
) {
130 if (src
[len
-1] == CHARPAD
) {
137 int leftover
= len
% 4;
138 int chunks
= (leftover
== 0) ? len
/ 4 - 1 : len
/4;
140 uint8_t* p
= (uint8_t*) dest
;
142 uint32_t* destInt
= (uint32_t*) p
;
143 uint32_t* srcInt
= (uint32_t*) src
;
144 uint32_t y
= *srcInt
++;
145 for (i
= 0; i
< chunks
; ++i
) {
146 x
= d0
[y
>> 24 & 0xff] | d1
[y
>> 16 & 0xff] |
147 d2
[y
>> 8 & 0xff] | d3
[y
& 0xff];
149 if (x
>= BADCHAR
) return -1;
152 destInt
= (uint32_t*)p
;
158 x
= d0
[y
>> 24 & 0xff] | d1
[y
>> 16 & 0xff] |
159 d2
[y
>> 8 & 0xff] | d3
[y
& 0xff];
160 if (x
>= BADCHAR
) return -1;
161 *p
++ = ((uint8_t*)&x
)[1];
162 *p
++ = ((uint8_t*)&x
)[2];
163 *p
= ((uint8_t*)&x
)[3];
170 x
= d3
[y
>> 24] *64 + d3
[(y
>> 16) & 0xff];
171 *p
= (uint8_t)(x
>> 4);
173 default: /* case 3 */
174 x
= (d3
[y
>> 24] *64 + d3
[(y
>> 16) & 0xff])*64 +
176 *p
++ = (uint8_t) (x
>> 10);
177 *p
= (uint8_t) (x
>> 2);
181 if (x
>= BADCHAR
) return -1;
182 return 3*chunks
+ (6*leftover
)/8;
185 #else /* LITTLE ENDIAN -- INTEL AND FRIENDS */
187 int modp_b64_decode(char* dest
, const char* src
, int len
)
189 if (len
== 0) return 0;
193 * if padding is used, then the message must be at least
194 * 4 chars and be a multiple of 4
196 if (len
< 4 || (len
% 4 != 0)) return -1; /* error */
197 /* there can be at most 2 pad chars at the end */
198 if (src
[len
-1] == CHARPAD
) {
200 if (src
[len
-1] == CHARPAD
) {
207 int leftover
= len
% 4;
208 int chunks
= (leftover
== 0) ? len
/ 4 - 1 : len
/4;
210 uint8_t* p
= (uint8_t*)dest
;
212 uint32_t* destInt
= (uint32_t*) p
;
213 uint32_t* srcInt
= (uint32_t*) src
;
214 uint32_t y
= *srcInt
++;
215 for (i
= 0; i
< chunks
; ++i
) {
217 d1
[(y
>> 8) & 0xff] |
218 d2
[(y
>> 16) & 0xff] |
219 d3
[(y
>> 24) & 0xff];
221 if (x
>= BADCHAR
) return -1;
224 destInt
= (uint32_t*)p
;
231 d1
[(y
>> 8) & 0xff] |
232 d2
[(y
>> 16) & 0xff] |
233 d3
[(y
>> 24) & 0xff];
235 if (x
>= BADCHAR
) return -1;
236 *p
++ = ((uint8_t*)(&x
))[0];
237 *p
++ = ((uint8_t*)(&x
))[1];
238 *p
= ((uint8_t*)(&x
))[2];
241 case 1: /* with padding this is an impossible case */
243 *p
= *((uint8_t*)(&x
)); // i.e. first char/byte in int
245 case 2: // * case 2, 1 output byte */
246 x
= d0
[y
& 0xff] | d1
[y
>> 8 & 0xff];
247 *p
= *((uint8_t*)(&x
)); // i.e. first char
249 default: /* case 3, 2 output bytes */
252 d2
[y
>> 16 & 0xff]; /* 0x3c */
253 *p
++ = ((uint8_t*)(&x
))[0];
254 *p
= ((uint8_t*)(&x
))[1];
258 if (x
>= BADCHAR
) return -1;
260 return 3*chunks
+ (6*leftover
)/8;
263 #endif /* if bigendian / else / endif */