closure 1.1.692

data/closure-library/closure/goog/crypt/hash32.js

@@ -0,0 +1,184 @@
+// Copyright 2008 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @fileoverview Implementation of 32-bit hashing functions.
+ *
+ * This is a direct port from the Google Java Hash class
+ *
+ */
+
+goog.provide('goog.crypt.hash32');
+
+goog.require('goog.crypt');
+
+
+/**
+ * Default seed used during hashing, digits of pie.
+ * See SEED32 in http://go/base.hash.java
+ * @type {number}
+ */
+goog.crypt.hash32.SEED32 = 314159265;
+
+
+/**
+ * Arbitrary constant used during hashing.
+ * See CONSTANT32 in http://go/base.hash.java
+ * @type {number}
+ */
+goog.crypt.hash32.CONSTANT32 = -1640531527;
+
+
+/**
+ * Hashes a string to a 32-bit value.
+ * @param {string} str String to hash.
+ * @return {number} 32-bit hash.
+ */
+goog.crypt.hash32.encodeString = function(str) {
+  return goog.crypt.hash32.encodeByteArray(goog.crypt.stringToByteArray(str));
+};
+
+
+/**
+ * Hashes a string to a 32-bit value, converting the string to UTF-8 before
+ * doing the encoding.
+ * @param {string} str String to hash.
+ * @return {number} 32-bit hash.
+ */
+goog.crypt.hash32.encodeStringUtf8 = function(str) {
+  return goog.crypt.hash32.encodeByteArray(
+      goog.crypt.stringToUtf8ByteArray(str));
+};
+
+
+/**
+ * Hashes an integer to a 32-bit value.
+ * @param {number} value Number to hash.
+ * @return {number} 32-bit hash.
+ */
+goog.crypt.hash32.encodeInteger = function(value) {
+  // TODO(user): Does this make sense in JavaScript with doubles?  Should we
+  // force the value to be in the correct range?
+  return goog.crypt.hash32.mix32_({
+    a: value,
+    b: goog.crypt.hash32.CONSTANT32,
+    c: goog.crypt.hash32.SEED32
+  });
+};
+
+
+/**
+ * Hashes a "byte" array to a 32-bit value using the supplied seed.
+ * @param {Array.<number>} bytes Array of bytes.
+ * @param {number=} opt_offset The starting position to use for hash
+ * computation.
+ * @param {number=} opt_length Number of bytes that are used for hashing.
+ * @param {number=} opt_seed The seed.
+ * @return {number} 32-bit hash.
+ */
+goog.crypt.hash32.encodeByteArray = function(
+    bytes, opt_offset, opt_length, opt_seed) {
+  var offset = opt_offset || 0;
+  var length = opt_length || bytes.length;
+  var seed = opt_seed || goog.crypt.hash32.SEED32;
+
+  var mix = {
+    a: goog.crypt.hash32.CONSTANT32,
+    b: goog.crypt.hash32.CONSTANT32,
+    c: seed
+  };
+
+  var keylen;
+  for (keylen = length; keylen >= 12; keylen -= 12, offset += 12) {
+    mix.a += goog.crypt.hash32.wordAt_(bytes, offset);
+    mix.b += goog.crypt.hash32.wordAt_(bytes, offset + 4);
+    mix.c += goog.crypt.hash32.wordAt_(bytes, offset + 8);
+    goog.crypt.hash32.mix32_(mix);
+  }
+  // Hash any remaining bytes
+  mix.c += length;
+  switch (keylen) {  // deal with rest.  Some cases fall through
+    case 11: mix.c += (bytes[offset + 10]) << 24;
+    case 10: mix.c += (bytes[offset + 9] & 0xff) << 16;
+    case 9 : mix.c += (bytes[offset + 8] & 0xff) << 8;
+      // the first byte of c is reserved for the length
+    case 8 :
+      mix.b += goog.crypt.hash32.wordAt_(bytes, offset + 4);
+      mix.a += goog.crypt.hash32.wordAt_(bytes, offset);
+      break;
+    case 7 : mix.b += (bytes[offset + 6] & 0xff) << 16;
+    case 6 : mix.b += (bytes[offset + 5] & 0xff) << 8;
+    case 5 : mix.b += (bytes[offset + 4] & 0xff);
+    case 4 :
+      mix.a += goog.crypt.hash32.wordAt_(bytes, offset);
+      break;
+    case 3 : mix.a += (bytes[offset + 2] & 0xff) << 16;
+    case 2 : mix.a += (bytes[offset + 1] & 0xff) << 8;
+    case 1 : mix.a += (bytes[offset + 0] & 0xff);
+      // case 0 : nothing left to add
+  }
+  return goog.crypt.hash32.mix32_(mix);
+};
+
+
+/**
+ * Performs an inplace mix of an object with the integer properties (a, b, c)
+ * and returns the final value of c.
+ * @param {Object} mix Object with properties, a, b, and c.
+ * @return {number} The end c-value for the mixing.
+ * @private
+ */
+goog.crypt.hash32.mix32_ = function(mix) {
+  var a = mix.a, b = mix.b, c = mix.c;
+  a -= b; a -= c; a ^= c >>> 13;
+  b -= c; b -= a; b ^= a << 8;
+  c -= a; c -= b; c ^= b >>> 13;
+  a -= b; a -= c; a ^= c >>> 12;
+  b -= c; b -= a; b ^= a << 16;
+  c -= a; c -= b; c ^= b >>> 5;
+  a -= b; a -= c; a ^= c >>> 3;
+  b -= c; b -= a; b ^= a << 10;
+  c -= a; c -= b; c ^= b >>> 15;
+  mix.a = a; mix.b = b; mix.c = c;
+  return c;
+};
+
+
+/**
+ * Returns the word at a given offset.  Treating an array of bytes a word at a
+ * time is far more efficient than byte-by-byte.
+ * @param {Array.<number>} bytes Array of bytes.
+ * @param {number} offset Offset in the byte array.
+ * @return {number} Integer value for the word.
+ * @private
+ */
+goog.crypt.hash32.wordAt_ = function(bytes, offset) {
+  var a = goog.crypt.hash32.toSigned_(bytes[offset + 0]);
+  var b = goog.crypt.hash32.toSigned_(bytes[offset + 1]);
+  var c = goog.crypt.hash32.toSigned_(bytes[offset + 2]);
+  var d = goog.crypt.hash32.toSigned_(bytes[offset + 3]);
+  return a + (b << 8) + (c << 16) + (d << 24);
+};
+
+
+/**
+ * Converts an unsigned "byte" to signed, that is, convert a value in the range
+ * (0, 2^8-1) to (-2^7, 2^7-1) in order to be compatible with Java's byte type.
+ * @param {number} n Unsigned "byte" value.
+ * @return {number} Signed "byte" value.
+ * @private
+ */
+goog.crypt.hash32.toSigned_ = function(n) {
+  return n > 127 ? n - 256 : n;
+};

