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