Reject some previuosly-escaped chars in hostnames.

url/url_canon_host.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/logging.h"
 #include "url/url_canon.h"
 #include "url/url_canon_internal.h"
 
 namespace url {
 
 namespace {
 
-// For reference, here's what IE supports:
+// For reference, here's what IE6 supported:
 // Key: 0 (disallowed: failure if present in the input)
 //      + (allowed either escaped or unescaped, and unmodified)
 //      U (allowed escaped or unescaped but always unescaped if present in
 //         escaped form)
 //      E (allowed escaped or unescaped but always escaped if present in
 //         unescaped form)
 //      % (only allowed escaped in the input, will be unmodified).
 //      I left blank alpha numeric characters.
 //
 //    00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f
 //    -----------------------------------------------
 // 0   0  E  E  E  E  E  E  E  E  E  E  E  E  E  E  E
 // 1   E  E  E  E  E  E  E  E  E  E  E  E  E  E  E  E
 // 2   E  +  E  E  +  E  +  +  +  +  +  +  +  U  U  0
 // 3                                 %  %  E  +  E  0  <-- Those are  : ; < = > ?
 // 4   %
 // 5                                    U  0  U  U  U  <-- Those are  [ \ ] ^ _
 // 6   E                                               <-- That's  `
 // 7                                    E  E  E  U  E  <-- Those are { | } ~ (UNPRINTABLE)
 //
 // NOTE: I didn't actually test all the control characters. Some may be
 // disallowed in the input, but they are all accepted escaped except for 0.
 // I also didn't test if characters affecting HTML parsing are allowed
 // unescaped, e.g. (") or (#), which would indicate the beginning of the path.
 // Surprisingly, space is accepted in the input and always escaped.
 
 // This table lists the canonical version of all characters we allow in the
-// input, with 0 indicating it is disallowed. We use the magic kEscapedHostChar
-// value to indicate that this character should be escaped. We are a little more
-// restrictive than IE, but less restrictive than Firefox.
-//
-// Note that we disallow the % character. We will allow it when part of an
-// escape sequence, of course, but this disallows "%25". Even though IE allows
-// it, allowing it would put us in a funny state. If there was an invalid
-// escape sequence like "%zz", we'll add "%25zz" to the output and fail.
-// Allowing percents means we'll succeed a second time, so validity would change
-// based on how many times you run the canonicalizer. We prefer to always report
-// the same vailidity, so reject this.
-const unsigned char kEsc = 0xff;
+// input, with 0 indicating it is disallowed.
 const unsigned char kHostCharLookup[0x80] = {
 // 00-1f: all are invalid
      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
      0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,
 //  ' '   !    "    #    $    %    &    '    (    )    *    +    ,    -    .    /
-   kEsc,kEsc,kEsc,kEsc,kEsc,  0, kEsc,kEsc,kEsc,kEsc,kEsc, '+',kEsc, '-', '.',  0,
+     0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,   0,  '-', '.',  0,
 //   0    1    2    3    4    5    6    7    8    9    :    ;    <    =    >    ?
-    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':',  0 ,kEsc,kEsc,kEsc,  0 ,
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':',  0,   0,   0,   0,   0 ,
 //   @    A    B    C    D    E    F    G    H    I    J    K    L    M    N    O
-   kEsc, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+     0,  'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
 //   P    Q    R    S    T    U    V    W    X    Y    Z    [    \    ]    ^    _
     'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '[',  0 , ']',  0 , '_',
 //   `    a    b    c    d    e    f    g    h    i    j    k    l    m    n    o
-   kEsc, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+     0,  'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
 //   p    q    r    s    t    u    v    w    x    y    z    {    |    }    ~
-    'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',kEsc,kEsc,kEsc,  0 ,  0 };
+    'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',  0,   0,   0,   0,   0 };
 
 const int kTempHostBufferLen = 1024;
 typedef RawCanonOutputT<char, kTempHostBufferLen> StackBuffer;
 typedef RawCanonOutputT<base::char16, kTempHostBufferLen> StackBufferW;
 
 // Scans a host name and fills in the output flags according to what we find.
 // |has_non_ascii| will be true if there are any non-7-bit characters, and
 // |has_escaped| will be true if there is a percent sign.
 template<typename CHAR, typename UCHAR>
 void ScanHostname(const CHAR* spec,
@@ skipping 56 matching lines @@
       }
     }
 
     if (source < 0x80) {
       // We have ASCII input, we can use our lookup table.
       unsigned char replacement = kHostCharLookup[source];
       if (!replacement) {
         // Invalid character, add it as percent-escaped and mark as failed.
         AppendEscapedChar(source, output);
         success = false;
-      } else if (replacement == kEsc) {
-        // This character is valid but should be escaped.
-        AppendEscapedChar(source, output);
       } else {
         // Common case, the given character is valid in a hostname, the lookup
         // table tells us the canonical representation of that character (lower
         // cased).
         output->push_back(replacement);
       }
     } else {
       // It's a non-ascii char. Just push it to the output.
       // In case where we have char16 input, and char output it's safe to
       // cast char16->char only if input string was converted to ASCII.
@@ skipping 249 matching lines @@
   return DoHostSubstring<char, unsigned char>(spec, host, output);
 }
 
 bool CanonicalizeHostSubstring(const base::char16* spec,
                                const Component& host,
                                CanonOutput* output) {
   return DoHostSubstring<base::char16, base::char16>(spec, host, output);
 }
 
 }  // namespace url