data/closure-library/closure/goog/crypt/hash32_test.html

@@ -0,0 +1,287 @@
+<!DOCTYPE html>
+<html>
+<!--
+Copyright 2008 The Closure Library Authors. All Rights Reserved.
+
+Use of this source code is governed by the Apache License, Version 2.0.
+See the COPYING file for details.
+-->
+<head>
+<meta http-equiv="X-UA-Compatible" content="IE=edge">
+<title>Closure Unit Tests - goog.crypt.hash32</title>
+<script src="../base.js"></script>
+<script>
+  goog.require('goog.crypt.hash32');
+  goog.require('goog.testing.jsunit');
+</script>
+</head>
+<body>
+<script>
+
+  // NOTE: This test uses a custom test case, see end of script block
+
+  // Test data based on known input/output pairs generated using
+  // http://go/hash.java
+
+  function testEncodeInteger() {
+    assertEquals(898813988, goog.crypt.hash32.encodeInteger(305419896));
+  }
+
+  function testEncodeByteArray() {
+    assertEquals(-1497024495,
+        goog.crypt.hash32.encodeByteArray([10, 20, 30, 40]));
+    assertEquals(-961586214,
+        goog.crypt.hash32.encodeByteArray([3, 1, 4, 1, 5, 9]));
+    assertEquals(-1482202299,
+        goog.crypt.hash32.encodeByteArray([127, 0, 0, 0, 123, 45]));
+    assertEquals(170907881,
+        goog.crypt.hash32.encodeByteArray([9, 1, 1]));
+  }
+
+  function testKnownByteArrays() {
+    for (var i = 0; i < byteArrays.length; i++) {
+      assertEquals(byteArrays[i],
+          goog.crypt.hash32.encodeByteArray(createByteArray(i)));
+    }
+  }
+
+  function testEncodeString() {
+    assertEquals(-937588052, goog.crypt.hash32.encodeString('Hello, world'));
+    assertEquals(62382810, goog.crypt.hash32.encodeString('Sch\xF6n'));
+  }
+
+  function testEncodeStringUtf8() {
+    assertEquals(-937588052,
+        goog.crypt.hash32.encodeStringUtf8('Hello, world'));
+    assertEquals(-833263351, goog.crypt.hash32.encodeStringUtf8('Sch\xF6n'));
+
+    assertEquals(-1771620293, goog.crypt.hash32.encodeStringUtf8(
+        '\u043A\u0440'));
+  }
+
+  function testEncodeString_ascii() {
+    assertEquals('For ascii characters UTF8 should be the same',
+        goog.crypt.hash32.encodeStringUtf8('abc123'),
+        goog.crypt.hash32.encodeString('abc123'));
+
+    assertEquals('For ascii characters UTF8 should be the same',
+        goog.crypt.hash32.encodeStringUtf8('The,quick.brown-fox'),
+        goog.crypt.hash32.encodeString('The,quick.brown-fox'));
+
+    assertNotEquals('For non-ascii characters UTF-8 encoding is different',
+        goog.crypt.hash32.encodeStringUtf8('Sch\xF6n'),
+        goog.crypt.hash32.encodeString('Sch\xF6n'));
+  }
+
+  function testEncodeString_poe() {
+    var poe = "Once upon a midnight dreary, while I pondered weak and weary," +
+        "Over many a quaint and curious volume of forgotten lore," +
+        "While I nodded, nearly napping, suddenly there came a tapping," +
+        "As of some one gently rapping, rapping at my chamber door." +
+        "`'Tis some visitor,' I muttered, `tapping at my chamber door -" +
+        "Only this, and nothing more.'" +
+        "Ah, distinctly I remember it was in the bleak December," +
+        "And each separate dying ember wrought its ghost upon the floor." +
+        "Eagerly I wished the morrow; - vainly I had sought to borrow" +
+        "From my books surcease of sorrow - sorrow for the lost Lenore -" +
+        "For the rare and radiant maiden whom the angels named Lenore -" +
+        "Nameless here for evermore." +
+        "And the silken sad uncertain rustling of each purple curtain" +
+        "Thrilled me - filled me with fantastic terrors never felt before;" +
+        "So that now, to still the beating of my heart, I stood repeating" +
+        "`'Tis some visitor entreating entrance at my chamber door -" +
+        "Some late visitor entreating entrance at my chamber door; -" +
+        "This it is, and nothing more,'" +
+        "Presently my soul grew stronger; hesitating then no longer," +
+        "`Sir,' said I, `or Madam, truly your forgiveness I implore;" +
+        "But the fact is I was napping, and so gently you came rapping," +
+        "And so faintly you came tapping, tapping at my chamber door," +
+        "That I scarce was sure I heard you' - here I opened wide the door; -" +
+        "Darkness there, and nothing more." +
+        "Deep into that darkness peering, long I stood there wondering, " +
+        "fearing," +
+        "Doubting, dreaming dreams no mortal ever dared to dream before" +
+        "But the silence was unbroken, and the darkness gave no token," +
+        "And the only word there spoken was the whispered word, `Lenore!'" +
+        "This I whispered, and an echo murmured back the word, `Lenore!'" +
+        "Merely this and nothing more." +
+        "Back into the chamber turning, all my soul within me burning," +
+        "Soon again I heard a tapping somewhat louder than before." +
+        "`Surely,\' said I, `surely that is something at my window lattice;" +
+        "Let me see then, what thereat is, and this mystery explore -" +
+        "Let my heart be still a moment and this mystery explore; -" +
+        "'Tis the wind and nothing more!'";
+
+    assertEquals(147608747, goog.crypt.hash32.encodeString(poe));
+    assertEquals(147608747, goog.crypt.hash32.encodeStringUtf8(poe));
+  }
+
+  function testBenchmarking() {
+    if (!testCase) return;
+    // Not a real test, just outputs some timing
+    function makeString(n) {
+      var str = [];
+      for (var i = 0; i < n; i++) {
+        str.push(String.fromCharCode(Math.round(Math.random() * 500)));
+      }
+      return str.join('');
+    }
+    for (var i = 0; i < 50000; i+= 10000) {
+      var str = makeString(i);
+      var start = goog.now();
+      var hash = goog.crypt.hash32.encodeString(str);
+      var diff = goog.now() - start;
+      testCase.saveMessage(
+          'testBenchmarking : hashing ' + i + ' chars in ' + diff + 'ms');
+    }
+  }
+
+  function createByteArray(n) {
+    var arr = [];
+    for (var i = 0; i < n; i++) {
+      arr.push(i);
+    }
+    return arr;
+  }
+
+  var byteArrays = {
+    0: 1539411136,
+    1: 1773524747,
+    2: -254958930,
+    3: 1532114172,
+    4: 1923165449,
+    5: 1611874589,
+    6: 1502126780,
+    7: -751745251,
+    8: -292491321,
+    9: 1106193218,
+    10: -722791438,
+    11: -2130666060,
+    12: -259304553,
+    13: 871461192,
+    14: 865773084,
+    15: 1615738330,
+    16: -1836636447,
+    17: -485722519,
+    18: -120832227,
+    19: 1954449704,
+    20: 491312921,
+    21: -1955462668,
+    22: 168565425,
+    23: -105893922,
+    24: 620486614,
+    25: -1789602428,
+    26: 1765793554,
+    27: 1723370948,
+    28: -1275405721,
+    29: 140421019,
+    30: -1438726307,
+    31: 538438903,
+    32: -729123980,
+    33: 1213490939,
+    34: -1814248478,
+    35: 1943703398,
+    36: 1603073219,
+    37: -2139639543,
+    38: -694153941,
+    39: 137511516,
+    40: -249943726,
+    41: -1166126060,
+    42: 53464833,
+    43: -915350862,
+    44: 1306585409,
+    45: 1064798289,
+    46: 335555913,
+    47: 224485496,
+    48: 275599760,
+    49: 409559869,
+    50: 673770580,
+    51: -2113819879,
+    52: -791338727,
+    53: -1716479479,
+    54: 1795018816,
+    55: 2020139343,
+    56: -1652827750,
+    57: -1509632558,
+    58: 751641995,
+    59: -217881377,
+    60: -476546900,
+    61: -1893349644,
+    62: -729290332,
+    63: 1359899321,
+    64: 1811814306,
+    65: 2100363086,
+    66: -794920327,
+    67: -1667555017,
+    68: -549980099,
+    69: -21170740,
+    70: -1324143722,
+    71: 1406730195,
+    72: 2111381574,
+    73: -1667480052,
+    74: 1071811178,
+    75: -1080194099,
+    76: -181186882,
+    77: 268677507,
+    78: -546766334,
+    79: 555953522,
+    80: -981311675,
+    81: 1988867392,
+    82: 773172547,
+    83: 1160806722,
+    84: -1455460187,
+    85: 83493600,
+    86: 155365142,
+    87: 1714618071,
+    88: 1487712615,
+    89: -810670278,
+    90: 2031655097,
+    91: 1286349470,
+    92: -1873594211,
+    93: 1875867480,
+    94: -1096259787,
+    95: -1054968610,
+    96: -1723043458,
+    97: 1278708307,
+    98: -601104085,
+    99: 1497928579,
+    100: 1329732615,
+    101: -1281696190,
+    102: 1471511953,
+    103: -62666299,
+    104: 807569747,
+    105: -1927974759,
+    106: 1462243717,
+    107: -862975602,
+    108: 824369927,
+    109: -1448816781,
+    110: 1434162022,
+    111: -881501413,
+    112: -1554381107,
+    113: -1730883204,
+    114: 431236217,
+    115: 1877278608,
+    116: -673864625,
+    117: 143000665,
+    118: -596902829,
+    119: 1038860559,
+    120: 805884326,
+    121: -1536181710,
+    122: -1357373256,
+    123: 1405134250,
+    124: -860816481,
+    125: 1393578269,
+    126: -810682545,
+    127: -635515639
+  };
+
+  var testCase;
+  if (G_testRunner) {
+    testCase = new goog.testing.TestCase(document.title);
+    testCase.autoDiscoverTests();
+    G_testRunner.initialize(testCase);
+  }
+
+</script>
+</body>
+</html>

