1 /* $NetBSD: base64.c,v 1.1.1.4 2014/05/28 09:58:45 tron Exp $ */ 2 3 /* base64.c -- routines to encode/decode base64 data */ 4 /* $OpenLDAP$ */ 5 /* This work is part of OpenLDAP Software <http://www.openldap.org/>. 6 * 7 * Copyright 1998-2014 The OpenLDAP Foundation. 8 * Portions Copyright 1998-2003 Kurt D. Zeilenga. 9 * Portions Copyright 1995 IBM Corporation. 10 * All rights reserved. 11 * 12 * Redistribution and use in source and binary forms, with or without 13 * modification, are permitted only as authorized by the OpenLDAP 14 * Public License. 15 * 16 * A copy of this license is available in the file LICENSE in the 17 * top-level directory of the distribution or, alternatively, at 18 * <http://www.OpenLDAP.org/license.html>. 19 */ 20 /* Portions Copyright (c) 1996, 1998 by Internet Software Consortium. 21 * 22 * Permission to use, copy, modify, and distribute this software for any 23 * purpose with or without fee is hereby granted, provided that the above 24 * copyright notice and this permission notice appear in all copies. 25 * 26 * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS 27 * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES 28 * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE 29 * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 30 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 31 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS 32 * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS 33 * SOFTWARE. 34 */ 35 /* This work is based upon Base64 routines (developed by IBM) found 36 * Berkeley Internet Name Daemon (BIND) as distributed by ISC. They 37 * were adapted for inclusion in OpenLDAP Software by Kurt D. Zeilenga. 38 */ 39 40 #include "portable.h" 41 42 #include <ac/assert.h> 43 #include <ac/stdlib.h> 44 #include <ac/ctype.h> 45 #include <ac/string.h> 46 47 /* include socket.h to get sys/types.h and/or winsock2.h */ 48 #include <ac/socket.h> 49 50 #include "lutil.h" 51 52 static const char Base64[] = 53 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; 54 static const char Pad64 = '='; 55 56 /* (From RFC1521 and draft-ietf-dnssec-secext-03.txt) 57 The following encoding technique is taken from RFC 1521 by Borenstein 58 and Freed. It is reproduced here in a slightly edited form for 59 convenience. 60 61 A 65-character subset of US-ASCII is used, enabling 6 bits to be 62 represented per printable character. (The extra 65th character, "=", 63 is used to signify a special processing function.) 64 65 The encoding process represents 24-bit groups of input bits as output 66 strings of 4 encoded characters. Proceeding from left to right, a 67 24-bit input group is formed by concatenating 3 8-bit input groups. 68 These 24 bits are then treated as 4 concatenated 6-bit groups, each 69 of which is translated into a single digit in the base64 alphabet. 70 71 Each 6-bit group is used as an index into an array of 64 printable 72 characters. The character referenced by the index is placed in the 73 output string. 74 75 Table 1: The Base64 Alphabet 76 77 Value Encoding Value Encoding Value Encoding Value Encoding 78 0 A 17 R 34 i 51 z 79 1 B 18 S 35 j 52 0 80 2 C 19 T 36 k 53 1 81 3 D 20 U 37 l 54 2 82 4 E 21 V 38 m 55 3 83 5 F 22 W 39 n 56 4 84 6 G 23 X 40 o 57 5 85 7 H 24 Y 41 p 58 6 86 8 I 25 Z 42 q 59 7 87 9 J 26 a 43 r 60 8 88 10 K 27 b 44 s 61 9 89 11 L 28 c 45 t 62 + 90 12 M 29 d 46 u 63 / 91 13 N 30 e 47 v 92 14 O 31 f 48 w (pad) = 93 15 P 32 g 49 x 94 16 Q 33 h 50 y 95 96 Special processing is performed if fewer than 24 bits are available 97 at the end of the data being encoded. A full encoding quantum is 98 always completed at the end of a quantity. When fewer than 24 input 99 bits are available in an input group, zero bits are added (on the 100 right) to form an integral number of 6-bit groups. Padding at the 101 end of the data is performed using the '=' character. 102 103 Since all base64 input is an integral number of octets, only the 104 ------------------------------------------------- 105 following cases can arise: 106 107 (1) the final quantum of encoding input is an integral 108 multiple of 24 bits; here, the final unit of encoded 109 output will be an integral multiple of 4 characters 110 with no "=" padding, 111 (2) the final quantum of encoding input is exactly 8 bits; 112 here, the final unit of encoded output will be two 113 characters followed by two "=" padding characters, or 114 (3) the final quantum of encoding input is exactly 16 bits; 115 here, the final unit of encoded output will be three 116 characters followed by one "=" padding character. 117 */ 118 119 int 120 lutil_b64_ntop( 121 u_char const *src, 122 size_t srclength, 123 char *target, 124 size_t targsize) 125 { 126 size_t datalength = 0; 127 u_char input[3]; 128 u_char output[4]; 129 size_t i; 130 131 while (2 < srclength) { 132 input[0] = *src++; 133 input[1] = *src++; 134 input[2] = *src++; 135 srclength -= 3; 136 137 output[0] = input[0] >> 2; 138 output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4); 139 output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6); 140 output[3] = input[2] & 0x3f; 141 assert(output[0] < 64); 142 assert(output[1] < 64); 143 assert(output[2] < 64); 144 assert(output[3] < 64); 145 146 if (datalength + 4 > targsize) 147 return (-1); 148 target[datalength++] = Base64[output[0]]; 149 target[datalength++] = Base64[output[1]]; 150 target[datalength++] = Base64[output[2]]; 151 target[datalength++] = Base64[output[3]]; 152 } 153 154 /* Now we worry about padding. */ 155 if (0 != srclength) { 156 /* Get what's left. */ 157 input[0] = input[1] = input[2] = '\0'; 158 for (i = 0; i < srclength; i++) 159 input[i] = *src++; 160 161 output[0] = input[0] >> 2; 162 output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4); 163 output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6); 164 assert(output[0] < 64); 165 assert(output[1] < 64); 166 assert(output[2] < 64); 167 168 if (datalength + 4 > targsize) 169 return (-1); 170 target[datalength++] = Base64[output[0]]; 171 target[datalength++] = Base64[output[1]]; 172 if (srclength == 1) 173 target[datalength++] = Pad64; 174 else 175 target[datalength++] = Base64[output[2]]; 176 target[datalength++] = Pad64; 177 } 178 if (datalength >= targsize) 179 return (-1); 180 target[datalength] = '\0'; /* Returned value doesn't count \0. */ 181 return (datalength); 182 } 183 184 /* skips all whitespace anywhere. 185 converts characters, four at a time, starting at (or after) 186 src from base - 64 numbers into three 8 bit bytes in the target area. 187 it returns the number of data bytes stored at the target, or -1 on error. 188 */ 189 190 int 191 lutil_b64_pton( 192 char const *src, 193 u_char *target, 194 size_t targsize) 195 { 196 int tarindex, state, ch; 197 char *pos; 198 199 state = 0; 200 tarindex = 0; 201 202 while ((ch = *src++) != '\0') { 203 if (isascii(ch) && isspace(ch)) /* Skip whitespace anywhere. */ 204 continue; 205 206 if (ch == Pad64) 207 break; 208 209 pos = strchr(Base64, ch); 210 if (pos == 0) /* A non-base64 character. */ 211 return (-1); 212 213 switch (state) { 214 case 0: 215 if (target) { 216 if ((size_t)tarindex >= targsize) 217 return (-1); 218 target[tarindex] = (pos - Base64) << 2; 219 } 220 state = 1; 221 break; 222 case 1: 223 if (target) { 224 if ((size_t)tarindex + 1 >= targsize) 225 return (-1); 226 target[tarindex] |= (pos - Base64) >> 4; 227 target[tarindex+1] = ((pos - Base64) & 0x0f) 228 << 4 ; 229 } 230 tarindex++; 231 state = 2; 232 break; 233 case 2: 234 if (target) { 235 if ((size_t)tarindex + 1 >= targsize) 236 return (-1); 237 target[tarindex] |= (pos - Base64) >> 2; 238 target[tarindex+1] = ((pos - Base64) & 0x03) 239 << 6; 240 } 241 tarindex++; 242 state = 3; 243 break; 244 case 3: 245 if (target) { 246 if ((size_t)tarindex >= targsize) 247 return (-1); 248 target[tarindex] |= (pos - Base64); 249 } 250 tarindex++; 251 state = 0; 252 break; 253 default: 254 abort(); 255 } 256 } 257 258 /* 259 * We are done decoding Base-64 chars. Let's see if we ended 260 * on a byte boundary, and/or with erroneous trailing characters. 261 */ 262 263 if (ch == Pad64) { /* We got a pad char. */ 264 ch = *src++; /* Skip it, get next. */ 265 switch (state) { 266 case 0: /* Invalid = in first position */ 267 case 1: /* Invalid = in second position */ 268 return (-1); 269 270 case 2: /* Valid, means one byte of info */ 271 /* Skip any number of spaces. */ 272 for ((void)NULL; ch != '\0'; ch = *src++) 273 if (! (isascii(ch) && isspace(ch))) 274 break; 275 /* Make sure there is another trailing = sign. */ 276 if (ch != Pad64) 277 return (-1); 278 ch = *src++; /* Skip the = */ 279 /* Fall through to "single trailing =" case. */ 280 /* FALLTHROUGH */ 281 282 case 3: /* Valid, means two bytes of info */ 283 /* 284 * We know this char is an =. Is there anything but 285 * whitespace after it? 286 */ 287 for ((void)NULL; ch != '\0'; ch = *src++) 288 if (! (isascii(ch) && isspace(ch))) 289 return (-1); 290 291 /* 292 * Now make sure for cases 2 and 3 that the "extra" 293 * bits that slopped past the last full byte were 294 * zeros. If we don't check them, they become a 295 * subliminal channel. 296 */ 297 if (target && target[tarindex] != 0) 298 return (-1); 299 } 300 } else { 301 /* 302 * We ended by seeing the end of the string. Make sure we 303 * have no partial bytes lying around. 304 */ 305 if (state != 0) 306 return (-1); 307 } 308 309 return (tarindex); 310 } 311