xref: /openssl/crypto/punycode.c (revision da1c088f)
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 : k - bias;
169 
170             if ((unsigned int)digit < t)
171                 break;
172 
173             if (w > maxint / (base - t))
174                 return 0;
175             w = w * (base - t);
176         }
177 
178         bias = adapt(i - oldi, written_out + 1, (oldi == 0));
179         if (i / (written_out + 1) > maxint - n)
180             return 0;
181         n = n + i / (written_out + 1);
182         i %= (written_out + 1);
183 
184         if (written_out >= max_out)
185             return 0;
186 
187         memmove(pDecoded + i + 1, pDecoded + i,
188                 (written_out - i) * sizeof(*pDecoded));
189         pDecoded[i] = n;
190         i++;
191         written_out++;
192     }
193 
194     *pout_length = written_out;
195     return 1;
196 }
197 
198 /*
199  * Encode a code point using UTF-8
200  * return number of bytes on success, 0 on failure
201  * (also produces U+FFFD, which uses 3 bytes on failure)
202  */
codepoint2utf8(unsigned char * out,unsigned long utf)203 static int codepoint2utf8(unsigned char *out, unsigned long utf)
204 {
205     if (utf <= 0x7F) {
206         /* Plain ASCII */
207         out[0] = (unsigned char)utf;
208         out[1] = 0;
209         return 1;
210     } else if (utf <= 0x07FF) {
211         /* 2-byte unicode */
212         out[0] = (unsigned char)(((utf >> 6) & 0x1F) | 0xC0);
213         out[1] = (unsigned char)(((utf >> 0) & 0x3F) | 0x80);
214         out[2] = 0;
215         return 2;
216     } else if (utf <= 0xFFFF) {
217         /* 3-byte unicode */
218         out[0] = (unsigned char)(((utf >> 12) & 0x0F) | 0xE0);
219         out[1] = (unsigned char)(((utf >> 6) & 0x3F) | 0x80);
220         out[2] = (unsigned char)(((utf >> 0) & 0x3F) | 0x80);
221         out[3] = 0;
222         return 3;
223     } else if (utf <= 0x10FFFF) {
224         /* 4-byte unicode */
225         out[0] = (unsigned char)(((utf >> 18) & 0x07) | 0xF0);
226         out[1] = (unsigned char)(((utf >> 12) & 0x3F) | 0x80);
227         out[2] = (unsigned char)(((utf >> 6) & 0x3F) | 0x80);
228         out[3] = (unsigned char)(((utf >> 0) & 0x3F) | 0x80);
229         out[4] = 0;
230         return 4;
231     } else {
232         /* error - use replacement character */
233         out[0] = (unsigned char)0xEF;
234         out[1] = (unsigned char)0xBF;
235         out[2] = (unsigned char)0xBD;
236         out[3] = 0;
237         return 0;
238     }
239 }
240 
241 /*-
242  * Return values:
243  * 1 - ok
244  * 0 - ok but buf was too short
245  * -1 - bad string passed or other error
246  */
247 
ossl_a2ulabel(const char * in,char * out,size_t outlen)248 int ossl_a2ulabel(const char *in, char *out, size_t outlen)
249 {
250     /*-
251      * Domain name has some parts consisting of ASCII chars joined with dot.
252      * If a part is shorter than 5 chars, it becomes U-label as is.
253      * If it does not start with xn--,    it becomes U-label as is.
254      * Otherwise we try to decode it.
255      */
256     const char *inptr = in;
257     int result = 1;
258     unsigned int i;
259     unsigned int buf[LABEL_BUF_SIZE];      /* It's a hostname */
260     WPACKET pkt;
261 
262     /* Internal API, so should not fail */
263     if (!ossl_assert(out != NULL))
264         return -1;
265 
266     if (!WPACKET_init_static_len(&pkt, (unsigned char *)out, outlen, 0))
267         return -1;
268 
269     while (1) {
270         char *tmpptr = strchr(inptr, '.');
271         size_t delta = tmpptr != NULL ? (size_t)(tmpptr - inptr) : strlen(inptr);
272 
273         if (!HAS_PREFIX(inptr, "xn--")) {
274             if (!WPACKET_memcpy(&pkt, inptr, delta))
275                 result = 0;
276         } else {
277             unsigned int bufsize = LABEL_BUF_SIZE;
278 
279             if (ossl_punycode_decode(inptr + 4, delta - 4, buf, &bufsize) <= 0) {
280                 result = -1;
281                 goto end;
282             }
283 
284             for (i = 0; i < bufsize; i++) {
285                 unsigned char seed[6];
286                 size_t utfsize = codepoint2utf8(seed, buf[i]);
287 
288                 if (utfsize == 0) {
289                     result = -1;
290                     goto end;
291                 }
292 
293                 if (!WPACKET_memcpy(&pkt, seed, utfsize))
294                     result = 0;
295             }
296         }
297 
298         if (tmpptr == NULL)
299             break;
300 
301         if (!WPACKET_put_bytes_u8(&pkt, '.'))
302             result = 0;
303 
304         inptr = tmpptr + 1;
305     }
306 
307     if (!WPACKET_put_bytes_u8(&pkt, '\0'))
308         result = 0;
309  end:
310     WPACKET_cleanup(&pkt);
311     return result;
312 }
313