]>
git.ipfire.org Git - thirdparty/openssl.git/blob - crypto/punycode.c
2 * Copyright 2019-2020 The OpenSSL Project Authors. All Rights Reserved.
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
12 #include <openssl/e_os2.h>
13 #include "crypto/punycode.h"
14 #include "internal/common.h" /* for HAS_PREFIX */
16 static const unsigned int base
= 36;
17 static const unsigned int tmin
= 1;
18 static const unsigned int tmax
= 26;
19 static const unsigned int skew
= 38;
20 static const unsigned int damp
= 700;
21 static const unsigned int initial_bias
= 72;
22 static const unsigned int initial_n
= 0x80;
23 static const unsigned int maxint
= 0xFFFFFFFF;
24 static const char delimiter
= '-';
26 #define LABEL_BUF_SIZE 512
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)
36 * while delta > ((base - tmin) * tmax) div 2 do begin
37 * let delta = delta div (base - tmin)
40 * return k + (((base - tmin + 1) * delta) div (delta + skew))
43 static int adapt(unsigned int delta
, unsigned int numpoints
,
44 unsigned int firsttime
)
48 delta
= (firsttime
) ? delta
/ damp
: delta
/ 2;
49 delta
= delta
+ delta
/ numpoints
;
51 while (delta
> ((base
- tmin
) * tmax
) / 2) {
52 delta
= delta
/ (base
- tmin
);
56 return k
+ (((base
- tmin
+ 1) * delta
) / (delta
+ skew
));
59 static ossl_inline
int is_basic(unsigned int a
)
61 return (a
< 0x80) ? 1 : 0;
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
71 static ossl_inline
int digit_decoded(const unsigned char a
)
73 if (a
>= 0x41 && a
<= 0x5A)
76 if (a
>= 0x61 && a
<= 0x7A)
79 if (a
>= 0x30 && a
<= 0x39)
88 * function ossl_punycode_decode
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
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
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
118 int ossl_punycode_decode(const char *pEncoded
, const size_t enc_len
,
119 unsigned int *pDecoded
, unsigned int *pout_length
)
121 unsigned int n
= initial_n
;
123 unsigned int bias
= initial_bias
;
124 size_t processed_in
= 0, written_out
= 0;
125 unsigned int max_out
= *pout_length
;
127 unsigned int basic_count
= 0;
130 for (loop
= 0; loop
< enc_len
; loop
++) {
131 if (pEncoded
[loop
] == delimiter
)
135 if (basic_count
> 0) {
136 if (basic_count
> max_out
)
139 for (loop
= 0; loop
< basic_count
; loop
++) {
140 if (is_basic(pEncoded
[loop
]) == 0)
143 pDecoded
[loop
] = pEncoded
[loop
];
146 processed_in
= basic_count
+ 1;
149 for (loop
= processed_in
; loop
< enc_len
;) {
150 unsigned int oldi
= i
;
155 for (k
= base
;; k
+= base
) {
159 digit
= digit_decoded(pEncoded
[loop
]);
164 if ((unsigned int)digit
> (maxint
- i
) / w
)
168 t
= (k
<= bias
) ? tmin
: (k
>= bias
+ tmax
) ? tmax
: k
- bias
;
170 if ((unsigned int)digit
< t
)
173 if (w
> maxint
/ (base
- t
))
178 bias
= adapt(i
- oldi
, written_out
+ 1, (oldi
== 0));
179 if (i
/ (written_out
+ 1) > maxint
- n
)
181 n
= n
+ i
/ (written_out
+ 1);
182 i
%= (written_out
+ 1);
184 if (written_out
> max_out
)
187 memmove(pDecoded
+ i
+ 1, pDecoded
+ i
,
188 (written_out
- i
) * sizeof *pDecoded
);
194 *pout_length
= written_out
;
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)
203 static int codepoint2utf8(unsigned char *out
, unsigned long utf
)
207 out
[0] = (unsigned char)utf
;
210 } else if (utf
<= 0x07FF) {
212 out
[0] = (unsigned char)(((utf
>> 6) & 0x1F) | 0xC0);
213 out
[1] = (unsigned char)(((utf
>> 0) & 0x3F) | 0x80);
216 } else if (utf
<= 0xFFFF) {
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);
223 } else if (utf
<= 0x10FFFF) {
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);
232 /* error - use replacement character */
233 out
[0] = (unsigned char)0xEF;
234 out
[1] = (unsigned char)0xBF;
235 out
[2] = (unsigned char)0xBD;
243 * 1 - ok, *outlen contains valid buf length
244 * 0 - ok but buf was too short, *outlen contains valid buf length
245 * -1 - bad string passed
248 int ossl_a2ulabel(const char *in
, char *out
, size_t *outlen
)
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.
257 const char *inptr
= in
;
261 unsigned int buf
[LABEL_BUF_SIZE
]; /* It's a hostname */
266 char *tmpptr
= strchr(inptr
, '.');
267 size_t delta
= (tmpptr
) ? (size_t)(tmpptr
- inptr
) : strlen(inptr
);
269 if (!HAS_PREFIX(inptr
, "xn--")) {
272 if (size
>= *outlen
- 1)
276 memcpy(outptr
, inptr
, delta
+ 1);
280 unsigned int bufsize
= LABEL_BUF_SIZE
;
283 if (ossl_punycode_decode(inptr
+ 4, delta
- 4, buf
, &bufsize
) <= 0)
286 for (i
= 0; i
< bufsize
; i
++) {
287 unsigned char seed
[6];
288 size_t utfsize
= codepoint2utf8(seed
, buf
[i
]);
293 if (size
>= *outlen
- 1)
297 memcpy(outptr
, seed
, utfsize
);
302 if (tmpptr
!= NULL
) {
306 if (size
>= *outlen
- 1)
323 * Returns 0 if compared values are equal
325 * -1 in case of errors
328 int ossl_a2ucompare(const char *a
, const char *u
)
330 char a_ulabel
[LABEL_BUF_SIZE
];
331 size_t a_size
= sizeof(a_ulabel
);
333 if (ossl_a2ulabel(a
, a_ulabel
, &a_size
) <= 0) {
337 return (strcmp(a_ulabel
, u
) == 0) ? 0 : 1;