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