Loading...
Searching...
No Matches
uspoof.h File Reference

C API: Unicode Security and Spoofing Detection. More...

`#include "unicode/ubidi.h"`
`#include "unicode/utypes.h"`
`#include "unicode/uset.h"`
`#include "unicode/parseerr.h"`
`#include "unicode/localpointer.h"`
`#include "unicode/unistr.h"`
`#include "unicode/uniset.h"`

Go to the source code of this file.

## Namespaces

namespace | icu
| File coll.h.

## Typedefs

typedef struct USpoofChecker | USpoofChecker
| typedef for C of USpoofChecker
typedef struct USpoofCheckResult | USpoofCheckResult
typedef enum USpoofChecks | USpoofChecks
| Enum for the kinds of checks that USpoofChecker can perform.
typedef enum URestrictionLevel | URestrictionLevel
| Constants from UTS #39 for use in `uspoof_setRestrictionLevel`, and for returned identifier restriction levels in check results.

## Enumerations

enum

USpoofChecks {
USPOOF_SINGLE_SCRIPT_CONFUSABLE = 1 , USPOOF_MIXED_SCRIPT_CONFUSABLE = 2 , USPOOF_WHOLE_SCRIPT_CONFUSABLE = 4 , USPOOF_CONFUSABLE = USPOOF_SINGLE_SCRIPT_CONFUSABLE | USPOOF_MIXED_SCRIPT_CONFUSABLE | USPOOF_WHOLE_SCRIPT_CONFUSABLE ,
USPOOF_ANY_CASE = 8 , USPOOF_RESTRICTION_LEVEL = 16 , USPOOF_SINGLE_SCRIPT = USPOOF_RESTRICTION_LEVEL , USPOOF_INVISIBLE = 32 ,
USPOOF_CHAR_LIMIT = 64 , USPOOF_MIXED_NUMBERS = 128 , USPOOF_HIDDEN_OVERLAY = 256 , USPOOF_ALL_CHECKS = 0xFFFF ,
USPOOF_AUX_INFO = 0x40000000
}

| Enum for the kinds of checks that USpoofChecker can perform. More...
enum | URestrictionLevel { USPOOF_ASCII = 0x10000000 , USPOOF_SINGLE_SCRIPT_RESTRICTIVE = 0x20000000 , USPOOF_HIGHLY_RESTRICTIVE = 0x30000000 , USPOOF_MODERATELY_RESTRICTIVE = 0x40000000 , USPOOF_MINIMALLY_RESTRICTIVE = 0x50000000 , USPOOF_UNRESTRICTIVE = 0x60000000 , USPOOF_RESTRICTION_LEVEL_MASK = 0x7F000000 , USPOOF_UNDEFINED_RESTRICTIVE = -1 }
| Constants from UTS #39 for use in `uspoof_setRestrictionLevel`, and for returned identifier restriction levels in check results. More...

## Functions

U_CAPI USpoofChecker * | uspoof_open (UErrorCode *status)
| Create a Unicode Spoof Checker, configured to perform all checks except for USPOOF_LOCALE_LIMIT and USPOOF_CHAR_LIMIT.
U_CAPI USpoofChecker * | uspoof_openFromSerialized (const void *data, int32_t length, int32_t *pActualLength, UErrorCode *pErrorCode)
| Open a Spoof checker from its serialized form, stored in 32-bit-aligned memory.
U_CAPI USpoofChecker * | uspoof_openFromSource (const char *confusables, int32_t confusablesLen, const char *confusablesWholeScript, int32_t confusablesWholeScriptLen, int32_t *errType, UParseError *pe, UErrorCode *status)
| Open a Spoof Checker from the source form of the spoof data.
U_CAPI void | uspoof_close (USpoofChecker *sc)
| Close a Spoof Checker, freeing any memory that was being held by its implementation.
U_CAPI USpoofChecker * | uspoof_clone (const USpoofChecker *sc, UErrorCode *status)
| Clone a Spoof Checker.
U_CAPI void | uspoof_setChecks (USpoofChecker *sc, int32_t checks, UErrorCode *status)
| Specify the bitmask of checks that will be performed by `uspoof_check`.
U_CAPI int32_t | uspoof_getChecks (const USpoofChecker *sc, UErrorCode *status)
| Get the set of checks that this Spoof Checker has been configured to perform.
U_CAPI void | uspoof_setRestrictionLevel (USpoofChecker *sc, URestrictionLevel restrictionLevel)
| Set the loosest restriction level allowed for strings.
U_CAPI URestrictionLevel | uspoof_getRestrictionLevel (const USpoofChecker *sc)
| Get the Restriction Level that will be tested if the checks include `USPOOF_RESTRICTION_LEVEL`.
U_CAPI void | uspoof_setAllowedLocales (USpoofChecker *sc, const char *localesList, UErrorCode *status)
| Limit characters that are acceptable in identifiers being checked to those normally used with the languages associated with the specified locales.
U_CAPI const char * | uspoof_getAllowedLocales (USpoofChecker *sc, UErrorCode *status)
| Get a list of locales for the scripts that are acceptable in strings to be checked.
U_CAPI void | uspoof_setAllowedChars (USpoofChecker *sc, const USet *chars, UErrorCode *status)
| Limit the acceptable characters to those specified by a Unicode Set.
U_CAPI const USet * | uspoof_getAllowedChars (const USpoofChecker *sc, UErrorCode *status)
| Get a USet for the characters permitted in an identifier.
U_CAPI int32_t | uspoof_check (const USpoofChecker *sc, const UChar *id, int32_t length, int32_t *position, UErrorCode *status)
| Check the specified string for possible security issues.
U_CAPI int32_t | uspoof_checkUTF8 (const USpoofChecker *sc, const char *id, int32_t length, int32_t *position, UErrorCode *status)
| Check the specified string for possible security issues.
U_CAPI int32_t | uspoof_check2 (const USpoofChecker *sc, const UChar *id, int32_t length, USpoofCheckResult *checkResult, UErrorCode *status)
| Check the specified string for possible security issues.
U_CAPI int32_t | uspoof_check2UTF8 (const USpoofChecker *sc, const char *id, int32_t length, USpoofCheckResult *checkResult, UErrorCode *status)
| Check the specified string for possible security issues.
U_CAPI USpoofCheckResult * | uspoof_openCheckResult (UErrorCode *status)
| Create a USpoofCheckResult, used by the `uspoof_check2` class of functions to return information about the identifier.
U_CAPI void | uspoof_closeCheckResult (USpoofCheckResult *checkResult)
| Close a USpoofCheckResult, freeing any memory that was being held by its implementation.
U_CAPI int32_t | uspoof_getCheckResultChecks (const USpoofCheckResult *checkResult, UErrorCode *status)
| Indicates which of the spoof check(s) have failed.
U_CAPI URestrictionLevel | uspoof_getCheckResultRestrictionLevel (const USpoofCheckResult *checkResult, UErrorCode *status)
| Gets the restriction level that the text meets, if the USPOOF_RESTRICTION_LEVEL check was enabled; otherwise, undefined.
U_CAPI const USet * | uspoof_getCheckResultNumerics (const USpoofCheckResult *checkResult, UErrorCode *status)
| Gets the set of numerics found in the string, if the USPOOF_MIXED_NUMBERS check was enabled; otherwise, undefined.
U_CAPI int32_t | uspoof_areConfusable (const USpoofChecker *sc, const UChar *id1, int32_t length1, const UChar *id2, int32_t length2, UErrorCode *status)
| Check whether two specified strings are visually confusable.
U_CAPI uint32_t | uspoof_areBidiConfusable (const USpoofChecker *sc, UBiDiDirection direction, const UChar *id1, int32_t length1, const UChar *id2, int32_t length2, UErrorCode *status)
| Check whether two specified strings are visually confusable when displayed in a context with the given paragraph direction.
U_CAPI int32_t | uspoof_areConfusableUTF8 (const USpoofChecker *sc, const char *id1, int32_t length1, const char *id2, int32_t length2, UErrorCode *status)
| A version of `uspoof_areConfusable` accepting strings in UTF-8 format.
U_CAPI uint32_t | uspoof_areBidiConfusableUTF8 (const USpoofChecker *sc, UBiDiDirection direction, const char *id1, int32_t length1, const char *id2, int32_t length2, UErrorCode *status)
| A version of `uspoof_areBidiConfusable` accepting strings in UTF-8 format.
U_CAPI int32_t | uspoof_getSkeleton (const USpoofChecker *sc, uint32_t type, const UChar *id, int32_t length, UChar *dest, int32_t destCapacity, UErrorCode *status)
| Get the "skeleton" for an identifier.
U_CAPI int32_t | uspoof_getBidiSkeleton (const USpoofChecker *sc, UBiDiDirection direction, const UChar *id, int32_t length, UChar *dest, int32_t destCapacity, UErrorCode *status)
| Get the "bidiSkeleton" for an identifier and a direction.
U_CAPI int32_t | uspoof_getSkeletonUTF8 (const USpoofChecker *sc, uint32_t type, const char *id, int32_t length, char *dest, int32_t destCapacity, UErrorCode *status)
| Get the "skeleton" for an identifier.
U_CAPI int32_t | uspoof_getBidiSkeletonUTF8 (const USpoofChecker *sc, UBiDiDirection direction, const char *id, int32_t length, char *dest, int32_t destCapacity, UErrorCode *status)
| Get the "bidiSkeleton" for an identifier and a direction.
U_CAPI const USet * | uspoof_getInclusionSet (UErrorCode *status)
| Get the set of Candidate Characters for Inclusion in Identifiers, as defined in http://unicode.org/Public/security/latest/xidmodifications.txt and documented in http://www.unicode.org/reports/tr39/, Unicode Security Mechanisms.
U_CAPI const USet * | uspoof_getRecommendedSet (UErrorCode *status)
| Get the set of characters from Recommended Scripts for Inclusion in Identifiers, as defined in http://unicode.org/Public/security/latest/xidmodifications.txt and documented in http://www.unicode.org/reports/tr39/, Unicode Security Mechanisms.
U_CAPI int32_t | uspoof_serialize (USpoofChecker *sc, void *data, int32_t capacity, UErrorCode *status)
| Serialize the data for a spoof detector into a chunk of memory.
U_CAPI void | uspoof_setAllowedUnicodeSet (USpoofChecker *sc, const icu::UnicodeSet *chars, UErrorCode *status)
| Limit the acceptable characters to those specified by a Unicode Set.
U_CAPI const icu::UnicodeSet * | uspoof_getAllowedUnicodeSet (const USpoofChecker *sc, UErrorCode *status)
| Get a UnicodeSet for the characters permitted in an identifier.
U_CAPI int32_t | uspoof_checkUnicodeString (const USpoofChecker *sc, const icu::UnicodeString &id, int32_t *position, UErrorCode *status)
| Check the specified string for possible security issues.
U_CAPI int32_t | uspoof_check2UnicodeString (const USpoofChecker *sc, const icu::UnicodeString &id, USpoofCheckResult *checkResult, UErrorCode *status)
| Check the specified string for possible security issues.
U_CAPI int32_t | uspoof_areConfusableUnicodeString (const USpoofChecker *sc, const icu::UnicodeString &s1, const icu::UnicodeString &s2, UErrorCode *status)
| A version of `uspoof_areConfusable` accepting UnicodeStrings.
U_CAPI uint32_t | uspoof_areBidiConfusableUnicodeString (const USpoofChecker *sc, UBiDiDirection direction, const icu::UnicodeString &s1, const icu::UnicodeString &s2, UErrorCode *status)
| A version of `uspoof_areBidiConfusable` accepting UnicodeStrings.
U_I18N_API icu::UnicodeString & | uspoof_getSkeletonUnicodeString (const USpoofChecker *sc, uint32_t type, const icu::UnicodeString &id, icu::UnicodeString &dest, UErrorCode *status)
| Get the "skeleton" for an identifier.
U_I18N_API icu::UnicodeString & | uspoof_getBidiSkeletonUnicodeString (const USpoofChecker *sc, UBiDiDirection direction, const icu::UnicodeString &id, icu::UnicodeString &dest, UErrorCode *status)
| Get the "bidiSkeleton" for an identifier and a direction.
U_CAPI const icu::UnicodeSet * | uspoof_getInclusionUnicodeSet (UErrorCode *status)
| Get the set of Candidate Characters for Inclusion in Identifiers, as defined in http://unicode.org/Public/security/latest/xidmodifications.txt and documented in http://www.unicode.org/reports/tr39/, Unicode Security Mechanisms.
U_CAPI const icu::UnicodeSet * | uspoof_getRecommendedUnicodeSet (UErrorCode *status)
| Get the set of characters from Recommended Scripts for Inclusion in Identifiers, as defined in http://unicode.org/Public/security/latest/xidmodifications.txt and documented in http://www.unicode.org/reports/tr39/, Unicode Security Mechanisms.

