Current File : /home/vacivi36/vittasync.vacivitta.com.br/vittasync/node/deps/openssl/openssl/crypto/punycode.c
/*
* Copyright 2019-2022 The OpenSSL Project Authors. All Rights Reserved.
*
* Licensed under the Apache License 2.0 (the "License"). You may not use
* this file except in compliance with the License. You can obtain a copy
* in the file LICENSE in the source distribution or at
* https://www.openssl.org/source/license.html
*/
#include <stddef.h>
#include <string.h>
#include <stdio.h>
#include <openssl/e_os2.h>
#include "crypto/punycode.h"
static const unsigned int base = 36;
static const unsigned int tmin = 1;
static const unsigned int tmax = 26;
static const unsigned int skew = 38;
static const unsigned int damp = 700;
static const unsigned int initial_bias = 72;
static const unsigned int initial_n = 0x80;
static const unsigned int maxint = 0xFFFFFFFF;
static const char delimiter = '-';
#define LABEL_BUF_SIZE 512
/*-
* Pseudocode:
*
* function adapt(delta,numpoints,firsttime):
* if firsttime then let delta = delta div damp
* else let delta = delta div 2
* let delta = delta + (delta div numpoints)
* let k = 0
* while delta > ((base - tmin) * tmax) div 2 do begin
* let delta = delta div (base - tmin)
* let k = k + base
* end
* return k + (((base - tmin + 1) * delta) div (delta + skew))
*/
static int adapt(unsigned int delta, unsigned int numpoints,
unsigned int firsttime)
{
unsigned int k = 0;
delta = (firsttime) ? delta / damp : delta / 2;
delta = delta + delta / numpoints;
while (delta > ((base - tmin) * tmax) / 2) {
delta = delta / (base - tmin);
k = k + base;
}
return k + (((base - tmin + 1) * delta) / (delta + skew));
}
static ossl_inline int is_basic(unsigned int a)
{
return (a < 0x80) ? 1 : 0;
}
/*-
* code points digit-values
* ------------ ----------------------
* 41..5A (A-Z) = 0 to 25, respectively
* 61..7A (a-z) = 0 to 25, respectively
* 30..39 (0-9) = 26 to 35, respectively
*/
static ossl_inline int digit_decoded(const unsigned char a)
{
if (a >= 0x41 && a <= 0x5A)
return a - 0x41;
if (a >= 0x61 && a <= 0x7A)
return a - 0x61;
if (a >= 0x30 && a <= 0x39)
return a - 0x30 + 26;
return -1;
}
/*-
* Pseudocode:
*
* function ossl_punycode_decode
* let n = initial_n
* let i = 0
* let bias = initial_bias
* let output = an empty string indexed from 0
* consume all code points before the last delimiter (if there is one)
* and copy them to output, fail on any non-basic code point
* if more than zero code points were consumed then consume one more
* (which will be the last delimiter)
* while the input is not exhausted do begin
* let oldi = i
* let w = 1
* for k = base to infinity in steps of base do begin
* consume a code point, or fail if there was none to consume
* let digit = the code point's digit-value, fail if it has none
* let i = i + digit * w, fail on overflow
* let t = tmin if k <= bias {+ tmin}, or
* tmax if k >= bias + tmax, or k - bias otherwise
* if digit < t then break
* let w = w * (base - t), fail on overflow
* end
* let bias = adapt(i - oldi, length(output) + 1, test oldi is 0?)
* let n = n + i div (length(output) + 1), fail on overflow
* let i = i mod (length(output) + 1)
* {if n is a basic code point then fail}
* insert n into output at position i
* increment i
* end
*/
int ossl_punycode_decode(const char *pEncoded, const size_t enc_len,
unsigned int *pDecoded, unsigned int *pout_length)
{
unsigned int n = initial_n;
unsigned int i = 0;
unsigned int bias = initial_bias;
size_t processed_in = 0, written_out = 0;
unsigned int max_out = *pout_length;
unsigned int basic_count = 0;
unsigned int loop;
for (loop = 0; loop < enc_len; loop++) {
if (pEncoded[loop] == delimiter)
basic_count = loop;
}
if (basic_count > 0) {
if (basic_count > max_out)
return 0;
for (loop = 0; loop < basic_count; loop++) {
if (is_basic(pEncoded[loop]) == 0)
return 0;
pDecoded[loop] = pEncoded[loop];
written_out++;
}
processed_in = basic_count + 1;
}
for (loop = processed_in; loop < enc_len;) {
unsigned int oldi = i;
unsigned int w = 1;
unsigned int k, t;
int digit;
for (k = base;; k += base) {
if (loop >= enc_len)
return 0;
digit = digit_decoded(pEncoded[loop]);
loop++;
if (digit < 0)
return 0;
if ((unsigned int)digit > (maxint - i) / w)
return 0;
i = i + digit * w;
t = (k <= bias) ? tmin : (k >= bias + tmax) ? tmax : k - bias;
if ((unsigned int)digit < t)
break;
if (w > maxint / (base - t))
return 0;
w = w * (base - t);
}
bias = adapt(i - oldi, written_out + 1, (oldi == 0));
if (i / (written_out + 1) > maxint - n)
return 0;
n = n + i / (written_out + 1);
i %= (written_out + 1);
if (written_out >= max_out)
return 0;
memmove(pDecoded + i + 1, pDecoded + i,
(written_out - i) * sizeof(*pDecoded));
pDecoded[i] = n;
i++;
written_out++;
}
*pout_length = written_out;
return 1;
}
/*
* Encode a code point using UTF-8
* return number of bytes on success, 0 on failure
* (also produces U+FFFD, which uses 3 bytes on failure)
*/
static int codepoint2utf8(unsigned char *out, unsigned long utf)
{
if (utf <= 0x7F) {
/* Plain ASCII */
out[0] = (unsigned char)utf;
out[1] = 0;
return 1;
} else if (utf <= 0x07FF) {
/* 2-byte unicode */
out[0] = (unsigned char)(((utf >> 6) & 0x1F) | 0xC0);
out[1] = (unsigned char)(((utf >> 0) & 0x3F) | 0x80);
out[2] = 0;
return 2;
} else if (utf <= 0xFFFF) {
/* 3-byte unicode */
out[0] = (unsigned char)(((utf >> 12) & 0x0F) | 0xE0);
out[1] = (unsigned char)(((utf >> 6) & 0x3F) | 0x80);
out[2] = (unsigned char)(((utf >> 0) & 0x3F) | 0x80);
out[3] = 0;
return 3;
} else if (utf <= 0x10FFFF) {
/* 4-byte unicode */
out[0] = (unsigned char)(((utf >> 18) & 0x07) | 0xF0);
out[1] = (unsigned char)(((utf >> 12) & 0x3F) | 0x80);
out[2] = (unsigned char)(((utf >> 6) & 0x3F) | 0x80);
out[3] = (unsigned char)(((utf >> 0) & 0x3F) | 0x80);
out[4] = 0;
return 4;
} else {
/* error - use replacement character */
out[0] = (unsigned char)0xEF;
out[1] = (unsigned char)0xBF;
out[2] = (unsigned char)0xBD;
out[3] = 0;
return 0;
}
}
/*-
* Return values:
* 1 - ok, *outlen contains valid buf length
* 0 - ok but buf was too short, *outlen contains valid buf length
* -1 - bad string passed
*/
int ossl_a2ulabel(const char *in, char *out, size_t *outlen)
{
/*-
* Domain name has some parts consisting of ASCII chars joined with dot.
* If a part is shorter than 5 chars, it becomes U-label as is.
* If it does not start with xn--, it becomes U-label as is.
* Otherwise we try to decode it.
*/
char *outptr = out;
const char *inptr = in;
size_t size = 0, maxsize;
int result = 1;
unsigned int i, j;
unsigned int buf[LABEL_BUF_SIZE]; /* It's a hostname */
if (out == NULL) {
result = 0;
maxsize = 0;
} else {
maxsize = *outlen;
}
#define PUSHC(c) \
do \
if (size++ < maxsize) \
*outptr++ = c; \
else \
result = 0; \
while (0)
while (1) {
char *tmpptr = strchr(inptr, '.');
size_t delta = tmpptr != NULL ? (size_t)(tmpptr - inptr) : strlen(inptr);
if (strncmp(inptr, "xn--", 4) != 0) {
for (i = 0; i < delta + 1; i++)
PUSHC(inptr[i]);
} else {
unsigned int bufsize = LABEL_BUF_SIZE;
if (ossl_punycode_decode(inptr + 4, delta - 4, buf, &bufsize) <= 0)
return -1;
for (i = 0; i < bufsize; i++) {
unsigned char seed[6];
size_t utfsize = codepoint2utf8(seed, buf[i]);
if (utfsize == 0)
return -1;
for (j = 0; j < utfsize; j++)
PUSHC(seed[j]);
}
PUSHC(tmpptr != NULL ? '.' : '\0');
}
if (tmpptr == NULL)
break;
inptr = tmpptr + 1;
}
#undef PUSHC
*outlen = size;
return result;
}
/*-
* a MUST be A-label
* u MUST be U-label
* Returns 0 if compared values are equal
* 1 if not
* -1 in case of errors
*/
int ossl_a2ucompare(const char *a, const char *u)
{
char a_ulabel[LABEL_BUF_SIZE + 1];
size_t a_size = sizeof(a_ulabel);
if (ossl_a2ulabel(a, a_ulabel, &a_size) <= 0)
return -1;
return strcmp(a_ulabel, u) != 0;
}
Mini Shell