Tech-invite3GPPspaceIETFspace
96959493929190898887868584838281807978777675747372717069686766656463626160595857565554535251504948474645444342414039383736353433323130292827262524232221201918171615141312111009080706050403020100
in Index   Prev   Next

RFC 8264

PRECIS Framework: Preparation, Enforcement, and Comparison of Internationalized Strings in Application Protocols

Pages: 43
Proposed Standard
Errata
Obsoletes:  7564
Part 1 of 3 – Pages 1 to 13
None   None   Next

Top   ToC   RFC8264 - Page 1
Internet Engineering Task Force (IETF)                    P. Saint-Andre
Request for Comments: 8264                                    Jabber.org
Obsoletes: 7564                                              M. Blanchet
Category: Standards Track                                       Viagenie
ISSN: 2070-1721                                             October 2017


     PRECIS Framework: Preparation, Enforcement, and Comparison of
           Internationalized Strings in Application Protocols

Abstract

Application protocols using Unicode code points in protocol strings need to properly handle such strings in order to enforce internationalization rules for strings placed in various protocol slots (such as addresses and identifiers) and to perform valid comparison operations (e.g., for purposes of authentication or authorization). This document defines a framework enabling application protocols to perform the preparation, enforcement, and comparison of internationalized strings ("PRECIS") in a way that depends on the properties of Unicode code points and thus is more agile with respect to versions of Unicode. As a result, this framework provides a more sustainable approach to the handling of internationalized strings than the previous framework, known as Stringprep (RFC 3454). This document obsoletes RFC 7564. Status of This Memo This is an Internet Standards Track document. This document is a product of the Internet Engineering Task Force (IETF). It represents the consensus of the IETF community. It has received public review and has been approved for publication by the Internet Engineering Steering Group (IESG). Further information on Internet Standards is available in Section 2 of RFC 7841. Information about the current status of this document, any errata, and how to provide feedback on it may be obtained at https://www.rfc-editor.org/info/rfc8264. Copyright Notice Copyright (c) 2017 IETF Trust and the persons identified as the document authors. All rights reserved. This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of
Top   ToC   RFC8264 - Page 2
   publication of this document.  Please review these documents
   carefully, as they describe your rights and restrictions with respect
   to this document.  Code Components extracted from this document must
   include Simplified BSD License text as described in Section 4.e of
   the Trust Legal Provisions and are provided without warranty as
   described in the Simplified BSD License.

Table of Contents