## Detailed Description

C API: Unicode Security and Spoofing Detection.

This class, based on Unicode Technical Report #36 and Unicode Technical Standard #39, has two main functions:

1. Checking whether two strings are visually confusable with each other, such as "Harvest" and "Ηarvest", where the second string starts with the Greek capital letter Eta.
2. Checking whether an individual string is likely to be an attempt at confusing the reader (spoof detection), such as "paypal" with some Latin characters substituted with Cyrillic look-alikes.

Although originally designed as a method for flagging suspicious identifier strings such as URLs, `USpoofChecker` has a number of other practical use cases, such as preventing attempts to evade bad-word content filters.

The functions of this class are exposed as C API, with a handful of syntactical conveniences for C++.

## Confusables

The following example shows how to use `USpoofChecker` to check for confusability between two strings:

UErrorCode status = U_ZERO_ERROR;
UChar* str1 = (UChar*) u"Harvest";
UChar* str2 = (UChar*) u"\u0397arvest"; // with U+0397 GREEK CAPITAL LETTER ETA
USpoofChecker* sc = uspoof_open(&status);
uspoof_setChecks(sc, USPOOF_CONFUSABLE, &status);
int32_t bitmask = uspoof_areConfusable(sc, str1, -1, str2, -1, &status);
UBool result = bitmask != 0;
// areConfusable: 1 (status: U_ZERO_ERROR)
printf("areConfusable: %d (status: %s)\n", result, u_errorName(status));
uspoof_close(sc);
UChar
char16_t UChar
The base type for UTF-16 code units and pointers.
Definition umachine.h:400
UBool
int8_t UBool
The ICU boolean type, a signed-byte integer.
Definition umachine.h:269
uspoof_setChecks
U_CAPI void uspoof_setChecks(USpoofChecker *sc, int32_t checks, UErrorCode *status)
Specify the bitmask of checks that will be performed by uspoof_check.
USPOOF_CONFUSABLE
@ USPOOF_CONFUSABLE
Enable this flag in uspoof_setChecks to turn on all types of confusables.
Definition uspoof.h:483
uspoof_open
U_CAPI USpoofChecker * uspoof_open(UErrorCode *status)
Create a Unicode Spoof Checker, configured to perform all checks except for USPOOF_LOCALE_LIMIT and U...
USpoofChecker
struct USpoofChecker USpoofChecker
typedef for C of USpoofChecker
Definition uspoof.h:427
uspoof_areConfusable
U_CAPI int32_t uspoof_areConfusable(const USpoofChecker *sc, const UChar *id1, int32_t length1, const UChar *id2, int32_t length2, UErrorCode *status)
Check whether two specified strings are visually confusable.
uspoof_close
U_CAPI void uspoof_close(USpoofChecker *sc)
Close a Spoof Checker, freeing any memory that was being held by its implementation.
u_errorName
U_CAPI const char * u_errorName(UErrorCode code)
Return a string for a UErrorCode value.
UErrorCode
UErrorCode
Standard ICU4C error code type, a substitute for exceptions.
Definition utypes.h:509
U_ZERO_ERROR
@ U_ZERO_ERROR
No error, no warning.
Definition utypes.h:544

The call to `uspoof_open` creates a `USpoofChecker` object; the call to `uspoof_setChecks` enables confusable checking and disables all other checks; the call to `uspoof_areConfusable` performs the confusability test; and the following line extracts the result out of the return value. For best performance, the instance should be created once (e.g., upon application startup), and the efficient `uspoof_areConfusable` method can be used at runtime.

If the paragraph direction used to display the strings is known, the bidi function should be used instead:

UErrorCode status = U_ZERO_ERROR;
// These strings look identical when rendered in a left-to-right context.
// They look distinct in a right-to-left context.
UChar* str1 = (UChar*) u"A1\u05D0"; // A1א
UChar* str2 = (UChar*) u"A\u05D01"; // Aא1
USpoofChecker* sc = uspoof_open(&status);
uspoof_setChecks(sc, USPOOF_CONFUSABLE, &status);
int32_t bitmask = uspoof_areBidiConfusable(sc, UBIDI_LTR, str1, -1, str2, -1, &status);
UBool result = bitmask != 0;
// areBidiConfusable: 1 (status: U_ZERO_ERROR)
printf("areBidiConfusable: %d (status: %s)\n", result, u_errorName(status));
uspoof_close(sc);
UBIDI_LTR
@ UBIDI_LTR
Left-to-right text.
Definition ubidi.h:441
uspoof_areBidiConfusable
U_CAPI uint32_t uspoof_areBidiConfusable(const USpoofChecker *sc, UBiDiDirection direction, const UChar *id1, int32_t length1, const UChar *id2, int32_t length2, UErrorCode *status)
Check whether two specified strings are visually confusable when displayed in a context with the give...

The type `LocalUSpoofCheckerPointer` is exposed for C++ programmers. It will automatically call `uspoof_close` when the object goes out of scope:

UErrorCode status = U_ZERO_ERROR;
LocalUSpoofCheckerPointer sc(uspoof_open(&status));
uspoof_setChecks(sc.getAlias(), USPOOF_CONFUSABLE, &status);
// ...
LocalUSpoofCheckerPointer
"Smart pointer" class, closes a USpoofChecker via uspoof_close().

UTS 39 defines two strings to be confusable if they map to the same skeleton string. A skeleton can be thought of as a "hash code". `uspoof_getSkeleton` computes the skeleton for a particular string, so the following snippet is equivalent to the example above:

UErrorCode status = U_ZERO_ERROR;
UChar* str1 = (UChar*) u"Harvest";
UChar* str2 = (UChar*) u"\u0397arvest"; // with U+0397 GREEK CAPITAL LETTER ETA
USpoofChecker* sc = uspoof_open(&status);
uspoof_setChecks(sc, USPOOF_CONFUSABLE, &status);
// Get skeleton 1
int32_t skel1Len = uspoof_getSkeleton(sc, 0, str1, -1, NULL, 0, &status);
UChar* skel1 = (UChar*) malloc(++skel1Len * sizeof(UChar));
status = U_ZERO_ERROR;
uspoof_getSkeleton(sc, 0, str1, -1, skel1, skel1Len, &status);
// Get skeleton 2
int32_t skel2Len = uspoof_getSkeleton(sc, 0, str2, -1, NULL, 0, &status);
UChar* skel2 = (UChar*) malloc(++skel2Len * sizeof(UChar));
status = U_ZERO_ERROR;
uspoof_getSkeleton(sc, 0, str2, -1, skel2, skel2Len, &status);
// Are the skeletons the same?
UBool result = u_strcmp(skel1, skel2) == 0;
// areConfusable: 1 (status: U_ZERO_ERROR)
printf("areConfusable: %d (status: %s)\n", result, u_errorName(status));
uspoof_close(sc);
free(skel1);
free(skel2);
uspoof_getSkeleton
U_CAPI int32_t uspoof_getSkeleton(const USpoofChecker *sc, uint32_t type, const UChar *id, int32_t length, UChar *dest, int32_t destCapacity, UErrorCode *status)
Get the "skeleton" for an identifier.
u_strcmp
U_CAPI int32_t u_strcmp(const UChar *s1, const UChar *s2)
Compare two Unicode strings for bitwise equality (code unit order).
NULL
#define NULL
Define NULL if necessary, to nullptr for C++ and to ((void *)0) for C.
Definition utypes.h:203

If you need to check if a string is confusable with any string in a dictionary of many strings, rather than calling `uspoof_areConfusable` many times in a loop, `uspoof_getSkeleton` can be used instead, as shown below:

UErrorCode status = U_ZERO_ERROR;
#define DICTIONARY_LENGTH 2
UChar* dictionary[DICTIONARY_LENGTH] = { (UChar*) u"lorem", (UChar*) u"ipsum" };
UChar* skeletons[DICTIONARY_LENGTH];
UChar* str = (UChar*) u"1orern";
// Setup:
USpoofChecker* sc = uspoof_open(&status);
uspoof_setChecks(sc, USPOOF_CONFUSABLE, &status);
for (size_t i=0; i<DICTIONARY_LENGTH; i++) {
UChar* word = dictionary[i];
int32_t len = uspoof_getSkeleton(sc, 0, word, -1, NULL, 0, &status);
skeletons[i] = (UChar*) malloc(++len * sizeof(UChar));
status = U_ZERO_ERROR;
uspoof_getSkeleton(sc, 0, word, -1, skeletons[i], len, &status);
}
// Live Check:
{
int32_t len = uspoof_getSkeleton(sc, 0, str, -1, NULL, 0, &status);
UChar* skel = (UChar*) malloc(++len * sizeof(UChar));
status = U_ZERO_ERROR;
uspoof_getSkeleton(sc, 0, str, -1, skel, len, &status);
UBool result = false;
for (size_t i=0; i<DICTIONARY_LENGTH; i++) {
result = u_strcmp(skel, skeletons[i]) == 0;
if (result == true) { break; }
}
// Has confusable in dictionary: 1 (status: U_ZERO_ERROR)
printf("Has confusable in dictionary: %d (status: %s)\n", result, u_errorName(status));
free(skel);
}
for (size_t i=0; i<DICTIONARY_LENGTH; i++) {
free(skeletons[i]);
}
uspoof_close(sc);

Note: Since the Unicode confusables mapping table is frequently updated, confusable skeletons are not guaranteed to be the same between ICU releases. We therefore recommend that you always compute confusable skeletons at runtime and do not rely on creating a permanent, or difficult to update, database of skeletons.

## Spoof Detection

