1 /***************************************************************************
2 * _ _ ____ _
3 * Project ___| | | | _ \| |
4 * / __| | | | |_) | |
5 * | (__| |_| | _ <| |___
6 * \___|\___/|_| \_\_____|
7 *
8 * Copyright (C) 1998 - 2008, Daniel Stenberg, <daniel@haxx.se>, et al.
9 *
10 * This software is licensed as described in the file COPYING, which
11 * you should have received as part of this distribution. The terms
12 * are also available at http://curl.haxx.se/docs/copyright.html.
13 *
14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell
15 * copies of the Software, and permit persons to whom the Software is
16 * furnished to do so, under the terms of the COPYING file.
17 *
18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
19 * KIND, either express or implied.
20 *
21 * $Id: base64.c,v 1.51 2008-11-14 16:22:18 bagder Exp $
22 ***************************************************************************/
23
24 /* Base64 encoding/decoding
25 *
26 * Test harnesses down the bottom - compile with -DTEST_ENCODE for
27 * a program that will read in raw data from stdin and write out
28 * a base64-encoded version to stdout, and the length returned by the
29 * encoding function to stderr. Compile with -DTEST_DECODE for a program that
30 * will go the other way.
31 *
32 * This code will break if int is smaller than 32 bits
33 */
34
35 #include "setup.h"
36
37 #include <stdlib.h>
38 #include <string.h>
39
40 #define _MPRINTF_REPLACE /* use our functions only */
41 #include <curl/mprintf.h>
42
43 #include "urldata.h" /* for the SessionHandle definition */
44 #include "easyif.h" /* for Curl_convert_... prototypes */
45 #include "curl_base64.h"
46 #include "memory.h"
47
48 /* include memdebug.h last */
49 #include "memdebug.h"
50
51 /* ---- Base64 Encoding/Decoding Table --- */
52 static const char table64[]=
53 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
54
decodeQuantum(unsigned char * dest,const char * src)55 static void decodeQuantum(unsigned char *dest, const char *src)
56 {
57 unsigned int x = 0;
58 int i;
59 char *found;
60
61 for(i = 0; i < 4; i++) {
62 if((found = strchr(table64, src[i])) != NULL)
63 x = (x << 6) + (unsigned int)(found - table64);
64 else if(src[i] == '=')
65 x = (x << 6);
66 }
67
68 dest[2] = (unsigned char)(x & 255);
69 x >>= 8;
70 dest[1] = (unsigned char)(x & 255);
71 x >>= 8;
72 dest[0] = (unsigned char)(x & 255);
73 }
74
75 /*
76 * Curl_base64_decode()
77 *
78 * Given a base64 string at src, decode it and return an allocated memory in
79 * the *outptr. Returns the length of the decoded data.
80 */
Curl_base64_decode(const char * src,unsigned char ** outptr)81 size_t Curl_base64_decode(const char *src, unsigned char **outptr)
82 {
83 int length = 0;
84 int equalsTerm = 0;
85 int i;
86 int numQuantums;
87 unsigned char lastQuantum[3];
88 size_t rawlen=0;
89 unsigned char *newstr;
90
91 *outptr = NULL;
92
93 while((src[length] != '=') && src[length])
94 length++;
95 /* A maximum of two = padding characters is allowed */
96 if(src[length] == '=') {
97 equalsTerm++;
98 if(src[length+equalsTerm] == '=')
99 equalsTerm++;
100 }
101 numQuantums = (length + equalsTerm) / 4;
102
103 /* Don't allocate a buffer if the decoded length is 0 */
104 if(numQuantums <= 0)
105 return 0;
106
107 rawlen = (numQuantums * 3) - equalsTerm;
108
109 /* The buffer must be large enough to make room for the last quantum
110 (which may be partially thrown out) and the zero terminator. */
111 newstr = malloc(rawlen+4);
112 if(!newstr)
113 return 0;
114
115 *outptr = newstr;
116
117 /* Decode all but the last quantum (which may not decode to a
118 multiple of 3 bytes) */
119 for(i = 0; i < numQuantums - 1; i++) {
120 decodeQuantum(newstr, src);
121 newstr += 3; src += 4;
122 }
123
124 /* This final decode may actually read slightly past the end of the buffer
125 if the input string is missing pad bytes. This will almost always be
126 harmless. */
127 decodeQuantum(lastQuantum, src);
128 for(i = 0; i < 3 - equalsTerm; i++)
129 newstr[i] = lastQuantum[i];
130
131 newstr[i] = 0; /* zero terminate */
132 return rawlen;
133 }
134
135 /*
136 * Curl_base64_encode()
137 *
138 * Returns the length of the newly created base64 string. The third argument
139 * is a pointer to an allocated area holding the base64 data. If something
140 * went wrong, 0 is returned.
141 *
142 */
Curl_base64_encode(struct SessionHandle * data,const char * inp,size_t insize,char ** outptr)143 size_t Curl_base64_encode(struct SessionHandle *data,
144 const char *inp, size_t insize, char **outptr)
145 {
146 unsigned char ibuf[3];
147 unsigned char obuf[4];
148 int i;
149 int inputparts;
150 char *output;
151 char *base64data;
152 #ifdef CURL_DOES_CONVERSIONS
153 char *convbuf = NULL;
154 #endif
155
156 const char *indata = inp;
157
158 *outptr = NULL; /* set to NULL in case of failure before we reach the end */
159
160 if(0 == insize)
161 insize = strlen(indata);
162
163 base64data = output = malloc(insize*4/3+4);
164 if(NULL == output)
165 return 0;
166
167 #ifdef CURL_DOES_CONVERSIONS
168 /*
169 * The base64 data needs to be created using the network encoding
170 * not the host encoding. And we can't change the actual input
171 * so we copy it to a buffer, translate it, and use that instead.
172 */
173 if(data) {
174 convbuf = malloc(insize);
175 if(!convbuf) {
176 free(output);
177 return 0;
178 }
179 memcpy(convbuf, indata, insize);
180 if(CURLE_OK != Curl_convert_to_network(data, convbuf, insize)) {
181 free(convbuf);
182 free(output);
183 return 0;
184 }
185 indata = convbuf; /* switch to the converted buffer */
186 }
187 #else
188 (void)data;
189 #endif
190
191 while(insize > 0) {
192 for (i = inputparts = 0; i < 3; i++) {
193 if(insize > 0) {
194 inputparts++;
195 ibuf[i] = *indata;
196 indata++;
197 insize--;
198 }
199 else
200 ibuf[i] = 0;
201 }
202
203 obuf[0] = (unsigned char) ((ibuf[0] & 0xFC) >> 2);
204 obuf[1] = (unsigned char) (((ibuf[0] & 0x03) << 4) | \
205 ((ibuf[1] & 0xF0) >> 4));
206 obuf[2] = (unsigned char) (((ibuf[1] & 0x0F) << 2) | \
207 ((ibuf[2] & 0xC0) >> 6));
208 obuf[3] = (unsigned char) (ibuf[2] & 0x3F);
209
210 switch(inputparts) {
211 case 1: /* only one byte read */
212 snprintf(output, 5, "%c%c==",
213 table64[obuf[0]],
214 table64[obuf[1]]);
215 break;
216 case 2: /* two bytes read */
217 snprintf(output, 5, "%c%c%c=",
218 table64[obuf[0]],
219 table64[obuf[1]],
220 table64[obuf[2]]);
221 break;
222 default:
223 snprintf(output, 5, "%c%c%c%c",
224 table64[obuf[0]],
225 table64[obuf[1]],
226 table64[obuf[2]],
227 table64[obuf[3]] );
228 break;
229 }
230 output += 4;
231 }
232 *output=0;
233 *outptr = base64data; /* make it return the actual data memory */
234
235 #ifdef CURL_DOES_CONVERSIONS
236 if(data)
237 free(convbuf);
238 #endif
239 return strlen(base64data); /* return the length of the new data */
240 }
241 /* ---- End of Base64 Encoding ---- */
242