Branch data Line data Source code
1 : : /* $OpenBSD: base64.c,v 1.5 2006/10/21 09:55:03 otto 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 : : /* OPENBSD ORIGINAL: lib/libc/net/base64.c */
46 : :
47 : : #include "includes.h"
48 : :
49 : : #if (!defined(HAVE_B64_NTOP) && !defined(HAVE___B64_NTOP)) || (!defined(HAVE_B64_PTON) && !defined(HAVE___B64_PTON))
50 : :
51 : : #include <sys/types.h>
52 : : #include <sys/param.h>
53 : : #include <sys/socket.h>
54 : : #include <netinet/in.h>
55 : : #include <arpa/inet.h>
56 : :
57 : : #include <ctype.h>
58 : : #include <stdio.h>
59 : :
60 : : #include <stdlib.h>
61 : : #include <string.h>
62 : :
63 : : #include "base64.h"
64 : :
65 : : static const char Base64[] =
66 : : "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
67 : : static const char Pad64 = '=';
68 : :
69 : : /* (From RFC1521 and draft-ietf-dnssec-secext-03.txt)
70 : : The following encoding technique is taken from RFC 1521 by Borenstein
71 : : and Freed. It is reproduced here in a slightly edited form for
72 : : convenience.
73 : :
74 : : A 65-character subset of US-ASCII is used, enabling 6 bits to be
75 : : represented per printable character. (The extra 65th character, "=",
76 : : is used to signify a special processing function.)
77 : :
78 : : The encoding process represents 24-bit groups of input bits as output
79 : : strings of 4 encoded characters. Proceeding from left to right, a
80 : : 24-bit input group is formed by concatenating 3 8-bit input groups.
81 : : These 24 bits are then treated as 4 concatenated 6-bit groups, each
82 : : of which is translated into a single digit in the base64 alphabet.
83 : :
84 : : Each 6-bit group is used as an index into an array of 64 printable
85 : : characters. The character referenced by the index is placed in the
86 : : output string.
87 : :
88 : : Table 1: The Base64 Alphabet
89 : :
90 : : Value Encoding Value Encoding Value Encoding Value Encoding
91 : : 0 A 17 R 34 i 51 z
92 : : 1 B 18 S 35 j 52 0
93 : : 2 C 19 T 36 k 53 1
94 : : 3 D 20 U 37 l 54 2
95 : : 4 E 21 V 38 m 55 3
96 : : 5 F 22 W 39 n 56 4
97 : : 6 G 23 X 40 o 57 5
98 : : 7 H 24 Y 41 p 58 6
99 : : 8 I 25 Z 42 q 59 7
100 : : 9 J 26 a 43 r 60 8
101 : : 10 K 27 b 44 s 61 9
102 : : 11 L 28 c 45 t 62 +
103 : : 12 M 29 d 46 u 63 /
104 : : 13 N 30 e 47 v
105 : : 14 O 31 f 48 w (pad) =
106 : : 15 P 32 g 49 x
107 : : 16 Q 33 h 50 y
108 : :
109 : : Special processing is performed if fewer than 24 bits are available
110 : : at the end of the data being encoded. A full encoding quantum is
111 : : always completed at the end of a quantity. When fewer than 24 input
112 : : bits are available in an input group, zero bits are added (on the
113 : : right) to form an integral number of 6-bit groups. Padding at the
114 : : end of the data is performed using the '=' character.
115 : :
116 : : Since all base64 input is an integral number of octets, only the
117 : : -------------------------------------------------
118 : : following cases can arise:
119 : :
120 : : (1) the final quantum of encoding input is an integral
121 : : multiple of 24 bits; here, the final unit of encoded
122 : : output will be an integral multiple of 4 characters
123 : : with no "=" padding,
124 : : (2) the final quantum of encoding input is exactly 8 bits;
125 : : here, the final unit of encoded output will be two
126 : : characters followed by two "=" padding characters, or
127 : : (3) the final quantum of encoding input is exactly 16 bits;
128 : : here, the final unit of encoded output will be three
129 : : characters followed by one "=" padding character.
130 : : */
131 : :
132 : : #if !defined(HAVE_B64_NTOP) && !defined(HAVE___B64_NTOP)
133 : : int
134 : 170 : b64_ntop(u_char const *src, size_t srclength, char *target, size_t targsize)
135 : : {
136 : 170 : size_t datalength = 0;
137 : : u_char input[3];
138 : : u_char output[4];
139 : : u_int i;
140 : :
141 [ + + ]: 39193 : while (2 < srclength) {
142 : 39023 : input[0] = *src++;
143 : 39023 : input[1] = *src++;
144 : 39023 : input[2] = *src++;
145 : 39023 : srclength -= 3;
146 : :
147 : 39023 : output[0] = input[0] >> 2;
148 : 39023 : output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
149 : 39023 : output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
150 : 39023 : output[3] = input[2] & 0x3f;
151 : :
152 [ + - ]: 39023 : if (datalength + 4 > targsize)
153 : : return (-1);
154 : 39023 : target[datalength++] = Base64[output[0]];
155 : 39023 : target[datalength++] = Base64[output[1]];
156 : 39023 : target[datalength++] = Base64[output[2]];
157 : 39023 : target[datalength++] = Base64[output[3]];
158 : : }
159 : :
160 : : /* Now we worry about padding. */
161 [ + + ]: 170 : if (0 != srclength) {
162 : : /* Get what's left. */
163 : 119 : input[0] = input[1] = input[2] = '\0';
164 [ + + ]: 306 : for (i = 0; i < srclength; i++)
165 : 187 : input[i] = *src++;
166 : :
167 : 119 : output[0] = input[0] >> 2;
168 : 119 : output[1] = ((input[0] & 0x03) << 4) + (input[1] >> 4);
169 : 119 : output[2] = ((input[1] & 0x0f) << 2) + (input[2] >> 6);
170 : :
171 [ + - ]: 119 : if (datalength + 4 > targsize)
172 : : return (-1);
173 : 119 : target[datalength++] = Base64[output[0]];
174 : 119 : target[datalength++] = Base64[output[1]];
175 [ + + ]: 119 : if (srclength == 1)
176 : 51 : target[datalength++] = Pad64;
177 : : else
178 : 68 : target[datalength++] = Base64[output[2]];
179 : 119 : target[datalength++] = Pad64;
180 : : }
181 [ + - ]: 170 : if (datalength >= targsize)
182 : : return (-1);
183 : 170 : target[datalength] = '\0'; /* Returned value doesn't count \0. */
184 : 170 : return (datalength);
185 : : }
186 : : #endif /* !defined(HAVE_B64_NTOP) && !defined(HAVE___B64_NTOP) */
187 : :
188 : : #if !defined(HAVE_B64_PTON) && !defined(HAVE___B64_PTON)
189 : :
190 : : /* skips all whitespace anywhere.
191 : : converts characters, four at a time, starting at (or after)
192 : : src from base - 64 numbers into three 8 bit bytes in the target area.
193 : : it returns the number of data bytes stored at the target, or -1 on error.
194 : : */
195 : :
196 : : int
197 : 9172 : b64_pton(char const *src, u_char *target, size_t targsize)
198 : : {
199 : : u_int tarindex, state;
200 : : int ch;
201 : : char *pos;
202 : :
203 : 9172 : state = 0;
204 : 9172 : tarindex = 0;
205 : :
206 [ + + ]: 3701495 : while ((ch = *src++) != '\0') {
207 [ - + ]: 3693197 : if (isspace(ch)) /* Skip whitespace anywhere. */
208 : 0 : continue;
209 : :
210 [ + + ]: 3693197 : if (ch == Pad64)
211 : : break;
212 : :
213 [ - + ][ # # ]: 3692323 : pos = strchr(Base64, ch);
214 [ + - ]: 3692323 : if (pos == 0) /* A non-base64 character. */
215 : : return (-1);
216 : :
217 [ + + + + : 3692323 : switch (state) {
- ]
218 : : case 0:
219 [ + - ]: 923385 : if (target) {
220 [ + - ]: 923385 : if (tarindex >= targsize)
221 : : return (-1);
222 : 923385 : target[tarindex] = (pos - Base64) << 2;
223 : : }
224 : : state = 1;
225 : : break;
226 : : case 1:
227 [ + - ]: 923385 : if (target) {
228 [ + - ]: 923385 : if (tarindex + 1 >= targsize)
229 : : return (-1);
230 : 923385 : target[tarindex] |= (pos - Base64) >> 4;
231 : 923385 : target[tarindex+1] = ((pos - Base64) & 0x0f)
232 : 923385 : << 4 ;
233 : : }
234 : 923385 : tarindex++;
235 : 923385 : state = 2;
236 : 923385 : break;
237 : : case 2:
238 [ + - ]: 923042 : if (target) {
239 [ + - ]: 923042 : if (tarindex + 1 >= targsize)
240 : : return (-1);
241 : 923042 : target[tarindex] |= (pos - Base64) >> 2;
242 : 923042 : target[tarindex+1] = ((pos - Base64) & 0x03)
243 : 923042 : << 6;
244 : : }
245 : 923042 : tarindex++;
246 : 923042 : state = 3;
247 : 923042 : break;
248 : : case 3:
249 [ + - ]: 922511 : if (target) {
250 [ + - ]: 922511 : if (tarindex >= targsize)
251 : : return (-1);
252 : 922511 : target[tarindex] |= (pos - Base64);
253 : : }
254 : 922511 : tarindex++;
255 : 922511 : state = 0;
256 : 3692323 : break;
257 : : }
258 : : }
259 : :
260 : : /*
261 : : * We are done decoding Base-64 chars. Let's see if we ended
262 : : * on a byte boundary, and/or with erroneous trailing characters.
263 : : */
264 : :
265 [ + + ]: 9172 : if (ch == Pad64) { /* We got a pad char. */
266 : 874 : ch = *src++; /* Skip it, get next. */
267 [ + + - - ]: 874 : switch (state) {
268 : : case 0: /* Invalid = in first position */
269 : : case 1: /* Invalid = in second position */
270 : : return (-1);
271 : :
272 : : case 2: /* Valid, means one byte of info */
273 : : /* Skip any number of spaces. */
274 [ + - ]: 343 : for (; ch != '\0'; ch = *src++)
275 [ - + ]: 343 : if (!isspace(ch))
276 : : break;
277 : : /* Make sure there is another trailing = sign. */
278 [ + - ]: 343 : if (ch != Pad64)
279 : : return (-1);
280 : 874 : ch = *src++; /* Skip the = */
281 : : /* Fall through to "single trailing =" case. */
282 : : /* FALLTHROUGH */
283 : :
284 : : case 3: /* Valid, means two bytes of info */
285 : : /*
286 : : * We know this char is an =. Is there anything but
287 : : * whitespace after it?
288 : : */
289 [ + + ]: 877 : for (; ch != '\0'; ch = *src++)
290 [ + - ]: 3 : if (!isspace(ch))
291 : : return (-1);
292 : :
293 : : /*
294 : : * Now make sure for cases 2 and 3 that the "extra"
295 : : * bits that slopped past the last full byte were
296 : : * zeros. If we don't check them, they become a
297 : : * subliminal channel.
298 : : */
299 [ + - ][ + - ]: 874 : if (target && target[tarindex] != 0)
300 : : return (-1);
301 : : }
302 : : } else {
303 : : /*
304 : : * We ended by seeing the end of the string. Make sure we
305 : : * have no partial bytes lying around.
306 : : */
307 [ + - ]: 8298 : if (state != 0)
308 : : return (-1);
309 : : }
310 : :
311 : 9172 : return (tarindex);
312 : : }
313 : :
314 : : #endif /* !defined(HAVE_B64_PTON) && !defined(HAVE___B64_PTON) */
315 : : #endif
|