The following snippet shows a minimal example of using `USpoofChecker` to perform spoof detection on a string:

UErrorCode status = U_ZERO_ERROR;
UChar* str = (UChar*) u"p\u0430ypal"; // with U+0430 CYRILLIC SMALL LETTER A
// Get the default set of allowable characters:
USet* allowed = uset_openEmpty();
uset_addAll(allowed, uspoof_getRecommendedSet(&status));
uset_addAll(allowed, uspoof_getInclusionSet(&status));
USpoofChecker* sc = uspoof_open(&status);
uspoof_setAllowedChars(sc, allowed, &status);
uspoof_setRestrictionLevel(sc, USPOOF_MODERATELY_RESTRICTIVE);
int32_t bitmask = uspoof_check(sc, str, -1, NULL, &status);
UBool result = bitmask != 0;
// fails checks: 1 (status: U_ZERO_ERROR)
printf("fails checks: %d (status: %s)\n", result, u_errorName(status));
uspoof_close(sc);
uset_close(allowed);
uset_openEmpty
U_CAPI USet * uset_openEmpty(void)
Create an empty USet object.
uset_close
U_CAPI void uset_close(USet *set)
Disposes of the storage used by a USet object.
USet
struct USet USet
USet is the C API type corresponding to C++ class UnicodeSet.
Definition uset.h:54
uset_addAll
U_CAPI void uset_addAll(USet *set, const USet *additionalSet)
Adds all of the elements in the specified set to this set if they're not already present.
uspoof_getRecommendedSet
U_CAPI const USet * uspoof_getRecommendedSet(UErrorCode *status)
Get the set of characters from Recommended Scripts for Inclusion in Identifiers, as defined in http:/...
uspoof_setAllowedChars
U_CAPI void uspoof_setAllowedChars(USpoofChecker *sc, const USet *chars, UErrorCode *status)
Limit the acceptable characters to those specified by a Unicode Set.
USPOOF_MODERATELY_RESTRICTIVE
@ USPOOF_MODERATELY_RESTRICTIVE
The string classifies as Highly Restrictive, or all characters in the string are in the identifier pr...
Definition uspoof.h:631
uspoof_check
U_CAPI int32_t uspoof_check(const USpoofChecker *sc, const UChar *id, int32_t length, int32_t *position, UErrorCode *status)
Check the specified string for possible security issues.
uspoof_getInclusionSet
U_CAPI const USet * uspoof_getInclusionSet(UErrorCode *status)
Get the set of Candidate Characters for Inclusion in Identifiers, as defined in http://unicode....
uspoof_setRestrictionLevel
U_CAPI void uspoof_setRestrictionLevel(USpoofChecker *sc, URestrictionLevel restrictionLevel)
Set the loosest restriction level allowed for strings.

As in the case for confusability checking, it is good practice to create one `USpoofChecker` instance at startup, and call the cheaper `uspoof_check` online. We specify the set of allowed characters to be those with type RECOMMENDED or INCLUSION, according to the recommendation in UTS 39.

In addition to `uspoof_check`, the function `uspoof_checkUTF8` is exposed for UTF8-encoded char* strings, and `uspoof_checkUnicodeString` is exposed for C++ programmers.

If the `USPOOF_AUX_INFO` check is enabled, a limited amount of information on why a string failed the checks is available in the returned bitmask. For complete information, use the `uspoof_check2` class of functions with a `USpoofCheckResult` parameter:

UErrorCode status = U_ZERO_ERROR;
UChar* str = (UChar*) u"p\u0430ypal"; // with U+0430 CYRILLIC SMALL LETTER A
// Get the default set of allowable characters:
USet* allowed = uset_openEmpty();
uset_addAll(allowed, uspoof_getRecommendedSet(&status));
uset_addAll(allowed, uspoof_getInclusionSet(&status));
USpoofChecker* sc = uspoof_open(&status);
uspoof_setAllowedChars(sc, allowed, &status);
uspoof_setRestrictionLevel(sc, USPOOF_MODERATELY_RESTRICTIVE);
USpoofCheckResult* checkResult = uspoof_openCheckResult(&status);
int32_t bitmask = uspoof_check2(sc, str, -1, checkResult, &status);
int32_t failures1 = bitmask;
int32_t failures2 = uspoof_getCheckResultChecks(checkResult, &status);
assert(failures1 == failures2);
// checks that failed: 0x00000010 (status: U_ZERO_ERROR)
printf("checks that failed: %#010x (status: %s)\n", failures1, u_errorName(status));
// Cleanup:
uspoof_close(sc);
uset_close(allowed);
uspoof_closeCheckResult(checkResult);
uspoof_openCheckResult
U_CAPI USpoofCheckResult * uspoof_openCheckResult(UErrorCode *status)
Create a USpoofCheckResult, used by the uspoof_check2 class of functions to return information about ...
uspoof_check2
U_CAPI int32_t uspoof_check2(const USpoofChecker *sc, const UChar *id, int32_t length, USpoofCheckResult *checkResult, UErrorCode *status)
Check the specified string for possible security issues.
uspoof_getCheckResultChecks
U_CAPI int32_t uspoof_getCheckResultChecks(const USpoofCheckResult *checkResult, UErrorCode *status)
Indicates which of the spoof check(s) have failed.
USpoofCheckResult
struct USpoofCheckResult USpoofCheckResult
Definition uspoof.h:434
uspoof_closeCheckResult
U_CAPI void uspoof_closeCheckResult(USpoofCheckResult *checkResult)
Close a USpoofCheckResult, freeing any memory that was being held by its implementation.

C++ users can take advantage of a few syntactical conveniences. The following snippet is functionally equivalent to the one above:

UErrorCode status = U_ZERO_ERROR;
UnicodeString str((UChar*) u"p\u0430ypal"); // with U+0430 CYRILLIC SMALL LETTER A
// Get the default set of allowable characters:
UnicodeSet allowed;
allowed.addAll(*uspoof_getRecommendedUnicodeSet(&status));
allowed.addAll(*uspoof_getInclusionUnicodeSet(&status));
LocalUSpoofCheckerPointer sc(uspoof_open(&status));
uspoof_setAllowedChars(sc.getAlias(), allowed.toUSet(), &status);
uspoof_setRestrictionLevel(sc.getAlias(), USPOOF_MODERATELY_RESTRICTIVE);
LocalUSpoofCheckResultPointer checkResult(uspoof_openCheckResult(&status));
int32_t bitmask = uspoof_check2UnicodeString(sc.getAlias(), str, checkResult.getAlias(), &status);
int32_t failures1 = bitmask;
int32_t failures2 = uspoof_getCheckResultChecks(checkResult.getAlias(), &status);
assert(failures1 == failures2);
// checks that failed: 0x00000010 (status: U_ZERO_ERROR)
printf("checks that failed: %#010x (status: %s)\n", failures1, u_errorName(status));
// Explicit cleanup not necessary.
LocalUSpoofCheckResultPointer
"Smart pointer" class, closes a USpoofCheckResult via uspoof_closeCheckResult().
uspoof_getRecommendedUnicodeSet
U_CAPI const icu::UnicodeSet * uspoof_getRecommendedUnicodeSet(UErrorCode *status)
Get the set of characters from Recommended Scripts for Inclusion in Identifiers, as defined in http:/...
uspoof_getInclusionUnicodeSet
U_CAPI const icu::UnicodeSet * uspoof_getInclusionUnicodeSet(UErrorCode *status)
Get the set of Candidate Characters for Inclusion in Identifiers, as defined in http://unicode....
uspoof_check2UnicodeString
U_CAPI int32_t uspoof_check2UnicodeString(const USpoofChecker *sc, const icu::UnicodeString &id, USpoofCheckResult *checkResult, UErrorCode *status)
Check the specified string for possible security issues.

The return value is a bitmask of the checks that failed. In this case, there was one check that failed: `USPOOF_RESTRICTION_LEVEL`, corresponding to the fifth bit (16). The possible checks are:

- `RESTRICTION_LEVEL`: flags strings that violate the Restriction Level test as specified in UTS 39; in most cases, this means flagging strings that contain characters from multiple different scripts.
- `INVISIBLE`: flags strings that contain invisible characters, such as zero-width spaces, or character sequences that are likely not to display, such as multiple occurrences of the same non-spacing mark.
- `CHAR_LIMIT`: flags strings that contain characters outside of a specified set of acceptable characters. See `uspoof_setAllowedChars` and `uspoof_setAllowedLocales`.
- `MIXED_NUMBERS`: flags strings that contain digits from multiple different numbering systems.

These checks can be enabled independently of each other. For example, if you were interested in checking for only the INVISIBLE and MIXED_NUMBERS conditions, you could do:

UErrorCode status = U_ZERO_ERROR;
UChar* str = (UChar*) u"8\u09EA"; // 8 mixed with U+09EA BENGALI DIGIT FOUR
USpoofChecker* sc = uspoof_open(&status);
uspoof_setChecks(sc, USPOOF_INVISIBLE | USPOOF_MIXED_NUMBERS, &status);
int32_t bitmask = uspoof_check2(sc, str, -1, NULL, &status);
UBool result = bitmask != 0;
// fails checks: 1 (status: U_ZERO_ERROR)
printf("fails checks: %d (status: %s)\n", result, u_errorName(status));
uspoof_close(sc);
USPOOF_MIXED_NUMBERS
@ USPOOF_MIXED_NUMBERS
Check that an identifier does not mix numbers from different numbering systems.
Definition uspoof.h:539
USPOOF_INVISIBLE
@ USPOOF_INVISIBLE
Check an identifier for the presence of invisible characters, such as zero-width spaces,...
Definition uspoof.h:524

Here is an example in C++ showing how to compute the restriction level of a string:

UErrorCode status = U_ZERO_ERROR;
UnicodeString str((UChar*) u"p\u0430ypal"); // with U+0430 CYRILLIC SMALL LETTER A
// Get the default set of allowable characters:
UnicodeSet allowed;
allowed.addAll(*uspoof_getRecommendedUnicodeSet(&status));
allowed.addAll(*uspoof_getInclusionUnicodeSet(&status));
LocalUSpoofCheckerPointer sc(uspoof_open(&status));
uspoof_setAllowedChars(sc.getAlias(), allowed.toUSet(), &status);
uspoof_setRestrictionLevel(sc.getAlias(), USPOOF_MODERATELY_RESTRICTIVE);
uspoof_setChecks(sc.getAlias(), USPOOF_RESTRICTION_LEVEL | USPOOF_AUX_INFO, &status);
LocalUSpoofCheckResultPointer checkResult(uspoof_openCheckResult(&status));
int32_t bitmask = uspoof_check2UnicodeString(sc.getAlias(), str, checkResult.getAlias(), &status);
URestrictionLevel restrictionLevel = uspoof_getCheckResultRestrictionLevel(checkResult.getAlias(), &status);
// Since USPOOF_AUX_INFO was enabled, the restriction level is also available in the upper bits of the bitmask:
assert((restrictionLevel & bitmask) == restrictionLevel);
// Restriction level: 0x50000000 (status: U_ZERO_ERROR)
printf("Restriction level: %#010x (status: %s)\n", restrictionLevel, u_errorName(status));
USPOOF_RESTRICTION_LEVEL
@ USPOOF_RESTRICTION_LEVEL
Check that an identifier is no looser than the specified RestrictionLevel.
Definition uspoof.h:507
USPOOF_AUX_INFO
@ USPOOF_AUX_INFO
Enable the return of auxiliary (non-error) information in the upper bits of the check results value.
Definition uspoof.h:581
URestrictionLevel
URestrictionLevel
Constants from UTS #39 for use in uspoof_setRestrictionLevel, and for returned identifier restriction...
Definition uspoof.h:595
uspoof_getCheckResultRestrictionLevel
U_CAPI URestrictionLevel uspoof_getCheckResultRestrictionLevel(const USpoofCheckResult *checkResult, UErrorCode *status)
Gets the restriction level that the text meets, if the USPOOF_RESTRICTION_LEVEL check was enabled; ot...