data/closure-library/closure/goog/crypt/sha1.js

@@ -0,0 +1,238 @@
+// Copyright 2005 The Closure Library Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/**
+ * @fileoverview SHA-1 cryptographic hash.
+ * Variable names follow the notation in FIPS PUB 180-3:
+ * http://csrc.nist.gov/publications/fips/fips180-3/fips180-3_final.pdf.
+ *
+ * Usage:
+ *   var sha1 = new goog.crypt.sha1();
+ *   sha1.update(bytes);
+ *   var hash = sha1.digest();
+ *
+ */
+
+goog.provide('goog.crypt.Sha1');
+
+
+
+/**
+ * SHA-1 cryptographic hash constructor.
+ *
+ * The properties declared here are discussed in the above algorithm document.
+ * @constructor
+ */
+goog.crypt.Sha1 = function() {
+  /**
+   * Holds the previous values of accumulated variables a-e in the compress_
+   * function.
+   * @type {Array.<number>}
+   * @private
+   */
+  this.chain_ = [];
+
+  /**
+   * A buffer holding the partially computed hash result.
+   * @type {Array.<number>}
+   * @private
+   */
+  this.buf_ = [];
+
+  /**
+   * An array of 80 bytes, each a part of the message to be hashed.  Referred to
+   * as the message schedule in the docs.
+   * @type {Array.<number>}
+   * @private
+   */
+  this.W_ = [];
+
+  /**
+   * Contains data needed to pad messages less than 64 bytes.
+   * @type {Array.<number>}
+   * @private
+   */
+  this.pad_ = [];
+
+  this.pad_[0] = 128;
+  for (var i = 1; i < 64; ++i) {
+    this.pad_[i] = 0;
+  }
+
+  this.reset();
+};
+
+
+/**
+ * Resets the internal accumulator.
+ */
+goog.crypt.Sha1.prototype.reset = function() {
+  this.chain_[0] = 0x67452301;
+  this.chain_[1] = 0xefcdab89;
+  this.chain_[2] = 0x98badcfe;
+  this.chain_[3] = 0x10325476;
+  this.chain_[4] = 0xc3d2e1f0;
+
+  this.inbuf_ = 0;
+  this.total_ = 0;
+};
+
+
+/**
+ * Internal helper performing 32 bit left rotate.
+ * @param {number} w 32-bit integer to rotate.
+ * @param {number} r Bits to rotate left by.
+ * @return {number} w rotated left by r bits.
+ * @private
+ */
+goog.crypt.Sha1.prototype.rotl_ = function(w, r) {
+  return ((w << r) | (w >>> (32 - r))) & 0xffffffff;
+};
+
+
+/**
+ * Internal compress helper function.
+ * @param {Array} buf containing block to compress.
+ * @private
+ */
+goog.crypt.Sha1.prototype.compress_ = function(buf) {
+  var W = this.W_;
+
+  // get 16 big endian words
+  for (var i = 0; i < 64; i += 4) {
+    var w = (buf[i] << 24) |
+            (buf[i + 1] << 16) |
+            (buf[i + 2] << 8) |
+            (buf[i + 3]);
+    W[i / 4] = w;
+  }
+
+  // expand to 80 words
+  for (var i = 16; i < 80; i++) {
+    W[i] = this.rotl_(W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16], 1);
+  }
+
+  var a = this.chain_[0];
+  var b = this.chain_[1];
+  var c = this.chain_[2];
+  var d = this.chain_[3];
+  var e = this.chain_[4];
+  var f, k;
+
+  for (var i = 0; i < 80; i++) {
+    if (i < 40) {
+      if (i < 20) {
+        f = d ^ (b & (c ^ d));
+        k = 0x5a827999;
+      } else {
+        f = b ^ c ^ d;
+        k = 0x6ed9eba1;
+      }
+    } else {
+      if (i < 60) {
+        f = (b & c) | (d & (b | c));
+        k = 0x8f1bbcdc;
+      } else {
+        f = b ^ c ^ d;
+        k = 0xca62c1d6;
+      }
+    }
+
+    var t = (this.rotl_(a, 5) + f + e + k + W[i]) & 0xffffffff;
+    e = d;
+    d = c;
+    c = this.rotl_(b, 30);
+    b = a;
+    a = t;
+  }
+
+  this.chain_[0] = (this.chain_[0] + a) & 0xffffffff;
+  this.chain_[1] = (this.chain_[1] + b) & 0xffffffff;
+  this.chain_[2] = (this.chain_[2] + c) & 0xffffffff;
+  this.chain_[3] = (this.chain_[3] + d) & 0xffffffff;
+  this.chain_[4] = (this.chain_[4] + e) & 0xffffffff;
+};
+
+
+/**
+ * Adds a byte array to internal accumulator.
+ * @param {Array.<number>} bytes to add to digest.
+ * @param {number=} opt_length is # of bytes to compress.
+ */
+goog.crypt.Sha1.prototype.update = function(bytes, opt_length) {
+  if (!opt_length) {
+    opt_length = bytes.length;
+  }
+
+  var n = 0;
+
+  // Optimize for 64 byte chunks at 64 byte boundaries.
+  if (this.inbuf_ == 0) {
+    while (n + 64 < opt_length) {
+      this.compress_(bytes.slice(n, n + 64));
+      n += 64;
+      this.total_ += 64;
+    }
+  }
+
+  while (n < opt_length) {
+    this.buf_[this.inbuf_++] = bytes[n++];
+    this.total_++;
+
+    if (this.inbuf_ == 64) {
+      this.inbuf_ = 0;
+      this.compress_(this.buf_);
+
+      // Pick up 64 byte chunks.
+      while (n + 64 < opt_length) {
+        this.compress_(bytes.slice(n, n + 64));
+        n += 64;
+        this.total_ += 64;
+      }
+    }
+  }
+};
+
+
+/**
+ * @return {Array} byte[20] containing finalized hash.
+ */
+goog.crypt.Sha1.prototype.digest = function() {
+  var digest = [];
+  var totalBits = this.total_ * 8;
+
+  // Add pad 0x80 0x00*.
+  if (this.inbuf_ < 56) {
+    this.update(this.pad_, 56 - this.inbuf_);
+  } else {
+    this.update(this.pad_, 64 - (this.inbuf_ - 56));
+  }
+
+  // Add # bits.
+  for (var i = 63; i >= 56; i--) {
+    this.buf_[i] = totalBits & 255;
+    totalBits >>>= 8;
+  }
+
+  this.compress_(this.buf_);
+
+  var n = 0;
+  for (var i = 0; i < 5; i++) {
+    for (var j = 24; j >= 0; j -= 8) {
+      digest[n++] = (this.chain_[i] >> j) & 255;
+    }
+  }
+
+  return digest;
+};