1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 3 2. Terminology . . . . . . . . . . . . . . . . . . . . . . . . . 6 3. Preparation, Enforcement, and Comparison . . . . . . . . . . 6 4. String Classes . . . . . . . . . . . . . . . . . . . . . . . 8 4.1. Overview . . . . . . . . . . . . . . . . . . . . . . . . 8 4.2. IdentifierClass . . . . . . . . . . . . . . . . . . . . . 9 4.2.1. Valid . . . . . . . . . . . . . . . . . . . . . . . . 9 4.2.2. Contextual Rule Required . . . . . . . . . . . . . . 10 4.2.3. Disallowed . . . . . . . . . . . . . . . . . . . . . 10 4.2.4. Unassigned . . . . . . . . . . . . . . . . . . . . . 10 4.2.5. Examples . . . . . . . . . . . . . . . . . . . . . . 11 4.3. FreeformClass . . . . . . . . . . . . . . . . . . . . . . 11 4.3.1. Valid . . . . . . . . . . . . . . . . . . . . . . . . 11 4.3.2. Contextual Rule Required . . . . . . . . . . . . . . 12 4.3.3. Disallowed . . . . . . . . . . . . . . . . . . . . . 12 4.3.4. Unassigned . . . . . . . . . . . . . . . . . . . . . 12 4.3.5. Examples . . . . . . . . . . . . . . . . . . . . . . 12 4.4. Summary . . . . . . . . . . . . . . . . . . . . . . . . . 12 5. Profiles . . . . . . . . . . . . . . . . . . . . . . . . . . 14 5.1. Profiles Must Not Be Multiplied beyond Necessity . . . . 14 5.2. Rules . . . . . . . . . . . . . . . . . . . . . . . . . . 15 5.2.1. Width Mapping Rule . . . . . . . . . . . . . . . . . 15 5.2.2. Additional Mapping Rule . . . . . . . . . . . . . . . 15 5.2.3. Case Mapping Rule . . . . . . . . . . . . . . . . . . 16 5.2.4. Normalization Rule . . . . . . . . . . . . . . . . . 16 5.2.5. Directionality Rule . . . . . . . . . . . . . . . . . 17 5.3. A Note about Spaces . . . . . . . . . . . . . . . . . . . 18 6. Applications . . . . . . . . . . . . . . . . . . . . . . . . 18 6.1. How to Use PRECIS in Applications . . . . . . . . . . . . 18 6.2. Further Excluded Characters . . . . . . . . . . . . . . . 20 6.3. Building Application-Layer Constructs . . . . . . . . . . 20 7. Order of Operations . . . . . . . . . . . . . . . . . . . . . 21 8. Code Point Properties . . . . . . . . . . . . . . . . . . . . 21 9. Category Definitions Used to Calculate Derived Property . . . 24 9.1. LetterDigits (A) . . . . . . . . . . . . . . . . . . . . 25 9.2. Unstable (B) . . . . . . . . . . . . . . . . . . . . . . 25 9.3. IgnorableProperties (C) . . . . . . . . . . . . . . . . . 25 9.4. IgnorableBlocks (D) . . . . . . . . . . . . . . . . . . . 25 9.5. LDH (E) . . . . . . . . . . . . . . . . . . . . . . . . . 25
Top   ToC   RFC8264 - Page 3
     9.6.  Exceptions (F)  . . . . . . . . . . . . . . . . . . . . .  25
     9.7.  BackwardCompatible (G)  . . . . . . . . . . . . . . . . .  25
     9.8.  JoinControl (H) . . . . . . . . . . . . . . . . . . . . .  26
     9.9.  OldHangulJamo (I) . . . . . . . . . . . . . . . . . . . .  26
     9.10. Unassigned (J)  . . . . . . . . . . . . . . . . . . . . .  26
     9.11. ASCII7 (K)  . . . . . . . . . . . . . . . . . . . . . . .  26
     9.12. Controls (L)  . . . . . . . . . . . . . . . . . . . . . .  27
     9.13. PrecisIgnorableProperties (M) . . . . . . . . . . . . . .  27
     9.14. Spaces (N)  . . . . . . . . . . . . . . . . . . . . . . .  27
     9.15. Symbols (O) . . . . . . . . . . . . . . . . . . . . . . .  27
     9.16. Punctuation (P) . . . . . . . . . . . . . . . . . . . . .  27
     9.17. HasCompat (Q) . . . . . . . . . . . . . . . . . . . . . .  28
     9.18. OtherLetterDigits (R) . . . . . . . . . . . . . . . . . .  28
   10. Guidelines for Designated Experts . . . . . . . . . . . . . .  28
   11. IANA Considerations . . . . . . . . . . . . . . . . . . . . .  29
     11.1.  PRECIS Derived Property Value Registry . . . . . . . . .  29
     11.2.  PRECIS Base Classes Registry . . . . . . . . . . . . . .  29
     11.3.  PRECIS Profiles Registry . . . . . . . . . . . . . . . .  30
   12. Security Considerations . . . . . . . . . . . . . . . . . . .  32
     12.1.  General Issues . . . . . . . . . . . . . . . . . . . . .  32
     12.2.  Use of the IdentifierClass . . . . . . . . . . . . . . .  33
     12.3.  Use of the FreeformClass . . . . . . . . . . . . . . . .  33
     12.4.  Local Character Set Issues . . . . . . . . . . . . . . .  33
     12.5.  Visually Similar Characters  . . . . . . . . . . . . . .  33
     12.6.  Security of Passwords  . . . . . . . . . . . . . . . . .  35
   13. Interoperability Considerations . . . . . . . . . . . . . . .  36
     13.1.  Coded Character Sets . . . . . . . . . . . . . . . . . .  36
     13.2.  Dependency on Unicode  . . . . . . . . . . . . . . . . .  37
     13.3.  Encoding . . . . . . . . . . . . . . . . . . . . . . . .  37
     13.4.  Unicode Versions . . . . . . . . . . . . . . . . . . . .  37
     13.5.  Potential Changes to Handling of Certain Unicode Code
            Points . . . . . . . . . . . . . . . . . . . . . . . . .  37
   14. References  . . . . . . . . . . . . . . . . . . . . . . . . .  38
     14.1.  Normative References . . . . . . . . . . . . . . . . . .  38
     14.2.  Informative References . . . . . . . . . . . . . . . . .  39
   Appendix A.  Changes from RFC 7564  . . . . . . . . . . . . . . .  43
   Acknowledgements  . . . . . . . . . . . . . . . . . . . . . . . .  43
   Authors' Addresses  . . . . . . . . . . . . . . . . . . . . . . .  43