The code '0x50000000' corresponds to the restriction level USPOOF_MINIMALLY_RESTRICTIVE. Since USPOOF_MINIMALLY_RESTRICTIVE is weaker than USPOOF_MODERATELY_RESTRICTIVE, the string fails the check.

Note: The Restriction Level is the most powerful of the checks. The full logic is documented in UTS 39, but the basic idea is that strings are restricted to contain characters from only a single script, except that most scripts are allowed to have Latin characters interspersed. Although the default restriction level is `HIGHLY_RESTRICTIVE`, it is recommended that users set their restriction level to `MODERATELY_RESTRICTIVE`, which allows Latin mixed with all other scripts except Cyrillic, Greek, and Cherokee, with which it is often confusable. For more details on the levels, see UTS 39 or `URestrictionLevel`. The Restriction Level test is aware of the set of allowed characters set in `uspoof_setAllowedChars`. Note that characters which have script code COMMON or INHERITED, such as numbers and punctuation, are ignored when computing whether a string has multiple scripts.

## Advanced bidirectional usage

If the paragraph direction with which the identifiers will be displayed is not known, there are multiple options for confusable detection depending on the circumstances.

In some circumstances, the only concern is confusion between identifiers displayed with the same paragraph direction.

An example is the case where identifiers are usernames prefixed with the @ symbol. That symbol will appear to the left in a left-to-right context, and to the right in a right-to-left context, so that an identifier displayed in a left-to-right context can never be confused with an identifier displayed in a right-to-left context:

- The usernames "A1א" (A one aleph) and "Aא1" (A aleph 1) would be considered confusable, since they both appear as @A1א in a left-to-right context, and the usernames "אA_1" (aleph A underscore one) and "א1_A" (aleph one underscore A) would be considered confusable, since they both appear as A_1א@ in a right-to-left context.
- The username "Mark_" would not be considered confusable with the username "_Mark", even though the latter would appear as Mark_@ in a right-to-left context, and the former as @Mark_ in a left-to-right context.

In that case, the caller should check for both LTR-confusability and RTL-confusability:

bool confusableInEitherDirection =
uspoof_areBidiConfusableUnicodeString(sc, UBIDI_LTR, id1, id2, &status) ||
uspoof_areBidiConfusableUnicodeString(sc, UBIDI_RTL, id1, id2, &status);
UBIDI_RTL
@ UBIDI_RTL
Right-to-left text.
Definition ubidi.h:453
uspoof_areBidiConfusableUnicodeString
U_CAPI uint32_t uspoof_areBidiConfusableUnicodeString(const USpoofChecker *sc, UBiDiDirection direction, const icu::UnicodeString &s1, const icu::UnicodeString &s2, UErrorCode *status)
A version of uspoof_areBidiConfusable accepting UnicodeStrings.

If the bidiSkeleton is used, the LTR and RTL skeleta should be kept separately and compared, LTR with LTR and RTL with RTL.

In cases where confusability between the visual appearances of an identifier displayed in a left-to-right context with another identifier displayed in a right-to-left context is a concern, the LTR skeleton of one can be compared with the RTL skeleton of the other. However, this very broad definition of confusability may have unexpected results; for instance, it treats the ASCII identifiers "Mark_" and "_Mark" as confusable.

## Additional Information

A `USpoofChecker` instance may be used repeatedly to perform checks on any number of identifiers.

Thread Safety: The test functions for checking a single identifier, or for testing whether two identifiers are possible confusable, are thread safe. They may called concurrently, from multiple threads, using the same USpoofChecker instance.

More generally, the standard ICU thread safety rules apply: functions that take a const USpoofChecker parameter are thread safe. Those that take a non-const USpoofChecker are not thread safe..

Stable
  ICU 4.6

Definition in file uspoof.h.

## Typedef Documentation

## URestrictionLevel

typedef enum URestrictionLevel URestrictionLevel

Constants from UTS #39 for use in `uspoof_setRestrictionLevel`, and for returned identifier restriction levels in check results.

Stable
  ICU 51

See also
  uspoof_setRestrictionLevel
  uspoof_check

## USpoofChecker

typedef struct USpoofChecker USpoofChecker

typedef for C of USpoofChecker

Stable
  ICU 4.2

Definition at line 427 of file uspoof.h.

## USpoofCheckResult

typedef struct USpoofCheckResult USpoofCheckResult

See also
  uspoof_openCheckResult

Stable
  ICU 58

Definition at line 434 of file uspoof.h.

## USpoofChecks

typedef enum USpoofChecks USpoofChecks

Enum for the kinds of checks that USpoofChecker can perform.

These enum values are used both to select the set of checks that will be performed, and to report results from the check function.

Stable
  ICU 4.2

## Enumeration Type Documentation

## URestrictionLevel

enum URestrictionLevel

Constants from UTS #39 for use in `uspoof_setRestrictionLevel`, and for returned identifier restriction levels in check results.

Stable
  ICU 51

See also
  uspoof_setRestrictionLevel
  uspoof_check

Enumerator

USPOOF_ASCII

All characters in the string are in the identifier profile and all characters in the string are in the ASCII range.

Stable
  ICU 51

USPOOF_SINGLE_SCRIPT_RESTRICTIVE

The string classifies as ASCII-Only, or all characters in the string are in the identifier profile and the string is single-script, according to the definition in UTS 39 section 5.1.

Stable
  ICU 53

USPOOF_HIGHLY_RESTRICTIVE

The string classifies as Single Script, or all characters in the string are in the identifier profile and the string is covered by any of the following sets of scripts, according to the definition in UTS 39 section 5.1:

- Latin + Han + Bopomofo (or equivalently: Latn + Hanb)
- Latin + Han + Hiragana + Katakana (or equivalently: Latn + Jpan)
- Latin + Han + Hangul (or equivalently: Latn +Kore)

This is the default restriction in ICU.

Stable
  ICU 51

USPOOF_MODERATELY_RESTRICTIVE

The string classifies as Highly Restrictive, or all characters in the string are in the identifier profile and the string is covered by Latin and any one other Recommended or Aspirational script, except Cyrillic, Greek, and Cherokee.

Stable
  ICU 51

USPOOF_MINIMALLY_RESTRICTIVE

All characters in the string are in the identifier profile.

Allow arbitrary mixtures of scripts.

Stable
  ICU 51

USPOOF_UNRESTRICTIVE

Any valid identifiers, including characters outside of the Identifier Profile.

Stable
  ICU 51

USPOOF_RESTRICTION_LEVEL_MASK

Mask for selecting the Restriction Level bits from the return value of `uspoof_check`.

Stable
  ICU 53

USPOOF_UNDEFINED_RESTRICTIVE

An undefined restriction level.

Internal
  Do not use. This API is for internal use only.

Definition at line 595 of file uspoof.h.

## USpoofChecks

enum USpoofChecks

Enum for the kinds of checks that USpoofChecker can perform.

These enum values are used both to select the set of checks that will be performed, and to report results from the check function.

Stable
  ICU 4.2

Enumerator

USPOOF_SINGLE_SCRIPT_CONFUSABLE

When performing the two-string `uspoof_areConfusable` test, this flag in the return value indicates that the two strings are visually confusable and that they are from the same script, according to UTS 39 section 4.

See also
  uspoof_areConfusable

Stable
  ICU 4.2

USPOOF_MIXED_SCRIPT_CONFUSABLE

When performing the two-string `uspoof_areConfusable` test, this flag in the return value indicates that the two strings are visually confusable and that they are not from the same script, according to UTS 39 section 4.

See also
  uspoof_areConfusable

Stable
  ICU 4.2

USPOOF_WHOLE_SCRIPT_CONFUSABLE

When performing the two-string `uspoof_areConfusable` test, this flag in the return value indicates that the two strings are visually confusable and that they are not from the same script but both of them are single-script strings, according to UTS 39 section 4.

See also
  uspoof_areConfusable

Stable
  ICU 4.2

USPOOF_CONFUSABLE

Enable this flag in `uspoof_setChecks` to turn on all types of confusables.

You may set the checks to some subset of SINGLE_SCRIPT_CONFUSABLE, MIXED_SCRIPT_CONFUSABLE, or WHOLE_SCRIPT_CONFUSABLE to make `uspoof_areConfusable` return only those types of confusables.

See also
  uspoof_areConfusable
  uspoof_getSkeleton

Stable
  ICU 58

USPOOF_ANY_CASE

This flag is deprecated and no longer affects the behavior of SpoofChecker.

Deprecated
  ICU 58 Any case confusable mappings were removed from UTS 39; the corresponding ICU API was deprecated.

USPOOF_RESTRICTION_LEVEL

Check that an identifier is no looser than the specified RestrictionLevel.

The default if `uspoof_setRestrictionLevel` is not called is HIGHLY_RESTRICTIVE.

If USPOOF_AUX_INFO is enabled the actual restriction level of the identifier being tested will also be returned by uspoof_check().

See also
  URestrictionLevel
  uspoof_setRestrictionLevel
  USPOOF_AUX_INFO

Stable
  ICU 51

USPOOF_SINGLE_SCRIPT

Check that an identifier contains only characters from a single script (plus chars from the common and inherited scripts.) Applies to checks of a single identifier check only.

Deprecated
  ICU 51 Use RESTRICTION_LEVEL instead.

USPOOF_INVISIBLE | Check an identifier for the presence of invisible characters, such as zero-width spaces, or character sequences that are likely not to display, such as multiple occurrences of the same non-spacing mark. This check does not test the input string as a whole for conformance to any particular syntax for identifiers.
USPOOF_CHAR_LIMIT | Check that an identifier contains only characters from a specified set of acceptable characters. See `uspoof_setAllowedChars` and `uspoof_setAllowedLocales`. Note that a string that fails this check will also fail the `USPOOF_RESTRICTION_LEVEL` check.

USPOOF_MIXED_NUMBERS

Check that an identifier does not mix numbers from different numbering systems.

For more information, see UTS 39 section 5.3.

Stable
  ICU 51

USPOOF_HIDDEN_OVERLAY

Check that an identifier does not have a combining character following a character in which that combining character would be hidden; for example 'i' followed by a U+0307 combining dot.

More specifically, the following characters are forbidden from preceding a U+0307:

- Those with the Soft_Dotted Unicode property (which includes 'i' and 'j')
- Latin lowercase letter 'l'
- Dotless 'i' and 'j' ('ı' and 'ȷ', U+0131 and U+0237)
- Any character whose confusable prototype ends with such a character (Soft_Dotted, 'l', 'ı', or 'ȷ')

