/*
* Copyright (C) 2016, 2017 Red Hat, Inc.
*
* Author: Nikos Mavrogiannopoulos
*
* This file is part of GnuTLS.
*
* The GnuTLS is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>
*
*/
#include "gnutls_int.h"
#include "errors.h"
#include "str.h"
#include <uninorm.h>
#include <unistr.h>
#include <unictype.h>
/* rfc5892#section-2.6 exceptions
*/
inline static int is_allowed_exception(uint32_t ch)
{
switch (ch) {
case 0xB7:
case 0x0375:
case 0x05F3:
case 0x05F4:
case 0x30FB:
case 0x0660:
case 0x0661:
case 0x0662:
case 0x0663:
case 0x0664:
case 0x0665:
case 0x0666:
case 0x0667:
case 0x0668:
case 0x0669:
case 0x06F0:
case 0x06F1:
case 0x06F2:
case 0x06F3:
case 0x06F4:
case 0x06F5:
case 0x06F6:
case 0x06F7:
case 0x06F8:
case 0x06F9:
case 0x0640:
case 0x07FA:
case 0x302E:
case 0x302F:
case 0x3031:
case 0x3032:
case 0x3033:
case 0x3034:
case 0x3035:
case 0x303B:
return 0; /* disallowed */
case 0xDF:
case 0x03C2:
case 0x06FD:
case 0x06FE:
case 0x0F0B:
case 0x3007:
return 1; /* allowed */
default:
return -1; /* not exception */
}
}
/* Checks whether the provided string is in the valid set of FreeFormClass (RFC7564
* as an RFC7613 requirement), and converts all spaces to the ASCII-space. */
static int check_for_valid_freeformclass(uint32_t *ucs4, unsigned ucs4_size)
{
unsigned i;
int rc;
uint32_t tmp[4];
size_t tmp_size;
uint32_t *nrm;
uc_general_category_t cat;
unsigned is_invalid;
/* make the union of Valid categories, excluding any invalid (i.e., control) */
cat = uc_general_category_or(UC_CATEGORY_Ll, UC_CATEGORY_Lu); /* LetterDigits */
cat = uc_general_category_or(cat, UC_CATEGORY_Lo);
cat = uc_general_category_or(cat, UC_CATEGORY_Nd);
cat = uc_general_category_or(cat, UC_CATEGORY_Lm);
cat = uc_general_category_or(cat, UC_CATEGORY_Mn);
cat = uc_general_category_or(cat, UC_CATEGORY_Mc);
cat = uc_general_category_or(cat, UC_CATEGORY_Lt); /* OtherLetterDigits */
cat = uc_general_category_or(cat, UC_CATEGORY_Nl);
cat = uc_general_category_or(cat, UC_CATEGORY_No);
cat = uc_general_category_or(cat, UC_CATEGORY_Me);
cat = uc_general_category_or(cat, UC_CATEGORY_Sm); /* Symbols */
cat = uc_general_category_or(cat, UC_CATEGORY_Sc);
cat = uc_general_category_or(cat, UC_CATEGORY_So);
cat = uc_general_category_or(cat, UC_CATEGORY_Sk);
cat = uc_general_category_or(cat, UC_CATEGORY_Pc); /* Punctuation */
cat = uc_general_category_or(cat, UC_CATEGORY_Pd);
cat = uc_general_category_or(cat, UC_CATEGORY_Ps);
cat = uc_general_category_or(cat, UC_CATEGORY_Pe);
cat = uc_general_category_or(cat, UC_CATEGORY_Pi);
cat = uc_general_category_or(cat, UC_CATEGORY_Pf);
cat = uc_general_category_or(cat, UC_CATEGORY_Po);
cat = uc_general_category_or(cat, UC_CATEGORY_Zs); /* Spaces */
cat = uc_general_category_and_not(cat, UC_CATEGORY_Cc); /* Not in Control */
/* check for being in the allowed sets in rfc7564#section-4.3 */
for (i=0;i<ucs4_size;i++) {
is_invalid = 0;
/* Disallowed
o Old Hangul Jamo characters, i.e., the OldHangulJamo ("I") category
(not handled in this code)
o Control characters, i.e., the Controls ("L") category
o Ignorable characters, i.e., the PrecisIgnorableProperties ("M")
*/
if (uc_is_property_default_ignorable_code_point(ucs4[i]) ||
uc_is_property_not_a_character(ucs4[i])) {
return gnutls_assert_val(GNUTLS_E_INVALID_UTF8_STRING);
}
/* Contextual rules - we do not implement them / we reject chars from these sets
o A number of characters from the Exceptions ("F") category defined
o Joining characters, i.e., the JoinControl ("H") category defined
*/
rc = is_allowed_exception(ucs4[i]);
if (rc == 0 || uc_is_property_join_control(ucs4[i]))
return gnutls_assert_val(GNUTLS_E_INVALID_UTF8_STRING);
if (rc == 1) /* exceptionally allowed, continue */
continue;
/* Replace all spaces; an RFC7613 requirement
*/
if (uc_is_general_category(ucs4[i], UC_CATEGORY_Zs)) /* replace */
ucs4[i] = 0x20;
/* Valid */
if ((ucs4[i] < 0x21 || ucs4[i] > 0x7E) && !uc_is_general_category(ucs4[i], cat))
is_invalid = 1;
/* HasCompat */
if (is_invalid) {
tmp_size = sizeof(tmp)/sizeof(tmp[0]);
nrm = u32_normalize(UNINORM_NFKC, &ucs4[i], 1, tmp, &tmp_size);
if (nrm == NULL || (tmp_size == 1 && nrm[0] == ucs4[i]))
return gnutls_assert_val(GNUTLS_E_INVALID_UTF8_STRING);
}
}
return 0;
}
/**
* gnutls_utf8_password_normalize:
* @password: contain the UTF-8 formatted password
* @plen: the length of the provided password
* @out: the result in an null-terminated allocated string
* @flags: should be zero
*
* This function will convert the provided UTF-8 password according
* to the normalization rules in RFC7613.
*
* If the flag %GNUTLS_UTF8_IGNORE_ERRS is specified, any UTF-8 encoding
* errors will be ignored, and in that case the output will be a copy of the input.
*
* Returns: %GNUTLS_E_INVALID_UTF8_STRING on invalid UTF-8 data, or 0 on success.
*
* Since: 3.5.7
**/
int gnutls_utf8_password_normalize(const unsigned char *password, unsigned plen,
gnutls_datum_t *out, unsigned flags)
{
size_t ucs4_size = 0, nrm_size = 0;
size_t final_size = 0;
uint8_t *final = NULL;
uint32_t *ucs4 = NULL;
uint32_t *nrm = NULL;
uint8_t *nrmu8 = NULL;
int ret;
if (plen == 0) {
out->data = (uint8_t*)gnutls_strdup("");
out->size = 0;
if (out->data == NULL)
return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);
return 0;
}
/* check for invalid UTF-8 */
if (u8_check((uint8_t*)password, plen) != NULL) {
gnutls_assert();
if (flags & GNUTLS_UTF8_IGNORE_ERRS) {
raw_copy:
out->data = gnutls_malloc(plen+1);
if (out->data == NULL)
return gnutls_assert_val(GNUTLS_E_MEMORY_ERROR);
out->size = plen;
memcpy(out->data, password, plen);
out->data[plen] = 0;
return 0;
} else {
return GNUTLS_E_INVALID_UTF8_STRING;
}
}
/* convert to UTF-32 */
ucs4 = u8_to_u32((uint8_t*)password, plen, NULL, &ucs4_size);
if (ucs4 == NULL) {
gnutls_assert();
ret = GNUTLS_E_PARSING_ERROR;
goto fail;
}
ret = check_for_valid_freeformclass(ucs4, ucs4_size);
if (ret < 0) {
gnutls_assert();
if (flags & GNUTLS_UTF8_IGNORE_ERRS) {
free(ucs4);
goto raw_copy;
}
if (ret == GNUTLS_E_INVALID_UTF8_STRING)
ret = GNUTLS_E_INVALID_PASSWORD_STRING;
goto fail;
}
/* normalize to NFC */
nrm = u32_normalize(UNINORM_NFC, ucs4, ucs4_size, NULL, &nrm_size);
if (nrm == NULL) {
gnutls_assert();
ret = GNUTLS_E_INVALID_PASSWORD_STRING;
goto fail;
}
/* convert back to UTF-8 */
final_size = 0;
nrmu8 = u32_to_u8(nrm, nrm_size, NULL, &final_size);
if (nrmu8 == NULL) {
gnutls_assert();
ret = GNUTLS_E_INVALID_PASSWORD_STRING;
goto fail;
}
/* copy to output with null terminator */
final = gnutls_malloc(final_size+1);
if (final == NULL) {
gnutls_assert();
ret = GNUTLS_E_MEMORY_ERROR;
goto fail;
}
memcpy(final, nrmu8, final_size);
final[final_size] = 0;
free(ucs4);
free(nrm);
free(nrmu8);
out->data = final;
out->size = final_size;
return 0;
fail:
gnutls_free(final);
free(ucs4);
free(nrm);
free(nrmu8);
return ret;
}