1. Introduction

Application protocols using Unicode code points [Unicode] in protocol strings need to properly handle such strings in order to enforce internationalization rules for strings placed in various protocol slots (such as addresses and identifiers) and to perform valid comparison operations (e.g., for purposes of authentication or authorization). This document defines a framework enabling application protocols to perform the preparation, enforcement, and
Top   ToC   RFC8264 - Page 4
   comparison of internationalized strings ("PRECIS") in a way that
   depends on the properties of Unicode code points and thus is more
   agile with respect to versions of Unicode.  (Note: PRECIS is
   restricted to Unicode and does not support any other coded character
   set [RFC6365].)

   As described in the PRECIS problem statement [RFC6885], many IETF
   protocols have used the Stringprep framework [RFC3454] as the basis
   for preparing, enforcing, and comparing protocol strings that contain
   Unicode code points, especially code points outside the ASCII range
   [RFC20].  The Stringprep framework was developed during work on the
   original technology for internationalized domain names (IDNs), here
   called "IDNA2003" [RFC3490], and Nameprep [RFC3491] was the
   Stringprep profile for IDNs.  At the time, Stringprep was designed as
   a general framework so that other application protocols could define
   their own Stringprep profiles.  Indeed, a number of application
   protocols defined such profiles.

   After the publication of [RFC3454] in 2002, several significant
   issues arose with the use of Stringprep in the IDN case, as
   documented in the IAB's recommendations regarding IDNs [RFC4690]
   (most significantly, Stringprep was tied to Unicode version 3.2).
   Therefore, the newer IDNA specifications, here called "IDNA2008"
   [RFC5890] [RFC5891] [RFC5892] [RFC5893] [RFC5894], no longer use
   Stringprep and Nameprep.  This migration away from Stringprep for
   IDNs prompted other "customers" of Stringprep to consider new
   approaches to the preparation, enforcement, and comparison of
   internationalized strings, as described in [RFC6885].

   This document defines a framework for a post-Stringprep approach to
   the preparation, enforcement, and comparison of internationalized
   strings in application protocols, based on several principles:

   1.  Define a small set of string classes that specify the Unicode
       code points appropriate for common application-protocol
       constructs (where possible, maintaining compatibility with
       IDNA2008 to help ensure a more consistent user experience).

   2.  Define each PRECIS string class in terms of Unicode code points
       and their properties so that an algorithm can be used to
       determine whether each code point or character category is
       (a) valid, (b) allowed in certain contexts, (c) disallowed, or
       (d) unassigned.

   3.  Use an "inclusion model" such that a string class consists only
       of code points that are explicitly allowed, with the result that
       any code point not explicitly allowed is forbidden.