In addition, combining characters are allowed between the above characters and U+0307 except those with combining class 0 or combining class "Above" (230, same class as U+0307).

This list and the number of combing characters considered by this check may grow over time.

Stable
  ICU 62

USPOOF_ALL_CHECKS

Enable all spoof checks.

Stable
  ICU 4.6

USPOOF_AUX_INFO

Enable the return of auxiliary (non-error) information in the upper bits of the check results value.

If this "check" is not enabled, the results of `uspoof_check` will be zero when an identifier passes all of the enabled checks.

If this "check" is enabled, (uspoof_check() & `USPOOF_ALL_CHECKS`) will be zero when an identifier passes all checks.

Stable
  ICU 51

Definition at line 443 of file uspoof.h.

## Function Documentation

## uspoof_areBidiConfusable()

U_CAPI uint32_t uspoof_areBidiConfusable | ( | const USpoofChecker * | sc,
|  | UBiDiDirection | direction,
|  | const UChar * | id1,
|  | int32_t | length1,
|  | const UChar * | id2,
|  | int32_t | length2,
|  | UErrorCode * | status )

Check whether two specified strings are visually confusable when displayed in a context with the given paragraph direction.

If the strings are confusable, the return value will be nonzero, as long as `USPOOF_CONFUSABLE` was enabled in uspoof_setChecks().

The bits in the return value correspond to flags for each of the classes of confusables applicable to the two input strings. According to UTS 39 section 4, the possible flags are:

- `USPOOF_SINGLE_SCRIPT_CONFUSABLE`
- `USPOOF_MIXED_SCRIPT_CONFUSABLE`
- `USPOOF_WHOLE_SCRIPT_CONFUSABLE`

If one or more of the above flags were not listed in uspoof_setChecks(), this function will never report that class of confusable. The check `USPOOF_CONFUSABLE` enables all three flags.

Parameters

  sc | The USpoofChecker
  direction | The paragraph direction with which the identifiers are displayed. Must be either UBIDI_LTR or UBIDI_RTL.
  id1 | The first of the two identifiers to be compared for confusability. The strings are in UTF-16 format.
  length1 | the length of the first identifier, expressed in 16 bit UTF-16 code units, or -1 if the string is nul terminated.
  id2 | The second of the two identifiers to be compared for confusability. The identifiers are in UTF-16 format.
  length2 | The length of the second identifiers, expressed in 16 bit UTF-16 code units, or -1 if the string is nul terminated.
  status | The error code, set if an error occurred while attempting to perform the check. Confusability of the identifiers is not reported here, but through this function's return value.

Returns
  An integer value with bit(s) set corresponding to the type of confusability found, as defined by enum USpoofChecks. Zero is returned if the identifiers are not confusable.

Stable
  ICU 74

References U_CAPI.

## uspoof_areBidiConfusableUnicodeString()

U_CAPI uint32_t uspoof_areBidiConfusableUnicodeString | ( | const USpoofChecker * | sc,
|  | UBiDiDirection | direction,
|  | const icu::UnicodeString & | s1,
|  | const icu::UnicodeString & | s2,
|  | UErrorCode * | status )

A version of `uspoof_areBidiConfusable` accepting UnicodeStrings.

Parameters

  sc | The USpoofChecker
  direction | The paragraph direction with which the identifiers are displayed. Must be either UBIDI_LTR or UBIDI_RTL.
  s1 | The first of the two identifiers to be compared for confusability. The strings are in UTF-8 format.
  s2 | The second of the two identifiers to be compared for confusability. The strings are in UTF-8 format.
  status | The error code, set if an error occurred while attempting to perform the check. Confusability of the identifiers is not reported here, but through this function's return value.

Returns
  An integer value with bit(s) set corresponding to the type of confusability found, as defined by enum USpoofChecks. Zero is returned if the identifiers are not confusable.

Stable
  ICU 74

See also
  uspoof_areBidiConfusable

References U_CAPI, and U_I18N_API.

## uspoof_areBidiConfusableUTF8()

U_CAPI uint32_t uspoof_areBidiConfusableUTF8 | ( | const USpoofChecker * | sc,
|  | UBiDiDirection | direction,
|  | const char * | id1,
|  | int32_t | length1,
|  | const char * | id2,
|  | int32_t | length2,
|  | UErrorCode * | status )

A version of `uspoof_areBidiConfusable` accepting strings in UTF-8 format.

Parameters

  sc | The USpoofChecker
  direction | The paragraph direction with which the identifiers are displayed. Must be either UBIDI_LTR or UBIDI_RTL.
  id1 | The first of the two identifiers to be compared for confusability. The strings are in UTF-8 format.
  length1 | the length of the first identifiers, in bytes, or -1 if the string is nul terminated.
  id2 | The second of the two identifiers to be compared for confusability. The strings are in UTF-8 format.
  length2 | The length of the second string in bytes, or -1 if the string is nul terminated.
  status | The error code, set if an error occurred while attempting to perform the check. Confusability of the strings is not reported here, but through this function's return value.

Returns
  An integer value with bit(s) set corresponding to the type of confusability found, as defined by enum USpoofChecks. Zero is returned if the strings are not confusable.

Stable
  ICU 74

See also
  uspoof_areBidiConfusable

References U_CAPI.

## uspoof_areConfusable()

U_CAPI int32_t uspoof_areConfusable | ( | const USpoofChecker * | sc,
|  | const UChar * | id1,
|  | int32_t | length1,
|  | const UChar * | id2,
|  | int32_t | length2,
|  | UErrorCode * | status )

Check whether two specified strings are visually confusable.

If the strings are confusable, the return value will be nonzero, as long as `USPOOF_CONFUSABLE` was enabled in uspoof_setChecks().

The bits in the return value correspond to flags for each of the classes of confusables applicable to the two input strings. According to UTS 39 section 4, the possible flags are:

- `USPOOF_SINGLE_SCRIPT_CONFUSABLE`
- `USPOOF_MIXED_SCRIPT_CONFUSABLE`
- `USPOOF_WHOLE_SCRIPT_CONFUSABLE`

If one or more of the above flags were not listed in uspoof_setChecks(), this function will never report that class of confusable. The check `USPOOF_CONFUSABLE` enables all three flags.

Parameters

  sc | The USpoofChecker
  id1 | The first of the two identifiers to be compared for confusability. The strings are in UTF-16 format.
  length1 | the length of the first identifier, expressed in 16 bit UTF-16 code units, or -1 if the string is nul terminated.
  id2 | The second of the two identifiers to be compared for confusability. The identifiers are in UTF-16 format.
  length2 | The length of the second identifiers, expressed in 16 bit UTF-16 code units, or -1 if the string is nul terminated.
  status | The error code, set if an error occurred while attempting to perform the check. Confusability of the identifiers is not reported here, but through this function's return value.

Returns
  An integer value with bit(s) set corresponding to the type of confusability found, as defined by enum USpoofChecks. Zero is returned if the identifiers are not confusable.

Stable
  ICU 4.2

## uspoof_areConfusableUnicodeString()

U_CAPI int32_t uspoof_areConfusableUnicodeString | ( | const USpoofChecker * | sc,
|  | const icu::UnicodeString & | s1,
|  | const icu::UnicodeString & | s2,
|  | UErrorCode * | status )

A version of `uspoof_areConfusable` accepting UnicodeStrings.

Parameters

  sc | The USpoofChecker
  s1 | The first of the two identifiers to be compared for confusability. The strings are in UTF-8 format.
  s2 | The second of the two identifiers to be compared for confusability. The strings are in UTF-8 format.
  status | The error code, set if an error occurred while attempting to perform the check. Confusability of the identifiers is not reported here, but through this function's return value.

Returns
  An integer value with bit(s) set corresponding to the type of confusability found, as defined by enum USpoofChecks. Zero is returned if the identifiers are not confusable.

Stable
  ICU 4.2

See also
  uspoof_areConfusable

## uspoof_areConfusableUTF8()

U_CAPI int32_t uspoof_areConfusableUTF8 | ( | const USpoofChecker * | sc,
|  | const char * | id1,
|  | int32_t | length1,
|  | const char * | id2,
|  | int32_t | length2,
|  | UErrorCode * | status )

A version of `uspoof_areConfusable` accepting strings in UTF-8 format.

Parameters

  sc | The USpoofChecker
  id1 | The first of the two identifiers to be compared for confusability. The strings are in UTF-8 format.
  length1 | the length of the first identifiers, in bytes, or -1 if the string is nul terminated.
  id2 | The second of the two identifiers to be compared for confusability. The strings are in UTF-8 format.
  length2 | The length of the second string in bytes, or -1 if the string is nul terminated.
  status | The error code, set if an error occurred while attempting to perform the check. Confusability of the strings is not reported here, but through this function's return value.

Returns
  An integer value with bit(s) set corresponding to the type of confusability found, as defined by enum USpoofChecks. Zero is returned if the strings are not confusable.

Stable
  ICU 4.2

See also
  uspoof_areConfusable

## uspoof_check()

U_CAPI int32_t uspoof_check | ( | const USpoofChecker * | sc,
|  | const UChar * | id,
|  | int32_t | length,
|  | int32_t * | position,
|  | UErrorCode * | status )

Check the specified string for possible security issues.

The text to be checked will typically be an identifier of some sort. The set of checks to be performed is specified with uspoof_setChecks().

Note
  Consider using the newer API, `uspoof_check2`, instead. The newer API exposes additional information from the check procedure and is otherwise identical to this method.

Parameters

  sc | The USpoofChecker
  id | The identifier to be checked for possible security issues, in UTF-16 format.
  length | the length of the string to be checked, expressed in 16 bit UTF-16 code units, or -1 if the string is zero terminated.
  position | Deprecated in ICU 51. Always returns zero. Originally, an out parameter for the index of the first string position that failed a check. This parameter may be NULL.
  status | The error code, set if an error occurred while attempting to perform the check. Spoofing or security issues detected with the input string are not reported here, but through the function's return value.

Returns
  An integer value with bits set for any potential security or spoofing issues detected. The bits are defined by enum USpoofChecks. (returned_value & USPOOF_ALL_CHECKS) will be zero if the input string passes all of the enabled checks.

See also
  uspoof_check2

Stable
  ICU 4.2

References U_CAPI.

## uspoof_check2()

U_CAPI int32_t uspoof_check2 | ( | const USpoofChecker * | sc,
|  | const UChar * | id,
|  | int32_t | length,
|  | USpoofCheckResult * | checkResult,
|  | UErrorCode * | status )

Check the specified string for possible security issues.

The text to be checked will typically be an identifier of some sort. The set of checks to be performed is specified with uspoof_setChecks().

Parameters

  sc | The USpoofChecker
  id | The identifier to be checked for possible security issues, in UTF-16 format.
  length | the length of the string to be checked, or -1 if the string is zero terminated.
  checkResult | An instance of USpoofCheckResult to be filled with details about the identifier. Can be NULL.
  status | The error code, set if an error occurred while attempting to perform the check. Spoofing or security issues detected with the input string are not reported here, but through the function's return value.

