The Tor Browser: toolkit/components/url-classifier/content/moz/cryptohasher.js@925c144e1f1f (annotated)

toolkit/components/url-classifier/content/moz/cryptohasher.js@925c144e1f1f (annotated)

toolkit/components/url-classifier/content/moz/cryptohasher.js

Fri, 16 Jan 2015 18:13:44 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Fri, 16 Jan 2015 18:13:44 +0100
branch: TOR_BUG_9701
changeset 14: 925c144e1f1f
permissions: -rw-r--r--

Integrate suggestion from review to improve consistency with existing code.

 # This Source Code Form is subject to the terms of the Mozilla Public
 # License, v. 2.0. If a copy of the MPL was not distributed with this
 # file, You can obtain one at http://mozilla.org/MPL/2.0/.
 // A very thin wrapper around nsICryptoHash. It's not strictly
 // necessary, but makes the code a bit cleaner and gives us the
 // opportunity to verify that our implementations give the results that
 // we expect, for example if we have to interoperate with a server.
 //
 // The digest* methods reset the state of the hasher, so it's
 // necessary to call init() explicitly after them.
 //
 // Works only in Firefox 1.5+.
 //
 // IMPORTANT NOTE: Due to https://bugzilla.mozilla.org/show_bug.cgi?id=321024
 // you cannot use the cryptohasher before app-startup. The symptom of doing
 // so is a segfault in NSS.
 /**
  * Instantiate a new hasher. You must explicitly call init() before use!
  */
 function G_CryptoHasher() {
   this.debugZone = "cryptohasher";
   this.hasher_ = null;
 }
 G_CryptoHasher.algorithms = {
   MD2: Ci.nsICryptoHash.MD2,
   MD5: Ci.nsICryptoHash.MD5,
   SHA1: Ci.nsICryptoHash.SHA1,
   SHA256: Ci.nsICryptoHash.SHA256,
   SHA384: Ci.nsICryptoHash.SHA384,
   SHA512: Ci.nsICryptoHash.SHA512,
 };
 /**
  * Initialize the hasher. This function must be called after every call
  * to one of the digest* methods.
  *
  * @param algorithm Constant from G_CryptoHasher.algorithms specifying the
  *                  algorithm this hasher will use
  */
 G_CryptoHasher.prototype.init = function(algorithm) {
   var validAlgorithm = false;
   for (var alg in G_CryptoHasher.algorithms)
     if (algorithm == G_CryptoHasher.algorithms[alg])
       validAlgorithm = true;
   if (!validAlgorithm)
     throw new Error("Invalid algorithm: " + algorithm);
   this.hasher_ = Cc["@mozilla.org/security/hash;1"]
                  .createInstance(Ci.nsICryptoHash);
   this.hasher_.init(algorithm);
 }
 /**
  * Update the hash's internal state with input given in a string. Can be
  * called multiple times for incrementeal hash updates.
  *
  * @param input String containing data to hash.
  */
 G_CryptoHasher.prototype.updateFromString = function(input) {
   if (!this.hasher_)
     throw new Error("You must initialize the hasher first!");
   var stream = Cc['@mozilla.org/io/string-input-stream;1']
                .createInstance(Ci.nsIStringInputStream);
   stream.setData(input, input.length);
   this.updateFromStream(stream);
 }
 /**
  * Update the hash's internal state with input given in an array. Can be
  * called multiple times for incremental hash updates.
  *
  * @param input Array containing data to hash.
  */
 G_CryptoHasher.prototype.updateFromArray = function(input) {
   if (!this.hasher_)
     throw new Error("You must initialize the hasher first!");
   this.hasher_.update(input, input.length);
 }
 /**
  * Update the hash's internal state with input given in a stream. Can be
  * called multiple times from incremental hash updates.
  */
 G_CryptoHasher.prototype.updateFromStream = function(stream) {
   if (!this.hasher_)
     throw new Error("You must initialize the hasher first!");
   if (stream.available())
     this.hasher_.updateFromStream(stream, stream.available());
 }
 /**
  * @returns The hash value as a string (sequence of 8-bit values)
  */
 G_CryptoHasher.prototype.digestRaw = function() {
   var digest = this.hasher_.finish(false /* not b64 encoded */);
   this.hasher_ = null;
   return digest;
 }
 /**
  * @returns The hash value as a base64-encoded string
  */
 G_CryptoHasher.prototype.digestBase64 = function() {
   var digest = this.hasher_.finish(true /* b64 encoded */);
   this.hasher_ = null;
   return digest;
 }
 /**
  * @returns The hash value as a hex-encoded string
  */
 G_CryptoHasher.prototype.digestHex = function() {
   var raw = this.digestRaw();
   return this.toHex_(raw);
 }
 /**
  * Converts a sequence of values to a hex-encoded string. The input is a
  * a string, so you can stick 16-bit values in each character.
  *
  * @param str String to conver to hex. (Often this is just a sequence of
  *            16-bit values)
  *
  * @returns String containing the hex representation of the input
  */
 G_CryptoHasher.prototype.toHex_ = function(str) {
   var hexchars = '0123456789ABCDEF';
   var hexrep = new Array(str.length * 2);
   for (var i = 0; i < str.length; ++i) {
     hexrep[i * 2] = hexchars.charAt((str.charCodeAt(i) >> 4) & 15);
     hexrep[i * 2 + 1] = hexchars.charAt(str.charCodeAt(i) & 15);
   }
   return hexrep.join('');
 }
 #ifdef DEBUG
 /**
  * Lame unittest function
  */
 function TEST_G_CryptoHasher() {
   if (G_GDEBUG) {
     var z = "cryptohasher UNITTEST";
     G_debugService.enableZone(z);
     G_Debug(z, "Starting");
     var md5 = function(str) {
       var hasher = new G_CryptoHasher();
       hasher.init(G_CryptoHasher.algorithms.MD5);
       hasher.updateFromString(str);
       return hasher.digestHex().toLowerCase();
     };
     // test vectors from: http://www.faqs.org/rfcs/rfc1321.html
     var vectors = {"": "d41d8cd98f00b204e9800998ecf8427e",
                    "a": "0cc175b9c0f1b6a831c399e269772661",
                    "abc": "900150983cd24fb0d6963f7d28e17f72",
                    "message digest": "f96b697d7cb7938d525a2f31aaf161d0",
                    "abcdefghijklmnopqrstuvwxyz": "c3fcd3d76192e4007dfb496cca67e13b",
                    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789": "d174ab98d277d9f5a5611c2c9f419d9f",
                    "12345678901234567890123456789012345678901234567890123456789012345678901234567890": "57edf4a22be3c955ac49da2e2107b67a"};
     G_Debug(z, "PASSED");
   }
 }
 #endif