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