Returns
  An integer value with bits set for any potential security or spoofing issues detected. The bits are defined by enum USpoofChecks. (returned_value & USPOOF_ALL_CHECKS) will be zero if the input string passes all of the enabled checks. Any information in this bitmask will be consistent with the information saved in the optional checkResult parameter.

See also
  uspoof_openCheckResult
  uspoof_check2UTF8
  uspoof_check2UnicodeString

Stable
  ICU 58

References U_CAPI.

## uspoof_check2UnicodeString()

U_CAPI int32_t uspoof_check2UnicodeString | ( | const USpoofChecker * | sc,
|  | const icu::UnicodeString & | id,
|  | USpoofCheckResult * | checkResult,
|  | UErrorCode * | status )

Check the specified string for possible security issues.

The text to be checked will typically be an identifier of some sort. The set of checks to be performed is specified with uspoof_setChecks().

Parameters

  sc | The USpoofChecker
  id | A identifier to be checked for possible security issues.
  checkResult | An instance of USpoofCheckResult to be filled with details about the identifier. Can be nullptr.
  status | The error code, set if an error occurred while attempting to perform the check. Spoofing or security issues detected with the input string are not reported here, but through the function's return value.

Returns
  An integer value with bits set for any potential security or spoofing issues detected. The bits are defined by enum USpoofChecks. (returned_value & USPOOF_ALL_CHECKS) will be zero if the input string passes all of the enabled checks. Any information in this bitmask will be consistent with the information saved in the optional checkResult parameter.

See also
  uspoof_openCheckResult
  uspoof_check2
  uspoof_check2UTF8

Stable
  ICU 58

References U_CAPI.

## uspoof_check2UTF8()

U_CAPI int32_t uspoof_check2UTF8 | ( | const USpoofChecker * | sc,
|  | const char * | id,
|  | int32_t | length,
|  | USpoofCheckResult * | checkResult,
|  | UErrorCode * | status )

Check the specified string for possible security issues.

The text to be checked will typically be an identifier of some sort. The set of checks to be performed is specified with uspoof_setChecks().

This version of `uspoof_check` accepts a USpoofCheckResult, which returns additional information about the identifier. For more information, see `uspoof_openCheckResult`.

Parameters

  sc | The USpoofChecker
  id | A identifier to be checked for possible security issues, in UTF8 format.
  length | the length of the string to be checked, or -1 if the string is zero terminated.
  checkResult | An instance of USpoofCheckResult to be filled with details about the identifier. Can be NULL.
  status | The error code, set if an error occurred while attempting to perform the check. Spoofing or security issues detected with the input string are not reported here, but through the function's return value.

Returns
  An integer value with bits set for any potential security or spoofing issues detected. The bits are defined by enum USpoofChecks. (returned_value & USPOOF_ALL_CHECKS) will be zero if the input string passes all of the enabled checks. Any information in this bitmask will be consistent with the information saved in the optional checkResult parameter.

See also
  uspoof_openCheckResult
  uspoof_check2
  uspoof_check2UnicodeString

Stable
  ICU 58

References U_CAPI.

## uspoof_checkUnicodeString()

U_CAPI int32_t uspoof_checkUnicodeString | ( | const USpoofChecker * | sc,
|  | const icu::UnicodeString & | id,
|  | int32_t * | position,
|  | UErrorCode * | status )

Check the specified string for possible security issues.

The text to be checked will typically be an identifier of some sort. The set of checks to be performed is specified with uspoof_setChecks().

Note
  Consider using the newer API, `uspoof_check2UnicodeString`, instead. The newer API exposes additional information from the check procedure and is otherwise identical to this method.

Parameters

  sc | The USpoofChecker
  id | A identifier to be checked for possible security issues.
  position | Deprecated in ICU 51. Always returns zero. Originally, an out parameter for the index of the first string position that failed a check. This parameter may be nullptr.
  status | The error code, set if an error occurred while attempting to perform the check. Spoofing or security issues detected with the input string are not reported here, but through the function's return value.

Returns
  An integer value with bits set for any potential security or spoofing issues detected. The bits are defined by enum USpoofChecks. (returned_value & USPOOF_ALL_CHECKS) will be zero if the input string passes all of the enabled checks.

See also
  uspoof_check2UnicodeString

Stable
  ICU 4.2

References U_CAPI.

## uspoof_checkUTF8()

U_CAPI int32_t uspoof_checkUTF8 | ( | const USpoofChecker * | sc,
|  | const char * | id,
|  | int32_t | length,
|  | int32_t * | position,
|  | UErrorCode * | status )

Check the specified string for possible security issues.

The text to be checked will typically be an identifier of some sort. The set of checks to be performed is specified with uspoof_setChecks().

Note
  Consider using the newer API, `uspoof_check2UTF8`, instead. The newer API exposes additional information from the check procedure and is otherwise identical to this method.

Parameters

  sc | The USpoofChecker
  id | A identifier to be checked for possible security issues, in UTF8 format.
  length | the length of the string to be checked, or -1 if the string is zero terminated.
  position | Deprecated in ICU 51. Always returns zero. Originally, an out parameter for the index of the first string position that failed a check. This parameter may be NULL.
  status | The error code, set if an error occurred while attempting to perform the check. Spoofing or security issues detected with the input string are not reported here, but through the function's return value. If the input contains invalid UTF-8 sequences, a status of U_INVALID_CHAR_FOUND will be returned.

Returns
  An integer value with bits set for any potential security or spoofing issues detected. The bits are defined by enum USpoofChecks. (returned_value & USPOOF_ALL_CHECKS) will be zero if the input string passes all of the enabled checks.

See also
  uspoof_check2UTF8

Stable
  ICU 4.2

References U_CAPI.

## uspoof_clone()

U_CAPI USpoofChecker * uspoof_clone | ( | const USpoofChecker * | sc,
|  | UErrorCode * | status )

Clone a Spoof Checker.

The clone will be set to perform the same checks as the original source.

Parameters

  sc | The source USpoofChecker
  status | The error code, set if this function encounters a problem.

Returns

Stable
  ICU 4.2

References U_CAPI.

## uspoof_close()

U_CAPI void uspoof_close | ( | USpoofChecker * | sc | ) |

Close a Spoof Checker, freeing any memory that was being held by its implementation.

Stable
  ICU 4.2

References U_CAPI.

## uspoof_closeCheckResult()

U_CAPI void uspoof_closeCheckResult | ( | USpoofCheckResult * | checkResult | ) |

Close a USpoofCheckResult, freeing any memory that was being held by its implementation.

Parameters

  checkResult | The instance of USpoofCheckResult to close

Stable
  ICU 58

References U_CAPI.

## uspoof_getAllowedChars()

U_CAPI const USet * uspoof_getAllowedChars | ( | const USpoofChecker * | sc,
|  | UErrorCode * | status )

Get a USet for the characters permitted in an identifier.

This corresponds to the limits imposed by the Set Allowed Characters functions. Limitations imposed by other checks will not be reflected in the set returned by this function.

The returned set will be frozen, meaning that it cannot be modified by the caller.

Ownership of the returned set remains with the Spoof Detector. The returned set will become invalid if the spoof detector is closed, or if a new set of allowed characters is specified.

Parameters

  sc | The USpoofChecker
  status | The error code, set if this function encounters a problem.

Returns
  A USet containing the characters that are permitted by the USPOOF_CHAR_LIMIT test.

Stable
  ICU 4.2

References U_CAPI.

## uspoof_getAllowedLocales()

U_CAPI const char * uspoof_getAllowedLocales | ( | USpoofChecker * | sc,
|  | UErrorCode * | status )

Get a list of locales for the scripts that are acceptable in strings to be checked.

If no limitations on scripts have been specified, an empty string will be returned.

uspoof_setAllowedChars() will reset the list of allowed to be empty.

The format of the returned list is the same as that supplied to uspoof_setAllowedLocales(), but returned list may not be identical to the originally specified string; the string may be reformatted, and information other than languages from the originally specified locales may be omitted.

Parameters

  sc | The USpoofChecker
  status | The error code, set if this function encounters a problem.

Returns
  A string containing a list of locales corresponding to the acceptable scripts, formatted like an HTTP Accept Language value.

Stable
  ICU 4.2

References U_CAPI.

## uspoof_getAllowedUnicodeSet()

U_CAPI const icu::UnicodeSet * uspoof_getAllowedUnicodeSet | ( | const USpoofChecker * | sc,
|  | UErrorCode * | status )

Get a UnicodeSet for the characters permitted in an identifier.

This corresponds to the limits imposed by the Set Allowed Characters / UnicodeSet functions. Limitations imposed by other checks will not be reflected in the set returned by this function.

The returned set will be frozen, meaning that it cannot be modified by the caller.

Ownership of the returned set remains with the Spoof Detector. The returned set will become invalid if the spoof detector is closed, or if a new set of allowed characters is specified.

Parameters

  sc | The USpoofChecker
  status | The error code, set if this function encounters a problem.

Returns
  A UnicodeSet containing the characters that are permitted by the USPOOF_CHAR_LIMIT test.

Stable
  ICU 4.2

References U_CAPI.

## uspoof_getBidiSkeleton()

U_CAPI int32_t uspoof_getBidiSkeleton | ( | const USpoofChecker * | sc,
|  | UBiDiDirection | direction,
|  | const UChar * | id,
|  | int32_t | length,
|  | UChar * | dest,
|  | int32_t | destCapacity,
|  | UErrorCode * | status )

Get the "bidiSkeleton" for an identifier and a direction.

Skeletons are a transformation of the input identifier; Two identifiers are LTR-confusable if their LTR bidiSkeletons are identical; they are RTL-confusable if their RTL bidiSkeletons are identical. See Unicode Technical Standard #39 for additional information: https://www.unicode.org/reports/tr39/#Confusable_Detection.

Using skeletons directly makes it possible to quickly check whether an identifier is confusable with any of some large set of existing identifiers, by creating an efficiently searchable collection of the skeletons.

Parameters

  sc | The USpoofChecker.
  direction | The context direction with which the identifier will be displayed. Must be either UBIDI_LTR or UBIDI_RTL.
  id | The input identifier whose skeleton will be computed.
  length | The length of the input identifier, expressed in 16 bit UTF-16 code units, or -1 if the string is zero terminated.
  dest | The output buffer, to receive the skeleton string.
  destCapacity | The length of the output buffer, in 16 bit units. The destCapacity may be zero, in which case the function will return the actual length of the skeleton.
  status | The error code, set if an error occurred while attempting to perform the check.

Returns
  The length of the skeleton string. The returned length is always that of the complete skeleton, even when the supplied buffer is too small (or of zero length)

Stable
  ICU 74

See also
  uspoof_areBidiConfusable

References U_CAPI.

## uspoof_getBidiSkeletonUnicodeString()

U_I18N_API icu::UnicodeString & uspoof_getBidiSkeletonUnicodeString | ( | const USpoofChecker * | sc,
|  | UBiDiDirection | direction,
|  | const icu::UnicodeString & | id,
|  | icu::UnicodeString & | dest,
|  | UErrorCode * | status )

Get the "bidiSkeleton" for an identifier and a direction.

Skeletons are a transformation of the input identifier; Two identifiers are LTR-confusable if their LTR bidiSkeletons are identical; they are RTL-confusable if their RTL bidiSkeletons are identical. See Unicode Technical Standard #39 for additional information. https://www.unicode.org/reports/tr39/#Confusable_Detection.