Top   ToC   RFC8264 - Page 5
   4.  Enable application protocols to define profiles of the PRECIS
       string classes if necessary (addressing matters such as width
       mapping, case mapping, Unicode normalization, and
       directionality), but strongly discourage the multiplication of
       profiles beyond necessity in order to avoid violations of the
       "Principle of Least Astonishment".

   It is expected that this framework will yield the following benefits:

   o  Application protocols will be more agile with regard to Unicode
      versions (recognizing that complete agility cannot be realized in
      practice).

   o  Implementers will be able to share code point tables and software
      code across application protocols, most likely by means of
      software libraries.

   o  End users will be able to acquire more accurate expectations about
      the code points that are acceptable in various contexts.  Given
      this more uniform set of string classes, it is also expected that
      copy/paste operations between software implementing different
      application protocols will be more predictable and coherent.

   Whereas the string classes define the "baseline" code points for a
   range of applications, profiling enables application protocols to
   apply the string classes in ways that are appropriate for common
   constructs such as usernames [RFC8265], opaque strings such as
   passwords [RFC8265], and nicknames [RFC8266].  Profiles are
   responsible for defining the handling of right-to-left code points as
   well as various mapping operations of the kind also discussed for
   IDNs in [RFC5895], such as case preservation or lowercasing, Unicode
   normalization, mapping of certain code points to other code points or
   to nothing, and mapping of fullwidth and halfwidth code points.

   When an application applies a profile of a PRECIS string class, it
   transforms an input string (which might or might not be conforming)
   into an output string that definitively conforms to the profile.  In
   particular, this document focuses on the resulting ability to achieve
   the following objectives:

   a.  Enforcing all the rules of a profile for a single output string
       to check whether the output string conforms to the rules of the
       profile and thus determine if a string can be included in a
       protocol slot, communicated to another entity within a protocol,
       stored in a retrieval system, etc.

   b.  Comparing two output strings to determine if they are equivalent,
       typically through octet-for-octet matching to test for
Top   ToC   RFC8264 - Page 6
       "bit-string identity" (e.g., to make an access decision for
       purposes of authentication or authorization as further described
       in [RFC6943]).

   The opportunity to define profiles naturally introduces the
   possibility of a proliferation of profiles, thus potentially
   mitigating the benefits of common code and violating user
   expectations.  See Section 5 for a discussion of this important
   topic.

   In addition, it is extremely important for protocol designers and
   application developers to understand that the transformation of an
   input string to an output string is rarely reversible.  As one
   relatively simple example, case mapping would transform an input
   string of "StPeter" to an output string of "stpeter", thus leading to
   a loss of information about the capitalization of the first and third
   characters.  Similar considerations apply to other forms of mapping
   and normalization.

   Although this framework is similar to IDNA2008 and includes by
   reference some of the character categories defined in [RFC5892], it
   defines additional character categories to meet the needs of common
   application protocols other than DNS.

   The character categories and calculation rules defined under
   Sections 8 and 9 are normative and apply to all Unicode code points.
   The code point table that results from applying the character
   categories and calculation rules to the latest version of Unicode can
   be found in an IANA registry (see Section 11).

2. Terminology

Many important terms used in this document are defined in [RFC5890], [RFC6365], [RFC6885], and [Unicode]. The terms "left-to-right" (LTR) and "right-to-left" (RTL) are defined in Unicode Standard Annex #9 [UAX9]. The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.

3. Preparation, Enforcement, and Comparison

