Annotation of embedaddon/curl/lib/base64.c, revision 1.1
1.1 ! misho 1: /***************************************************************************
! 2: * _ _ ____ _
! 3: * Project ___| | | | _ \| |
! 4: * / __| | | | |_) | |
! 5: * | (__| |_| | _ <| |___
! 6: * \___|\___/|_| \_\_____|
! 7: *
! 8: * Copyright (C) 1998 - 2019, 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 https://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: ***************************************************************************/
! 22:
! 23: /* Base64 encoding/decoding */
! 24:
! 25: #include "curl_setup.h"
! 26:
! 27: #if !defined(CURL_DISABLE_HTTP_AUTH) || defined(USE_SSH) || \
! 28: !defined(CURL_DISABLE_LDAP) || \
! 29: !defined(CURL_DISABLE_DOH) || defined(USE_SSL)
! 30:
! 31: #include "urldata.h" /* for the Curl_easy definition */
! 32: #include "warnless.h"
! 33: #include "curl_base64.h"
! 34: #include "non-ascii.h"
! 35:
! 36: /* The last 3 #include files should be in this order */
! 37: #include "curl_printf.h"
! 38: #include "curl_memory.h"
! 39: #include "memdebug.h"
! 40:
! 41: /* ---- Base64 Encoding/Decoding Table --- */
! 42: static const char base64[]=
! 43: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
! 44:
! 45: /* The Base 64 encoding with an URL and filename safe alphabet, RFC 4648
! 46: section 5 */
! 47: static const char base64url[]=
! 48: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
! 49:
! 50: static size_t decodeQuantum(unsigned char *dest, const char *src)
! 51: {
! 52: size_t padding = 0;
! 53: const char *s, *p;
! 54: unsigned long i, x = 0;
! 55:
! 56: for(i = 0, s = src; i < 4; i++, s++) {
! 57: if(*s == '=') {
! 58: x = (x << 6);
! 59: padding++;
! 60: }
! 61: else {
! 62: unsigned long v = 0;
! 63: p = base64;
! 64:
! 65: while(*p && (*p != *s)) {
! 66: v++;
! 67: p++;
! 68: }
! 69:
! 70: if(*p == *s)
! 71: x = (x << 6) + v;
! 72: else
! 73: return 0;
! 74: }
! 75: }
! 76:
! 77: if(padding < 1)
! 78: dest[2] = curlx_ultouc(x & 0xFFUL);
! 79:
! 80: x >>= 8;
! 81: if(padding < 2)
! 82: dest[1] = curlx_ultouc(x & 0xFFUL);
! 83:
! 84: x >>= 8;
! 85: dest[0] = curlx_ultouc(x & 0xFFUL);
! 86:
! 87: return 3 - padding;
! 88: }
! 89:
! 90: /*
! 91: * Curl_base64_decode()
! 92: *
! 93: * Given a base64 NUL-terminated string at src, decode it and return a
! 94: * pointer in *outptr to a newly allocated memory area holding decoded
! 95: * data. Size of decoded data is returned in variable pointed by outlen.
! 96: *
! 97: * Returns CURLE_OK on success, otherwise specific error code. Function
! 98: * output shall not be considered valid unless CURLE_OK is returned.
! 99: *
! 100: * When decoded data length is 0, returns NULL in *outptr.
! 101: *
! 102: * @unittest: 1302
! 103: */
! 104: CURLcode Curl_base64_decode(const char *src,
! 105: unsigned char **outptr, size_t *outlen)
! 106: {
! 107: size_t srclen = 0;
! 108: size_t length = 0;
! 109: size_t padding = 0;
! 110: size_t i;
! 111: size_t numQuantums;
! 112: size_t rawlen = 0;
! 113: unsigned char *pos;
! 114: unsigned char *newstr;
! 115:
! 116: *outptr = NULL;
! 117: *outlen = 0;
! 118: srclen = strlen(src);
! 119:
! 120: /* Check the length of the input string is valid */
! 121: if(!srclen || srclen % 4)
! 122: return CURLE_BAD_CONTENT_ENCODING;
! 123:
! 124: /* Find the position of any = padding characters */
! 125: while((src[length] != '=') && src[length])
! 126: length++;
! 127:
! 128: /* A maximum of two = padding characters is allowed */
! 129: if(src[length] == '=') {
! 130: padding++;
! 131: if(src[length + 1] == '=')
! 132: padding++;
! 133: }
! 134:
! 135: /* Check the = padding characters weren't part way through the input */
! 136: if(length + padding != srclen)
! 137: return CURLE_BAD_CONTENT_ENCODING;
! 138:
! 139: /* Calculate the number of quantums */
! 140: numQuantums = srclen / 4;
! 141:
! 142: /* Calculate the size of the decoded string */
! 143: rawlen = (numQuantums * 3) - padding;
! 144:
! 145: /* Allocate our buffer including room for a zero terminator */
! 146: newstr = malloc(rawlen + 1);
! 147: if(!newstr)
! 148: return CURLE_OUT_OF_MEMORY;
! 149:
! 150: pos = newstr;
! 151:
! 152: /* Decode the quantums */
! 153: for(i = 0; i < numQuantums; i++) {
! 154: size_t result = decodeQuantum(pos, src);
! 155: if(!result) {
! 156: free(newstr);
! 157:
! 158: return CURLE_BAD_CONTENT_ENCODING;
! 159: }
! 160:
! 161: pos += result;
! 162: src += 4;
! 163: }
! 164:
! 165: /* Zero terminate */
! 166: *pos = '\0';
! 167:
! 168: /* Return the decoded data */
! 169: *outptr = newstr;
! 170: *outlen = rawlen;
! 171:
! 172: return CURLE_OK;
! 173: }
! 174:
! 175: static CURLcode base64_encode(const char *table64,
! 176: struct Curl_easy *data,
! 177: const char *inputbuff, size_t insize,
! 178: char **outptr, size_t *outlen)
! 179: {
! 180: CURLcode result;
! 181: unsigned char ibuf[3];
! 182: unsigned char obuf[4];
! 183: int i;
! 184: int inputparts;
! 185: char *output;
! 186: char *base64data;
! 187: char *convbuf = NULL;
! 188:
! 189: const char *indata = inputbuff;
! 190:
! 191: *outptr = NULL;
! 192: *outlen = 0;
! 193:
! 194: if(!insize)
! 195: insize = strlen(indata);
! 196:
! 197: #if SIZEOF_SIZE_T == 4
! 198: if(insize > UINT_MAX/4)
! 199: return CURLE_OUT_OF_MEMORY;
! 200: #endif
! 201:
! 202: base64data = output = malloc(insize * 4 / 3 + 4);
! 203: if(!output)
! 204: return CURLE_OUT_OF_MEMORY;
! 205:
! 206: /*
! 207: * The base64 data needs to be created using the network encoding
! 208: * not the host encoding. And we can't change the actual input
! 209: * so we copy it to a buffer, translate it, and use that instead.
! 210: */
! 211: result = Curl_convert_clone(data, indata, insize, &convbuf);
! 212: if(result) {
! 213: free(output);
! 214: return result;
! 215: }
! 216:
! 217: if(convbuf)
! 218: indata = (char *)convbuf;
! 219:
! 220: while(insize > 0) {
! 221: for(i = inputparts = 0; i < 3; i++) {
! 222: if(insize > 0) {
! 223: inputparts++;
! 224: ibuf[i] = (unsigned char) *indata;
! 225: indata++;
! 226: insize--;
! 227: }
! 228: else
! 229: ibuf[i] = 0;
! 230: }
! 231:
! 232: obuf[0] = (unsigned char) ((ibuf[0] & 0xFC) >> 2);
! 233: obuf[1] = (unsigned char) (((ibuf[0] & 0x03) << 4) | \
! 234: ((ibuf[1] & 0xF0) >> 4));
! 235: obuf[2] = (unsigned char) (((ibuf[1] & 0x0F) << 2) | \
! 236: ((ibuf[2] & 0xC0) >> 6));
! 237: obuf[3] = (unsigned char) (ibuf[2] & 0x3F);
! 238:
! 239: switch(inputparts) {
! 240: case 1: /* only one byte read */
! 241: msnprintf(output, 5, "%c%c==",
! 242: table64[obuf[0]],
! 243: table64[obuf[1]]);
! 244: break;
! 245:
! 246: case 2: /* two bytes read */
! 247: msnprintf(output, 5, "%c%c%c=",
! 248: table64[obuf[0]],
! 249: table64[obuf[1]],
! 250: table64[obuf[2]]);
! 251: break;
! 252:
! 253: default:
! 254: msnprintf(output, 5, "%c%c%c%c",
! 255: table64[obuf[0]],
! 256: table64[obuf[1]],
! 257: table64[obuf[2]],
! 258: table64[obuf[3]]);
! 259: break;
! 260: }
! 261: output += 4;
! 262: }
! 263:
! 264: /* Zero terminate */
! 265: *output = '\0';
! 266:
! 267: /* Return the pointer to the new data (allocated memory) */
! 268: *outptr = base64data;
! 269:
! 270: free(convbuf);
! 271:
! 272: /* Return the length of the new data */
! 273: *outlen = strlen(base64data);
! 274:
! 275: return CURLE_OK;
! 276: }
! 277:
! 278: /*
! 279: * Curl_base64_encode()
! 280: *
! 281: * Given a pointer to an input buffer and an input size, encode it and
! 282: * return a pointer in *outptr to a newly allocated memory area holding
! 283: * encoded data. Size of encoded data is returned in variable pointed by
! 284: * outlen.
! 285: *
! 286: * Input length of 0 indicates input buffer holds a NUL-terminated string.
! 287: *
! 288: * Returns CURLE_OK on success, otherwise specific error code. Function
! 289: * output shall not be considered valid unless CURLE_OK is returned.
! 290: *
! 291: * When encoded data length is 0, returns NULL in *outptr.
! 292: *
! 293: * @unittest: 1302
! 294: */
! 295: CURLcode Curl_base64_encode(struct Curl_easy *data,
! 296: const char *inputbuff, size_t insize,
! 297: char **outptr, size_t *outlen)
! 298: {
! 299: return base64_encode(base64, data, inputbuff, insize, outptr, outlen);
! 300: }
! 301:
! 302: /*
! 303: * Curl_base64url_encode()
! 304: *
! 305: * Given a pointer to an input buffer and an input size, encode it and
! 306: * return a pointer in *outptr to a newly allocated memory area holding
! 307: * encoded data. Size of encoded data is returned in variable pointed by
! 308: * outlen.
! 309: *
! 310: * Input length of 0 indicates input buffer holds a NUL-terminated string.
! 311: *
! 312: * Returns CURLE_OK on success, otherwise specific error code. Function
! 313: * output shall not be considered valid unless CURLE_OK is returned.
! 314: *
! 315: * When encoded data length is 0, returns NULL in *outptr.
! 316: *
! 317: * @unittest: 1302
! 318: */
! 319: CURLcode Curl_base64url_encode(struct Curl_easy *data,
! 320: const char *inputbuff, size_t insize,
! 321: char **outptr, size_t *outlen)
! 322: {
! 323: return base64_encode(base64url, data, inputbuff, insize, outptr, outlen);
! 324: }
! 325:
! 326: #endif /* no users so disabled */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to base64.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / curl / lib