Using skeletons directly makes it possible to quickly check whether an identifier is confusable with any of some large set of existing identifiers, by creating an efficiently searchable collection of the skeletons.

Parameters

  sc | The USpoofChecker.
  direction | The context direction with which the identifier will be displayed. Must be either UBIDI_LTR or UBIDI_RTL.
  id | The input identifier whose bidiSkeleton will be computed.
  dest | The output identifier, to receive the skeleton string.
  status | The error code, set if an error occurred while attempting to perform the check.

Returns
  A reference to the destination (skeleton) string.

Stable
  ICU 74

References U_CAPI, and U_I18N_API.

## uspoof_getBidiSkeletonUTF8()

U_CAPI int32_t uspoof_getBidiSkeletonUTF8 | ( | const USpoofChecker * | sc,
|  | UBiDiDirection | direction,
|  | const char * | id,
|  | int32_t | length,
|  | char * | dest,
|  | int32_t | destCapacity,
|  | UErrorCode * | status )

Get the "bidiSkeleton" for an identifier and a direction.

Skeletons are a transformation of the input identifier; Two identifiers are LTR-confusable if their LTR bidiSkeletons are identical; they are RTL-confusable if their RTL bidiSkeletons are identical. See Unicode Technical Standard #39 for additional information: https://www.unicode.org/reports/tr39/#Confusable_Detection.

Using skeletons directly makes it possible to quickly check whether an identifier is confusable with any of some large set of existing identifiers, by creating an efficiently searchable collection of the skeletons.

Parameters

  sc | The USpoofChecker
  direction | The context direction with which the identifier will be displayed. Must be either UBIDI_LTR or UBIDI_RTL.
  id | The UTF-8 format identifier whose skeleton will be computed.
  length | The length of the input string, in bytes, or -1 if the string is zero terminated.
  dest | The output buffer, to receive the skeleton string.
  destCapacity | The length of the output buffer, in bytes. The destCapacity may be zero, in which case the function will return the actual length of the skeleton.
  status | The error code, set if an error occurred while attempting to perform the check. Possible Errors include U_INVALID_CHAR_FOUND for invalid UTF-8 sequences, and U_BUFFER_OVERFLOW_ERROR if the destination buffer is too small to hold the complete skeleton.

Returns
  The length of the skeleton string, in bytes. The returned length is always that of the complete skeleton, even when the supplied buffer is too small (or of zero length)

Stable
  ICU 74

References U_CAPI.

## uspoof_getCheckResultChecks()

U_CAPI int32_t uspoof_getCheckResultChecks | ( | const USpoofCheckResult * | checkResult,
|  | UErrorCode * | status )

Indicates which of the spoof check(s) have failed.

The value is a bitwise OR of the constants for the tests in question: USPOOF_RESTRICTION_LEVEL, USPOOF_CHAR_LIMIT, and so on.

Parameters

  checkResult | The instance of USpoofCheckResult created by `uspoof_openCheckResult`
  status | The error code, set if an error occurred.

Returns
  An integer value with bits set for any potential security or spoofing issues detected. The bits are defined by enum USpoofChecks. (returned_value & USPOOF_ALL_CHECKS) will be zero if the input string passes all of the enabled checks.

See also
  uspoof_setChecks

Stable
  ICU 58

References U_CAPI.

## uspoof_getCheckResultNumerics()

U_CAPI const USet * uspoof_getCheckResultNumerics | ( | const USpoofCheckResult * | checkResult,
|  | UErrorCode * | status )

Gets the set of numerics found in the string, if the USPOOF_MIXED_NUMBERS check was enabled; otherwise, undefined.

The set will contain the zero digit from each decimal number system found in the input string. Ownership of the returned USet remains with the USpoofCheckResult. The USet will be free'd when `uspoof_closeCheckResult` is called.

Parameters

  checkResult | The instance of USpoofCheckResult created by `uspoof_openCheckResult`

Returns
  The set of numerics contained in the USpoofCheckResult

Parameters

  status | The error code, set if an error occurred.

Stable
  ICU 58

References U_CAPI.

## uspoof_getCheckResultRestrictionLevel()

U_CAPI URestrictionLevel uspoof_getCheckResultRestrictionLevel | ( | const USpoofCheckResult * | checkResult,
|  | UErrorCode * | status )

Gets the restriction level that the text meets, if the USPOOF_RESTRICTION_LEVEL check was enabled; otherwise, undefined.

Parameters

  checkResult | The instance of USpoofCheckResult created by `uspoof_openCheckResult`
  status | The error code, set if an error occurred.

Returns
  The restriction level contained in the USpoofCheckResult

See also
  uspoof_setRestrictionLevel

Stable
  ICU 58

References U_CAPI.

## uspoof_getChecks()

U_CAPI int32_t uspoof_getChecks | ( | const USpoofChecker * | sc,
|  | UErrorCode * | status )

Get the set of checks that this Spoof Checker has been configured to perform.

Parameters

  sc | The USpoofChecker
  status | The error code, set if this function encounters a problem.

Returns
  The set of checks that this spoof checker will perform. The value is a bit set, obtained by OR-ing together values from enum USpoofChecks.

Stable
  ICU 4.2

References U_CAPI.

## uspoof_getInclusionSet()

U_CAPI const USet * uspoof_getInclusionSet | ( | UErrorCode * | status | ) |

Get the set of Candidate Characters for Inclusion in Identifiers, as defined in http://unicode.org/Public/security/latest/xidmodifications.txt and documented in http://www.unicode.org/reports/tr39/, Unicode Security Mechanisms.

The returned set is frozen. Ownership of the set remains with the ICU library; it must not be deleted by the caller.

Parameters

  status | The error code, set if a problem occurs while creating the set.

Stable
  ICU 51

References U_CAPI.

## uspoof_getInclusionUnicodeSet()

U_CAPI const icu::UnicodeSet * uspoof_getInclusionUnicodeSet | ( | UErrorCode * | status | ) |

Get the set of Candidate Characters for Inclusion in Identifiers, as defined in http://unicode.org/Public/security/latest/xidmodifications.txt and documented in http://www.unicode.org/reports/tr39/, Unicode Security Mechanisms.

The returned set is frozen. Ownership of the set remains with the ICU library; it must not be deleted by the caller.

Parameters

  status | The error code, set if a problem occurs while creating the set.

Stable
  ICU 51

References U_CAPI.

## uspoof_getRecommendedSet()

U_CAPI const USet * uspoof_getRecommendedSet | ( | UErrorCode * | status | ) |

Get the set of characters from Recommended Scripts for Inclusion in Identifiers, as defined in http://unicode.org/Public/security/latest/xidmodifications.txt and documented in http://www.unicode.org/reports/tr39/, Unicode Security Mechanisms.

The returned set is frozen. Ownership of the set remains with the ICU library; it must not be deleted by the caller.

Parameters

  status | The error code, set if a problem occurs while creating the set.

Stable
  ICU 51

References U_CAPI.

## uspoof_getRecommendedUnicodeSet()

U_CAPI const icu::UnicodeSet * uspoof_getRecommendedUnicodeSet | ( | UErrorCode * | status | ) |

Get the set of characters from Recommended Scripts for Inclusion in Identifiers, as defined in http://unicode.org/Public/security/latest/xidmodifications.txt and documented in http://www.unicode.org/reports/tr39/, Unicode Security Mechanisms.

The returned set is frozen. Ownership of the set remains with the ICU library; it must not be deleted by the caller.

Parameters

  status | The error code, set if a problem occurs while creating the set.

Stable
  ICU 51

## uspoof_getRestrictionLevel()

U_CAPI URestrictionLevel uspoof_getRestrictionLevel | ( | const USpoofChecker * | sc | ) |

Get the Restriction Level that will be tested if the checks include `USPOOF_RESTRICTION_LEVEL`.

Returns
  The restriction level

See also
  URestrictionLevel

Stable
  ICU 51

References U_CAPI.

## uspoof_getSkeleton()

U_CAPI int32_t uspoof_getSkeleton | ( | const USpoofChecker * | sc,
|  | uint32_t | type,
|  | const UChar * | id,
|  | int32_t | length,
|  | UChar * | dest,
|  | int32_t | destCapacity,
|  | UErrorCode * | status )

Get the "skeleton" for an identifier.

Skeletons are a transformation of the input identifier; Two identifiers are confusable if their skeletons are identical. See Unicode Technical Standard #39 for additional information.

Using skeletons directly makes it possible to quickly check whether an identifier is confusable with any of some large set of existing identifiers, by creating an efficiently searchable collection of the skeletons.

Parameters

  sc | The USpoofChecker
  type | Deprecated in ICU 58. You may pass any number. Originally, controlled which of the Unicode confusable data tables to use.
  id | The input identifier whose skeleton will be computed.
  length | The length of the input identifier, expressed in 16 bit UTF-16 code units, or -1 if the string is zero terminated.
  dest | The output buffer, to receive the skeleton string.
  destCapacity | The length of the output buffer, in 16 bit units. The destCapacity may be zero, in which case the function will return the actual length of the skeleton.
  status | The error code, set if an error occurred while attempting to perform the check.

Returns
  The length of the skeleton string. The returned length is always that of the complete skeleton, even when the supplied buffer is too small (or of zero length)

Stable
  ICU 4.2

See also
  uspoof_areConfusable

## uspoof_getSkeletonUnicodeString()

U_I18N_API icu::UnicodeString & uspoof_getSkeletonUnicodeString | ( | const USpoofChecker * | sc,
|  | uint32_t | type,
|  | const icu::UnicodeString & | id,
|  | icu::UnicodeString & | dest,
|  | UErrorCode * | status )

Get the "skeleton" for an identifier.

Skeletons are a transformation of the input identifier; Two identifiers are confusable if their skeletons are identical. See Unicode Technical Standard #39 for additional information.

Using skeletons directly makes it possible to quickly check whether an identifier is confusable with any of some large set of existing identifiers, by creating an efficiently searchable collection of the skeletons.

Parameters

  sc | The USpoofChecker.
  type | Deprecated in ICU 58. You may pass any number. Originally, controlled which of the Unicode confusable data tables to use.
  id | The input identifier whose skeleton will be computed.
  dest | The output identifier, to receive the skeleton string.
  status | The error code, set if an error occurred while attempting to perform the check.

Returns
  A reference to the destination (skeleton) string.

Stable
  ICU 4.2

## uspoof_getSkeletonUTF8()

U_CAPI int32_t uspoof_getSkeletonUTF8 | ( | const USpoofChecker * | sc,
|  | uint32_t | type,
|  | const char * | id,
|  | int32_t | length,
|  | char * | dest,
|  | int32_t | destCapacity,
|  | UErrorCode * | status )

Get the "skeleton" for an identifier.

Skeletons are a transformation of the input identifier; Two identifiers are confusable if their skeletons are identical. See Unicode Technical Standard #39 for additional information.

Using skeletons directly makes it possible to quickly check whether an identifier is confusable with any of some large set of existing identifiers, by creating an efficiently searchable collection of the skeletons.