This document distinguishes between three different actions that an entity can take with regard to a string:
Top   ToC   RFC8264 - Page 7
   o  Enforcement entails applying all of the rules specified for a
      particular string class, or profile thereof, to a single input
      string, for the purpose of checking whether the string conforms to
      all of the rules and thus determining if the string can be used in
      a given protocol slot.

   o  Comparison entails applying all of the rules specified for a
      particular string class, or profile thereof, to two separate input
      strings, for the purpose of determining if the two strings are
      equivalent.

   o  Preparation primarily entails ensuring that the code points in a
      single input string are allowed by the underlying PRECIS string
      class, and sometimes also entails applying one or more of the
      rules specified for a particular string class or profile thereof.
      Preparation can be appropriate for constrained devices that can to
      some extent restrict the code points in a string to a limited
      repertoire of characters but that do not have the processing power
      or onboard memory to perform operations such as Unicode
      normalization.  However, preparation does not ensure that an input
      string conforms to all of the rules for a string class or profile
      thereof.

         Note: The term "preparation" as used in this specification and
         related documents has a much more limited scope than it did in
         Stringprep; it essentially refers to a kind of preprocessing of
         an input string, not the actual operations that apply
         internationalization rules to produce an output string (here
         termed "enforcement") or to compare two output strings (here
         termed "comparison").

   In most cases, authoritative entities such as servers are responsible
   for enforcement, whereas subsidiary entities such as clients are
   responsible only for preparation.  The rationale for this distinction
   is that clients might not have the facilities (in terms of device
   memory and processing power) to enforce all the rules regarding
   internationalized strings (such as width mapping and Unicode
   normalization), although they can more easily limit the repertoire of
   characters they offer to an end user.  By contrast, it is assumed
   that a server would have more capacity to enforce the rules, and in
   any case a server acts as an authority regarding allowable strings in
   protocol slots such as addresses and endpoint identifiers.  In
   addition, a client cannot necessarily be trusted to properly generate
   such strings, especially for security-sensitive contexts such as
   authentication and authorization.
Top   ToC   RFC8264 - Page 8

4. String Classes

4.1. Overview

Starting in 2010, various "customers" of Stringprep began to discuss the need to define a post-Stringprep approach to the preparation and comparison of internationalized strings other than IDNs. This community analyzed the existing Stringprep profiles and also weighed the costs and benefits of defining a relatively small set of Unicode code points that would minimize the potential for user confusion caused by visually similar code points (and thus be relatively "safe") vs. defining a much larger set of Unicode code points that would maximize the potential for user creativity (and thus be relatively "expressive"). As a result, the community concluded that most existing uses could be addressed by two string classes: IdentifierClass: a sequence of letters, numbers, and some symbols that is used to identify or address a network entity such as a user account, a venue (e.g., a chat room), an information source (e.g., a data feed), or a collection of data (e.g., a file); the intent is that this class will minimize user confusion in a wide variety of application protocols, with the result that safety has been prioritized over expressiveness for this class. FreeformClass: a sequence of letters, numbers, symbols, spaces, and other code points that is used for free-form strings, including passwords as well as display elements such as human-friendly nicknames for devices or for participants in a chat room; the intent is that this class will allow nearly any Unicode code point, with the result that expressiveness has been prioritized over safety for this class. Note well that protocol designers, application developers, service providers, and end users might not understand or be able to enter all of the code points that can be included in the FreeformClass (see Section 12.3 for details). Future specifications might define additional PRECIS string classes, such as a class that falls somewhere between the IdentifierClass and the FreeformClass. At this time, it is not clear how useful such a class would be. In any case, because application developers are able to define profiles of PRECIS string classes, a protocol needing a construct between the IdentifierClass and the FreeformClass could define a restricted profile of the FreeformClass if needed. The following subsections discuss the IdentifierClass and FreeformClass in more detail, with reference to the dimensions described in Section 5 of [RFC6885]. Each string class is defined by the following behavioral rules:
Top   ToC   RFC8264 - Page 9
   Valid:  Defines which code points are treated as valid for the
      string.

   Contextual Rule Required:  Defines which code points are treated as
      allowed only if the requirements of a contextual rule are met
      (i.e., either CONTEXTJ or CONTEXTO as originally defined in the
      IDNA2008 specifications).

   Disallowed:  Defines which code points need to be excluded from the
      string.

   Unassigned:  Defines application behavior in the presence of code
      points that are unknown (i.e., not yet designated) for the version
      of Unicode used by the application.

   This document defines the valid, contextual rule required,
   disallowed, and unassigned rules for the IdentifierClass and
   FreeformClass.  As described under Section 5, profiles of these
   string classes are responsible for defining the width mapping,
   additional mapping, case mapping, normalization, and directionality
   rules.

