1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 #include <sys/types.h>
27 #ifdef _KERNEL
28 #include <sys/sunddi.h>
29 #include <sys/errno.h>
30 #else
31 #include <string.h>
32 #include <errno.h>
33 #endif /* _KERNEL */
34
35 /*
36 * base64 decoding table (from uudecode.c)
37 */
38 /* BEGIN CSTYLED */
39 static char base64_decode_tab[] = {
40 '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377',
41 '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377',
42 '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377',
43 '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377',
44 '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377',
45 '\377', '\377', '\377', 62, '\377', '\377', '\377', 63,
46 52, 53, 54, 55, 56, 57, 58, 59,
47 60, 61, '\377', '\377', '\377', '\377', '\377', '\377',
48 '\377', 0, 1, 2, 3, 4, 5, 6,
49 7, 8, 9, 10, 11, 12, 13, 14,
50 15, 16, 17, 18, 19, 20, 21, 22,
51 23, 24, 25, '\377', '\377', '\377', '\377', '\377',
52 '\377', 26, 27, 28, 29, 30, 31, 32,
53 33, 34, 35, 36, 37, 38, 39, 40,
54 41, 42, 43, 44, 45, 46, 47, 48,
55 49, 50, 51, '\377', '\377', '\377', '\377', '\377'
56 };
57 /* END CSTYLED */
58
59 /* true if the character is in the base64 encoding table */
60 #define validbase64(c) (('A' <= (c) && (c) <= 'Z') || \
61 ('a' <= (c) && (c) <= 'z') || \
62 ('0' <= (c) && (c) <= '9') || \
63 (c) == '+' || (c) == '/')
64
65 static int
outdec64(unsigned char * out,unsigned char * chr,int num)66 outdec64(unsigned char *out, unsigned char *chr, int num)
67 {
68
69 unsigned char char1, char2, char3, char4;
70 unsigned char *outptr = out;
71 int rc = 0;
72
73 switch (num) {
74 case 0:
75 case 1: /* these are impossible */
76 default:
77 break;
78 case 2: /* 2 base64 bytes == 1 decoded byte */
79 char1 = base64_decode_tab[chr[0]] & 0xFF;
80 char2 = base64_decode_tab[chr[1]] & 0xFF;
81 *(outptr++) = ((char1 << 2) & 0xFC) |
82 ((char2 >> 4) & 0x03);
83 rc = 1;
84 break;
85 case 3: /* 3 base64 bytes == 2 decoded bytes */
86 char1 = base64_decode_tab[chr[0]] & 0xFF;
87 char2 = base64_decode_tab[chr[1]] & 0xFF;
88 char3 = base64_decode_tab[chr[2]] & 0xFF;
89 *(outptr++) = ((char1 << 2) & 0xFC) |
90 ((char2 >> 4) & 0x03);
91 *(outptr++) = ((char2 << 4) & 0xF0) |
92 ((char3 >> 2) & 0x0F);
93 rc = 2;
94 break;
95 case 4: /* 4 base64 bytes == 3 decoded bytes */
96 char1 = base64_decode_tab[chr[0]] & 0xFF;
97 char2 = base64_decode_tab[chr[1]] & 0xFF;
98 char3 = base64_decode_tab[chr[2]] & 0xFF;
99 char4 = base64_decode_tab[chr[3]] & 0xFF;
100 *(outptr++) = ((char1 << 2) & 0xFC) |
101 ((char2 >> 4) & 0x03);
102 *(outptr++) = ((char2 << 4) & 0xF0) |
103 ((char3 >> 2) & 0x0F);
104 *(outptr++) = ((char3 << 6) & 0xC0) |
105 (char4 & 0x3F);
106 rc = 3;
107 break;
108 }
109 return (rc);
110 }
111
112 #define BUFSIZE 12
113
114 int
iscsi_base64_str_to_binary(char * hstr,int hstr_len,uint8_t * binary,int binary_buf_len,int * out_len)115 iscsi_base64_str_to_binary(char *hstr, int hstr_len,
116 uint8_t *binary, int binary_buf_len, int *out_len)
117 {
118 char *iptr;
119 uint8_t tmp_out[BUFSIZE];
120 int octets, endseen, numbase64chars;
121 unsigned char chr[4], curchr;
122
123 /*
124 * base64 decode algorith, adapted from uudecode.c
125 *
126 * A valid base64 string is a multiple of 4 bytes in length
127 */
128 if ((hstr_len % 4) != 0)
129 return (EINVAL);
130
131 endseen = numbase64chars = 0;
132 *out_len = 0;
133 iptr = hstr;
134
135 while (((curchr = *(iptr++)) != '\0') &&
136 (((uintptr_t)iptr - (uintptr_t)hstr) <= hstr_len)) {
137 /* decode chars */
138 if (curchr == '=') /* if end */
139 endseen++;
140
141 if (validbase64(curchr))
142 chr[numbase64chars++] = curchr;
143 /*
144 * if we've gathered 4 base64 octets
145 * we need to decode and output them
146 */
147 if (numbase64chars == 4) {
148 octets = outdec64(tmp_out, chr, 4);
149 numbase64chars = 0;
150
151 if (*out_len + octets > binary_buf_len)
152 return (E2BIG);
153
154 (void) memcpy(binary + *out_len, tmp_out, octets);
155 *out_len += octets;
156 }
157
158 /*
159 * handle any remaining base64 octets at end
160 */
161 if (endseen && numbase64chars > 0) {
162 octets = outdec64(tmp_out, chr, numbase64chars);
163 numbase64chars = 0;
164 if (*out_len + octets > binary_buf_len)
165 return (E2BIG);
166
167 (void) memcpy(binary + *out_len, tmp_out, octets);
168 *out_len += octets;
169 }
170 }
171
172 return (0);
173 }
174
175
176 static char base64_encode_tab[] =
177 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
178 "abcdefghijklmnopqrstuvwxyz0123456789+/";
179
180 #define ENC(c) base64_encode_tab[(c) & 0x3f]
181
182 #define BASE64_BUF_HAS_ROOM(bytes_needed) \
183 ((optr + (bytes_needed)) <= base64_str_buf + base64_buf_len)
184
185 int
iscsi_binary_to_base64_str(uint8_t * in_buf,int in_buf_len,char * base64_str_buf,int base64_buf_len)186 iscsi_binary_to_base64_str(uint8_t *in_buf, int in_buf_len,
187 char *base64_str_buf, int base64_buf_len)
188 {
189 uint8_t *iptr;
190 char *optr;
191 int in_bytes_remaining;
192
193 /* base64 encode algorith, adapted from uuencode.c */
194 iptr = in_buf;
195 optr = base64_str_buf;
196
197 /*
198 * read must be a multiple of 3 bytes for
199 * this algorithm to work, and also must
200 * be small enough that read_size * (4/3)
201 * will always be 76 bytes or less, since
202 * base64 lines can be no longer than that
203 */
204 while (iptr + 3 <= in_buf + in_buf_len) {
205 if (!BASE64_BUF_HAS_ROOM(4))
206 return (E2BIG);
207
208 *(optr++) = ENC(*iptr >> 2);
209 *(optr++) = ENC((*iptr << 4) & 060 |
210 (*(iptr + 1) >> 4) & 017);
211 *(optr++) = ENC((*(iptr + 1) << 2)
212 & 074 | (*(iptr + 2) >> 6) & 03);
213 *(optr++) = ENC(*(iptr + 2) & 077);
214
215 iptr += 3;
216 }
217
218 /* need output padding ? */
219 in_bytes_remaining = ((uintptr_t)in_buf + in_buf_len) - (uintptr_t)iptr;
220 /* ASSERT(in_bytes_remaining < 3); */
221 switch (in_bytes_remaining) {
222 case 0:
223 /* no-op - 24 bits of data encoded */
224 if (!BASE64_BUF_HAS_ROOM(1))
225 return (E2BIG);
226 *(optr++) = '\0';
227 break;
228 case 1:
229 /* 8 bits encoded - pad with 2 '=' */
230 if (!BASE64_BUF_HAS_ROOM(5))
231 return (E2BIG);
232 *(optr++) = ENC((*iptr & 0xFC) >> 2);
233 *(optr++) = ENC((*iptr & 0x03) << 4);
234 *(optr++) = '=';
235 *(optr++) = '=';
236 *(optr++) = '\0';
237 break;
238 case 2:
239 /* 16 bits encoded - pad with 1 '=' */
240 if (!BASE64_BUF_HAS_ROOM(5))
241 return (E2BIG);
242 *(optr++) = ENC((*iptr & 0xFC) >> 2);
243 *(optr++) = ENC(((*iptr & 0x03) << 4) |
244 ((*(iptr + 1) & 0xF0) >> 4));
245 *(optr++) = ENC((*(iptr + 1) & 0x0F) << 2);
246 *(optr++) = '=';
247 *(optr++) = '\0';
248 break;
249 default:
250 /* impossible */
251 break;
252 }
253
254 return (0);
255 }
256