cmd/bpa-operator/vendor/golang.org/x/text/secure/bidirule/bidirule.go

   1 // Copyright 2016 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // Package bidirule implements the Bidi Rule defined by RFC 5893.
   6 //
   7 // This package is under development. The API may change without notice and
   8 // without preserving backward compatibility.
   9 package bidirule
  10
  11 import (
  12         "errors"
  13         "unicode/utf8"
  14
  15         "golang.org/x/text/transform"
  16         "golang.org/x/text/unicode/bidi"
  17 )
  18
  19 // This file contains an implementation of RFC 5893: Right-to-Left Scripts for
  20 // Internationalized Domain Names for Applications (IDNA)
  21 //
  22 // A label is an individual component of a domain name.  Labels are usually
  23 // shown separated by dots; for example, the domain name "www.example.com" is
  24 // composed of three labels: "www", "example", and "com".
  25 //
  26 // An RTL label is a label that contains at least one character of class R, AL,
  27 // or AN. An LTR label is any label that is not an RTL label.
  28 //
  29 // A "Bidi domain name" is a domain name that contains at least one RTL label.
  30 //
  31 //  The following guarantees can be made based on the above:
  32 //
  33 //  o  In a domain name consisting of only labels that satisfy the rule,
  34 //     the requirements of Section 3 are satisfied.  Note that even LTR
  35 //     labels and pure ASCII labels have to be tested.
  36 //
  37 //  o  In a domain name consisting of only LDH labels (as defined in the
  38 //     Definitions document [RFC5890]) and labels that satisfy the rule,
  39 //     the requirements of Section 3 are satisfied as long as a label
  40 //     that starts with an ASCII digit does not come after a
  41 //     right-to-left label.
  42 //
  43 //  No guarantee is given for other combinations.
  44
  45 // ErrInvalid indicates a label is invalid according to the Bidi Rule.
  46 var ErrInvalid = errors.New("bidirule: failed Bidi Rule")
  47
  48 type ruleState uint8
  49
  50 const (
  51         ruleInitial ruleState = iota
  52         ruleLTR
  53         ruleLTRFinal
  54         ruleRTL
  55         ruleRTLFinal
  56         ruleInvalid
  57 )
  58
  59 type ruleTransition struct {
  60         next ruleState
  61         mask uint16
  62 }
  63
  64 var transitions = [...][2]ruleTransition{
  65         // [2.1] The first character must be a character with Bidi property L, R, or
  66         // AL. If it has the R or AL property, it is an RTL label; if it has the L
  67         // property, it is an LTR label.
  68         ruleInitial: {
  69                 {ruleLTRFinal, 1 << bidi.L},
  70                 {ruleRTLFinal, 1<<bidi.R | 1<<bidi.AL},
  71         },
  72         ruleRTL: {
  73                 // [2.3] In an RTL label, the end of the label must be a character with
  74                 // Bidi property R, AL, EN, or AN, followed by zero or more characters
  75                 // with Bidi property NSM.
  76                 {ruleRTLFinal, 1<<bidi.R | 1<<bidi.AL | 1<<bidi.EN | 1<<bidi.AN},
  77
  78                 // [2.2] In an RTL label, only characters with the Bidi properties R,
  79                 // AL, AN, EN, ES, CS, ET, ON, BN, or NSM are allowed.
  80                 // We exclude the entries from [2.3]
  81                 {ruleRTL, 1<<bidi.ES | 1<<bidi.CS | 1<<bidi.ET | 1<<bidi.ON | 1<<bidi.BN | 1<<bidi.NSM},
  82         },
  83         ruleRTLFinal: {
  84                 // [2.3] In an RTL label, the end of the label must be a character with
  85                 // Bidi property R, AL, EN, or AN, followed by zero or more characters
  86                 // with Bidi property NSM.
  87                 {ruleRTLFinal, 1<<bidi.R | 1<<bidi.AL | 1<<bidi.EN | 1<<bidi.AN | 1<<bidi.NSM},
  88
  89                 // [2.2] In an RTL label, only characters with the Bidi properties R,
  90                 // AL, AN, EN, ES, CS, ET, ON, BN, or NSM are allowed.
  91                 // We exclude the entries from [2.3] and NSM.
  92                 {ruleRTL, 1<<bidi.ES | 1<<bidi.CS | 1<<bidi.ET | 1<<bidi.ON | 1<<bidi.BN},
  93         },
  94         ruleLTR: {
  95                 // [2.6] In an LTR label, the end of the label must be a character with
  96                 // Bidi property L or EN, followed by zero or more characters with Bidi
  97                 // property NSM.
  98                 {ruleLTRFinal, 1<<bidi.L | 1<<bidi.EN},
  99
 100                 // [2.5] In an LTR label, only characters with the Bidi properties L,
 101                 // EN, ES, CS, ET, ON, BN, or NSM are allowed.
 102                 // We exclude the entries from [2.6].
 103                 {ruleLTR, 1<<bidi.ES | 1<<bidi.CS | 1<<bidi.ET | 1<<bidi.ON | 1<<bidi.BN | 1<<bidi.NSM},
 104         },
 105         ruleLTRFinal: {
 106                 // [2.6] In an LTR label, the end of the label must be a character with
 107                 // Bidi property L or EN, followed by zero or more characters with Bidi
 108                 // property NSM.
 109                 {ruleLTRFinal, 1<<bidi.L | 1<<bidi.EN | 1<<bidi.NSM},
 110
 111                 // [2.5] In an LTR label, only characters with the Bidi properties L,
 112                 // EN, ES, CS, ET, ON, BN, or NSM are allowed.
 113                 // We exclude the entries from [2.6].
 114                 {ruleLTR, 1<<bidi.ES | 1<<bidi.CS | 1<<bidi.ET | 1<<bidi.ON | 1<<bidi.BN},
 115         },
 116         ruleInvalid: {
 117                 {ruleInvalid, 0},
 118                 {ruleInvalid, 0},
 119         },
 120 }
 121
 122 // [2.4] In an RTL label, if an EN is present, no AN may be present, and
 123 // vice versa.
 124 const exclusiveRTL = uint16(1<<bidi.EN | 1<<bidi.AN)
 125
 126 // From RFC 5893
 127 // An RTL label is a label that contains at least one character of type
 128 // R, AL, or AN.
 129 //
 130 // An LTR label is any label that is not an RTL label.
 131
 132 // Direction reports the direction of the given label as defined by RFC 5893.
 133 // The Bidi Rule does not have to be applied to labels of the category
 134 // LeftToRight.
 135 func Direction(b []byte) bidi.Direction {
 136         for i := 0; i < len(b); {
 137                 e, sz := bidi.Lookup(b[i:])
 138                 if sz == 0 {
 139                         i++
 140                 }
 141                 c := e.Class()
 142                 if c == bidi.R || c == bidi.AL || c == bidi.AN {
 143                         return bidi.RightToLeft
 144                 }
 145                 i += sz
 146         }
 147         return bidi.LeftToRight
 148 }
 149
 150 // DirectionString reports the direction of the given label as defined by RFC
 151 // 5893. The Bidi Rule does not have to be applied to labels of the category
 152 // LeftToRight.
 153 func DirectionString(s string) bidi.Direction {
 154         for i := 0; i < len(s); {
 155                 e, sz := bidi.LookupString(s[i:])
 156                 if sz == 0 {
 157                         i++
 158                         continue
 159                 }
 160                 c := e.Class()
 161                 if c == bidi.R || c == bidi.AL || c == bidi.AN {
 162                         return bidi.RightToLeft
 163                 }
 164                 i += sz
 165         }
 166         return bidi.LeftToRight
 167 }
 168
 169 // Valid reports whether b conforms to the BiDi rule.
 170 func Valid(b []byte) bool {
 171         var t Transformer
 172         if n, ok := t.advance(b); !ok || n < len(b) {
 173                 return false
 174         }
 175         return t.isFinal()
 176 }
 177
 178 // ValidString reports whether s conforms to the BiDi rule.
 179 func ValidString(s string) bool {
 180         var t Transformer
 181         if n, ok := t.advanceString(s); !ok || n < len(s) {
 182                 return false
 183         }
 184         return t.isFinal()
 185 }
 186
 187 // New returns a Transformer that verifies that input adheres to the Bidi Rule.
 188 func New() *Transformer {
 189         return &Transformer{}
 190 }
 191
 192 // Transformer implements transform.Transform.
 193 type Transformer struct {
 194         state  ruleState
 195         hasRTL bool
 196         seen   uint16
 197 }
 198
 199 // A rule can only be violated for "Bidi Domain names", meaning if one of the
 200 // following categories has been observed.
 201 func (t *Transformer) isRTL() bool {
 202         const isRTL = 1<<bidi.R | 1<<bidi.AL | 1<<bidi.AN
 203         return t.seen&isRTL != 0
 204 }
 205
 206 // Reset implements transform.Transformer.
 207 func (t *Transformer) Reset() { *t = Transformer{} }
 208
 209 // Transform implements transform.Transformer. This Transformer has state and
 210 // needs to be reset between uses.
 211 func (t *Transformer) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
 212         if len(dst) < len(src) {
 213                 src = src[:len(dst)]
 214                 atEOF = false
 215                 err = transform.ErrShortDst
 216         }
 217         n, err1 := t.Span(src, atEOF)
 218         copy(dst, src[:n])
 219         if err == nil || err1 != nil && err1 != transform.ErrShortSrc {
 220                 err = err1
 221         }
 222         return n, n, err
 223 }
 224
 225 // Span returns the first n bytes of src that conform to the Bidi rule.
 226 func (t *Transformer) Span(src []byte, atEOF bool) (n int, err error) {
 227         if t.state == ruleInvalid && t.isRTL() {
 228                 return 0, ErrInvalid
 229         }
 230         n, ok := t.advance(src)
 231         switch {
 232         case !ok:
 233                 err = ErrInvalid
 234         case n < len(src):
 235                 if !atEOF {
 236                         err = transform.ErrShortSrc
 237                         break
 238                 }
 239                 err = ErrInvalid
 240         case !t.isFinal():
 241                 err = ErrInvalid
 242         }
 243         return n, err
 244 }
 245
 246 // Precomputing the ASCII values decreases running time for the ASCII fast path
 247 // by about 30%.
 248 var asciiTable [128]bidi.Properties
 249
 250 func init() {
 251         for i := range asciiTable {
 252                 p, _ := bidi.LookupRune(rune(i))
 253                 asciiTable[i] = p
 254         }
 255 }
 256
 257 func (t *Transformer) advance(s []byte) (n int, ok bool) {
 258         var e bidi.Properties
 259         var sz int
 260         for n < len(s) {
 261                 if s[n] < utf8.RuneSelf {
 262                         e, sz = asciiTable[s[n]], 1
 263                 } else {
 264                         e, sz = bidi.Lookup(s[n:])
 265                         if sz <= 1 {
 266                                 if sz == 1 {
 267                                         // We always consider invalid UTF-8 to be invalid, even if
 268                                         // the string has not yet been determined to be RTL.
 269                                         // TODO: is this correct?
 270                                         return n, false
 271                                 }
 272                                 return n, true // incomplete UTF-8 encoding
 273                         }
 274                 }
 275                 // TODO: using CompactClass would result in noticeable speedup.
 276                 // See unicode/bidi/prop.go:Properties.CompactClass.
 277                 c := uint16(1 << e.Class())
 278                 t.seen |= c
 279                 if t.seen&exclusiveRTL == exclusiveRTL {
 280                         t.state = ruleInvalid
 281                         return n, false
 282                 }
 283                 switch tr := transitions[t.state]; {
 284                 case tr[0].mask&c != 0:
 285                         t.state = tr[0].next
 286                 case tr[1].mask&c != 0:
 287                         t.state = tr[1].next
 288                 default:
 289                         t.state = ruleInvalid
 290                         if t.isRTL() {
 291                                 return n, false
 292                         }
 293                 }
 294                 n += sz
 295         }
 296         return n, true
 297 }
 298
 299 func (t *Transformer) advanceString(s string) (n int, ok bool) {
 300         var e bidi.Properties
 301         var sz int
 302         for n < len(s) {
 303                 if s[n] < utf8.RuneSelf {
 304                         e, sz = asciiTable[s[n]], 1
 305                 } else {
 306                         e, sz = bidi.LookupString(s[n:])
 307                         if sz <= 1 {
 308                                 if sz == 1 {
 309                                         return n, false // invalid UTF-8
 310                                 }
 311                                 return n, true // incomplete UTF-8 encoding
 312                         }
 313                 }
 314                 // TODO: using CompactClass results in noticeable speedup.
 315                 // See unicode/bidi/prop.go:Properties.CompactClass.
 316                 c := uint16(1 << e.Class())
 317                 t.seen |= c
 318                 if t.seen&exclusiveRTL == exclusiveRTL {
 319                         t.state = ruleInvalid
 320                         return n, false
 321                 }
 322                 switch tr := transitions[t.state]; {
 323                 case tr[0].mask&c != 0:
 324                         t.state = tr[0].next
 325                 case tr[1].mask&c != 0:
 326                         t.state = tr[1].next
 327                 default:
 328                         t.state = ruleInvalid
 329                         if t.isRTL() {
 330                                 return n, false
 331                         }
 332                 }
 333                 n += sz
 334         }
 335         return n, true
 336 }