4.2. IdentifierClass

Most application technologies need strings that can be used to refer to, include, or communicate protocol strings like usernames, filenames, data feed identifiers, and chat room names. We group such strings into a class called "IdentifierClass" having the following features.

4.2.1. Valid

o Code points traditionally used as letters and numbers in writing systems, i.e., the LetterDigits ("A") category first defined in [RFC5892] and listed here under Section 9.1. o Code points in the range U+0021 through U+007E, i.e., the (printable) ASCII7 ("K") category defined under Section 9.11. These code points are "grandfathered" into PRECIS and thus are valid even if they would otherwise be disallowed according to the property-based rules specified in the next section. Note: Although the PRECIS IdentifierClass reuses the LetterDigits category from IDNA2008, the range of code points allowed in the IdentifierClass is wider than the range of code points allowed in IDNA2008. The main reason is that IDNA2008 applies the Unstable ("B") category (Section 9.2) before the LetterDigits
Top   ToC   RFC8264 - Page 10
      category, thus disallowing uppercase code points, whereas the
      IdentifierClass does not apply the Unstable category.

4.2.2. Contextual Rule Required

o A number of code points from the Exceptions ("F") category defined under Section 9.6. o Joining code points, i.e., the JoinControl ("H") category defined under Section 9.8.

4.2.3. Disallowed

o Old Hangul Jamo code points, i.e., the OldHangulJamo ("I") category defined under Section 9.9. o Control code points, i.e., the Controls ("L") category defined under Section 9.12. o Ignorable code points, i.e., the PrecisIgnorableProperties ("M") category defined under Section 9.13. o Space code points, i.e., the Spaces ("N") category defined under Section 9.14. o Symbol code points, i.e., the Symbols ("O") category defined under Section 9.15. o Punctuation code points, i.e., the Punctuation ("P") category defined under Section 9.16. o Any code point that is decomposed and recomposed into something other than itself under Unicode Normalization Form KC, i.e., the HasCompat ("Q") category defined under Section 9.17. These code points are disallowed even if they would otherwise be valid according to the property-based rules specified in the previous section. o Letters and digits other than the "traditional" letters and digits allowed in IDNs, i.e., the OtherLetterDigits ("R") category defined under Section 9.18.

4.2.4. Unassigned

Any code points that are not yet designated in the Unicode coded character set are considered unassigned for purposes of the IdentifierClass, and such code points are to be treated as disallowed. See Section 9.10.
Top   ToC   RFC8264 - Page 11

4.2.5. Examples

As described in the Introduction to this document, the string classes do not handle all issues related to string preparation and comparison (such as case mapping); instead, such issues are handled at the level of profiles. Examples for profiles of the IdentifierClass can be found in [RFC8265] (the UsernameCaseMapped and UsernameCasePreserved profiles).

4.3. FreeformClass

Some application technologies need strings that can be used in a free-form way, e.g., as a password in an authentication exchange (see [RFC8265]) or a nickname in a chat room (see [RFC8266]). We group such things into a class called "FreeformClass" having the following features. Security Warning: As mentioned, the FreeformClass prioritizes expressiveness over safety; Section 12.3 describes some of the security hazards involved with using or profiling the FreeformClass. Security Warning: Consult Section 12.6 for relevant security considerations when strings conforming to the FreeformClass, or a profile thereof, are used as passwords.

4.3.1. Valid

o Traditional letters and numbers, i.e., the LetterDigits ("A") category first defined in [RFC5892] and listed here under Section 9.1. o Code points in the range U+0021 through U+007E, i.e., the (printable) ASCII7 ("K") category defined under Section 9.11. o Space code points, i.e., the Spaces ("N") category defined under Section 9.14. o Symbol code points, i.e., the Symbols ("O") category defined under Section 9.15. o Punctuation code points, i.e., the Punctuation ("P") category defined under Section 9.16. o Any code point that is decomposed and recomposed into something other than itself under Unicode Normalization Form KC, i.e., the HasCompat ("Q") category defined under Section 9.17.
Top   ToC   RFC8264 - Page 12
   o  Letters and digits other than the "traditional" letters and digits
      allowed in IDNs, i.e., the OtherLetterDigits ("R") category
      defined under Section 9.18.

