зеркало из https://github.com/mozilla/gecko-dev.git
913 строки
28 KiB
C++
913 строки
28 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "mozilla/Preferences.h"
|
|
#include "nsIDNService.h"
|
|
#include "nsReadableUtils.h"
|
|
#include "nsCRT.h"
|
|
#include "nsUnicharUtils.h"
|
|
#include "nsUnicodeProperties.h"
|
|
#include "nsUnicodeScriptCodes.h"
|
|
#include "harfbuzz/hb.h"
|
|
#include "nsIServiceManager.h"
|
|
#include "nsIObserverService.h"
|
|
#include "nsISupportsPrimitives.h"
|
|
#include "punycode.h"
|
|
|
|
// Currently we use the non-transitional processing option -- see
|
|
// http://unicode.org/reports/tr46/
|
|
// To switch to transitional processing, change the value of this flag
|
|
// and kTransitionalProcessing in netwerk/test/unit/test_idna2008.js to true
|
|
// (revert bug 1218179).
|
|
const bool kIDNA2008_TransitionalProcessing = false;
|
|
|
|
#include "ICUUtils.h"
|
|
#include "unicode/uscript.h"
|
|
|
|
using namespace mozilla::unicode;
|
|
using namespace mozilla::net;
|
|
using mozilla::Preferences;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// RFC 1034 - 3.1. Name space specifications and terminology
|
|
static const uint32_t kMaxDNSNodeLen = 63;
|
|
// RFC 3490 - 5. ACE prefix
|
|
static const char kACEPrefix[] = "xn--";
|
|
#define kACEPrefixLen 4
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#define NS_NET_PREF_EXTRAALLOWED "network.IDN.extra_allowed_chars"
|
|
#define NS_NET_PREF_EXTRABLOCKED "network.IDN.extra_blocked_chars"
|
|
#define NS_NET_PREF_SHOWPUNYCODE "network.IDN_show_punycode"
|
|
#define NS_NET_PREF_IDNWHITELIST "network.IDN.whitelist."
|
|
#define NS_NET_PREF_IDNUSEWHITELIST "network.IDN.use_whitelist"
|
|
#define NS_NET_PREF_IDNRESTRICTION "network.IDN.restriction_profile"
|
|
|
|
static inline bool isOnlySafeChars(const nsString& in,
|
|
const nsTArray<BlocklistRange>& aBlocklist) {
|
|
if (aBlocklist.IsEmpty()) {
|
|
return true;
|
|
}
|
|
const char16_t* cur = in.BeginReading();
|
|
const char16_t* end = in.EndReading();
|
|
|
|
for (; cur < end; ++cur) {
|
|
if (CharInBlocklist(*cur, aBlocklist)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// nsIDNService
|
|
//-----------------------------------------------------------------------------
|
|
|
|
/* Implementation file */
|
|
NS_IMPL_ISUPPORTS(nsIDNService, nsIIDNService, nsISupportsWeakReference)
|
|
|
|
static const char* gCallbackPrefs[] = {
|
|
NS_NET_PREF_EXTRAALLOWED, NS_NET_PREF_EXTRABLOCKED,
|
|
NS_NET_PREF_SHOWPUNYCODE, NS_NET_PREF_IDNRESTRICTION,
|
|
NS_NET_PREF_IDNUSEWHITELIST, nullptr,
|
|
};
|
|
|
|
nsresult nsIDNService::Init() {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
MutexAutoLock lock(mLock);
|
|
|
|
nsCOMPtr<nsIPrefService> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));
|
|
if (prefs)
|
|
prefs->GetBranch(NS_NET_PREF_IDNWHITELIST,
|
|
getter_AddRefs(mIDNWhitelistPrefBranch));
|
|
|
|
Preferences::RegisterPrefixCallbacks(PrefChanged, gCallbackPrefs, this);
|
|
prefsChanged(nullptr);
|
|
InitializeBlocklist(mIDNBlocklist);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
void nsIDNService::prefsChanged(const char* pref) {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
mLock.AssertCurrentThreadOwns();
|
|
|
|
if (pref && NS_LITERAL_CSTRING(NS_NET_PREF_EXTRAALLOWED).Equals(pref)) {
|
|
InitializeBlocklist(mIDNBlocklist);
|
|
}
|
|
if (pref && NS_LITERAL_CSTRING(NS_NET_PREF_EXTRABLOCKED).Equals(pref)) {
|
|
InitializeBlocklist(mIDNBlocklist);
|
|
}
|
|
if (!pref || NS_LITERAL_CSTRING(NS_NET_PREF_SHOWPUNYCODE).Equals(pref)) {
|
|
bool val;
|
|
if (NS_SUCCEEDED(Preferences::GetBool(NS_NET_PREF_SHOWPUNYCODE, &val)))
|
|
mShowPunycode = val;
|
|
}
|
|
if (!pref || NS_LITERAL_CSTRING(NS_NET_PREF_IDNUSEWHITELIST).Equals(pref)) {
|
|
bool val;
|
|
if (NS_SUCCEEDED(Preferences::GetBool(NS_NET_PREF_IDNUSEWHITELIST, &val)))
|
|
mIDNUseWhitelist = val;
|
|
}
|
|
if (!pref || NS_LITERAL_CSTRING(NS_NET_PREF_IDNRESTRICTION).Equals(pref)) {
|
|
nsAutoCString profile;
|
|
if (NS_FAILED(
|
|
Preferences::GetCString(NS_NET_PREF_IDNRESTRICTION, profile))) {
|
|
profile.Truncate();
|
|
}
|
|
if (profile.EqualsLiteral("moderate")) {
|
|
mRestrictionProfile = eModeratelyRestrictiveProfile;
|
|
} else if (profile.EqualsLiteral("high")) {
|
|
mRestrictionProfile = eHighlyRestrictiveProfile;
|
|
} else {
|
|
mRestrictionProfile = eASCIIOnlyProfile;
|
|
}
|
|
}
|
|
}
|
|
|
|
nsIDNService::nsIDNService()
|
|
: mLock("DNService pref value lock"),
|
|
mShowPunycode(false),
|
|
mRestrictionProfile(static_cast<restrictionProfile>(0)),
|
|
mIDNUseWhitelist(false) {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
uint32_t IDNAOptions = UIDNA_CHECK_BIDI | UIDNA_CHECK_CONTEXTJ;
|
|
if (!kIDNA2008_TransitionalProcessing) {
|
|
IDNAOptions |= UIDNA_NONTRANSITIONAL_TO_UNICODE;
|
|
}
|
|
UErrorCode errorCode = U_ZERO_ERROR;
|
|
mIDNA = uidna_openUTS46(IDNAOptions, &errorCode);
|
|
}
|
|
|
|
nsIDNService::~nsIDNService() {
|
|
MOZ_ASSERT(NS_IsMainThread());
|
|
|
|
Preferences::UnregisterPrefixCallbacks(PrefChanged, gCallbackPrefs, this);
|
|
|
|
uidna_close(mIDNA);
|
|
}
|
|
|
|
nsresult nsIDNService::IDNA2008ToUnicode(const nsACString& input,
|
|
nsAString& output) {
|
|
NS_ConvertUTF8toUTF16 inputStr(input);
|
|
UIDNAInfo info = UIDNA_INFO_INITIALIZER;
|
|
UErrorCode errorCode = U_ZERO_ERROR;
|
|
int32_t inLen = inputStr.Length();
|
|
int32_t outMaxLen = kMaxDNSNodeLen + 1;
|
|
UChar outputBuffer[kMaxDNSNodeLen + 1];
|
|
|
|
int32_t outLen =
|
|
uidna_labelToUnicode(mIDNA, (const UChar*)inputStr.get(), inLen,
|
|
outputBuffer, outMaxLen, &info, &errorCode);
|
|
if (info.errors != 0) {
|
|
return NS_ERROR_MALFORMED_URI;
|
|
}
|
|
|
|
if (U_SUCCESS(errorCode)) {
|
|
ICUUtils::AssignUCharArrayToString(outputBuffer, outLen, output);
|
|
}
|
|
|
|
nsresult rv = ICUUtils::UErrorToNsResult(errorCode);
|
|
if (rv == NS_ERROR_FAILURE) {
|
|
rv = NS_ERROR_MALFORMED_URI;
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
nsresult nsIDNService::IDNA2008StringPrep(const nsAString& input,
|
|
nsAString& output,
|
|
stringPrepFlag flag) {
|
|
UIDNAInfo info = UIDNA_INFO_INITIALIZER;
|
|
UErrorCode errorCode = U_ZERO_ERROR;
|
|
int32_t inLen = input.Length();
|
|
int32_t outMaxLen = kMaxDNSNodeLen + 1;
|
|
UChar outputBuffer[kMaxDNSNodeLen + 1];
|
|
|
|
int32_t outLen =
|
|
uidna_labelToUnicode(mIDNA, (const UChar*)PromiseFlatString(input).get(),
|
|
inLen, outputBuffer, outMaxLen, &info, &errorCode);
|
|
nsresult rv = ICUUtils::UErrorToNsResult(errorCode);
|
|
if (rv == NS_ERROR_FAILURE) {
|
|
rv = NS_ERROR_MALFORMED_URI;
|
|
}
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// Output the result of nameToUnicode even if there were errors.
|
|
// But in the case of invalid punycode, the uidna_labelToUnicode result
|
|
// appears to get an appended U+FFFD REPLACEMENT CHARACTER, which will
|
|
// confuse our subsequent processing, so we drop that.
|
|
// (https://bugzilla.mozilla.org/show_bug.cgi?id=1399540#c9)
|
|
if ((info.errors & UIDNA_ERROR_PUNYCODE) && outLen > 0 &&
|
|
outputBuffer[outLen - 1] == 0xfffd) {
|
|
--outLen;
|
|
}
|
|
ICUUtils::AssignUCharArrayToString(outputBuffer, outLen, output);
|
|
|
|
if (flag == eStringPrepIgnoreErrors) {
|
|
return NS_OK;
|
|
}
|
|
|
|
if (info.errors != 0) {
|
|
if (flag == eStringPrepForDNS) {
|
|
output.Truncate();
|
|
}
|
|
rv = NS_ERROR_MALFORMED_URI;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP nsIDNService::ConvertUTF8toACE(const nsACString& input,
|
|
nsACString& ace) {
|
|
return UTF8toACE(input, ace, eStringPrepForDNS);
|
|
}
|
|
|
|
nsresult nsIDNService::UTF8toACE(const nsACString& input, nsACString& ace,
|
|
stringPrepFlag flag) {
|
|
nsresult rv;
|
|
NS_ConvertUTF8toUTF16 ustr(input);
|
|
|
|
// map ideographic period to ASCII period etc.
|
|
normalizeFullStops(ustr);
|
|
|
|
uint32_t len, offset;
|
|
len = 0;
|
|
offset = 0;
|
|
nsAutoCString encodedBuf;
|
|
|
|
nsAString::const_iterator start, end;
|
|
ustr.BeginReading(start);
|
|
ustr.EndReading(end);
|
|
ace.Truncate();
|
|
|
|
// encode nodes if non ASCII
|
|
while (start != end) {
|
|
len++;
|
|
if (*start++ == (char16_t)'.') {
|
|
rv = stringPrepAndACE(Substring(ustr, offset, len - 1), encodedBuf, flag);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
ace.Append(encodedBuf);
|
|
ace.Append('.');
|
|
offset += len;
|
|
len = 0;
|
|
}
|
|
}
|
|
|
|
// encode the last node if non ASCII
|
|
if (len) {
|
|
rv = stringPrepAndACE(Substring(ustr, offset, len), encodedBuf, flag);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
ace.Append(encodedBuf);
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP nsIDNService::ConvertACEtoUTF8(const nsACString& input,
|
|
nsACString& _retval) {
|
|
return ACEtoUTF8(input, _retval, eStringPrepForDNS);
|
|
}
|
|
|
|
nsresult nsIDNService::ACEtoUTF8(const nsACString& input, nsACString& _retval,
|
|
stringPrepFlag flag) {
|
|
// RFC 3490 - 4.2 ToUnicode
|
|
// ToUnicode never fails. If any step fails, then the original input
|
|
// sequence is returned immediately in that step.
|
|
//
|
|
// Note that this refers to the decoding of a single label.
|
|
// ACEtoUTF8 may be called with a sequence of labels separated by dots;
|
|
// this test applies individually to each label.
|
|
|
|
uint32_t len = 0, offset = 0;
|
|
nsAutoCString decodedBuf;
|
|
|
|
nsACString::const_iterator start, end;
|
|
input.BeginReading(start);
|
|
input.EndReading(end);
|
|
_retval.Truncate();
|
|
|
|
// loop and decode nodes
|
|
while (start != end) {
|
|
len++;
|
|
if (*start++ == '.') {
|
|
nsDependentCSubstring origLabel(input, offset, len - 1);
|
|
if (NS_FAILED(decodeACE(origLabel, decodedBuf, flag))) {
|
|
// If decoding failed, use the original input sequence
|
|
// for this label.
|
|
_retval.Append(origLabel);
|
|
} else {
|
|
_retval.Append(decodedBuf);
|
|
}
|
|
|
|
_retval.Append('.');
|
|
offset += len;
|
|
len = 0;
|
|
}
|
|
}
|
|
// decode the last node
|
|
if (len) {
|
|
nsDependentCSubstring origLabel(input, offset, len);
|
|
if (NS_FAILED(decodeACE(origLabel, decodedBuf, flag))) {
|
|
_retval.Append(origLabel);
|
|
} else {
|
|
_retval.Append(decodedBuf);
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP nsIDNService::IsACE(const nsACString& input, bool* _retval) {
|
|
const char* data = input.BeginReading();
|
|
uint32_t dataLen = input.Length();
|
|
|
|
// look for the ACE prefix in the input string. it may occur
|
|
// at the beginning of any segment in the domain name. for
|
|
// example: "www.xn--ENCODED.com"
|
|
|
|
const char* p = PL_strncasestr(data, kACEPrefix, dataLen);
|
|
|
|
*_retval = p && (p == data || *(p - 1) == '.');
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP nsIDNService::Normalize(const nsACString& input,
|
|
nsACString& output) {
|
|
// protect against bogus input
|
|
NS_ENSURE_TRUE(IsUTF8(input), NS_ERROR_UNEXPECTED);
|
|
|
|
NS_ConvertUTF8toUTF16 inUTF16(input);
|
|
normalizeFullStops(inUTF16);
|
|
|
|
// pass the domain name to stringprep label by label
|
|
nsAutoString outUTF16, outLabel;
|
|
|
|
uint32_t len = 0, offset = 0;
|
|
nsresult rv;
|
|
nsAString::const_iterator start, end;
|
|
inUTF16.BeginReading(start);
|
|
inUTF16.EndReading(end);
|
|
|
|
while (start != end) {
|
|
len++;
|
|
if (*start++ == char16_t('.')) {
|
|
rv = stringPrep(Substring(inUTF16, offset, len - 1), outLabel,
|
|
eStringPrepIgnoreErrors);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
outUTF16.Append(outLabel);
|
|
outUTF16.Append(char16_t('.'));
|
|
offset += len;
|
|
len = 0;
|
|
}
|
|
}
|
|
if (len) {
|
|
rv = stringPrep(Substring(inUTF16, offset, len), outLabel,
|
|
eStringPrepIgnoreErrors);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
outUTF16.Append(outLabel);
|
|
}
|
|
|
|
CopyUTF16toUTF8(outUTF16, output);
|
|
return NS_OK;
|
|
}
|
|
|
|
namespace {
|
|
|
|
class MOZ_STACK_CLASS MutexSettableAutoUnlock final {
|
|
Mutex* mMutex;
|
|
|
|
public:
|
|
MutexSettableAutoUnlock() : mMutex(nullptr) {}
|
|
|
|
void Acquire(mozilla::Mutex& aMutex) {
|
|
MOZ_ASSERT(!mMutex);
|
|
mMutex = &aMutex;
|
|
mMutex->Lock();
|
|
}
|
|
|
|
~MutexSettableAutoUnlock() {
|
|
if (mMutex) {
|
|
mMutex->Unlock();
|
|
}
|
|
}
|
|
};
|
|
|
|
} // anonymous namespace
|
|
|
|
NS_IMETHODIMP nsIDNService::ConvertToDisplayIDN(const nsACString& input,
|
|
bool* _isASCII,
|
|
nsACString& _retval) {
|
|
MutexSettableAutoUnlock lock;
|
|
if (!NS_IsMainThread()) {
|
|
lock.Acquire(mLock);
|
|
}
|
|
|
|
// If host is ACE, then convert to UTF-8 if the host is in the IDN whitelist.
|
|
// Else, if host is already UTF-8, then make sure it is normalized per IDN.
|
|
|
|
nsresult rv = NS_OK;
|
|
|
|
// Even if the hostname is not ASCII, individual labels may still be ACE, so
|
|
// test IsACE before testing IsASCII
|
|
bool isACE;
|
|
IsACE(input, &isACE);
|
|
|
|
if (IsASCII(input)) {
|
|
// first, canonicalize the host to lowercase, for whitelist lookup
|
|
_retval = input;
|
|
ToLowerCase(_retval);
|
|
|
|
if (isACE && !mShowPunycode) {
|
|
// ACEtoUTF8() can't fail, but might return the original ACE string
|
|
nsAutoCString temp(_retval);
|
|
// If the domain is in the whitelist, return the host in UTF-8.
|
|
// Otherwise convert from ACE to UTF8 only those labels which are
|
|
// considered safe for display
|
|
ACEtoUTF8(
|
|
temp, _retval,
|
|
isInWhitelist(temp) ? eStringPrepIgnoreErrors : eStringPrepForUI);
|
|
*_isASCII = IsASCII(_retval);
|
|
} else {
|
|
*_isASCII = true;
|
|
}
|
|
} else {
|
|
// We have to normalize the hostname before testing against the domain
|
|
// whitelist (see bug 315411), and to ensure the entire string gets
|
|
// normalized.
|
|
//
|
|
// Normalization and the tests for safe display below, assume that the
|
|
// input is Unicode, so first convert any ACE labels to UTF8
|
|
if (isACE) {
|
|
nsAutoCString temp;
|
|
ACEtoUTF8(input, temp, eStringPrepIgnoreErrors);
|
|
rv = Normalize(temp, _retval);
|
|
} else {
|
|
rv = Normalize(input, _retval);
|
|
}
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
if (mShowPunycode &&
|
|
NS_SUCCEEDED(UTF8toACE(_retval, _retval, eStringPrepIgnoreErrors))) {
|
|
*_isASCII = true;
|
|
return NS_OK;
|
|
}
|
|
|
|
// normalization could result in an ASCII-only hostname. alternatively, if
|
|
// the host is converted to ACE by the normalizer, then the host may contain
|
|
// unsafe characters, so leave it ACE encoded. see bug 283016, bug 301694,
|
|
// and bug 309311.
|
|
*_isASCII = IsASCII(_retval);
|
|
if (!*_isASCII && !isInWhitelist(_retval)) {
|
|
// UTF8toACE with eStringPrepForUI may return a domain name where
|
|
// some labels are in UTF-8 and some are in ACE, depending on
|
|
// whether they are considered safe for display
|
|
rv = UTF8toACE(_retval, _retval, eStringPrepForUI);
|
|
*_isASCII = IsASCII(_retval);
|
|
return rv;
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
static nsresult utf16ToUcs4(const nsAString& in, uint32_t* out,
|
|
uint32_t outBufLen, uint32_t* outLen) {
|
|
uint32_t i = 0;
|
|
nsAString::const_iterator start, end;
|
|
in.BeginReading(start);
|
|
in.EndReading(end);
|
|
|
|
while (start != end) {
|
|
char16_t curChar;
|
|
|
|
curChar = *start++;
|
|
|
|
if (start != end && NS_IS_HIGH_SURROGATE(curChar) &&
|
|
NS_IS_LOW_SURROGATE(*start)) {
|
|
out[i] = SURROGATE_TO_UCS4(curChar, *start);
|
|
++start;
|
|
} else
|
|
out[i] = curChar;
|
|
|
|
i++;
|
|
if (i >= outBufLen) return NS_ERROR_MALFORMED_URI;
|
|
}
|
|
out[i] = (uint32_t)'\0';
|
|
*outLen = i;
|
|
return NS_OK;
|
|
}
|
|
|
|
static nsresult punycode(const nsAString& in, nsACString& out) {
|
|
uint32_t ucs4Buf[kMaxDNSNodeLen + 1];
|
|
uint32_t ucs4Len = 0u;
|
|
nsresult rv = utf16ToUcs4(in, ucs4Buf, kMaxDNSNodeLen, &ucs4Len);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
// need maximum 20 bits to encode 16 bit Unicode character
|
|
// (include null terminator)
|
|
const uint32_t kEncodedBufSize = kMaxDNSNodeLen * 20 / 8 + 1 + 1;
|
|
char encodedBuf[kEncodedBufSize];
|
|
punycode_uint encodedLength = kEncodedBufSize;
|
|
|
|
enum punycode_status status =
|
|
punycode_encode(ucs4Len, ucs4Buf, nullptr, &encodedLength, encodedBuf);
|
|
|
|
if (punycode_success != status || encodedLength >= kEncodedBufSize)
|
|
return NS_ERROR_MALFORMED_URI;
|
|
|
|
encodedBuf[encodedLength] = '\0';
|
|
out.Assign(nsDependentCString(kACEPrefix) + nsDependentCString(encodedBuf));
|
|
|
|
return rv;
|
|
}
|
|
|
|
// RFC 3454
|
|
//
|
|
// 1) Map -- For each character in the input, check if it has a mapping
|
|
// and, if so, replace it with its mapping. This is described in section 3.
|
|
//
|
|
// 2) Normalize -- Possibly normalize the result of step 1 using Unicode
|
|
// normalization. This is described in section 4.
|
|
//
|
|
// 3) Prohibit -- Check for any characters that are not allowed in the
|
|
// output. If any are found, return an error. This is described in section
|
|
// 5.
|
|
//
|
|
// 4) Check bidi -- Possibly check for right-to-left characters, and if any
|
|
// are found, make sure that the whole string satisfies the requirements
|
|
// for bidirectional strings. If the string does not satisfy the requirements
|
|
// for bidirectional strings, return an error. This is described in section 6.
|
|
//
|
|
// 5) Check unassigned code points -- If allowUnassigned is false, check for
|
|
// any unassigned Unicode points and if any are found return an error.
|
|
// This is described in section 7.
|
|
//
|
|
nsresult nsIDNService::stringPrep(const nsAString& in, nsAString& out,
|
|
stringPrepFlag flag) {
|
|
return IDNA2008StringPrep(in, out, flag);
|
|
}
|
|
|
|
nsresult nsIDNService::stringPrepAndACE(const nsAString& in, nsACString& out,
|
|
stringPrepFlag flag) {
|
|
nsresult rv = NS_OK;
|
|
|
|
out.Truncate();
|
|
|
|
if (in.Length() > kMaxDNSNodeLen) {
|
|
NS_WARNING("IDN node too large");
|
|
return NS_ERROR_MALFORMED_URI;
|
|
}
|
|
|
|
if (IsASCII(in)) {
|
|
LossyCopyUTF16toASCII(in, out);
|
|
return NS_OK;
|
|
}
|
|
|
|
nsAutoString strPrep;
|
|
rv = stringPrep(in, strPrep, flag);
|
|
if (flag == eStringPrepForDNS) {
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
}
|
|
|
|
if (IsASCII(strPrep)) {
|
|
LossyCopyUTF16toASCII(strPrep, out);
|
|
return NS_OK;
|
|
}
|
|
|
|
if (flag == eStringPrepForUI && NS_SUCCEEDED(rv) && isLabelSafe(in)) {
|
|
CopyUTF16toUTF8(strPrep, out);
|
|
return NS_OK;
|
|
}
|
|
|
|
rv = punycode(strPrep, out);
|
|
// Check that the encoded output isn't larger than the maximum length
|
|
// of a DNS node per RFC 1034.
|
|
// This test isn't necessary in the code paths above where the input
|
|
// is ASCII (since the output will be the same length as the input) or
|
|
// where we convert to UTF-8 (since the output is only used for
|
|
// display in the UI and not passed to DNS and can legitimately be
|
|
// longer than the limit).
|
|
if (out.Length() > kMaxDNSNodeLen) {
|
|
NS_WARNING("IDN node too large");
|
|
return NS_ERROR_MALFORMED_URI;
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
// RFC 3490
|
|
// 1) Whenever dots are used as label separators, the following characters
|
|
// MUST be recognized as dots: U+002E (full stop), U+3002 (ideographic full
|
|
// stop), U+FF0E (fullwidth full stop), U+FF61 (halfwidth ideographic full
|
|
// stop).
|
|
|
|
void nsIDNService::normalizeFullStops(nsAString& s) {
|
|
nsAString::const_iterator start, end;
|
|
s.BeginReading(start);
|
|
s.EndReading(end);
|
|
int32_t index = 0;
|
|
|
|
while (start != end) {
|
|
switch (*start) {
|
|
case 0x3002:
|
|
case 0xFF0E:
|
|
case 0xFF61:
|
|
s.ReplaceLiteral(index, 1, u".");
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
start++;
|
|
index++;
|
|
}
|
|
}
|
|
|
|
nsresult nsIDNService::decodeACE(const nsACString& in, nsACString& out,
|
|
stringPrepFlag flag) {
|
|
bool isAce;
|
|
IsACE(in, &isAce);
|
|
if (!isAce) {
|
|
out.Assign(in);
|
|
return NS_OK;
|
|
}
|
|
|
|
nsAutoString utf16;
|
|
nsresult result = IDNA2008ToUnicode(in, utf16);
|
|
NS_ENSURE_SUCCESS(result, result);
|
|
|
|
if (flag != eStringPrepForUI || isLabelSafe(utf16)) {
|
|
CopyUTF16toUTF8(utf16, out);
|
|
} else {
|
|
out.Assign(in);
|
|
return NS_OK;
|
|
}
|
|
|
|
// Validation: encode back to ACE and compare the strings
|
|
nsAutoCString ace;
|
|
nsresult rv = UTF8toACE(out, ace, flag);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (flag == eStringPrepForDNS &&
|
|
!ace.Equals(in, nsCaseInsensitiveCStringComparator())) {
|
|
return NS_ERROR_MALFORMED_URI;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
bool nsIDNService::isInWhitelist(const nsACString& host) {
|
|
if (!NS_IsMainThread()) {
|
|
mLock.AssertCurrentThreadOwns();
|
|
}
|
|
|
|
if (mIDNUseWhitelist && mIDNWhitelistPrefBranch) {
|
|
nsAutoCString tld(host);
|
|
// make sure the host is ACE for lookup and check that there are no
|
|
// unassigned codepoints
|
|
if (!IsASCII(tld) && NS_FAILED(UTF8toACE(tld, tld, eStringPrepForDNS))) {
|
|
return false;
|
|
}
|
|
|
|
// truncate trailing dots first
|
|
tld.Trim(".");
|
|
int32_t pos = tld.RFind(".");
|
|
if (pos == kNotFound) return false;
|
|
|
|
tld.Cut(0, pos + 1);
|
|
|
|
bool safe;
|
|
if (NS_SUCCEEDED(mIDNWhitelistPrefBranch->GetBoolPref(tld.get(), &safe)))
|
|
return safe;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool nsIDNService::isLabelSafe(const nsAString& label) {
|
|
if (!NS_IsMainThread()) {
|
|
mLock.AssertCurrentThreadOwns();
|
|
}
|
|
|
|
if (!isOnlySafeChars(PromiseFlatString(label), mIDNBlocklist)) {
|
|
return false;
|
|
}
|
|
|
|
// We should never get here if the label is ASCII
|
|
NS_ASSERTION(!IsASCII(label), "ASCII label in IDN checking");
|
|
if (mRestrictionProfile == eASCIIOnlyProfile) {
|
|
return false;
|
|
}
|
|
|
|
nsAString::const_iterator current, end;
|
|
label.BeginReading(current);
|
|
label.EndReading(end);
|
|
|
|
Script lastScript = Script::INVALID;
|
|
uint32_t previousChar = 0;
|
|
uint32_t baseChar = 0; // last non-diacritic seen (base char for marks)
|
|
uint32_t savedNumberingSystem = 0;
|
|
// Simplified/Traditional Chinese check temporarily disabled -- bug 857481
|
|
#if 0
|
|
HanVariantType savedHanVariant = HVT_NotHan;
|
|
#endif
|
|
|
|
int32_t savedScript = -1;
|
|
|
|
while (current != end) {
|
|
uint32_t ch = *current++;
|
|
|
|
if (NS_IS_HIGH_SURROGATE(ch) && current != end &&
|
|
NS_IS_LOW_SURROGATE(*current)) {
|
|
ch = SURROGATE_TO_UCS4(ch, *current++);
|
|
}
|
|
|
|
IdentifierType idType = GetIdentifierType(ch);
|
|
if (idType == IDTYPE_RESTRICTED) {
|
|
return false;
|
|
}
|
|
MOZ_ASSERT(idType == IDTYPE_ALLOWED);
|
|
|
|
// Check for mixed script
|
|
Script script = GetScriptCode(ch);
|
|
if (script != Script::COMMON && script != Script::INHERITED &&
|
|
script != lastScript) {
|
|
if (illegalScriptCombo(script, savedScript)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Check for mixed numbering systems
|
|
auto genCat = GetGeneralCategory(ch);
|
|
if (genCat == HB_UNICODE_GENERAL_CATEGORY_DECIMAL_NUMBER) {
|
|
uint32_t zeroCharacter = ch - GetNumericValue(ch);
|
|
if (savedNumberingSystem == 0) {
|
|
// If we encounter a decimal number, save the zero character from that
|
|
// numbering system.
|
|
savedNumberingSystem = zeroCharacter;
|
|
} else if (zeroCharacter != savedNumberingSystem) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (genCat == HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK) {
|
|
// Check for consecutive non-spacing marks.
|
|
if (previousChar != 0 && previousChar == ch) {
|
|
return false;
|
|
}
|
|
// Check for marks whose expected script doesn't match the base script.
|
|
if (lastScript != Script::INVALID) {
|
|
const size_t kMaxScripts = 32; // more than ample for current values
|
|
// of ScriptExtensions property
|
|
UScriptCode scripts[kMaxScripts];
|
|
UErrorCode errorCode = U_ZERO_ERROR;
|
|
int nScripts =
|
|
uscript_getScriptExtensions(ch, scripts, kMaxScripts, &errorCode);
|
|
MOZ_ASSERT(U_SUCCESS(errorCode), "uscript_getScriptExtensions failed");
|
|
if (U_FAILURE(errorCode)) {
|
|
return false;
|
|
}
|
|
// nScripts will always be >= 1, because even for undefined characters
|
|
// uscript_getScriptExtensions will return Script::INVALID.
|
|
// If the mark just has script=COMMON or INHERITED, we can't check any
|
|
// more carefully, but if it has specific scriptExtension codes, then
|
|
// assume those are the only valid scripts to use it with.
|
|
if (nScripts > 1 || (Script(scripts[0]) != Script::COMMON &&
|
|
Script(scripts[0]) != Script::INHERITED)) {
|
|
while (--nScripts >= 0) {
|
|
if (Script(scripts[nScripts]) == lastScript) {
|
|
break;
|
|
}
|
|
}
|
|
if (nScripts == -1) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
// Check for diacritics on dotless-i, which would be indistinguishable
|
|
// from normal accented letter i.
|
|
if (baseChar == 0x0131 &&
|
|
((ch >= 0x0300 && ch <= 0x0314) || ch == 0x031a)) {
|
|
return false;
|
|
}
|
|
} else {
|
|
baseChar = ch;
|
|
}
|
|
|
|
if (script != Script::COMMON && script != Script::INHERITED) {
|
|
lastScript = script;
|
|
}
|
|
|
|
// Simplified/Traditional Chinese check temporarily disabled -- bug 857481
|
|
#if 0
|
|
|
|
// Check for both simplified-only and traditional-only Chinese characters
|
|
HanVariantType hanVariant = GetHanVariant(ch);
|
|
if (hanVariant == HVT_SimplifiedOnly || hanVariant == HVT_TraditionalOnly) {
|
|
if (savedHanVariant == HVT_NotHan) {
|
|
savedHanVariant = hanVariant;
|
|
} else if (hanVariant != savedHanVariant) {
|
|
return false;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
previousChar = ch;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Scripts that we care about in illegalScriptCombo
|
|
static const Script scriptTable[] = {
|
|
Script::BOPOMOFO, Script::CYRILLIC, Script::GREEK, Script::HANGUL,
|
|
Script::HAN, Script::HIRAGANA, Script::KATAKANA, Script::LATIN};
|
|
|
|
#define BOPO 0
|
|
#define CYRL 1
|
|
#define GREK 2
|
|
#define HANG 3
|
|
#define HANI 4
|
|
#define HIRA 5
|
|
#define KATA 6
|
|
#define LATN 7
|
|
#define OTHR 8
|
|
#define JPAN 9 // Latin + Han + Hiragana + Katakana
|
|
#define CHNA 10 // Latin + Han + Bopomofo
|
|
#define KORE 11 // Latin + Han + Hangul
|
|
#define HNLT 12 // Latin + Han (could be any of the above combinations)
|
|
#define FAIL 13
|
|
|
|
static inline int32_t findScriptIndex(Script aScript) {
|
|
int32_t tableLength = mozilla::ArrayLength(scriptTable);
|
|
for (int32_t index = 0; index < tableLength; ++index) {
|
|
if (aScript == scriptTable[index]) {
|
|
return index;
|
|
}
|
|
}
|
|
return OTHR;
|
|
}
|
|
|
|
static const int32_t scriptComboTable[13][9] = {
|
|
/* thisScript: BOPO CYRL GREK HANG HANI HIRA KATA LATN OTHR
|
|
* savedScript */
|
|
/* BOPO */ {BOPO, FAIL, FAIL, FAIL, CHNA, FAIL, FAIL, CHNA, FAIL},
|
|
/* CYRL */ {FAIL, CYRL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL},
|
|
/* GREK */ {FAIL, FAIL, GREK, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL},
|
|
/* HANG */ {FAIL, FAIL, FAIL, HANG, KORE, FAIL, FAIL, KORE, FAIL},
|
|
/* HANI */ {CHNA, FAIL, FAIL, KORE, HANI, JPAN, JPAN, HNLT, FAIL},
|
|
/* HIRA */ {FAIL, FAIL, FAIL, FAIL, JPAN, HIRA, JPAN, JPAN, FAIL},
|
|
/* KATA */ {FAIL, FAIL, FAIL, FAIL, JPAN, JPAN, KATA, JPAN, FAIL},
|
|
/* LATN */ {CHNA, FAIL, FAIL, KORE, HNLT, JPAN, JPAN, LATN, OTHR},
|
|
/* OTHR */ {FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, OTHR, FAIL},
|
|
/* JPAN */ {FAIL, FAIL, FAIL, FAIL, JPAN, JPAN, JPAN, JPAN, FAIL},
|
|
/* CHNA */ {CHNA, FAIL, FAIL, FAIL, CHNA, FAIL, FAIL, CHNA, FAIL},
|
|
/* KORE */ {FAIL, FAIL, FAIL, KORE, KORE, FAIL, FAIL, KORE, FAIL},
|
|
/* HNLT */ {CHNA, FAIL, FAIL, KORE, HNLT, JPAN, JPAN, HNLT, FAIL}};
|
|
|
|
bool nsIDNService::illegalScriptCombo(Script script, int32_t& savedScript) {
|
|
if (!NS_IsMainThread()) {
|
|
mLock.AssertCurrentThreadOwns();
|
|
}
|
|
|
|
if (savedScript == -1) {
|
|
savedScript = findScriptIndex(script);
|
|
return false;
|
|
}
|
|
|
|
savedScript = scriptComboTable[savedScript][findScriptIndex(script)];
|
|
/*
|
|
* Special case combinations that depend on which profile is in use
|
|
* In the Highly Restrictive profile Latin is not allowed with any
|
|
* other script
|
|
*
|
|
* In the Moderately Restrictive profile Latin mixed with any other
|
|
* single script is allowed.
|
|
*/
|
|
return ((savedScript == OTHR &&
|
|
mRestrictionProfile == eHighlyRestrictiveProfile) ||
|
|
savedScript == FAIL);
|
|
}
|
|
|
|
#undef BOPO
|
|
#undef CYRL
|
|
#undef GREK
|
|
#undef HANG
|
|
#undef HANI
|
|
#undef HIRA
|
|
#undef KATA
|
|
#undef LATN
|
|
#undef OTHR
|
|
#undef JPAN
|
|
#undef CHNA
|
|
#undef KORE
|
|
#undef HNLT
|
|
#undef FAIL
|