Parameters

  sc | The USpoofChecker
  type | Deprecated in ICU 58. You may pass any number. Originally, controlled which of the Unicode confusable data tables to use.
  id | The UTF-8 format identifier whose skeleton will be computed.
  length | The length of the input string, in bytes, or -1 if the string is zero terminated.
  dest | The output buffer, to receive the skeleton string.
  destCapacity | The length of the output buffer, in bytes. The destCapacity may be zero, in which case the function will return the actual length of the skeleton.
  status | The error code, set if an error occurred while attempting to perform the check. Possible Errors include U_INVALID_CHAR_FOUND for invalid UTF-8 sequences, and U_BUFFER_OVERFLOW_ERROR if the destination buffer is too small to hold the complete skeleton.

Returns
  The length of the skeleton string, in bytes. The returned length is always that of the complete skeleton, even when the supplied buffer is too small (or of zero length)

Stable
  ICU 4.2

## uspoof_open()

U_CAPI USpoofChecker * uspoof_open | ( | UErrorCode * | status | ) |

Create a Unicode Spoof Checker, configured to perform all checks except for USPOOF_LOCALE_LIMIT and USPOOF_CHAR_LIMIT.

Note that additional checks may be added in the future, resulting in the changes to the default checking behavior.

Parameters

  status | The error code, set if this function encounters a problem.

Returns
  the newly created Spoof Checker

Stable
  ICU 4.2

References U_CAPI.

## uspoof_openCheckResult()

U_CAPI USpoofCheckResult * uspoof_openCheckResult | ( | UErrorCode * | status | ) |

Create a USpoofCheckResult, used by the `uspoof_check2` class of functions to return information about the identifier.

Information includes:

- A bitmask of the checks that failed
- The identifier's restriction level (UTS 39 section 5.2)
- The set of numerics in the string (UTS 39 section 5.3)

The data held in a USpoofCheckResult is cleared whenever it is passed into a new call of `uspoof_check2`.

Parameters

  status | The error code, set if this function encounters a problem.

Returns
  the newly created USpoofCheckResult

See also
  uspoof_check2
  uspoof_check2UTF8
  uspoof_check2UnicodeString

Stable
  ICU 58

References U_CAPI.

## uspoof_openFromSerialized()

U_CAPI USpoofChecker * uspoof_openFromSerialized | ( | const void * | data,
|  | int32_t | length,
|  | int32_t * | pActualLength,
|  | UErrorCode * | pErrorCode )

Open a Spoof checker from its serialized form, stored in 32-bit-aligned memory.

Inverse of uspoof_serialize(). The memory containing the serialized data must remain valid and unchanged as long as the spoof checker, or any cloned copies of the spoof checker, are in use. Ownership of the memory remains with the caller. The spoof checker (and any clones) must be closed prior to deleting the serialized data.

Parameters

  data | a pointer to 32-bit-aligned memory containing the serialized form of spoof data
  length | the number of bytes available at data; can be more than necessary
  pActualLength | receives the actual number of bytes at data taken up by the data; can be NULL
  pErrorCode | ICU error code

Returns
  the spoof checker.

See also
  uspoof_open
  uspoof_serialize

Stable
  ICU 4.2

References U_CAPI.

## uspoof_openFromSource()

U_CAPI USpoofChecker * uspoof_openFromSource | ( | const char * | confusables,
|  | int32_t | confusablesLen,
|  | const char * | confusablesWholeScript,
|  | int32_t | confusablesWholeScriptLen,
|  | int32_t * | errType,
|  | UParseError * | pe,
|  | UErrorCode * | status )

Open a Spoof Checker from the source form of the spoof data.

The input corresponds to the Unicode data file confusables.txt as described in Unicode Technical Standard #39. The syntax of the source data is as described in UTS #39 for this file, and the content of this file is acceptable input.

The character encoding of the (char *) input text is UTF-8.

Parameters

  confusables | a pointer to the confusable characters definitions, as found in file confusables.txt from unicode.org.
  confusablesLen | The length of the confusables text, or -1 if the input string is zero terminated.
  confusablesWholeScript | Deprecated in ICU 58. No longer used.
  confusablesWholeScriptLen | Deprecated in ICU 58. No longer used.
  errType | In the event of an error in the input, indicates which of the input files contains the error. The value is one of USPOOF_SINGLE_SCRIPT_CONFUSABLE or USPOOF_WHOLE_SCRIPT_CONFUSABLE, or zero if no errors are found.
  pe | In the event of an error in the input, receives the position in the input text (line, offset) of the error.
  status | an in/out ICU UErrorCode. Among the possible errors is U_PARSE_ERROR, which is used to report syntax errors in the input.

Returns
  A spoof checker that uses the rules from the input files.

Stable
  ICU 4.2

References U_CAPI.

## uspoof_serialize()

U_CAPI int32_t uspoof_serialize | ( | USpoofChecker * | sc,
|  | void * | data,
|  | int32_t | capacity,
|  | UErrorCode * | status )

Serialize the data for a spoof detector into a chunk of memory.

The flattened spoof detection tables can later be used to efficiently instantiate a new Spoof Detector.

The serialized spoof checker includes only the data compiled from the Unicode data tables by uspoof_openFromSource(); it does not include include any other state or configuration that may have been set.

Parameters

  sc | the Spoof Detector whose data is to be serialized.
  data | a pointer to 32-bit-aligned memory to be filled with the data, can be NULL if capacity==0
  capacity | the number of bytes available at data, or 0 for preflighting

  status

  an in/out ICU UErrorCode; possible errors include:
  - U_BUFFER_OVERFLOW_ERROR if the data storage block is too small for serialization
  - U_ILLEGAL_ARGUMENT_ERROR the data or capacity parameters are bad

Returns
  the number of bytes written or needed for the spoof data

See also
  utrie2_openFromSerialized()

Stable
  ICU 4.2

References U_CDECL_END.

## uspoof_setAllowedChars()

U_CAPI void uspoof_setAllowedChars | ( | USpoofChecker * | sc,
|  | const USet * | chars,
|  | UErrorCode * | status )

Limit the acceptable characters to those specified by a Unicode Set.

Any previously specified character limit is is replaced by the new settings. This includes limits on characters that were set with the uspoof_setAllowedLocales() function.

The USPOOF_CHAR_LIMIT test is automatically enabled for this USpoofChecker by this function.

Parameters

  sc | The USpoofChecker
  chars | A Unicode Set containing the list of characters that are permitted. Ownership of the set remains with the caller. The incoming set is cloned by this function, so there are no restrictions on modifying or deleting the USet after calling this function.
  status | The error code, set if this function encounters a problem.

Stable
  ICU 4.2

References U_CAPI.

## uspoof_setAllowedLocales()

U_CAPI void uspoof_setAllowedLocales | ( | USpoofChecker * | sc,
|  | const char * | localesList,
|  | UErrorCode * | status )

Limit characters that are acceptable in identifiers being checked to those normally used with the languages associated with the specified locales.

Any previously specified list of locales is replaced by the new settings.

A set of languages is determined from the locale(s), and from those a set of acceptable Unicode scripts is determined. Characters from this set of scripts, along with characters from the "common" and "inherited" Unicode Script categories will be permitted.

Supplying an empty string removes all restrictions; characters from any script will be allowed.

The `USPOOF_CHAR_LIMIT` test is automatically enabled for this USpoofChecker when calling this function with a non-empty list of locales.

The Unicode Set of characters that will be allowed is accessible via the uspoof_getAllowedChars() function. uspoof_setAllowedLocales() will replace any previously applied set of allowed characters.

Adjustments, such as additions or deletions of certain classes of characters, can be made to the result of uspoof_setAllowedLocales() by fetching the resulting set with uspoof_getAllowedChars(), manipulating it with the Unicode Set API, then resetting the spoof detectors limits with uspoof_setAllowedChars().

Parameters

  sc | The USpoofChecker

  localesList

  A list list of locales, from which the language and associated script are extracted. The locales are comma-separated if there is more than one. White space may not appear within an individual locale, but is ignored otherwise. The locales are syntactically like those from the HTTP Accept-Language header. If the localesList is empty, no restrictions will be placed on the allowed characters.

  status | The error code, set if this function encounters a problem.

Stable
  ICU 4.2

References U_CAPI.

## uspoof_setAllowedUnicodeSet()

U_CAPI void uspoof_setAllowedUnicodeSet | ( | USpoofChecker * | sc,
|  | const icu::UnicodeSet * | chars,
|  | UErrorCode * | status )

Limit the acceptable characters to those specified by a Unicode Set.

Any previously specified character limit is is replaced by the new settings. This includes limits on characters that were set with the uspoof_setAllowedLocales() function.

The USPOOF_CHAR_LIMIT test is automatically enabled for this USoofChecker by this function.

Parameters

  sc | The USpoofChecker
  chars | A Unicode Set containing the list of characters that are permitted. Ownership of the set remains with the caller. The incoming set is cloned by this function, so there are no restrictions on modifying or deleting the UnicodeSet after calling this function.
  status | The error code, set if this function encounters a problem.

Stable
  ICU 4.2

References U_CAPI.

## uspoof_setChecks()

U_CAPI void uspoof_setChecks | ( | USpoofChecker * | sc,
|  | int32_t | checks,
|  | UErrorCode * | status )

Specify the bitmask of checks that will be performed by `uspoof_check`.

Calling this method overwrites any checks that may have already been enabled. By default, all checks are enabled.

To enable specific checks and disable all others, OR together only the bit constants for the desired checks. For example, to fail strings containing characters outside of the set specified by `uspoof_setAllowedChars` and also strings that contain digits from mixed numbering systems:

    uspoof_setChecks(USPOOF_CHAR_LIMIT | USPOOF_MIXED_NUMBERS);

To disable specific checks and enable all others, start with ALL_CHECKS and "AND away" the not-desired checks. For example, if you are not planning to use the `uspoof_areConfusable` functionality, it is good practice to disable the CONFUSABLE check:

    uspoof_setChecks(USPOOF_ALL_CHECKS & ~USPOOF_CONFUSABLE);

Note that methods such as `uspoof_setAllowedChars`, `uspoof_setAllowedLocales`, and `uspoof_setRestrictionLevel` will enable certain checks when called. Those methods will OR the check they enable onto the existing bitmask specified by this method. For more details, see the documentation of those methods.

Parameters

  sc | The USpoofChecker
  checks | The set of checks that this spoof checker will perform. The value is a bit set, obtained by OR-ing together values from enum USpoofChecks.
  status | The error code, set if this function encounters a problem.

Stable
  ICU 4.2

References U_CAPI.

## uspoof_setRestrictionLevel()

U_CAPI void uspoof_setRestrictionLevel | ( | USpoofChecker * | sc,
|  | URestrictionLevel | restrictionLevel )

Set the loosest restriction level allowed for strings.

The default if this is not called is `USPOOF_HIGHLY_RESTRICTIVE`. Calling this method enables the `USPOOF_RESTRICTION_LEVEL` and `USPOOF_MIXED_NUMBERS` checks, corresponding to Sections 5.1 and 5.2 of UTS 39. To customize which checks are to be performed by `uspoof_check`, see `uspoof_setChecks`.

Parameters

  sc | The USpoofChecker
  restrictionLevel | The loosest restriction level allowed.

See also
  URestrictionLevel

Stable
  ICU 51

References U_CAPI.