4.3.2. Contextual Rule Required

o A number of code points from the Exceptions ("F") category defined under Section 9.6. o Joining code points, i.e., the JoinControl ("H") category defined under Section 9.8.

4.3.3. Disallowed

o Old Hangul Jamo code points, i.e., the OldHangulJamo ("I") category defined under Section 9.9. o Control code points, i.e., the Controls ("L") category defined under Section 9.12. o Ignorable code points, i.e., the PrecisIgnorableProperties ("M") category defined under Section 9.13.

4.3.4. Unassigned

Any code points that are not yet designated in the Unicode coded character set are considered unassigned for purposes of the FreeformClass, and such code points are to be treated as disallowed.

4.3.5. Examples

As described in the Introduction to this document, the string classes do not handle all issues related to string preparation and comparison (such as case mapping); instead, such issues are handled at the level of profiles. Examples for profiles of the FreeformClass can be found in [RFC8265] (the OpaqueString profile) and [RFC8266] (the Nickname profile).

4.4. Summary

The following table summarizes the differences between the IdentifierClass and the FreeformClass (i.e., the disposition of a code point as valid, contextual rule required, disallowed, or unassigned), depending on its PRECIS category.
Top   ToC   RFC8264 - Page 13
    +===============================+=================+===============+
    |        CATEGORY               | IDENTIFIERCLASS | FREEFORMCLASS |
    +===============================+=================+===============+
    | (A) LetterDigits              | Valid           | Valid         |
    +-------------------------------+-----------------+---------------+
    | (B) Unstable                  |          [N/A (unused)]         |
    +-------------------------------+-----------------+---------------+
    | (C) IgnorableProperties       |          [N/A (unused)]         |
    +-------------------------------+-----------------+---------------+
    | (D) IgnorableBlocks           |          [N/A (unused)]         |
    +-------------------------------+-----------------+---------------+
    | (E) LDH                       |          [N/A (unused)]         |
    +-------------------------------+-----------------+---------------+
    | (F) Exceptions                | Contextual      | Contextual    |
    |                               | Rule Required   | Rule Required |
    +-------------------------------+-----------------+---------------+
    | (G) BackwardCompatible        |      [Handled by IDNA Rules]    |
    +-------------------------------+-----------------+---------------+
    | (H) JoinControl               | Contextual      | Contextual    |
    |                               | Rule Required   | Rule Required |
    +-------------------------------+-----------------+---------------+
    | (I) OldHangulJamo             | Disallowed      | Disallowed    |
    +-------------------------------+-----------------+---------------+
    | (J) Unassigned                | Unassigned      | Unassigned    |
    +-------------------------------+-----------------+---------------+
    | (K) ASCII7                    | Valid           | Valid         |
    +-------------------------------+-----------------+---------------+
    | (L) Controls                  | Disallowed      | Disallowed    |
    +-------------------------------+-----------------+---------------+
    | (M) PrecisIgnorableProperties | Disallowed      | Disallowed    |
    +-------------------------------+-----------------+---------------+
    | (N) Spaces                    | Disallowed      | Valid         |
    +-------------------------------+-----------------+---------------+
    | (O) Symbols                   | Disallowed      | Valid         |
    +-------------------------------+-----------------+---------------+
    | (P) Punctuation               | Disallowed      | Valid         |
    +-------------------------------+-----------------+---------------+
    | (Q) HasCompat                 | Disallowed      | Valid         |
    +-------------------------------+-----------------+---------------+
    | (R) OtherLetterDigits         | Disallowed      | Valid         |
    +-------------------------------+-----------------+---------------+

              Table 1: Comparative Disposition of Code Points


(next page on part 2)

Next Section