1 /*
2 * Copyright 2019-2023 The OpenSSL Project Authors. All Rights Reserved.
3 *
4 * Licensed under the Apache License 2.0 (the "License"). You may not use
5 * this file except in compliance with the License. You can obtain a copy
6 * in the file LICENSE in the source distribution or at
7 * https://www.openssl.org/source/license.html
8 */
9
10 #include <stddef.h>
11 #include <stdio.h>
12 #include <openssl/e_os2.h>
13 #include "crypto/punycode.h"
14 #include "internal/common.h" /* for HAS_PREFIX */
15 #include "internal/packet.h" /* for WPACKET */
16
17 static const unsigned int base = 36;
18 static const unsigned int tmin = 1;
19 static const unsigned int tmax = 26;
20 static const unsigned int skew = 38;
21 static const unsigned int damp = 700;
22 static const unsigned int initial_bias = 72;
23 static const unsigned int initial_n = 0x80;
24 static const unsigned int maxint = 0xFFFFFFFF;
25 static const char delimiter = '-';
26
27 #define LABEL_BUF_SIZE 512
28
29 /*-
30 * Pseudocode:
31 *
32 * function adapt(delta,numpoints,firsttime):
33 * if firsttime then let delta = delta div damp
34 * else let delta = delta div 2
35 * let delta = delta + (delta div numpoints)
36 * let k = 0
37 * while delta > ((base - tmin) * tmax) div 2 do begin
38 * let delta = delta div (base - tmin)
39 * let k = k + base
40 * end
41 * return k + (((base - tmin + 1) * delta) div (delta + skew))
42 */
43
adapt(unsigned int delta,unsigned int numpoints,unsigned int firsttime)44 static int adapt(unsigned int delta, unsigned int numpoints,
45 unsigned int firsttime)
46 {
47 unsigned int k = 0;
48
49 delta = (firsttime) ? delta / damp : delta / 2;
50 delta = delta + delta / numpoints;
51
52 while (delta > ((base - tmin) * tmax) / 2) {
53 delta = delta / (base - tmin);
54 k = k + base;
55 }
56
57 return k + (((base - tmin + 1) * delta) / (delta + skew));
58 }
59
is_basic(unsigned int a)60 static ossl_inline int is_basic(unsigned int a)
61 {
62 return (a < 0x80) ? 1 : 0;
63 }
64
65 /*-
66 * code points digit-values
67 * ------------ ----------------------
68 * 41..5A (A-Z) = 0 to 25, respectively
69 * 61..7A (a-z) = 0 to 25, respectively
70 * 30..39 (0-9) = 26 to 35, respectively
71 */
digit_decoded(const unsigned char a)72 static ossl_inline int digit_decoded(const unsigned char a)
73 {
74 if (a >= 0x41 && a <= 0x5A)
75 return a - 0x41;
76
77 if (a >= 0x61 && a <= 0x7A)
78 return a - 0x61;
79
80 if (a >= 0x30 && a <= 0x39)
81 return a - 0x30 + 26;
82
83 return -1;
84 }
85
86 /*-
87 * Pseudocode:
88 *
89 * function ossl_punycode_decode
90 * let n = initial_n
91 * let i = 0
92 * let bias = initial_bias
93 * let output = an empty string indexed from 0
94 * consume all code points before the last delimiter (if there is one)
95 * and copy them to output, fail on any non-basic code point
96 * if more than zero code points were consumed then consume one more
97 * (which will be the last delimiter)
98 * while the input is not exhausted do begin
99 * let oldi = i
100 * let w = 1
101 * for k = base to infinity in steps of base do begin
102 * consume a code point, or fail if there was none to consume
103 * let digit = the code point's digit-value, fail if it has none
104 * let i = i + digit * w, fail on overflow
105 * let t = tmin if k <= bias {+ tmin}, or
106 * tmax if k >= bias + tmax, or k - bias otherwise
107 * if digit < t then break
108 * let w = w * (base - t), fail on overflow
109 * end
110 * let bias = adapt(i - oldi, length(output) + 1, test oldi is 0?)
111 * let n = n + i div (length(output) + 1), fail on overflow
112 * let i = i mod (length(output) + 1)
113 * {if n is a basic code point then fail}
114 * insert n into output at position i
115 * increment i
116 * end
117 */
118
ossl_punycode_decode(const char * pEncoded,const size_t enc_len,unsigned int * pDecoded,unsigned int * pout_length)119 int ossl_punycode_decode(const char *pEncoded, const size_t enc_len,
120 unsigned int *pDecoded, unsigned int *pout_length)
121 {
122 unsigned int n = initial_n;
123 unsigned int i = 0;
124 unsigned int bias = initial_bias;
125 size_t processed_in = 0, written_out = 0;
126 unsigned int max_out = *pout_length;
127 unsigned int basic_count = 0;
128 unsigned int loop;
129
130 for (loop = 0; loop < enc_len; loop++) {
131 if (pEncoded[loop] == delimiter)
132 basic_count = loop;
133 }
134
135 if (basic_count > 0) {
136 if (basic_count > max_out)
137 return 0;
138
139 for (loop = 0; loop < basic_count; loop++) {
140 if (is_basic(pEncoded[loop]) == 0)
141 return 0;
142
143 pDecoded[loop] = pEncoded[loop];
144 written_out++;
145 }
146 processed_in = basic_count + 1;
147 }
148
149 for (loop = processed_in; loop < enc_len;) {
150 unsigned int oldi = i;
151 unsigned int w = 1;
152 unsigned int k, t;
153 int digit;
154
155 for (k = base;; k += base) {
156 if (loop >= enc_len)
157 return 0;
158
159 digit = digit_decoded(pEncoded[loop]);
160 loop++;
161
162 if (digit < 0)
163 return 0;
164 if ((unsigned int)digit > (maxint - i) / w)
165 return 0;
166
167 i = i + digit * w;
168 t = (k <= bias) ? tmin : (k >= bias + tmax) ? tmax
169 : k - bias;
170
171 if ((unsigned int)digit < t)
172 break;
173
174 if (w > maxint / (base - t))
175 return 0;
176 w = w * (base - t);
177 }
178
179 bias = adapt(i - oldi, written_out + 1, (oldi == 0));
180 if (i / (written_out + 1) > maxint - n)
181 return 0;
182 n = n + i / (written_out + 1);
183 i %= (written_out + 1);
184
185 if (written_out >= max_out)
186 return 0;
187
188 memmove(pDecoded + i + 1, pDecoded + i,
189 (written_out - i) * sizeof(*pDecoded));
190 pDecoded[i] = n;
191 i++;
192 written_out++;
193 }
194
195 *pout_length = written_out;
196 return 1;
197 }
198
199 /*
200 * Encode a code point using UTF-8
201 * return number of bytes on success, 0 on failure
202 * (also produces U+FFFD, which uses 3 bytes on failure)
203 */
codepoint2utf8(unsigned char * out,unsigned long utf)204 static int codepoint2utf8(unsigned char *out, unsigned long utf)
205 {
206 if (utf <= 0x7F) {
207 /* Plain ASCII */
208 out[0] = (unsigned char)utf;
209 out[1] = 0;
210 return 1;
211 } else if (utf <= 0x07FF) {
212 /* 2-byte unicode */
213 out[0] = (unsigned char)(((utf >> 6) & 0x1F) | 0xC0);
214 out[1] = (unsigned char)(((utf >> 0) & 0x3F) | 0x80);
215 out[2] = 0;
216 return 2;
217 } else if (utf <= 0xFFFF) {
218 /* 3-byte unicode */
219 out[0] = (unsigned char)(((utf >> 12) & 0x0F) | 0xE0);
220 out[1] = (unsigned char)(((utf >> 6) & 0x3F) | 0x80);
221 out[2] = (unsigned char)(((utf >> 0) & 0x3F) | 0x80);
222 out[3] = 0;
223 return 3;
224 } else if (utf <= 0x10FFFF) {
225 /* 4-byte unicode */
226 out[0] = (unsigned char)(((utf >> 18) & 0x07) | 0xF0);
227 out[1] = (unsigned char)(((utf >> 12) & 0x3F) | 0x80);
228 out[2] = (unsigned char)(((utf >> 6) & 0x3F) | 0x80);
229 out[3] = (unsigned char)(((utf >> 0) & 0x3F) | 0x80);
230 out[4] = 0;
231 return 4;
232 } else {
233 /* error - use replacement character */
234 out[0] = (unsigned char)0xEF;
235 out[1] = (unsigned char)0xBF;
236 out[2] = (unsigned char)0xBD;
237 out[3] = 0;
238 return 0;
239 }
240 }
241
242 /*-
243 * Return values:
244 * 1 - ok
245 * 0 - ok but buf was too short
246 * -1 - bad string passed or other error
247 */
248
ossl_a2ulabel(const char * in,char * out,size_t outlen)249 int ossl_a2ulabel(const char *in, char *out, size_t outlen)
250 {
251 /*-
252 * Domain name has some parts consisting of ASCII chars joined with dot.
253 * If a part is shorter than 5 chars, it becomes U-label as is.
254 * If it does not start with xn--, it becomes U-label as is.
255 * Otherwise we try to decode it.
256 */
257 const char *inptr = in;
258 int result = 1;
259 unsigned int i;
260 unsigned int buf[LABEL_BUF_SIZE]; /* It's a hostname */
261 WPACKET pkt;
262
263 /* Internal API, so should not fail */
264 if (!ossl_assert(out != NULL))
265 return -1;
266
267 if (!WPACKET_init_static_len(&pkt, (unsigned char *)out, outlen, 0))
268 return -1;
269
270 while (1) {
271 char *tmpptr = strchr(inptr, '.');
272 size_t delta = tmpptr != NULL ? (size_t)(tmpptr - inptr) : strlen(inptr);
273
274 if (!HAS_PREFIX(inptr, "xn--")) {
275 if (!WPACKET_memcpy(&pkt, inptr, delta))
276 result = 0;
277 } else {
278 unsigned int bufsize = LABEL_BUF_SIZE;
279
280 if (ossl_punycode_decode(inptr + 4, delta - 4, buf, &bufsize) <= 0) {
281 result = -1;
282 goto end;
283 }
284
285 for (i = 0; i < bufsize; i++) {
286 unsigned char seed[6];
287 size_t utfsize = codepoint2utf8(seed, buf[i]);
288
289 if (utfsize == 0) {
290 result = -1;
291 goto end;
292 }
293
294 if (!WPACKET_memcpy(&pkt, seed, utfsize))
295 result = 0;
296 }
297 }
298
299 if (tmpptr == NULL)
300 break;
301
302 if (!WPACKET_put_bytes_u8(&pkt, '.'))
303 result = 0;
304
305 inptr = tmpptr + 1;
306 }
307
308 if (!WPACKET_put_bytes_u8(&pkt, '\0'))
309 result = 0;
310 end:
311 WPACKET_cleanup(&pkt);
312 return result;
313 }
314