Normalize UriData.parse result.

sdk/lib/convert/base64.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of dart.convert;
 
 /**
  * A [base64](https://tools.ietf.org/html/rfc4648) encoder and decoder.
  *
  * It encodes using the default base64 alphabet,
@@ skipping 39 matching lines @@
  * characters.
  */
 class Base64Codec extends Codec<List<int>, String> {
   final Base64Encoder _encoder;
   const Base64Codec() : _encoder = const Base64Encoder();
   const Base64Codec.urlSafe() : _encoder = const Base64Encoder.urlSafe();
 
   Base64Encoder get encoder => _encoder;
 
   Base64Decoder get decoder => const Base64Decoder();
+
+  /**
+   * Validates and normalizes the base64 encoded data in [source].
+   *
+   * Only acts on the substring from [start] to [end], with [end]
+   * defaulting to the end of the string.
+   *
+   * Normalization will:
+   * * Unescape any `%`-escapes.
+   * * Only allow valid characters (`A`-`Z`, `a`-`z`, `0`-`9`, `/` and `+`).
+   * * Normalize a `_` or `-` character to `/` or `+`.
+   * * Validate that existing padding (trailing `=` characters) is correct.
+   * * If no padding exists, add correct padding if necessary and possible.
+   * * Validate that the length is correct (a multiple of four).
+   */
+  String normalize(String source, [int start = 0, int end]) {
+    end = RangeError.checkValidRange(start, end, source.length);
+    const int percent = 0x25;
+    const int equals = 0x3d;
+    StringBuffer buffer = null;
+    int sliceStart = start;
+    var alphabet = _Base64Encoder._base64Alphabet;
+    var inverseAlphabet = _Base64Decoder._inverseAlphabet;
+    int firstPadding = -1;
+    int firstPaddingSourceIndex = -1;
+    int paddingCount = 0;
+    for (int i = start; i < end;) {
+      int sliceEnd = i;
+      int char = source.codeUnitAt(i++);
+      int originalChar = char;
+      // Normalize char, keep originalChar to see if it matches the source.
+      if (char == percent) {
+        if (i + 2 <= end) {
+          char = parseHexByte(source, i);  // May be negative.
+          i += 2;
+          // We know that %25 isn't valid, but our table considers it
+          // a potential padding start, so skip the checks.
+          if (char == percent) char = -1;
+        } else {
+          // An invalid HEX escape (too short).
+          // Just skip past the handling and reach the throw below.
+          char = -1;
+        }
+      }
+      // If char is negative here, hex-decoding failed in some way.
+      if (0 <= char && char <= 127) {
+        int value = inverseAlphabet[char];
+        if (value >= 0) {
+          char = alphabet.codeUnitAt(value);
+          if (char == originalChar) continue;
+        } else if (value == _Base64Decoder._padding) {
+          // We have ruled out percent, so char is '='.
+          if (firstPadding < 0) {
+            // Mark position in normalized output where padding occurs.
+            firstPadding = (buffer?.length ?? 0) + (sliceEnd - sliceStart);
+            firstPaddingSourceIndex = sliceEnd;
+          }
+          paddingCount++;
+          // It could have been an escaped equals (%3D).
+          if (originalChar == equals) continue;
+        }
+        if (value != _Base64Decoder._invalid) {
+          buffer ??= new StringBuffer();
+          buffer.write(source.substring(sliceStart, sliceEnd));
+          buffer.writeCharCode(char);
+          sliceStart = i;
+          continue;
+        }
+      }
+      throw new FormatException("Invalid base64 data", source, sliceEnd);
+    }
+    if (buffer != null) {
+      buffer.write(source.substring(sliceStart, end));
+      if (firstPadding >= 0) {
+        // There was padding in the source. Check that it is valid:
+        // * result length a multiple of four
+        // * one or two padding characters at the end.
+        _checkPadding(source, firstPaddingSourceIndex, end,
+                      firstPadding, paddingCount, buffer.length);
+      } else {
+        // Length of last chunk (1-4 chars) in the encoding.
+        int endLength = ((buffer.length - 1) % 4) + 1;
+        if (endLength == 1) {
+          // The data must have length 0, 2 or 3 modulo 4.
+          throw new FormatException("Invalid base64 encoding length ",
+              source, end);
+        }
+        while (endLength < 4) {
+          buffer.write("=");
+          endLength++;
+        }
+      }
+      return source.replaceRange(start, end, buffer.toString());
+    }
+    // Original was already normalized, only check padding.
+    int length = end - start;
+    if (firstPadding >= 0) {
+      _checkPadding(source, firstPaddingSourceIndex, end,
+          firstPadding, paddingCount, length);
+    } else {
+      // No padding given, so add some if needed it.
+      int endLength = length % 4;
+      if (endLength == 1) {
+          // The data must have length 0, 2 or 3 modulo 4.
+          throw new FormatException("Invalid base64 encoding length ",
+              source, end);
+      }
+      if (endLength > 1) {
+        // There is no "insertAt" on String, but this works as well.
+        source = source.replaceRange(end, end, (endLength == 2) ? "==" : "=");
+      }
+    }
+    return source;
+  }
+
+  static int _checkPadding(String source, int sourceIndex, int sourceEnd,
+          int firstPadding, int paddingCount, int length) {
+    if (length % 4 != 0) {
+      throw new FormatException(
+          "Invalid base64 padding, padded length must be multiple of four, "
+          "is $length",
+          source, sourceEnd);
+    }
+    if (firstPadding + paddingCount != length) {
+      throw new FormatException(
+          "Invalid base64 padding, '=' not at the end",
+          source, sourceIndex);
+    }
+    if (paddingCount > 2) {
+      throw new FormatException(
+          "Invalid base64 padding, more than two '=' characters",
+          source, sourceIndex);
+    }
+  }
 }
 
 // ------------------------------------------------------------------------
 // Encoder
 // ------------------------------------------------------------------------
 
 /**
  * Base64 and base64url encoding converter.
  *
  * Encodes lists of bytes using base64 or base64url encoding.
@@ skipping 312 matching lines @@
   static const int _p = _padding;
 
   /**
    * Mapping from ASCII characters to their index in the base64 alphabet.
    *
    * Uses [_invalid] for invalid indices and [_padding] for the padding
    * character.
    *
    * Accepts the "URL-safe" alphabet as well (`-` and `_` are the
    * 62nd and 63rd alphabet characters), and considers `%` a padding
-   * character, which mush then be followed by `3D`, the percent-escape
+   * character, which must then be followed by `3D`, the percent-escape
    * for `=`.
    */
   static final List<int> _inverseAlphabet = new Int8List.fromList([
     __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
     __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __,
     __, __, __, __, __, _p, __, __, __, __, __, 62, __, 62, __, 63,
     52, 53, 54, 55, 56, 57, 58, 59, 60, 61, __, __, __, _p, __, __,
     __,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
     15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, __, __, __, __, 63,
     __, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
@@ skipping 341 matching lines @@
     end = RangeError.checkValidRange(start, end, string.length);
     if (start == end) return;
     Uint8List buffer = _decoder.decode(string, start, end);
     if (buffer != null) _sink.add(buffer);
     if (isLast) {
       _decoder.close(string, end);
       _sink.close();
     }
   }
 }