Bump version to 0.12.6

pass issuers to AutobridgeCalculator so
it can create offers with right issuers

.gitignore

@@ -17,7 +17,7 @@
 
 # Ignore object files.
 *.o
-build/*.js
+build/
 tags
 bin/rippled
 Debug/*.*

.npmignore

@@ -1,3 +1,4 @@
-deploy
 lib-cov
 coverage.html
+src
+dist/bower

.travis.yml

@@ -1,10 +1,10 @@
 language: node_js
 node_js:
-  - "0.10"
+  - "0.12"
 before_script:
   - npm install -g eslint
-  - curl 'https://raw.githubusercontent.com/ripple/javascript-style-guide/master/eslintrc' > ./eslintrc
-  - eslint --reset -c ./eslintrc $(git --no-pager diff --name-only --diff-filter=AM --relative $(git merge-base FETCH_HEAD origin/HEAD) FETCH_HEAD | grep "\.js$")
+  - curl 'https://raw.githubusercontent.com/ripple/javascript-style-guide/es6/eslintrc' > ./eslintrc
+  - eslint --reset -c ./eslintrc $(git --no-pager diff --name-only -M100% --diff-filter=AM --relative $(git merge-base FETCH_HEAD origin/HEAD) FETCH_HEAD | grep "\.js$")
 script: MOCHA_REPORTER=tap npm test --coverage
 after_success:
 - npm run coveralls

Gulpfile.js

@@ -1,11 +1,13 @@
+/* eslint-disable no-var, no-param-reassign */
+/* these eslint rules are disabled because gulp does not support babel yet */
 'use strict';
+var _ = require('lodash');
 var gulp = require('gulp');
 var gutil = require('gulp-util');
 var watch = require('gulp-watch');
 var plumber = require('gulp-plumber');
 var filelog = require('gulp-filelog');
 var cleanDest = require('gulp-clean-dest');
-var concat = require('gulp-concat');
 var uglify = require('gulp-uglify');
 var rename = require('gulp-rename');
 var webpack = require('webpack');
@@ -13,63 +15,36 @@ var bump = require('gulp-bump');
 var react = require('gulp-react');
 var flow = require('gulp-flowtype');
 var argv = require('yargs').argv;
-// var header = require('gulp-header');
 
 var pkg = require('./package.json');
 
-var sjclSrc = [
-  'src/js/sjcl/core/sjcl.js',
-  'src/js/sjcl/core/aes.js',
-  'src/js/sjcl/core/bitArray.js',
-  'src/js/sjcl/core/codecString.js',
-  'src/js/sjcl/core/codecHex.js',
-  'src/js/sjcl/core/codecBase64.js',
-  'src/js/sjcl/core/codecBytes.js',
-  'src/js/sjcl/core/sha256.js',
-  'src/js/sjcl/core/sha512.js',
-  'src/js/sjcl/core/sha1.js',
-  'src/js/sjcl/core/ccm.js',
-  // 'src/js/sjcl/core/cbc.js',
-  // 'src/js/sjcl/core/ocb2.js',
-  'src/js/sjcl/core/hmac.js',
-  'src/js/sjcl/core/pbkdf2.js',
-  'src/js/sjcl/core/random.js',
-  'src/js/sjcl/core/convenience.js',
-  'src/js/sjcl/core/bn.js',
-  'src/js/sjcl/core/ecc.js',
-  'src/js/sjcl/core/srp.js',
-  'src/js/sjcl-custom/sjcl-ecc-pointextras.js',
-  'src/js/sjcl-custom/sjcl-secp256k1.js',
-  'src/js/sjcl-custom/sjcl-ripemd160.js',
-  'src/js/sjcl-custom/sjcl-extramath.js',
-  'src/js/sjcl-custom/sjcl-montgomery.js',
-  'src/js/sjcl-custom/sjcl-validecc.js',
-  'src/js/sjcl-custom/sjcl-ecdsa-canonical.js',
-  'src/js/sjcl-custom/sjcl-ecdsa-der.js',
-  'src/js/sjcl-custom/sjcl-ecdsa-recoverablepublickey.js',
-  'src/js/sjcl-custom/sjcl-jacobi.js'
-];
+function webpackConfig(extension, overrides) {
+  overrides = overrides || {};
+  var defaults = {
+    cache: true,
+    entry: './src/index.js',
+    output: {
+      library: 'ripple',
+      path: './build/',
+      filename: ['ripple-', extension].join(pkg.version)
+    },
+    module: {
+      loaders: [{
+        test: /\.js$/,
+        exclude: /node_modules/,
+        loader: 'babel-loader?optional=runtime'
+      }]
+    }
+  };
+  return _.assign({}, defaults, overrides);
+}
 
 function logPluginError(error) {
   gutil.log(error.toString());
 }
 
-gulp.task('concat-sjcl', function() {
-  return gulp.src(sjclSrc)
-  .pipe(concat('sjcl.js'))
-  .pipe(gulp.dest('./build/'));
-});
-
-gulp.task('build', ['concat-sjcl'], function(callback) {
-  webpack({
-    cache: true,
-    entry: './src/js/ripple/index.js',
-    output: {
-      library: 'ripple',
-      path: './build/',
-      filename: ['ripple-', '.js'].join(pkg.version)
-    }
-  }, callback);
+gulp.task('build', function(callback) {
+  webpack(webpackConfig('.js'), callback);
 });
 
 gulp.task('build-min', ['build'], function() {
@@ -79,18 +54,9 @@ gulp.task('build-min', ['build'], function() {
   .pipe(gulp.dest('./build/'));
 });
 
-gulp.task('build-debug', ['concat-sjcl'], function(callback) {
-  webpack({
-    cache: true,
-    entry: './src/js/ripple/index.js',
-    output: {
-      library: 'ripple',
-      path: './build/',
-      filename: ['ripple-', '-debug.js'].join(pkg.version)
-    },
-    debug: true,
-    devtool: 'eval'
-  }, callback);
+gulp.task('build-debug', function(callback) {
+  var configOverrides = {debug: true, devtool: 'eval'};
+  webpack(webpackConfig('-debug.js', configOverrides), callback);
 });
 
 /**
@@ -104,64 +70,57 @@ function buildUseError(cons) {
           .replace(new RegExp('<CONS>', 'g'), cons);
 }
 
-gulp.task('build-core', ['concat-sjcl'], function(callback) {
-  webpack({
-    entry: [
-      './src/js/ripple/remote.js'
-    ],
-    externals: [
-      {
-        './transaction': buildUseError('Transaction'),
-        './orderbook': buildUseError('OrderBook'),
-        './account': buildUseError('Account'),
-        './serializedobject': buildUseError('SerializedObject')
-      }
-    ],
-    output: {
-      library: 'ripple',
-      path: './build/',
-      filename: ['ripple-', '-core.js'].join(pkg.version)
-    },
+gulp.task('build-core', function(callback) {
+  var configOverrides = {
+    cache: false,
+    entry: './src/remote.js',
+    externals: [{
+      './transaction': buildUseError('Transaction'),
+      './orderbook': buildUseError('OrderBook'),
+      './account': buildUseError('Account'),
+      './serializedobject': buildUseError('SerializedObject')
+    }],
     plugins: [
       new webpack.optimize.UglifyJsPlugin()
     ]
-  }, callback);
+  };
+  webpack(webpackConfig('-core.js', configOverrides), callback);
 });
 
 gulp.task('bower-build', ['build'], function() {
   return gulp.src(['./build/ripple-', '.js'].join(pkg.version))
   .pipe(rename('ripple.js'))
-  .pipe(gulp.dest('./dist/'));
+  .pipe(gulp.dest('./dist/bower'));
 });
 
 gulp.task('bower-build-min', ['build-min'], function() {
   return gulp.src(['./build/ripple-', '-min.js'].join(pkg.version))
   .pipe(rename('ripple-min.js'))
-  .pipe(gulp.dest('./dist/'));
+  .pipe(gulp.dest('./dist/bower'));
 });
 
 gulp.task('bower-build-debug', ['build-debug'], function() {
   return gulp.src(['./build/ripple-', '-debug.js'].join(pkg.version))
   .pipe(rename('ripple-debug.js'))
-  .pipe(gulp.dest('./dist/'));
+  .pipe(gulp.dest('./dist/bower'));
 });
 
 gulp.task('bower-version', function() {
-  gulp.src('./dist/bower.json')
+  gulp.src('./dist/bower/bower.json')
   .pipe(bump({version: pkg.version}))
-  .pipe(gulp.dest('./dist/'));
+  .pipe(gulp.dest('./dist/bower'));
 });
 
 gulp.task('bower', ['bower-build', 'bower-build-min', 'bower-build-debug',
                     'bower-version']);
 
 gulp.task('watch', function() {
-  gulp.watch('src/js/ripple/*', ['build-debug']);
+  gulp.watch('src/*', ['build-debug']);
 });
 
 // To use this, each javascript file must have /* @flow */ on the first line
 gulp.task('typecheck', function() {
-  return gulp.src('src/js/ripple/*.js')
+  return gulp.src('src/*.js')
   .pipe(flow({      // note: do not set the 'all' option, it is broken
     weak: true,   // remove this after all errors are addressed
     killFlow: true
@@ -169,8 +128,8 @@ gulp.task('typecheck', function() {
 });
 
 gulp.task('strip', function() {
-  return gulp.src('src/js/ripple/*.js')
-  .pipe(watch('src/js/ripple/*.js'))
+  return gulp.src('src/*.js')
+  .pipe(watch('src/*.js'))
   .pipe(cleanDest('out'))   // delete outdated output file before stripping
   .pipe(plumber())        // prevent an error in one file from ending build
   .pipe(react({stripTypes: true}).on('error', logPluginError))
@@ -194,4 +153,4 @@ gulp.task('version-beta', function() {
   .pipe(gulp.dest('./'));
 });
 
-gulp.task('default', ['concat-sjcl', 'build', 'build-debug', 'build-min']);
+gulp.task('default', ['build', 'build-debug', 'build-min']);

HISTORY.md

@@ -1,3 +1,53 @@
+##0.12.6
+
++ [Fix webpack require failure due to "./" notation](https://github.com/ripple/ripple-lib/commit/8d9746d7b10be203ee613df523c2522012ff1baf)
+
+##0.12.15
+
++ [Add offer autobridging](https://github.com/ripple/ripple-lib/commit/c7bbce83719c1e8c6a4fae5ca850e7515db1a4a5)
+
++ [Prevent crash when listening for "model" events on the OrderBook class](https://github.com/ripple/ripple-lib/commit/5824c3cb7cb6bd834d6e037f69943aebf3d83351)
+
++ [Fix empty order edgecase](https://github.com/ripple/ripple-lib/commit/64809d9ae23dc24f47accd4b4788b48f49880d3e)
+
++ [Fix AutobridgeCalculator (RT-3445)](https://github.com/ripple/ripple-lib/commit/1fff5ea6dcbcee856536df26f3b9cf1aec3c3b55)
+
++ [Update sjcl and delete custom ripemd160, montgomery, and jacobi](https://github.com/ripple/ripple-lib/commit/50cda426eb83599c38c0b725e1524a01fc415da2)
+
++ [Fix transaction summary for transactions that fail with remoteError](https://github.com/ripple/ripple-lib/commit/5e714f6143464d7912f42537acaa553b88eaf6dc)
+
++ [Fix serializedobject append for excessively large bytes length](https://github.com/ripple/ripple-lib/commit/e93f1ab6f4aaad347450aee75a169af0faa2121c)
+
++ [Switch to sjcl npm module](https://github.com/ripple/ripple-lib/commit/9a502580fd89ec6a9aa55f4e5847f6a4a2cb5bba)
+
++ [Add babel transpiler](https://github.com/ripple/ripple-lib/commit/398f8d001f758bf575b959537a17e79e4042d17b)
+
++ [Remove unused float.js and wallet.js](https://github.com/ripple/ripple-lib/commit/d4a4b5f4fbbf09677a59ce81bace35c6426a2fda)
+
++ [Remove config singleton to reduce global state](https://github.com/ripple/ripple-lib/commit/c655c2a20ee5d150a4b5a1b6717b9fb81f636025)
+
+##0.12.4
+
++ [Improve entropy security](https://github.com/ripple/ripple-lib/commit/c7ba822320880037796f57876d1abb4e525648ed)
+
++ [Remove unused crypt.js file](https://github.com/ripple/ripple-lib/commit/1f68eba1461bca03a4d22872450d15ae5a185334)
+
+##0.12.3
+
++ [Add getLedgerSequence to Remote](https://github.com/ripple/ripple-lib/commit/d09548d04d3238fca653d482ec1d5faa7254559a)
+
++ [Improve randomness when generating ECDSA signatures](https://github.com/ripple/ripple-lib/commit/fe7e30b737ead6e71adfa466f5835ba546feab31)
+
++ [Improve SerializedObject.append performance](https://github.com/ripple/ripple-lib/commit/f7c35b118ebba549a64bcaa1a0629385ec6dbf6f)
+
++ [Add `Amount.scale`. Multiply an amount’s value by a scale factor](https://github.com/ripple/ripple-lib/commit/74dac97b368493056474468520f05671f458a69f)
+
+
+##0.12.2
+
++ [Check that stack trace is available, fixes logging in browser](https://github.com/ripple/ripple-lib/commit/53cae3a66d48e88e8a6bbb96d6489ce7b9e22975)
+
+
 ##0.12.1
 
 **Breaking Changes**
@@ -19,10 +69,16 @@
 
 + [Add filename and line number to log, use log.warn() for deprecations](https://github.com/ripple/ripple-lib/commit/90329d3d73f1a76675063655b407513e32dc048b)
 
++ [Add GlobalFreeze and NoFreeze flags](https://github.com/ripple/ripple-lib/commit/e2ed2bdbf6f01c7d4d690c2cf0b83fba94558dd7)
+
 + [Fix handling of falsy parameters in requestLedger](https://github.com/ripple/ripple-lib/commit/6023efed41b7812b3bab660a1c0dc9f0a21000b9)
 
 + [Fix Base:decode](https://github.com/ripple/ripple-lib/commit/719f39c01c6941d9a650aa94f95617793dd53ea0)
 
++ [Fix Amount: clone in ratio_human, product_human](https://github.com/ripple/ripple-lib/commit/19e17a8431550cf156b1ad669a19dedfe4e28e4a)
+
++ [Fix Amount.to_human for very small numbers](https://github.com/ripple/ripple-lib/commit/6abfa759aa09d68074ac558d96c4b126a7cd1719)
+
 + [Refactor base conversion](https://github.com/ripple/ripple-lib/commit/f2b63fa4a80663eb29472bc6bb1aea8159f1f205)
 
 + [Update binary transaction format](https://github.com/ripple/ripple-lib/commit/8e134918fb4c22983320a3102f955e4568bb1dfb)
@@ -50,8 +106,8 @@
     - [Handle invalid input in parse_human - c8f18c8c](https://github.com/ripple/ripple-lib/commit/c8f18c8c8590b7b48e370e0325b6677b7720294f)
     - [Check for null in isNumber - b86790c8](https://github.com/ripple/ripple-lib/commit/b86790c8543c239a532fd7697d4652829019d385)
     - [Cleanup amount.js - d0fb291c](https://github.com/ripple/ripple-lib/commit/d0fb291c4e330193a244902156f1d74730da357d)
- 
- 
+
+
 **Changes**
 
 + [Add deprecation warnings to request constructors. The first argument to request constructor functions should be an object containing request properties](https://github.com/ripple/ripple-lib/commit/35d76b3520934285f80059c1badd6c522539104c)
@@ -66,13 +122,13 @@
 
 + [Bumped dependencies](https://github.com/ripple/ripple-lib/commit/f9bc7cc746b44b24b61bbe260ae2e9d9617286da)
 
- 
+
 
 ##0.11.0
 
 + [Track the funded status of an order based on cumulative account orders](https://github.com/ripple/ripple-lib/commit/67d39737a4d5e0fcd9d9b47b9083ee00e5a9e652) and [67d3973](https://github.com/ripple/ripple-lib/commit/b6b99dde022e1e14c4797e454b1d7fca50e49482)
 
-+ Remove blobvault client from ripple-lib, use the [`ripple-vault-client`](https://github.com/ripple/ripple-vault-client) instead [9b3d62b7](https://github.com/ripple/ripple-lib/commit/9b3d62b765c4c25beae6eb0fa57ef3a07f2581b1) 
++ Remove blobvault client from ripple-lib, use the [`ripple-vault-client`](https://github.com/ripple/ripple-vault-client) instead [9b3d62b7](https://github.com/ripple/ripple-lib/commit/9b3d62b765c4c25beae6eb0fa57ef3a07f2581b1)
 
 + [Add support for `ledger` option in requestBookOffers](https://github.com/ripple/ripple-lib/commit/34c0677c453c409ef0a5b351959abdc176d3bacb)
 
@@ -111,13 +167,13 @@ are locally determined to have expired: `tejMaxLedger`.
 + [Improve memo support](https://github.com/ripple/ripple-lib/commit/1704ac4ae144c0ce54afad86f644c75a632080b1)
     - Add `MemoFormat` property for memo
     - Enforce `MemoFormat` and `MemoType` to be valid ASCII
-    - Support `text` and `json` MemoFormat 
+    - Support `text` and `json` MemoFormat
 
 + [Update jscl library](https://github.com/ripple/ripple-lib/commit/3204998fcb6f31d6c90532a737a4adb8a1e420f6)
     - Improved entropy by taking advantage of platform crypto
     - Use jscl's k256 curve instead of altering the c256 curve with k256 configuration
     - **deprecated:** the c256 curve is linked to the k256 curve to provide backwards compatibility, this link will be removed in the future
-     
+
 + [Fix empty queue check on reconnect](https://github.com/ripple/ripple-lib/commit/3c21994adcf72d1fbd87d453ceb917f9ad6df4ec)
 
 ##0.9.4
@@ -146,7 +202,7 @@ are locally determined to have expired: `tejMaxLedger`.
 
 + [**Breaking change**: Change accountRequest method signature](https://github.com/ripple/ripple-lib/commit/6f5d1104aa3eb440c518ec4f39e264fdce15fa15)
 
-+ [Add paging behavior for account requests, `account_lines` and `account_offers`](https://github.com/ripple/ripple-lib/commit/722f4e175dbbf378e51b49142d0285f87acb22d7) 
++ [Add paging behavior for account requests, `account_lines` and `account_offers`](https://github.com/ripple/ripple-lib/commit/722f4e175dbbf378e51b49142d0285f87acb22d7)
 
 + [Add max_fee setter to transactions to set max fee the submitter is willing to pay] (https://github.com/ripple/ripple-lib/commit/24587fab9c8ad3840d7aa345a7037b48839e09d7)
 
@@ -162,7 +218,7 @@ var options = {
     ledger: < valid ledger_index or ledger_hash >
 }
 
-// The `marker` comes back in an account request if there are more results than are returned 
+// The `marker` comes back in an account request if there are more results than are returned
 // in the current response. The amount of results per response are determined by the `limit`.
 if (marker) {
     options.marker = < marker >;

bin/decode_binary.js

@@ -1,47 +1,52 @@
 #!/usr/bin/env node
+/* eslint-disable no-var */
+'use strict';
+var SerializedObject = require('..').SerializedObject;
 
-var SerializedObject = require('../src/js/ripple/serializedobject').SerializedObject;
+function main() {
+  var argv = process.argv.slice(2);
+  var blob = argv.shift();
 
-var argv = process.argv.slice(2);
-
-var blob;
-
-blob = argv.shift();
-
-if (blob === '-') {
-  read_input(ready);
-} else {
-  ready();
+  if (blob === '-') {
+    read_input(ready);
+  } else {
+    ready(blob);
+  }
 }
 
 function read_input(callback) {
-  tx_json = '';
-  process.stdin.on('data', function(data) { tx_json += data; });
+  var tx_json = '';
+  process.stdin.on('data', function(data) {
+    tx_json += data;
+  });
   process.stdin.on('end', callback);
   process.stdin.resume();
 }
 
-function ready() {
+function ready(blob) {
   var valid_arguments = blob;
 
   if (!valid_arguments) {
     console.error('Invalid arguments\n');
     print_usage();
   } else {
-      decode();
-    }
+    decode(blob);
+  }
 }
 
 function print_usage() {
+  /* eslint-disable max-len */
   console.log(
     'Usage: decode_binary.js <hex_blob>\n\n',
     'Example: decode_binary.js 120000240000000161D6871AFD498D00000000000000000000000000005553440000000000550FC62003E785DC231A1058A05E56E3F09CF4E668400000000000000A732102AE75B908F0A95F740A7BFA96057637E5C2170BC8DAD13B2F7B52AE75FAEBEFCF811450F97A072F1C4357F1AD84566A609479D927C9428314550FC62003E785DC231A1058A05E56E3F09CF4E6'
   );
-};
+  /* eslint-enable max-len */
+}
 
-function decode() {
-  buffer = new SerializedObject(blob);
+function decode(blob) {
+  var buffer = new SerializedObject(blob);
   console.log(buffer.to_json());
-};
+}
 
+main();
 // vim:sw=2:sts=2:ts=8:et

bin/rsign.js

@@ -1,62 +1,23 @@
 #!/usr/bin/env node
-
-var Transaction = require('../src/js/ripple/transaction').Transaction;
-
-var argv = process.argv.slice(2);
-
-var verbose;
-var secret;
-var tx_json;
-
-if (~argv.indexOf('-v')){
-  argv.splice(argv.indexOf('-v'), 1);
-  verbose = true;
-}
-
-secret  = argv.shift();
-tx_json = argv.shift();
-
-if (tx_json === '-') {
-  read_input(ready);
-} else {
-  ready();
-}
+/* eslint-disable no-var */
+'use strict';
+var Transaction = require('..').Transaction;
 
 function read_input(callback) {
-  tx_json = '';
-  process.stdin.on('data', function(data) { tx_json += data; });
-  process.stdin.on('end', callback);
+  var stdin = '';
+  process.stdin.on('data', function(data) {
+    stdin += data;
+  });
+  process.stdin.on('end', function() {
+    callback(stdin);
+  });
   process.stdin.resume();
 }
 
-function ready() {
-  var valid_arguments = secret && tx_json;
-
-  if (!valid_arguments) {
-    console.error('Invalid arguments\n');
-    print_usage();
-  } else {
-    var valid_json = true;
-
-    try {
-      tx_json = JSON.parse(tx_json);
-    } catch(exception) {
-      valid_json = false;
-    }
-
-    if (!valid_json) {
-      console.error('Invalid JSON\n');
-      print_usage();
-    } else {
-      sign_transaction();
-    }
-  }
-}
-
 function print_usage() {
   console.log(
     'Usage: rsign.js <secret> <json>\n\n',
-    'Example: rsign.js ssq55ueDob4yV3kPVnNQLHB6icwpC','\''+
+    'Example: rsign.js ssq55ueDob4yV3kPVnNQLHB6icwpC', '\'' +
     JSON.stringify({
       TransactionType: 'Payment',
       Account: 'r3P9vH81KBayazSTrQj6S25jW6kDb779Gi',
@@ -64,14 +25,14 @@ function print_usage() {
       Amount: '200000000',
       Fee: '10',
       Sequence: 1
-    })+'\''
-    );
-};
+    }) + '\''
+  );
+}
 
-function sign_transaction() {
+function sign_transaction(tx_json_object, secret, verbose) {
   var tx = new Transaction();
 
-  tx.tx_json = tx_json;
+  tx.tx_json = tx_json_object;
   tx._secret = secret;
   tx.complete();
 
@@ -81,16 +42,56 @@ function sign_transaction() {
 
   if (verbose) {
     var sim = { };
-
-    sim.tx_blob         = tx.serialize().to_hex();
-    sim.tx_json         = tx.tx_json;
+    sim.tx_blob = tx.serialize().to_hex();
+    sim.tx_json = tx.tx_json;
     sim.tx_signing_hash = unsigned_hash;
-    sim.tx_unsigned     = unsigned_blob;
-
+    sim.tx_unsigned = unsigned_blob;
     console.log(JSON.stringify(sim, null, 2));
   } else {
     console.log(tx.serialize().to_hex());
   }
-};
+}
 
+function ready(tx_json, secret, verbose) {
+  if (!(tx_json && secret)) {
+    console.error('Invalid arguments\n');
+    print_usage();
+    return;
+  }
+
+  var tx_json_object;
+  try {
+    tx_json_object = JSON.parse(tx_json);
+  } catch(exception) {
+    console.error('Invalid JSON\n');
+    print_usage();
+    return;
+  }
+  sign_transaction(tx_json_object, secret, verbose);
+}
+
+function main() {
+  var argv = process.argv.slice(2);
+  var verbose;
+  var secret;
+  var tx_json;
+
+  if (~argv.indexOf('-v')) {
+    argv.splice(argv.indexOf('-v'), 1);
+    verbose = true;
+  }
+
+  secret = argv.shift();
+  tx_json = argv.shift();
+
+  if (tx_json === '-') {
+    read_input(function(stdin) {
+      ready(stdin, secret, verbose);
+    });
+  } else {
+    ready(tx_json, secret, verbose);
+  }
+}
+
+main();
 // vim:sw=2:sts=2:ts=8:et

bin/validate_address.js

@@ -1,12 +1,16 @@
 #!/usr/bin/env node
+/* eslint-disable no-var */
+'use strict';
+var UInt160 = require('..').UInt160;
 
-var UInt160 = require('../').UInt160;
-var address = process.argv[2];
+function main() {
+  var address = process.argv[2];
 
-if (address === '-') {
-  readInput(validateAddress);
-} else {
-  validateAddress(address);
+  if (address === '-') {
+    readInput(validateAddress);
+  } else {
+    validateAddress(address);
+  }
 }
 
 function readInput(callback) {
@@ -19,8 +23,10 @@ function readInput(callback) {
   process.stdin.on('end', function() {
     callback(result);
   });
-};
+}
 
 function validateAddress(address) {
   process.stdout.write((UInt160.is_valid(address.trim()) ? '0' : '1') + '\r\n');
-};
+}
+
+main();

deploy/start rippled.bat

@@ -1,3 +0,0 @@
-start newcoin
-sleep 4
-start index.html

docs/GUIDES.md

@@ -18,7 +18,7 @@ This file provides step-by-step walkthroughs for some of the most common usages
 
 ##Connecting to the Ripple network
 
-1. [Get ripple-lib](README.md#getting-ripple-lib)
+1. [Get ripple-lib](../README.md#installation)
 2. Load the ripple-lib module into a Node.js file or webpage:
   ```js
   /* Loading ripple-lib with Node.js */
@@ -37,7 +37,7 @@ This file provides step-by-step walkthroughs for some of the most common usages
     servers: [
       { host: 's-west.ripple.com', port: 443, secure: true }
     ]
-  }
+  };
 
   var remote = new Remote(options);
 

npm-shrinkwrap.json

@@ -1,181 +1,84 @@
 {
   "name": "ripple-lib",
-  "version": "0.12.1-rc4",
+  "version": "0.12.6",
+  "npm-shrinkwrap-version": "5.4.0",
+  "node-version": "v0.12.6",
   "dependencies": {
     "async": {
-      "version": "0.9.0",
-      "from": "async@>=0.9.0 <0.10.0",
-      "resolved": "https://registry.npmjs.org/async/-/async-0.9.0.tgz"
+      "version": "0.9.2",
+      "resolved": "https://registry.npmjs.org/async/-/async-0.9.2.tgz"
     },
-    "bignumber.js": {
-      "version": "2.0.3",
-      "from": "bignumber.js@>=2.0.3 <3.0.0",
-      "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-2.0.3.tgz"
-    },
-    "extend": {
-      "version": "1.2.1",
-      "from": "extend@>=1.2.1 <1.3.0",
-      "resolved": "https://registry.npmjs.org/extend/-/extend-1.2.1.tgz"
-    },
-    "lodash": {
-      "version": "3.5.0",
-      "from": "lodash@>=3.1.0 <4.0.0",
-      "resolved": "https://registry.npmjs.org/lodash/-/lodash-3.5.0.tgz"
-    },
-    "lru-cache": {
-      "version": "2.5.0",
-      "from": "lru-cache@>=2.5.0 <2.6.0",
-      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-2.5.0.tgz"
-    },
-    "ripple-wallet-generator": {
-      "version": "1.0.2",
-      "from": "ripple-wallet-generator@1.0.2",
-      "resolved": "https://registry.npmjs.org/ripple-wallet-generator/-/ripple-wallet-generator-1.0.2.tgz"
-    },
-    "superagent": {
-      "version": "0.18.2",
-      "from": "superagent@>=0.18.0 <0.19.0",
-      "resolved": "https://registry.npmjs.org/superagent/-/superagent-0.18.2.tgz",
+    "babel-runtime": {
+      "version": "5.8.3",
+      "resolved": "https://registry.npmjs.org/babel-runtime/-/babel-runtime-5.8.3.tgz",
       "dependencies": {
-        "qs": {
-          "version": "0.6.6",
-          "from": "qs@0.6.6",
-          "resolved": "https://registry.npmjs.org/qs/-/qs-0.6.6.tgz"
-        },
-        "formidable": {
-          "version": "1.0.14",
-          "from": "formidable@1.0.14",
-          "resolved": "https://registry.npmjs.org/formidable/-/formidable-1.0.14.tgz"
-        },
-        "mime": {
-          "version": "1.2.11",
-          "from": "mime@1.2.11",
-          "resolved": "https://registry.npmjs.org/mime/-/mime-1.2.11.tgz"
-        },
-        "component-emitter": {
-          "version": "1.1.2",
-          "from": "component-emitter@1.1.2",
-          "resolved": "https://registry.npmjs.org/component-emitter/-/component-emitter-1.1.2.tgz"
-        },
-        "methods": {
-          "version": "1.0.1",
-          "from": "methods@1.0.1",
-          "resolved": "https://registry.npmjs.org/methods/-/methods-1.0.1.tgz"
-        },
-        "cookiejar": {
-          "version": "2.0.1",
-          "from": "cookiejar@2.0.1",
-          "resolved": "https://registry.npmjs.org/cookiejar/-/cookiejar-2.0.1.tgz"
-        },
-        "debug": {
-          "version": "1.0.4",
-          "from": "debug@>=1.0.1 <1.1.0",
-          "resolved": "https://registry.npmjs.org/debug/-/debug-1.0.4.tgz",
-          "dependencies": {
-            "ms": {
-              "version": "0.6.2",
-              "from": "ms@0.6.2",
-              "resolved": "https://registry.npmjs.org/ms/-/ms-0.6.2.tgz"
-            }
-          }
-        },
-        "reduce-component": {
-          "version": "1.0.1",
-          "from": "reduce-component@1.0.1",
-          "resolved": "https://registry.npmjs.org/reduce-component/-/reduce-component-1.0.1.tgz"
-        },
-        "form-data": {
-          "version": "0.1.3",
-          "from": "form-data@0.1.3",
-          "resolved": "https://registry.npmjs.org/form-data/-/form-data-0.1.3.tgz",
-          "dependencies": {
-            "combined-stream": {
-              "version": "0.0.7",
-              "from": "combined-stream@>=0.0.4 <0.1.0",
-              "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-0.0.7.tgz",
-              "dependencies": {
-                "delayed-stream": {
-                  "version": "0.0.5",
-                  "from": "delayed-stream@0.0.5",
-                  "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-0.0.5.tgz"
-                }
-              }
-            }
-          }
-        },
-        "readable-stream": {
-          "version": "1.0.27-1",
-          "from": "readable-stream@1.0.27-1",
-          "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-1.0.27-1.tgz",
-          "dependencies": {
-            "core-util-is": {
-              "version": "1.0.1",
-              "from": "core-util-is@>=1.0.0 <1.1.0",
-              "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.1.tgz"
-            },
-            "isarray": {
-              "version": "0.0.1",
-              "from": "isarray@0.0.1",
-              "resolved": "https://registry.npmjs.org/isarray/-/isarray-0.0.1.tgz"
-            },
-            "string_decoder": {
-              "version": "0.10.31",
-              "from": "string_decoder@>=0.10.0 <0.11.0",
-              "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-0.10.31.tgz"
-            },
-            "inherits": {
-              "version": "2.0.1",
-              "from": "inherits@>=2.0.1 <2.1.0",
-              "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.1.tgz"
-            }
-          }
+        "core-js": {
+          "version": "0.9.18",
+          "resolved": "https://registry.npmjs.org/core-js/-/core-js-0.9.18.tgz"
         }
       }
     },
+    "bignumber.js": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/bignumber.js/-/bignumber.js-2.0.7.tgz"
+    },
+    "extend": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/extend/-/extend-1.2.1.tgz"
+    },
+    "lodash": {
+      "version": "3.10.0",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-3.10.0.tgz"
+    },
+    "lru-cache": {
+      "version": "2.5.2",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-2.5.2.tgz"
+    },
+    "ripple-wallet-generator": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/ripple-wallet-generator/-/ripple-wallet-generator-1.0.3.tgz"
+    },
+    "sjcl": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/sjcl/-/sjcl-1.0.3.tgz"
+    },
     "ws": {
-      "version": "0.7.1",
-      "from": "ws@>=0.7.1 <0.8.0",
-      "resolved": "https://registry.npmjs.org/ws/-/ws-0.7.1.tgz",
+      "version": "0.7.2",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-0.7.2.tgz",
       "dependencies": {
-        "options": {
-          "version": "0.0.6",
-          "from": "options@>=0.0.5",
-          "resolved": "https://registry.npmjs.org/options/-/options-0.0.6.tgz"
-        },
-        "ultron": {
-          "version": "1.0.1",
-          "from": "ultron@>=1.0.0 <1.1.0",
-          "resolved": "https://registry.npmjs.org/ultron/-/ultron-1.0.1.tgz"
-        },
         "bufferutil": {
-          "version": "1.0.1",
-          "from": "bufferutil@>=1.0.0 <1.1.0",
-          "resolved": "https://registry.npmjs.org/bufferutil/-/bufferutil-1.0.1.tgz",
+          "version": "1.1.0",
+          "resolved": "https://registry.npmjs.org/bufferutil/-/bufferutil-1.1.0.tgz",
           "dependencies": {
             "bindings": {
               "version": "1.2.1",
-              "from": "bindings@>=1.2.0 <1.3.0"
+              "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.2.1.tgz"
             },
             "nan": {
-              "version": "1.6.2",
-              "from": "nan@>=1.6.0 <1.7.0",
-              "resolved": "https://registry.npmjs.org/nan/-/nan-1.6.2.tgz"
+              "version": "1.8.4",
+              "resolved": "https://registry.npmjs.org/nan/-/nan-1.8.4.tgz"
             }
           }
         },
+        "options": {
+          "version": "0.0.6",
+          "resolved": "https://registry.npmjs.org/options/-/options-0.0.6.tgz"
+        },
+        "ultron": {
+          "version": "1.0.2",
+          "resolved": "https://registry.npmjs.org/ultron/-/ultron-1.0.2.tgz"
+        },
         "utf-8-validate": {
-          "version": "1.0.1",
-          "from": "utf-8-validate@>=1.0.0 <1.1.0",
-          "resolved": "https://registry.npmjs.org/utf-8-validate/-/utf-8-validate-1.0.1.tgz",
+          "version": "1.1.0",
+          "resolved": "https://registry.npmjs.org/utf-8-validate/-/utf-8-validate-1.1.0.tgz",
           "dependencies": {
             "bindings": {
               "version": "1.2.1",
-              "from": "bindings@>=1.2.0 <1.3.0"
+              "resolved": "https://registry.npmjs.org/bindings/-/bindings-1.2.1.tgz"
             },
             "nan": {
-              "version": "1.6.2",
-              "from": "nan@>=1.6.0 <1.7.0",
-              "resolved": "https://registry.npmjs.org/nan/-/nan-1.6.2.tgz"
+              "version": "1.8.4",
+              "resolved": "https://registry.npmjs.org/nan/-/nan-1.8.4.tgz"
             }
           }
         }

package.json

@@ -1,37 +1,39 @@
 {
   "name": "ripple-lib",
-  "version": "0.12.1-rc4",
+  "version": "0.12.6",
   "description": "A JavaScript API for interacting with Ripple in Node.js and the browser",
   "files": [
-    "src/js/*",
+    "dist/npm/*",
     "bin/*",
     "build/*",
     "test/*",
-    "Makefile",
     "Gulpfile.js"
   ],
-  "main": "src/js/ripple",
+  "main": "dist/npm/",
   "directories": {
     "test": "test"
   },
   "dependencies": {
     "async": "~0.9.0",
+    "babel-runtime": "^5.3.2",
     "bignumber.js": "^2.0.3",
     "extend": "~1.2.1",
     "lodash": "^3.1.0",
     "lru-cache": "~2.5.0",
-    "ripple-wallet-generator": "1.0.2",
-    "ws": "~0.7.1",
-    "superagent": "^0.18.0"
+    "ripple-wallet-generator": "^1.0.3",
+    "sjcl": "^1.0.3",
+    "ws": "~0.7.1"
   },
   "devDependencies": {
     "assert-diff": "^1.0.1",
+    "babel": "^5.3.3",
+    "babel-core": "^5.3.2",
+    "babel-loader": "^5.0.0",
     "coveralls": "~2.10.0",
-    "eslint": "^0.13.0",
+    "eslint": "^0.18.0",
     "gulp": "~3.8.10",
     "gulp-bump": "~0.1.13",
     "gulp-clean-dest": "^0.1.0",
-    "gulp-concat": "~2.4.3",
     "gulp-filelog": "^0.4.1",
     "gulp-flowtype": "^0.4.1",
     "gulp-plumber": "^0.6.6",
@@ -48,11 +50,14 @@
     "yargs": "~1.3.1"
   },
   "scripts": {
-    "build": "node_modules/.bin/gulp",
-    "pretest": "node_modules/.bin/gulp concat-sjcl",
-    "test": "./node_modules/.bin/istanbul test -x build/sjcl.js -x src/js/jsbn/* ./node_modules/mocha/bin/_mocha -- --reporter ${MOCHA_REPORTER:=spec} test/*-test.js",
-    "coveralls": "cat ./coverage/lcov.info | ./node_modules/.bin/coveralls",
-    "lint": "if ! [ -f eslintrc ]; then curl -o eslintrc 'https://raw.githubusercontent.com/ripple/javascript-style-guide/master/eslintrc'; fi; eslint --reset -c eslintrc src/js/ripple/*.js",
+    "build": "gulp",
+    "compile": "babel -i runtime -d dist/npm/ src/",
+    "compile-with-source-maps": "babel -i runtime -s -t -d dist/npm/ src/",
+    "prepublish": "npm run compile",
+    "postinstall": "cd node_modules/sjcl; ./configure --with-all --compress=none; make",
+    "test": "istanbul test _mocha",
+    "coveralls": "cat ./coverage/lcov.info | coveralls",
+    "lint": "if ! [ -f eslintrc ]; then curl -o eslintrc 'https://raw.githubusercontent.com/ripple/javascript-style-guide/es6/eslintrc'; fi; eslint --reset -c eslintrc src/*.js",
     "perf": "./scripts/perf_test.sh"
   },
   "repository": {

scripts/perf_test.sh

@@ -8,4 +8,4 @@ then
   mkdir -p "$DIR/cache"
   curl -L "$URL" > "$DEST"
 fi
-time node "$DIR/verify_ledger_json.js" "$DEST"
+npm run compile && time node "$DIR/verify_ledger_json.js" "$DEST"

scripts/publish

@@ -17,15 +17,15 @@ echo "publish to npm"
 npm publish
 exit_on_error
 
-rm -rf dist
+rm -rf dist/bower
 echo ""
 echo "publish to bower"
 
-git clone git@github.com:ripple/bower-ripple.git dist
+git clone git@github.com:ripple/bower-ripple.git dist/bower
 gulp bower
 exit_on_error
 
-cd dist
+cd dist/bower
 version=$(cat bower.json | grep -Eo '([0-9]\.?)+(-rc[0-9])?')
 echo "version: $version"
 git add ripple.js ripple-debug.js ripple-min.js bower.json
@@ -40,4 +40,4 @@ exit_on_error
 git push origin master
 git push --tags origin master
 
-cd ..
+cd ..

scripts/publish_rc

@@ -17,15 +17,15 @@ echo "publish rc to npm"
 npm publish --tag beta
 exit_on_error
 
-rm -rf dist
+rm -rf dist/bower
 echo ""
 echo "publish to bower"
 
-git clone git@github.com:ripple/bower-ripple.git dist
+git clone git@github.com:ripple/bower-ripple.git dist/bower
 gulp bower
 exit_on_error
 
-cd dist
+cd dist/bower
 version=$(cat bower.json | grep -Eo '([0-9]\.?)+(-rc[0-9])?')
 echo "version: $version"
 git add ripple.js ripple-debug.js ripple-min.js bower.json
@@ -40,4 +40,4 @@ exit_on_error
 git push origin master
 git push --tags origin master
 
-cd ..
+cd ..

scripts/publish_to_bower

@@ -1,7 +1,7 @@
-rm -rf dist
-git clone git@github.com:ripple/bower-ripple.git dist
+rm -rf dist/bower
+git clone git@github.com:ripple/bower-ripple.git dist/bower
 gulp bower
-cd dist
+cd dist/bower
 version=$(cat bower.json | grep -Eo '([0-9]\.?)+(-rc[0-9])?')
 echo "version: $version"
 git add ripple.js ripple-debug.js ripple-min.js bower.json
@@ -9,4 +9,4 @@ git commit -m "[TASK] add v$version"
 git tag "v$version"
 git push origin master
 git push --tags origin master
-cd ..
+cd ..

scripts/verify_ledger_json.js

@@ -1,31 +1,35 @@
+/* eslint-disable no-var */
+'use strict';
+
 var fs = require('fs');
-var Ledger = require('../src/js/ripple/ledger').Ledger;
+var Amount = require('../dist/npm').Amount;
+var Ledger = require('../dist/npm/ledger').Ledger;
 
 function parse_options(from, flags) {
   var argv = from.slice(),
-      opts = {argv:argv};
+      opts_ = {argv: argv};
 
   flags.forEach(function(f) {
     // Do we have the flag?
     var flag_index = argv.indexOf('--' + f);
     // normalize the name of the flag
-    f = f.replace('-', '_');
-    // opts has Boolean value for normalized flag key
-    opts[f] = !!~flag_index;
-    if (opts[f]) {
+    var flag = f.replace('-', '_');
+    // opts_ has Boolean value for normalized flag key
+    opts_[flag] = flag_index !== -1;
+    if (opts_[flag]) {
       // remove the flag from the argv
       argv.splice(flag_index, 1);
     }
   });
-  return opts;
+  return opts_;
 }
 
 var opts = parse_options(process.argv.slice(2), // remove `node` and `this.js`
                         ['sanity-test']);
 
 if (opts.argv.length < 1) {
-  console.error("Usage: scripts/verify_ledger_json path/to/ledger.json");
-  console.error("       optional: --sanity-test (json>binary>json>binary)");
+  console.error('Usage: scripts/verify_ledger_json path/to/ledger.json');
+  console.error('       optional: --sanity-test (json>binary>json>binary)');
   process.exit(1);
 }
 
@@ -36,14 +40,27 @@ var ledger = Ledger.from_json(JSON.parse(json));
 // before finally serializing for hashing. This is mostly to expose any issues
 // with ripple-libs binary <--> json codecs.
 if (opts.sanity_test) {
-    console.log("All accountState nodes will be processed from " +
-                "json->binary->json->binary. This may take some time " +
-                "with large ledgers.");
+  console.log('All accountState nodes will be processed from ' +
+              'json->binary->json->binary. This may take some time ' +
+              'with large ledgers.');
 }
 
-console.log("Transaction hash in header:    " + ledger.ledger_json.transaction_hash);
-console.log("Calculated transaction hash:   " + ledger.calc_tx_hash().to_hex());
-console.log("Account state hash in header:  " + ledger.ledger_json.account_hash);
-console.log("Calculated account state hash: " + ledger.calc_account_hash(
-                                                 {sanity_test:opts.sanity_test})
-                                                   .to_hex());
+// To recompute the hashes of some ledgers, we must allow values that slipped in
+// before strong policies were in place.
+Amount.strict_mode = false;
+
+console.log('Transaction hash in header:    ' +
+             ledger.ledger_json.transaction_hash);
+console.log('Calculated transaction hash:   ' +
+             ledger.calc_tx_hash().to_hex());
+
+console.log('Account state hash in header:  ' +
+             ledger.ledger_json.account_hash);
+
+if (ledger.ledger_json.accountState) {
+  console.log('Calculated account state hash: ' +
+               ledger.calc_account_hash({sanity_test: opts.sanity_test})
+                                                      .to_hex());
+} else {
+  console.log('Ledger has no accountState');
+}

src/amount.js

@@ -1,4 +1,4 @@
- 'use strict';
+'use strict';
 
 // Represent Ripple amounts and currencies.
 // - Numbers in hex are big-endian.
@@ -156,6 +156,10 @@ Amount.prototype.multiply = function(multiplicand) {
   return this._copy(this._value.times(multiplyBy));
 };
 
+Amount.prototype.scale = function(scaleFactor) {
+  return this._copy(this._value.times(scaleFactor));
+};
+
 Amount.prototype.divide = function(divisor) {
   var divisorAmount = Amount.from_json(divisor);
   if (!this.is_valid()) {
@@ -197,9 +201,7 @@ Amount.prototype.divide = function(divisor) {
 Amount.prototype.ratio_human = function(denominator, opts) {
   opts = extend({ }, opts);
 
-  /*eslint-disable consistent-this */
-  var numerator = this;
-  /*eslint-enable consistent-this */
+  var numerator = this.clone();
 
   denominator = Amount.from_json(denominator);
 
@@ -844,7 +846,7 @@ Amount.prototype.to_human = function(opts) {
   }
 
   var isNegative = ref._value.isNegative();
-  var valueString = ref._value.abs().toString();
+  var valueString = ref._value.abs().toFixed();
   var parts = valueString.split('.');
   var int_part = parts[0];
   var fraction_part = parts.length === 2 ? parts[1] : '';

src/autobridgecalculator.js

@@ -0,0 +1,437 @@
+'use strict';
+
+const _ = require('lodash');
+const assert = require('assert');
+const UInt160 = require('./uint160').UInt160;
+const Amount = require('./amount').Amount;
+const Utils = require('./orderbookutils');
+
+function assertValidNumber(number, message) {
+  assert(!_.isNull(number) && !isNaN(number), message);
+}
+
+function assertValidLegOneOffer(legOneOffer, message) {
+  assert(legOneOffer);
+  assert.strictEqual(typeof legOneOffer, 'object', message);
+  assert.strictEqual(typeof legOneOffer.TakerPays, 'object', message);
+  assertValidNumber(legOneOffer.TakerGets, message);
+}
+
+function AutobridgeCalculator(currencyGets, currencyPays,
+  legOneOffers, legTwoOffers, issuerGets, issuerPays) {
+  this._currencyGets = currencyGets;
+  this._currencyPays = currencyPays;
+  this._issuerGets = issuerGets;
+  this._issuerPays = issuerPays;
+  this.legOneOffers = _.cloneDeep(legOneOffers);
+  this.legTwoOffers = _.cloneDeep(legTwoOffers);
+
+  this._ownerFundsLeftover = {};
+}
+
+/**
+ * Calculates an ordered array of autobridged offers by quality
+ *
+ * @return {Array}
+ */
+
+AutobridgeCalculator.prototype.calculate = function() {
+  let legOnePointer = 0;
+  let legTwoPointer = 0;
+
+  let offersAutobridged = [];
+
+  this.clearOwnerFundsLeftover();
+
+  while (this.legOneOffers[legOnePointer] && this.legTwoOffers[legTwoPointer]) {
+    const legOneOffer = this.legOneOffers[legOnePointer];
+    const legTwoOffer = this.legTwoOffers[legTwoPointer];
+    const leftoverFunds = this.getLeftoverOwnerFunds(legOneOffer.Account);
+    let autobridgedOffer;
+
+    if (legOneOffer.Account === legTwoOffer.Account) {
+      this.unclampLegOneOwnerFunds(legOneOffer);
+    } else if (!legOneOffer.is_fully_funded && !leftoverFunds.is_zero()) {
+      this.adjustLegOneFundedAmount(legOneOffer);
+    }
+
+    const legOneTakerGetsFunded = Utils.getOfferTakerGetsFunded(legOneOffer);
+    const legTwoTakerPaysFunded = Utils.getOfferTakerPaysFunded(legTwoOffer);
+
+    if (legOneTakerGetsFunded.is_zero()) {
+      legOnePointer++;
+
+      continue;
+    }
+
+    if (legTwoTakerPaysFunded.is_zero()) {
+      legTwoPointer++;
+
+      continue;
+    }
+
+    if (legOneTakerGetsFunded.compareTo(legTwoTakerPaysFunded) > 0) {
+      autobridgedOffer = this.getAutobridgedOfferWithClampedLegOne(
+        legOneOffer,
+        legTwoOffer
+      );
+
+      legTwoPointer++;
+    } else if (legTwoTakerPaysFunded.compareTo(legOneTakerGetsFunded) > 0) {
+      autobridgedOffer = this.getAutobridgedOfferWithClampedLegTwo(
+        legOneOffer,
+        legTwoOffer
+      );
+
+      legOnePointer++;
+    } else {
+      autobridgedOffer = this.getAutobridgedOfferWithoutClamps(
+        legOneOffer,
+        legTwoOffer
+      );
+
+      legOnePointer++;
+      legTwoPointer++;
+    }
+
+    offersAutobridged.push(autobridgedOffer);
+  }
+
+  return offersAutobridged;
+};
+
+/**
+ * In this case, the output from leg one is greater than the input to leg two.
+ * Therefore, we must effectively clamp leg one output to leg two input.
+ *
+ * @param {Object} legOneOffer
+ * @param {Object} legTwoOffer
+ *
+ * @return {Object}
+ */
+
+AutobridgeCalculator.prototype.getAutobridgedOfferWithClampedLegOne =
+function(legOneOffer, legTwoOffer) {
+  const legOneTakerGetsFunded = Utils.getOfferTakerGetsFunded(legOneOffer);
+  const legTwoTakerPaysFunded = Utils.getOfferTakerPaysFunded(legTwoOffer);
+  const legOneQuality = Utils.getOfferQuality(legOneOffer, this._currencyGets);
+
+  const autobridgedTakerGets = Utils.getOfferTakerGetsFunded(legTwoOffer);
+  const autobridgedTakerPays = legTwoTakerPaysFunded.multiply(legOneQuality);
+
+  if (legOneOffer.Account === legTwoOffer.Account) {
+    const legOneTakerGets = Utils.getOfferTakerGets(legOneOffer);
+    const updatedTakerGets = legOneTakerGets.subtract(legTwoTakerPaysFunded);
+
+    this.setLegOneTakerGets(legOneOffer, updatedTakerGets);
+
+    this.clampLegOneOwnerFunds(legOneOffer);
+  } else {
+    // Update funded amount since leg one offer was not completely consumed
+    const updatedTakerGetsFunded = legOneTakerGetsFunded
+      .subtract(legTwoTakerPaysFunded);
+
+    this.setLegOneTakerGetsFunded(legOneOffer, updatedTakerGetsFunded);
+  }
+
+  return this.formatAutobridgedOffer(
+    autobridgedTakerGets,
+    autobridgedTakerPays
+  );
+};
+
+/**
+ * In this case, the input from leg two is greater than the output to leg one.
+ * Therefore, we must effectively clamp leg two input to leg one output.
+ *
+ * @param {Object} legOneOffer
+ * @param {Object} legTwoOffer
+ *
+ * @return {Object}
+ */
+
+AutobridgeCalculator.prototype.getAutobridgedOfferWithClampedLegTwo =
+function(legOneOffer, legTwoOffer) {
+  const legOneTakerGetsFunded = Utils.getOfferTakerGetsFunded(legOneOffer);
+  const legTwoTakerPaysFunded = Utils.getOfferTakerPaysFunded(legTwoOffer);
+  const legTwoQuality = Utils.getOfferQuality(legTwoOffer, this._currencyGets);
+
+  const autobridgedTakerGets = legOneTakerGetsFunded.divide(legTwoQuality);
+  const autobridgedTakerPays = Utils.getOfferTakerPaysFunded(legOneOffer);
+
+  // Update funded amount since leg two offer was not completely consumed
+  legTwoOffer.taker_gets_funded = Utils.getOfferTakerGetsFunded(legTwoOffer)
+    .subtract(autobridgedTakerGets)
+    .to_text();
+  legTwoOffer.taker_pays_funded = legTwoTakerPaysFunded
+    .subtract(legOneTakerGetsFunded)
+    .to_text();
+
+  return this.formatAutobridgedOffer(
+    autobridgedTakerGets,
+    autobridgedTakerPays
+  );
+};
+
+/**
+ * In this case, the output from leg one and the input to leg two are the same.
+ * We do not need to clamp either.
+ * @param {Object} legOneOffer
+ * @param {Object} legTwoOffer
+ *
+ * @return {Object}
+ */
+
+AutobridgeCalculator.prototype.getAutobridgedOfferWithoutClamps =
+function(legOneOffer, legTwoOffer) {
+  const autobridgedTakerGets = Utils.getOfferTakerGetsFunded(legTwoOffer);
+  const autobridgedTakerPays = Utils.getOfferTakerPaysFunded(legOneOffer);
+
+  return this.formatAutobridgedOffer(
+    autobridgedTakerGets,
+    autobridgedTakerPays
+  );
+};
+
+/**
+ * Clear owner funds leftovers
+ */
+
+AutobridgeCalculator.prototype.clearOwnerFundsLeftover = function() {
+  this._ownerFundsLeftover = {};
+};
+
+/**
+ * Reset owner funds leftovers for an account to 0
+ *
+ * @param {String} account
+ *
+ * @return {Amount}
+ */
+
+AutobridgeCalculator.prototype.resetOwnerFundsLeftover = function(account) {
+  assert(UInt160.is_valid(account), 'Account is invalid');
+
+  this._ownerFundsLeftover[account] = Utils.normalizeAmount('0');
+
+  return this._ownerFundsLeftover[account];
+};
+
+/**
+ * Retrieve leftover funds found after clamping leg one by account
+ *
+ * @param {String} account
+ *
+ * @return {Amount}
+ */
+
+AutobridgeCalculator.prototype.getLeftoverOwnerFunds = function(account) {
+  assert(UInt160.is_valid(account), 'Account is invalid');
+
+  let amount = this._ownerFundsLeftover[account];
+
+  if (!amount) {
+    amount = Utils.normalizeAmount('0');
+  }
+
+  return amount;
+};
+
+/**
+ * Add funds to account's leftover funds
+ *
+ * @param {String} account
+ * @param {Amount} amount
+ *
+ * @return {Amount}
+ */
+
+AutobridgeCalculator.prototype.addLeftoverOwnerFunds =
+function(account, amount) {
+  assert(UInt160.is_valid(account), 'Account is invalid');
+  assert(amount instanceof Amount, 'Amount is invalid');
+
+  this._ownerFundsLeftover[account] = this.getLeftoverOwnerFunds(account)
+    .add(amount);
+
+  return this._ownerFundsLeftover[account];
+};
+
+/**
+ * Set account's leftover funds
+ *
+ * @param {String} account
+ * @param {Amount} amount
+ */
+
+AutobridgeCalculator.prototype.setLeftoverOwnerFunds =
+function(account, amount) {
+  assert(UInt160.is_valid(account), 'Account is invalid');
+  assert(amount instanceof Amount, 'Amount is invalid');
+
+  this._ownerFundsLeftover[account] = amount;
+};
+
+/**
+ * Format an autobridged offer and compute synthetic values (e.g. quality)
+ *
+ * @param {Amount} takerGets
+ * @param {Amount} takerPays
+ *
+ * @return {Object}
+ */
+
+AutobridgeCalculator.prototype.formatAutobridgedOffer =
+function(takerGets, takerPays) {
+  assert(takerGets instanceof Amount, 'Autobridged taker gets is invalid');
+  assert(takerPays instanceof Amount, 'Autobridged taker pays is invalid');
+
+  const autobridgedOffer = {};
+  const quality = takerPays.divide(takerGets);
+
+  autobridgedOffer.TakerGets = {
+    value: takerGets.to_text(),
+    currency: this._currencyGets.to_hex(),
+    issuer: this._issuerGets
+  };
+
+  autobridgedOffer.TakerPays = {
+    value: takerPays.to_text(),
+    currency: this._currencyPays.to_hex(),
+    issuer: this._issuerPays
+  };
+
+  autobridgedOffer.quality = quality.to_text();
+
+  autobridgedOffer.taker_gets_funded = autobridgedOffer.TakerGets.value;
+  autobridgedOffer.taker_pays_funded = autobridgedOffer.TakerPays.value;
+
+  autobridgedOffer.autobridged = true;
+
+  autobridgedOffer.BookDirectory = Utils.convertOfferQualityToHex(quality);
+
+  return autobridgedOffer;
+};
+
+/**
+ * Remove funds clamp on leg one offer. This is necessary when the two offers
+ * are owned by the same account. In this case, it doesn't matter if offer one
+ * is not fully funded. Leg one out goes to leg two in and since its the same
+ * account, an infinite amount can flow.
+ *
+ * @param {Object} legOneOffer - IOU:XRP offer
+ */
+
+AutobridgeCalculator.prototype.unclampLegOneOwnerFunds = function(legOneOffer) {
+  assertValidLegOneOffer(legOneOffer, 'Leg one offer is invalid');
+
+  legOneOffer.initTakerGetsFunded = Utils.getOfferTakerGetsFunded(legOneOffer);
+
+  this.setLegOneTakerGetsFunded(
+    legOneOffer,
+    Utils.getOfferTakerGets(legOneOffer)
+  );
+};
+
+/**
+ * Apply clamp back on leg one offer after a round of autobridge calculation
+ * completes. We must reapply clamps that have been removed because we cannot
+ * guarantee that the next offer from leg two will also be from the same
+ * account.
+ *
+ * When we reapply, it could happen that the amount of TakerGets left after
+ * the autobridge calculation is less than the original funded amount. In this
+ * case, we have extra funds we can use towards unfunded offers with worse
+ * quality by the same owner.
+ *
+ * @param {Object} legOneOffer - IOU:XRP offer
+ */
+
+AutobridgeCalculator.prototype.clampLegOneOwnerFunds = function(legOneOffer) {
+  assertValidLegOneOffer(legOneOffer, 'Leg one offer is invalid');
+
+  const takerGets = Utils.getOfferTakerGets(legOneOffer);
+
+  if (takerGets.compareTo(legOneOffer.initTakerGetsFunded) > 0) {
+    // After clamping, TakerGets is still greater than initial funded amount
+    this.setLegOneTakerGetsFunded(legOneOffer, legOneOffer.initTakerGetsFunded);
+  } else {
+    const updatedLeftover = legOneOffer.initTakerGetsFunded.subtract(takerGets);
+
+    this.setLegOneTakerGetsFunded(legOneOffer, takerGets);
+    this.addLeftoverOwnerFunds(legOneOffer.Account, updatedLeftover);
+  }
+};
+
+/**
+ * Increase leg one offer funded amount with extra funds found after applying
+ * clamp.
+ *
+ * @param {Object} legOneOffer - IOU:XRP offer
+ */
+
+AutobridgeCalculator.prototype.adjustLegOneFundedAmount =
+function(legOneOffer) {
+  assertValidLegOneOffer(legOneOffer, 'Leg one offer is invalid');
+  assert(!legOneOffer.is_fully_funded, 'Leg one offer cannot be fully funded');
+
+  const fundedSum = Utils.getOfferTakerGetsFunded(legOneOffer)
+    .add(this.getLeftoverOwnerFunds(legOneOffer.Account));
+
+  if (fundedSum.compareTo(Utils.getOfferTakerGets(legOneOffer)) >= 0) {
+    // There are enough extra funds to fully fund the offer
+    const legOneTakerGets = Utils.getOfferTakerGets(legOneOffer);
+    const updatedLeftover = fundedSum.subtract(legOneTakerGets);
+
+    this.setLegOneTakerGetsFunded(legOneOffer, legOneTakerGets);
+    this.setLeftoverOwnerFunds(legOneOffer.Account, updatedLeftover);
+  } else {
+    // There are not enough extra funds to fully fund the offer
+    this.setLegOneTakerGetsFunded(legOneOffer, fundedSum);
+    this.resetOwnerFundsLeftover(legOneOffer.Account);
+  }
+};
+
+/**
+ * Set taker gets funded amount for a IOU:XRP offer. Also calculates taker
+ * pays funded using offer quality and updates is_fully_funded flag
+ *
+ * @param {Object} legOneOffer - IOU:XRP offer
+ * @param {Amount} takerGetsFunded
+ */
+
+AutobridgeCalculator.prototype.setLegOneTakerGetsFunded =
+function setLegOneTakerGetsFunded(legOneOffer, takerGetsFunded) {
+  assertValidLegOneOffer(legOneOffer, 'Leg one offer is invalid');
+  assert(takerGetsFunded instanceof Amount, 'Taker gets funded is invalid');
+
+  legOneOffer.taker_gets_funded = takerGetsFunded.to_text();
+  legOneOffer.taker_pays_funded = takerGetsFunded
+    .multiply(Utils.getOfferQuality(legOneOffer, this._currencyGets))
+    .to_text();
+
+  if (legOneOffer.taker_gets_funded === legOneOffer.TakerGets.value) {
+    legOneOffer.is_fully_funded = true;
+  }
+};
+
+/**
+ * Set taker gets amount for a IOU:XRP offer. Also calculates taker pays
+ * using offer quality
+ *
+ * @param {Object} legOneOffer - IOU:XRP offer
+ * @param {Amount} takerGets
+ */
+
+AutobridgeCalculator.prototype.setLegOneTakerGets =
+function(legOneOffer, takerGets) {
+  assertValidLegOneOffer(legOneOffer, 'Leg one offer is invalid');
+  assert(takerGets instanceof Amount, 'Taker gets funded is invalid');
+
+  const legOneQuality = Utils.getOfferQuality(legOneOffer, this._currencyGets);
+
+  legOneOffer.TakerGets = takerGets.to_text();
+  legOneOffer.TakerPays = takerGets.multiply(legOneQuality);
+};
+
+module.exports = AutobridgeCalculator;

src/base.js

@@ -1,13 +1,13 @@
 'use strict';
-var _ = require('lodash');
-var sjcl = require('./utils').sjcl;
-var utils = require('./utils');
-var extend = require('extend');
-var convertBase = require('./baseconverter');
+const _ = require('lodash');
+const sjcl = require('./utils').sjcl;
+const utils = require('./utils');
+const extend = require('extend');
+const convertBase = require('./baseconverter');
 
-var Base = {};
+const Base = {};
 
-var alphabets = Base.alphabets = {
+const alphabets = Base.alphabets = {
   ripple: 'rpshnaf39wBUDNEGHJKLM4PQRST7VWXYZ2bcdeCg65jkm8oFqi1tuvAxyz',
   tipple: 'RPShNAF39wBUDnEGHJKLM4pQrsT7VWXYZ2bcdeCg65jkm8ofqi1tuvaxyz',
   bitcoin: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
@@ -34,16 +34,16 @@ function encodeString(alphabet, input) {
     return '';
   }
 
-  var leadingZeros = _.takeWhile(input, function(d) {
+  const leadingZeros = _.takeWhile(input, function(d) {
     return d === 0;
   });
-  var out = convertBase(input, 256, 58).map(function(digit) {
+  const out = convertBase(input, 256, 58).map(function(digit) {
     if (digit < 0 || digit >= alphabet.length) {
       throw new Error('Value ' + digit + ' is out of bounds for encoding');
     }
     return alphabet[digit];
   });
-  var prefix = leadingZeros.map(function() {
+  const prefix = leadingZeros.map(function() {
     return alphabet[0];
   });
   return prefix.concat(out).join('');
@@ -54,23 +54,23 @@ function decodeString(indexes, input) {
     return [];
   }
 
-  var input58 = input.split('').map(function(c) {
-    var charCode = c.charCodeAt(0);
+  const input58 = input.split('').map(function(c) {
+    const charCode = c.charCodeAt(0);
     if (charCode >= indexes.length || indexes[charCode] === -1) {
       throw new Error('Character ' + c + ' is not valid for encoding');
     }
     return indexes[charCode];
   });
-  var leadingZeros = _.takeWhile(input58, function(d) {
+  const leadingZeros = _.takeWhile(input58, function(d) {
     return d === 0;
   });
-  var out = convertBase(input58, 58, 256);
+  const out = convertBase(input58, 58, 256);
   return leadingZeros.concat(out);
 }
 
 function Base58(alphabet) {
-  var indexes = utils.arraySet(128, -1);
-  for (var i = 0; i < alphabet.length; i++) {
+  const indexes = utils.arraySet(128, -1);
+  for (let i = 0; i < alphabet.length; i++) {
     indexes[alphabet.charCodeAt(i)] = i;
   }
   return {
@@ -104,16 +104,16 @@ Base.decode = function(input, alpha) {
 };
 
 Base.verify_checksum = function(bytes) {
-  var computed = sha256(sha256(bytes.slice(0, -4))).slice(0, 4);
-  var checksum = bytes.slice(-4);
+  const computed = sha256(sha256(bytes.slice(0, -4))).slice(0, 4);
+  const checksum = bytes.slice(-4);
   return _.isEqual(computed, checksum);
 };
 
 // --> input: Array
 // <-- String
 Base.encode_check = function(version, input, alphabet) {
-  var buffer = [].concat(version, input);
-  var check = sha256(sha256(buffer)).slice(0, 4);
+  const buffer = [].concat(version, input);
+  const check = sha256(sha256(buffer)).slice(0, 4);
 
   return Base.encode([].concat(buffer, check), alphabet);
 };
@@ -121,7 +121,7 @@ Base.encode_check = function(version, input, alphabet) {
 // --> input : String
 // <-- NaN || sjcl.bn
 Base.decode_check = function(version, input, alphabet) {
-  var buffer = Base.decode(input, alphabet);
+  const buffer = Base.decode(input, alphabet);
 
   if (!buffer || buffer.length < 5) {
     return NaN;
@@ -134,8 +134,8 @@ Base.decode_check = function(version, input, alphabet) {
 
   // Multiple allowed versions
   if (Array.isArray(version) && _.every(version, function(v) {
-          return v !== buffer[0];
-      })) {
+    return v !== buffer[0];
+  })) {
     return NaN;
   }
 

src/binformat.js

@@ -48,7 +48,7 @@ exports.types = [
  * Mapping of field type id to field type name.
  */
 
-var FIELDS_MAP = exports.fields = {
+const FIELDS_MAP = exports.fields = {
   // Common types
   1: { // Int16
     1: 'LedgerEntryType',
@@ -202,7 +202,7 @@ var FIELDS_MAP = exports.fields = {
   }
 };
 
-var INVERSE_FIELDS_MAP = exports.fieldsInverseMap = { };
+let INVERSE_FIELDS_MAP = exports.fieldsInverseMap = { };
 
 Object.keys(FIELDS_MAP).forEach(function(k1) {
   Object.keys(FIELDS_MAP[k1]).forEach(function(k2) {
@@ -210,11 +210,11 @@ Object.keys(FIELDS_MAP).forEach(function(k1) {
   });
 });
 
-var REQUIRED = exports.REQUIRED = 0,
-    OPTIONAL = exports.OPTIONAL = 1,
-    DEFAULT  = exports.DEFAULT  = 2;
+const REQUIRED = exports.REQUIRED = 0,
+      OPTIONAL = exports.OPTIONAL = 1,
+      DEFAULT  = exports.DEFAULT  = 2;
 
-var base = [
+const base = [
   [ 'TransactionType'    , REQUIRED ],
   [ 'Flags'              , OPTIONAL ],
   [ 'SourceTag'          , OPTIONAL ],
@@ -224,7 +224,9 @@ var base = [
   [ 'Fee'                , REQUIRED ],
   [ 'OperationLimit'     , OPTIONAL ],
   [ 'SigningPubKey'      , REQUIRED ],
-  [ 'TxnSignature'       , OPTIONAL ]
+  [ 'TxnSignature'       , OPTIONAL ],
+  [ 'AccountTxnID'       , OPTIONAL ],
+  [ 'Memos'              , OPTIONAL ]
 ];
 
 exports.tx = {
@@ -297,7 +299,7 @@ exports.tx = {
   ])
 };
 
-var sleBase = [
+const sleBase = [
   ['LedgerIndex',          OPTIONAL],
   ['LedgerEntryType',      REQUIRED],
   ['Flags',                REQUIRED]

src/cpp/TransactionErr.cpp

@@ -1,126 +0,0 @@
-#include "TransactionErr.h"
-#include "utils.h"
-
-bool transResultInfo(TER terCode, std::string& strToken, std::string& strHuman)
-{
-	static struct {
-		TER				terCode;
-		const char*		cpToken;
-		const char*		cpHuman;
-	} transResultInfoA[] = {
-		{	tecCLAIM,				"tecCLAIM",					"Fee claimed. Sequence used. No action."				},
-		{	tecDIR_FULL,			"tecDIR_FULL",				"Can not add entry to full directory."					},
-		{	tecFAILED_PROCESSING,	"tecFAILED_PROCESSING",		"Failed to correctly process transaction."				},
-		{	tecINSUF_RESERVE_LINE,	"tecINSUF_RESERVE_LINE",	"Insufficient reserve to add trust line."				},
-		{	tecINSUF_RESERVE_OFFER,	"tecINSUF_RESERVE_OFFER",	"Insufficient reserve to create offer."					},
-		{	tecNO_DST,				"tecNO_DST",				"Destination does not exist. Send XRP to create it."	},
-		{	tecNO_DST_INSUF_XRP,	"tecNO_DST_INSUF_XRP",		"Destination does not exist. Too little XRP sent to create it."		},
-		{	tecNO_LINE_INSUF_RESERVE,	"tecNO_LINE_INSUF_RESERVE",	"No such line. Too little reserve to create it."	},
-		{	tecNO_LINE_REDUNDANT,	"tecNO_LINE_REDUNDANT",		"Can't set non-existant line to default."				},
-		{	tecPATH_DRY,			"tecPATH_DRY",				"Path could not send partial amount."					},
-		{	tecPATH_PARTIAL,		"tecPATH_PARTIAL",			"Path could not send full amount."						},
-
-		{	tecUNFUNDED,			"tecUNFUNDED",				"One of _ADD, _OFFER, or _SEND. Deprecated."			},
-		{	tecUNFUNDED_ADD,		"tecUNFUNDED_ADD",			"Insufficient XRP balance for WalletAdd."				},
-		{	tecUNFUNDED_OFFER,		"tecUNFUNDED_OFFER",		"Insufficient balance to fund created offer."			},
-		{	tecUNFUNDED_PAYMENT,	"tecUNFUNDED_PAYMENT",		"Insufficient XRP balance to send."						},
-
-		{	tefFAILURE,				"tefFAILURE",				"Failed to apply."										},
-		{	tefALREADY,				"tefALREADY",				"The exact transaction was already in this ledger."		},
-		{	tefBAD_ADD_AUTH,		"tefBAD_ADD_AUTH",			"Not authorized to add account."						},
-		{	tefBAD_AUTH,			"tefBAD_AUTH",				"Transaction's public key is not authorized."			},
-		{	tefBAD_CLAIM_ID,		"tefBAD_CLAIM_ID",			"Malformed: Bad claim id."								},
-		{	tefBAD_GEN_AUTH,		"tefBAD_GEN_AUTH",			"Not authorized to claim generator."					},
-		{	tefBAD_LEDGER,			"tefBAD_LEDGER",			"Ledger in unexpected state."							},
-		{	tefCLAIMED,				"tefCLAIMED",				"Can not claim a previously claimed account."			},
-		{	tefCREATED,				"tefCREATED",				"Can't add an already created account."					},
-		{	tefDST_TAG_NEEDED,		"tefDST_TAG_NEEDED",		"Destination tag required."								},
-		{	tefEXCEPTION,			"tefEXCEPTION",				"Unexpected program state."								},
-		{	tefGEN_IN_USE,			"tefGEN_IN_USE",			"Generator already in use."								},
-		{	tefINTERNAL,			"tefINTERNAL",				"Internal error."										},
-		{	tefNO_AUTH_REQUIRED,	"tefNO_AUTH_REQUIRED",		"Auth is not required."									},
-		{	tefPAST_SEQ,			"tefPAST_SEQ",				"This sequence number has already past."				},
-
-		{	telLOCAL_ERROR,			"telLOCAL_ERROR",			"Local failure."										},
-		{	telBAD_DOMAIN,			"telBAD_DOMAIN",			"Domain too long."										},
-		{	telBAD_PATH_COUNT,		"telBAD_PATH_COUNT",		"Malformed: Too many paths."							},
-		{	telBAD_PUBLIC_KEY,		"telBAD_PUBLIC_KEY",		"Public key too long."									},
-		{	telFAILED_PROCESSING,	"telFAILED_PROCESSING",		"Failed to correctly process transaction."				},
-		{	telINSUF_FEE_P,			"telINSUF_FEE_P",			"Fee insufficient."										},
-		{	telNO_DST_PARTIAL,		"telNO_DST_PARTIAL",		"Partial payment to create account not allowed."		},
-
-		{	temMALFORMED,			"temMALFORMED",				"Malformed transaction."								},
-		{	temBAD_AMOUNT,			"temBAD_AMOUNT",			"Can only send positive amounts."						},
-		{	temBAD_AUTH_MASTER,		"temBAD_AUTH_MASTER",		"Auth for unclaimed account needs correct master key."	},
-		{	temBAD_CURRENCY,		"temBAD_CURRENCY",			"Malformed: Bad currency."								},
-		{	temBAD_FEE,				"temBAD_FEE",				"Invalid fee, negative or not XRP."						},
-		{	temBAD_EXPIRATION,		"temBAD_EXPIRATION",		"Malformed: Bad expiration."							},
-		{	temBAD_ISSUER,			"temBAD_ISSUER",			"Malformed: Bad issuer."								},
-		{	temBAD_LIMIT,			"temBAD_LIMIT",				"Limits must be non-negative."							},
-		{	temBAD_OFFER,			"temBAD_OFFER",				"Malformed: Bad offer."									},
-		{	temBAD_PATH,			"temBAD_PATH",				"Malformed: Bad path."									},
-		{	temBAD_PATH_LOOP,		"temBAD_PATH_LOOP",			"Malformed: Loop in path."								},
-		{	temBAD_PUBLISH,			"temBAD_PUBLISH",			"Malformed: Bad publish."								},
-		{	temBAD_SIGNATURE,		"temBAD_SIGNATURE",			"Malformed: Bad signature."								},
-		{	temBAD_SRC_ACCOUNT,		"temBAD_SRC_ACCOUNT",		"Malformed: Bad source account."						},
-		{	temBAD_TRANSFER_RATE,	"temBAD_TRANSFER_RATE",		"Malformed: Transfer rate must be >= 1.0"				},
-		{	temBAD_SEQUENCE,		"temBAD_SEQUENCE",			"Malformed: Sequence is not in the past."				},
-		{	temBAD_SEND_XRP_LIMIT,		"temBAD_SEND_XRP_LIMIT",		"Malformed: Limit quality is not allowed for XRP to XRP."		},
-		{	temBAD_SEND_XRP_MAX,		"temBAD_SEND_XRP_MAX",			"Malformed: Send max is not allowed for XRP to XRP."			},
-		{	temBAD_SEND_XRP_NO_DIRECT,	"temBAD_SEND_XRP_NO_DIRECT",	"Malformed: No Ripple direct is not allowed for XRP to XRP."	},
-		{	temBAD_SEND_XRP_PARTIAL,	"temBAD_SEND_XRP_PARTIAL",		"Malformed: Partial payment is not allowed for XRP to XRP."		},
-		{	temBAD_SEND_XRP_PATHS,		"temBAD_SEND_XRP_PATHS",		"Malformed: Paths are not allowed for XRP to XRP."				},
-		{	temDST_IS_SRC,			"temDST_IS_SRC",			"Destination may not be source."						},
-		{	temDST_NEEDED,			"temDST_NEEDED",			"Destination not specified."							},
-		{	temINVALID,				"temINVALID",				"The transaction is ill-formed."						},
-		{	temINVALID_FLAG,		"temINVALID_FLAG",			"The transaction has an invalid flag."					},
-		{	temREDUNDANT,			"temREDUNDANT",				"Sends same currency to self."							},
-		{	temREDUNDANT_SEND_MAX,	"temREDUNDANT_SEND_MAX",	"Send max is redundant."								},
-		{	temRIPPLE_EMPTY,		"temRIPPLE_EMPTY",			"PathSet with no paths."								},
-		{	temUNCERTAIN,			"temUNCERTAIN",				"In process of determining result. Never returned."		},
-		{	temUNKNOWN,				"temUNKNOWN",				"The transactions requires logic not implemented yet."	},
-
-		{	terRETRY,				"terRETRY",					"Retry transaction."									},
-		{	terFUNDS_SPENT,			"terFUNDS_SPENT",			"Can't set password, password set funds already spent."	},
-		{	terINSUF_FEE_B,			"terINSUF_FEE_B",			"Account balance can't pay fee."						},
-		{	terLAST,				"terLAST",					"Process last."											},
-		{	terNO_ACCOUNT,			"terNO_ACCOUNT",			"The source account does not exist."					},
-		{	terNO_AUTH,				"terNO_AUTH",				"Not authorized to hold IOUs."							},
-		{	terNO_LINE,				"terNO_LINE",				"No such line."											},
-		{	terPRE_SEQ,				"terPRE_SEQ",				"Missing/inapplicable prior transaction."				},
-		{	terOWNERS,				"terOWNERS",				"Non-zero owner count."									},
-
-		{	tesSUCCESS,				"tesSUCCESS",				"The transaction was applied."							},
-	};
-
-	int	iIndex	= NUMBER(transResultInfoA);
-
-	while (iIndex-- && transResultInfoA[iIndex].terCode != terCode)
-		;
-
-	if (iIndex >= 0)
-	{
-		strToken	= transResultInfoA[iIndex].cpToken;
-		strHuman	= transResultInfoA[iIndex].cpHuman;
-	}
-
-	return iIndex >= 0;
-}
-
-std::string transToken(TER terCode)
-{
-	std::string	strToken;
-	std::string	strHuman;
-
-	return transResultInfo(terCode, strToken, strHuman) ? strToken : "-";
-}
-
-std::string transHuman(TER terCode)
-{
-	std::string	strToken;
-	std::string	strHuman;
-
-	return transResultInfo(terCode, strToken, strHuman) ? strHuman : "-";
-}
-
-// vim:ts=4

src/cpp/TransactionErr.h

@@ -1,153 +0,0 @@
-#ifndef _TRANSACTION_ERR_
-#define _TRANSACTION_ERR_
-
-#include <string>
-
-enum TER	// aka TransactionEngineResult
-{
-	// Note: Range is stable.  Exact numbers are currently unstable.  Use tokens.
-
-	// -399 .. -300: L Local error (transaction fee inadequate, exceeds local limit)
-	// Only valid during non-consensus processing.
-	// Implications:
-	// - Not forwarded
-	// - No fee check
-	telLOCAL_ERROR	= -399,
-	telBAD_DOMAIN,
-	telBAD_PATH_COUNT,
-	telBAD_PUBLIC_KEY,
-	telFAILED_PROCESSING,
-	telINSUF_FEE_P,
-	telNO_DST_PARTIAL,
-
-	// -299 .. -200: M Malformed (bad signature)
-	// Causes:
-	// - Transaction corrupt.
-	// Implications:
-	// - Not applied
-	// - Not forwarded
-	// - Reject
-	// - Can not succeed in any imagined ledger.
-	temMALFORMED	= -299,
-	temBAD_AMOUNT,
-	temBAD_AUTH_MASTER,
-	temBAD_CURRENCY,
-	temBAD_FEE,
-	temBAD_EXPIRATION,
-	temBAD_ISSUER,
-	temBAD_LIMIT,
-	temBAD_OFFER,
-	temBAD_PATH,
-	temBAD_PATH_LOOP,
-	temBAD_PUBLISH,
-	temBAD_TRANSFER_RATE,
-	temBAD_SEND_XRP_LIMIT,
-	temBAD_SEND_XRP_MAX,
-	temBAD_SEND_XRP_NO_DIRECT,
-	temBAD_SEND_XRP_PARTIAL,
-	temBAD_SEND_XRP_PATHS,
-	temBAD_SIGNATURE,
-	temBAD_SRC_ACCOUNT,
-	temBAD_SEQUENCE,
-	temDST_IS_SRC,
-	temDST_NEEDED,
-	temINVALID,
-	temINVALID_FLAG,
-	temREDUNDANT,
-	temREDUNDANT_SEND_MAX,
-	temRIPPLE_EMPTY,
-	temUNCERTAIN,		// An intermediate result used internally, should never be returned.
-	temUNKNOWN,
-
-	// -199 .. -100: F Failure (sequence number previously used)
-	// Causes:
-	// - Transaction cannot succeed because of ledger state.
-	// - Unexpected ledger state.
-	// - C++ exception.
-	// Implications:
-	// - Not applied
-	// - Not forwarded
-	// - Could succeed in an imagined ledger.
-	tefFAILURE		= -199,
-	tefALREADY,
-	tefBAD_ADD_AUTH,
-	tefBAD_AUTH,
-	tefBAD_CLAIM_ID,
-	tefBAD_GEN_AUTH,
-	tefBAD_LEDGER,
-	tefCLAIMED,
-	tefCREATED,
-	tefDST_TAG_NEEDED,
-	tefEXCEPTION,
-	tefGEN_IN_USE,
-	tefINTERNAL,
-	tefNO_AUTH_REQUIRED,	// Can't set auth if auth is not required.
-	tefPAST_SEQ,
-
-	// -99 .. -1: R Retry (sequence too high, no funds for txn fee, originating account non-existent)
-	// Causes:
-	// - Prior application of another, possibly non-existant, another transaction could allow this transaction to succeed.
-	// Implications:
-	// - Not applied
-	// - Not forwarded
-	// - Might succeed later
-	// - Hold
-	// - Makes hole in sequence which jams transactions.
-	terRETRY		= -99,
-	terFUNDS_SPENT,			// This is a free transaction, therefore don't burden network.
-	terINSUF_FEE_B,			// Can't pay fee, therefore don't burden network.
-	terNO_ACCOUNT,			// Can't pay fee, therefore don't burden network.
-	terNO_AUTH,				// Not authorized to hold IOUs.
-	terNO_LINE,				// Internal flag.
-	terOWNERS,				// Can't succeed with non-zero owner count.
-	terPRE_SEQ,				// Can't pay fee, no point in forwarding, therefore don't burden network.
-	terLAST,				// Process after all other transactions
-
-	// 0: S Success (success)
-	// Causes:
-	// - Success.
-	// Implications:
-	// - Applied
-	// - Forwarded
-	tesSUCCESS		= 0,
-
-	// 100 .. 129 C Claim fee only (ripple transaction with no good paths, pay to non-existent account, no path)
-	// Causes:
-	// - Success, but does not achieve optimal result.
-	// - Invalid transaction or no effect, but claim fee to use the sequence number.
-	// Implications:
-	// - Applied
-	// - Forwarded
-	// Only allowed as a return code of appliedTransaction when !tapRetry. Otherwise, treated as terRETRY.
-	//
-	// DO NOT CHANGE THESE NUMBERS: They appear in ledger meta data.
-	tecCLAIM					= 100,
-	tecPATH_PARTIAL				= 101,
-	tecUNFUNDED_ADD				= 102,
-	tecUNFUNDED_OFFER			= 103,
-	tecUNFUNDED_PAYMENT			= 104,
-	tecFAILED_PROCESSING		= 105,
-	tecDIR_FULL					= 121,
-	tecINSUF_RESERVE_LINE		= 122,
-	tecINSUF_RESERVE_OFFER		= 123,
-	tecNO_DST					= 124,
-	tecNO_DST_INSUF_XRP			= 125,
-	tecNO_LINE_INSUF_RESERVE	= 126,
-	tecNO_LINE_REDUNDANT		= 127,
-	tecPATH_DRY					= 128,
-	tecUNFUNDED					= 129,	// Deprecated, old ambiguous unfunded.
-};
-
-#define isTelLocal(x)		((x) >= telLOCAL_ERROR && (x) < temMALFORMED)
-#define isTemMalformed(x)	((x) >= temMALFORMED && (x) < tefFAILURE)
-#define isTefFailure(x)		((x) >= tefFAILURE && (x) < terRETRY)
-#define isTerRetry(x)		((x) >= terRETRY && (x) < tesSUCCESS)
-#define isTesSuccess(x)		((x) == tesSUCCESS)
-#define isTecClaim(x)		((x) >= tecCLAIM)
-
-bool transResultInfo(TER terCode, std::string& strToken, std::string& strHuman);
-std::string transToken(TER terCode);
-std::string transHuman(TER terCode);
-
-#endif
-// vim:ts=4

src/index.js

@@ -17,12 +17,17 @@ exports.Message = require('./message').Message;
 exports.binformat = require('./binformat');
 exports.utils = require('./utils');
 exports.Server = require('./server').Server;
-exports.Wallet = require('./wallet');
 exports.Ledger = require('./ledger').Ledger;
 exports.TransactionQueue = require('./transactionqueue').TransactionQueue;
 exports.RangeSet = require('./rangeset').RangeSet;
 exports.convertBase = require('./baseconverter');
 
+exports._test = {
+  Log: require('./log'),
+  PathFind: require('./pathfind').PathFind,
+  TransactionManager: require('./transactionmanager').TransactionManager
+};
+
 // Important: We do not guarantee any specific version of SJCL or for any
 // specific features to be included. The version and configuration may change at
 // any time without warning.
@@ -31,27 +36,26 @@ exports.convertBase = require('./baseconverter');
 // the official client, it makes sense to expose the SJCL instance so we don't
 // have to include it twice.
 exports.sjcl = require('./utils').sjcl;
+exports.Wallet = require('ripple-wallet-generator')({sjcl: exports.sjcl});
 exports.types = require('./serializedtypes');
 
-exports.config = require('./config');
-
 // camelCase to under_scored API conversion
 function attachUnderscored(name) {
- var o = exports[name];
+  const o = exports[name];
 
- Object.keys(o.prototype).forEach(function(key) {
-   var UPPERCASE = /([A-Z]{1})[a-z]+/g;
+  Object.keys(o.prototype).forEach(function(key) {
+    const UPPERCASE = /([A-Z]{1})[a-z]+/g;
 
-   if (!UPPERCASE.test(key)) {
-     return;
-   }
+    if (!UPPERCASE.test(key)) {
+      return;
+    }
 
-   var underscored = key.replace(UPPERCASE, function(c) {
-     return '_' + c.toLowerCase();
-   });
+    const underscored = key.replace(UPPERCASE, function(c) {
+      return '_' + c.toLowerCase();
+    });
 
-   o.prototype[underscored] = o.prototype[key];
- });
+    o.prototype[underscored] = o.prototype[key];
+  });
 }
 
 ['Remote',

src/js/ripple/config.js

@@ -1,10 +0,0 @@
-// This object serves as a singleton to store config options
-
-var extend = require('extend');
-
-var config = module.exports = {
-  load: function (newOpts) {
-    extend(config, newOpts);
-    return config;
-  }
-};

src/js/ripple/crypt.js

@@ -1,333 +0,0 @@
-var sjcl        = require('./utils').sjcl;
-var base        = require('./base').Base;
-var Seed        = require('./seed').Seed;
-var UInt160     = require('./uint160').UInt160;
-var UInt256     = require('./uint256').UInt256;
-var request     = require('superagent');
-var querystring = require('querystring');
-var extend      = require("extend");
-var parser      = require("url");
-var Crypt       = { };
-
-var cryptConfig = {
-  cipher : 'aes',
-  mode   : 'ccm',
-  ts     : 64,   // tag length
-  ks     : 256,  // key size
-  iter   : 1000  // iterations (key derivation)
-};
-
-/**
- * Full domain hash based on SHA512
- */
-
-function fdh(data, bytelen) {
-  var bitlen = bytelen << 3;
-
-  if (typeof data === 'string') {
-    data = sjcl.codec.utf8String.toBits(data);
-  }
-
-  // Add hashing rounds until we exceed desired length in bits
-  var counter = 0, output = [];
-
-  while (sjcl.bitArray.bitLength(output) < bitlen) {
-    var hash = sjcl.hash.sha512.hash(sjcl.bitArray.concat([counter], data));
-    output = sjcl.bitArray.concat(output, hash);
-    counter++;
-  }
-
-  // Truncate to desired length
-  output = sjcl.bitArray.clamp(output, bitlen);
-
-  return output;
-};
-
-/**
- * This is a function to derive different hashes from the same key. 
- * Each hash is derived as HMAC-SHA512HALF(key, token).
- *
- * @param {string} key
- * @param {string} hash
- */
-
-function keyHash(key, token) {
-  var hmac = new sjcl.misc.hmac(key, sjcl.hash.sha512);
-  return sjcl.codec.hex.fromBits(sjcl.bitArray.bitSlice(hmac.encrypt(token), 0, 256));
-};
-
-/**
- * add entropy at each call to get random words
- * @param {number} nWords
- */
-function randomWords (nWords) {
-  for (var i = 0; i < 8; i++) {
-    sjcl.random.addEntropy(Math.random(), 32, "Math.random()");
-  }  
-  
-  return sjcl.random.randomWords(nWords);  
-}
-
-/****** exposed functions ******/
-
-/**
- * KEY DERIVATION FUNCTION
- *
- * This service takes care of the key derivation, i.e. converting low-entropy
- * secret into higher entropy secret via either computationally expensive
- * processes or peer-assisted key derivation (PAKDF).
- *
- * @param {object}    opts
- * @param {string}    purpose - Key type/purpose
- * @param {string}    username
- * @param {string}    secret - Also known as passphrase/password
- * @param {function}  fn
- */
-
-Crypt.derive = function(opts, purpose, username, secret, fn) {
-  var tokens;
-
-  if (purpose === 'login') {
-    tokens = ['id', 'crypt'];
-  } else {
-    tokens = ['unlock'];
-  }
-
-  var iExponent = new sjcl.bn(String(opts.exponent));
-  var iModulus  = new sjcl.bn(String(opts.modulus));
-  var iAlpha    = new sjcl.bn(String(opts.alpha));
-
-  var publicInfo = [ 'PAKDF_1_0_0', opts.host.length, opts.host, username.length, username, purpose.length, purpose ].join(':') + ':';
-  var publicSize = Math.ceil(Math.min((7 + iModulus.bitLength()) >>> 3, 256) / 8);
-  var publicHash = fdh(publicInfo, publicSize);
-  var publicHex  = sjcl.codec.hex.fromBits(publicHash);
-  var iPublic    = new sjcl.bn(String(publicHex)).setBitM(0);
-  var secretInfo = [ publicInfo, secret.length, secret ].join(':') + ':';
-  var secretSize = (7 + iModulus.bitLength()) >>> 3;
-  var secretHash = fdh(secretInfo, secretSize);
-  var secretHex  = sjcl.codec.hex.fromBits(secretHash);
-  var iSecret    = new sjcl.bn(String(secretHex)).mod(iModulus);
-
-  if (iSecret.jacobi(iModulus) !== 1) {
-    iSecret = iSecret.mul(iAlpha).mod(iModulus);
-  }
-
-  var iRandom;
-
-  for (;;) {
-    iRandom = sjcl.bn.random(iModulus, 0);
-    if (iRandom.jacobi(iModulus) === 1) {
-      break;
-    }
-  }
-
-  var iBlind   = iRandom.powermodMontgomery(iPublic.mul(iExponent), iModulus);
-  var iSignreq = iSecret.mulmod(iBlind, iModulus);
-  var signreq  = sjcl.codec.hex.fromBits(iSignreq.toBits());
-
-  request.post(opts.url)
-    .send({ info: publicInfo, signreq: signreq })
-    .end(function(err, resp) {
-      if (err || !resp) {
-        return fn(new Error('Could not query PAKDF server ' + opts.host));
-      }
-
-      var data = resp.body || resp.text ? JSON.parse(resp.text) : {};
-
-      if (data.result !== 'success') {
-        return fn(new Error('Could not query PAKDF server '+opts.host));
-      }
-
-      var iSignres = new sjcl.bn(String(data.signres));
-      var iRandomInv = iRandom.inverseMod(iModulus);
-      var iSigned    = iSignres.mulmod(iRandomInv, iModulus);
-      var key        = iSigned.toBits();
-      var result     = { };
-
-      tokens.forEach(function(token) {
-        result[token] = keyHash(key, token);
-      });
-
-      fn(null, result);
-    });
-};
-
-/**
- * Imported from ripple-client
- */
-
-
-
-/**
- * Encrypt data
- *
- * @param {string} key
- * @param {string} data
- */
-
-Crypt.encrypt = function(key, data) {
-  key = sjcl.codec.hex.toBits(key);
-
-  var opts = extend(true, {}, cryptConfig);
-
-  var encryptedObj = JSON.parse(sjcl.encrypt(key, data, opts));
-  var version = [sjcl.bitArray.partial(8, 0)];
-  var initVector = sjcl.codec.base64.toBits(encryptedObj.iv);
-  var ciphertext = sjcl.codec.base64.toBits(encryptedObj.ct);
-
-  var encryptedBits = sjcl.bitArray.concat(version, initVector);
-  encryptedBits = sjcl.bitArray.concat(encryptedBits, ciphertext);
-
-  return sjcl.codec.base64.fromBits(encryptedBits);
-};
-
-/**
- * Decrypt data
- *
- * @param {string} key
- * @param {string} data
- */
-
-Crypt.decrypt = function (key, data) {
-  
-  key = sjcl.codec.hex.toBits(key);
-  var encryptedBits = sjcl.codec.base64.toBits(data);
-
-  var version = sjcl.bitArray.extract(encryptedBits, 0, 8);
-
-  if (version !== 0) {
-    throw new Error('Unsupported encryption version: '+version);
-  }
-
-  var encrypted = extend(true, {}, cryptConfig, {
-    iv: sjcl.codec.base64.fromBits(sjcl.bitArray.bitSlice(encryptedBits, 8, 8+128)),
-    ct: sjcl.codec.base64.fromBits(sjcl.bitArray.bitSlice(encryptedBits, 8+128))
-  });
-
-  return sjcl.decrypt(key, JSON.stringify(encrypted));
-};
-
-
-/**
- * Validate a ripple address
- *
- * @param {string} address
- */
-
-Crypt.isValidAddress = function (address) {
-  return UInt160.is_valid(address);
-};
-
-/**
- * Create an encryption key
- *
- * @param {integer} nWords - number of words
- */
-
-Crypt.createSecret = function (nWords) {
-  return sjcl.codec.hex.fromBits(randomWords(nWords));
-};
-
-/**
- * Create a new master key
- */
-
-Crypt.createMaster = function () {
-  return base.encode_check(33, sjcl.codec.bytes.fromBits(randomWords(4)));
-};
-
-
-/**
- * Create a ripple address from a master key
- *
- * @param {string} masterkey
- */
-
-Crypt.getAddress = function (masterkey) {
-  return Seed.from_json(masterkey).get_key().get_address().to_json();
-};
-
-/**
- * Hash data using SHA-512.
- *
- * @param {string|bitArray} data
- * @return {string} Hash of the data
- */
-
-Crypt.hashSha512 = function (data) {
-  // XXX Should return a UInt512
-  return sjcl.codec.hex.fromBits(sjcl.hash.sha512.hash(data)); 
-};
-
-/**
- * Hash data using SHA-512 and return the first 256 bits.
- *
- * @param {string|bitArray} data
- * @return {UInt256} Hash of the data
- */
-Crypt.hashSha512Half = function (data) {
-  return UInt256.from_hex(Crypt.hashSha512(data).substr(0, 64));
-};
-
-
-/**
- * Sign a data string with a secret key
- *
- * @param {string} secret
- * @param {string} data
- */
-
-Crypt.signString = function(secret, data) {
-  var hmac = new sjcl.misc.hmac(sjcl.codec.hex.toBits(secret), sjcl.hash.sha512);
-  return sjcl.codec.hex.fromBits(hmac.mac(data));
-};
-
-/**
- * Create an an accout recovery key
- *
- * @param {string} secret
- */
-
-Crypt.deriveRecoveryEncryptionKeyFromSecret = function(secret) {
-  var seed = Seed.from_json(secret).to_bits();
-  var hmac = new sjcl.misc.hmac(seed, sjcl.hash.sha512);
-  var key  = hmac.mac('ripple/hmac/recovery_encryption_key/v1');
-  key      = sjcl.bitArray.bitSlice(key, 0, 256);
-  return sjcl.codec.hex.fromBits(key);
-};
-
-/**
- * Convert base64 encoded data into base64url encoded data.
- *
- * @param {String} base64 Data
- */
-
-Crypt.base64ToBase64Url = function(encodedData) {
-  return encodedData.replace(/\+/g, '-').replace(/\//g, '_').replace(/[=]+$/, '');
-};
-
-/**
- * Convert base64url encoded data into base64 encoded data.
- *
- * @param {String} base64 Data
- */
-
-Crypt.base64UrlToBase64 = function(encodedData) {
-  encodedData = encodedData.replace(/-/g, '+').replace(/_/g, '/');
-
-  while (encodedData.length % 4) {
-    encodedData += '=';
-  }
-
-  return encodedData;
-};
-
-/**
- * base64 to UTF8
- */
-
-Crypt.decodeBase64 = function (data) {
-  return sjcl.codec.utf8String.fromBits(sjcl.codec.base64.toBits(data));
-}
-
-exports.Crypt = Crypt;

src/js/ripple/float.js

@@ -1,59 +0,0 @@
-/**
- * IEEE 754 floating-point.
- *
- * Supports single- or double-precision
- */
-var Float = exports.Float = {};
-
-var allZeros = /^0+$/;
-var allOnes = /^1+$/;
-
-Float.fromBytes = function(bytes) {
-  // Render in binary.  Hackish.
-  var b = '';
-
-  for (var i = 0, n = bytes.length; i < n; i++) {
-    var bits = (bytes[i] & 0xff).toString(2);
-
-    while (bits.length < 8) {
-      bits = '0' + bits;
-    }
-
-    b += bits;
-  }
-
-  // Determine configuration.  This could have all been precomputed but it is fast enough.
-  var exponentBits = bytes.length === 4 ? 4 : 11;
-  var mantissaBits = (bytes.length * 8) - exponentBits - 1;
-  var bias = Math.pow(2, exponentBits - 1) - 1;
-  var minExponent = 1 - bias - mantissaBits;
-
-  // Break up the binary representation into its pieces for easier processing.
-  var s = b[0];
-  var e = b.substring(1, exponentBits + 1);
-  var m = b.substring(exponentBits + 1);
-
-  var value = 0;
-  var multiplier = (s === '0' ? 1 : -1);
-
-  if (allZeros.test(e)) {
-    // Zero or denormalized
-    if (!allZeros.test(m)) {
-      value = parseInt(m, 2) * Math.pow(2, minExponent);
-    }
-  } else if (allOnes.test(e)) {
-    // Infinity or NaN
-    if (allZeros.test(m)) {
-      value = Infinity;
-    } else {
-      value = NaN;
-    }
-  } else {
-    // Normalized
-    var exponent = parseInt(e, 2) - bias;
-    var mantissa = parseInt(m, 2);
-    value = (1 + (mantissa * Math.pow(2, -mantissaBits))) * Math.pow(2, exponent);
-  }
-
-  return value * multiplier;
-};

src/js/ripple/uint128.js

@@ -1,22 +0,0 @@
-var utils  = require('./utils');
-var extend = require('extend');
-var UInt   = require('./uint').UInt;
-
-//
-// UInt128 support
-//
-
-var UInt128 = extend(function () {
-  this._value  = NaN;
-}, UInt);
-
-UInt128.width = 16;
-UInt128.prototype = extend({}, UInt.prototype);
-UInt128.prototype.constructor = UInt128;
-
-var HEX_ZERO = UInt128.HEX_ZERO = '00000000000000000000000000000000';
-var HEX_ONE  = UInt128.HEX_ONE  = '00000000000000000000000000000000';
-var STR_ZERO = UInt128.STR_ZERO = utils.hexToString(HEX_ZERO);
-var STR_ONE  = UInt128.STR_ONE  = utils.hexToString(HEX_ONE);
-
-exports.UInt128 = UInt128;

src/js/ripple/uint256.js

@@ -1,22 +0,0 @@
-var utils  = require('./utils');
-var extend = require('extend');
-var UInt   = require('./uint').UInt;
-
-//
-// UInt256 support
-//
-
-var UInt256 = extend(function() {
-  this._value = NaN;
-}, UInt);
-
-UInt256.width = 32;
-UInt256.prototype = extend({}, UInt.prototype);
-UInt256.prototype.constructor = UInt256;
-
-var HEX_ZERO = UInt256.HEX_ZERO = '00000000000000000000000000000000' + '00000000000000000000000000000000';
-var HEX_ONE  = UInt256.HEX_ONE  = '00000000000000000000000000000000' + '00000000000000000000000000000001';
-var STR_ZERO = UInt256.STR_ZERO = utils.hexToString(HEX_ZERO);
-var STR_ONE  = UInt256.STR_ONE  = utils.hexToString(HEX_ONE);
-
-exports.UInt256 = UInt256;

src/js/ripple/wallet.js

@@ -1,8 +0,0 @@
-var sjcl = require('./utils').sjcl;
-
-var WalletGenerator = require('ripple-wallet-generator')({
-  sjcl: sjcl
-});
-
-module.exports = WalletGenerator;
-

src/js/sjcl-custom/sjcl-jacobi.js

@@ -1,45 +0,0 @@
-sjcl.bn.prototype.jacobi = function (that) {
-  var a = this;
-  that = new sjcl.bn(that);
-
-  if (that.sign() === -1) return;
-
-  // 1. If a = 0 then return(0).
-  if (a.equals(0)) { return 0; }
-
-  // 2. If a = 1 then return(1).
-  if (a.equals(1)) { return 1; }
-
-  var s = 0;
-
-  // 3. Write a = 2^e * a1, where a1 is odd.
-  var e = 0;
-  while (!a.testBit(e)) e++;
-  var a1 = a.shiftRight(e);
-
-  // 4. If e is even then set s ← 1.
-  if ((e & 1) === 0) {
-    s = 1;
-  } else {
-    var residue = that.modInt(8);
-
-    if (residue === 1 || residue === 7) {
-      // Otherwise set s ← 1 if n ≡ 1 or 7 (mod 8)
-      s = 1;
-    } else if (residue === 3 || residue === 5) {
-      // Or set s ← −1 if n ≡ 3 or 5 (mod 8).
-      s = -1;
-    }
-  }
-
-  // 5. If n ≡ 3 (mod 4) and a1 ≡ 3 (mod 4) then set s ← −s.
-  if (that.modInt(4) === 3 && a1.modInt(4) === 3) {
-    s = -s;
-  }
-
-  if (a1.equals(1)) {
-    return s;
-  } else {
-    return s * that.mod(a1).jacobi(a1);
-  }
-};

src/js/sjcl-custom/sjcl-montgomery.js

@@ -1,156 +0,0 @@
-sjcl.bn.prototype.invDigit = function ()
-{
-  var radixMod = 1 + this.radixMask;
-
-  if (this.limbs.length < 1) return 0;
-  var x = this.limbs[0];
-  if ((x&1) == 0) return 0;
-  var y = x&3;		// y == 1/x mod 2^2
-  y = (y*(2-(x&0xf)*y))&0xf;	// y == 1/x mod 2^4
-  y = (y*(2-(x&0xff)*y))&0xff;	// y == 1/x mod 2^8
-  y = (y*(2-(((x&0xffff)*y)&0xffff)))&0xffff;	// y == 1/x mod 2^16
-  // last step - calculate inverse mod DV directly;
-  // assumes 16 < radixMod <= 32 and assumes ability to handle 48-bit ints
-  y = (y*(2-x*y%radixMod))%radixMod;		// y == 1/x mod 2^dbits
-  // we really want the negative inverse, and -DV < y < DV
-  return (y>0)?radixMod-y:-y;
-};
-
-// returns bit length of the integer x
-function nbits(x) {
-  var r = 1, t;
-  if((t=x>>>16) != 0) { x = t; r += 16; }
-  if((t=x>>8) != 0) { x = t; r += 8; }
-  if((t=x>>4) != 0) { x = t; r += 4; }
-  if((t=x>>2) != 0) { x = t; r += 2; }
-  if((t=x>>1) != 0) { x = t; r += 1; }
-  return r;
-}
-
-// JSBN-style add and multiply for SJCL w/ 24 bit radix
-sjcl.bn.prototype.am = function (i,x,w,j,c,n) {
-  var xl = x&0xfff, xh = x>>12;
-  while (--n >= 0) {
-    var l = this.limbs[i]&0xfff;
-    var h = this.limbs[i++]>>12;
-    var m = xh*l+h*xl;
-    l = xl*l+((m&0xfff)<<12)+w.limbs[j]+c;
-    c = (l>>24)+(m>>12)+xh*h;
-    w.limbs[j++] = l&0xffffff;
-  }
-  return c;
-}
-
-var Montgomery = function (m)
-{
-  this.m = m;
-  this.mt = m.limbs.length;
-  this.mt2 = this.mt * 2;
-  this.mp = m.invDigit();
-  this.mpl = this.mp&0x7fff;
-  this.mph = this.mp>>15;
-  this.um = (1<<(m.radix-15))-1;
-};
-
-Montgomery.prototype.reduce = function (x)
-{
-  var radixMod = x.radixMask + 1;
-  while (x.limbs.length <= this.mt2)	// pad x so am has enough room later
-    x.limbs[x.limbs.length] = 0;
-  for (var i = 0; i < this.mt; ++i) {
-    // faster way of calculating u0 = x[i]*mp mod 2^radix
-    var j = x.limbs[i]&0x7fff;
-    var u0 = (j*this.mpl+(((j*this.mph+(x.limbs[i]>>15)*this.mpl)&this.um)<<15))&x.radixMask;
-    // use am to combine the multiply-shift-add into one call
-    j = i+this.mt;
-    x.limbs[j] += this.m.am(0,u0,x,i,0,this.mt);
-    // propagate carry
-    while (x.limbs[j] >= radixMod) { x.limbs[j] -= radixMod; x.limbs[++j]++; }
-  }
-  x.trim();
-  x = x.shiftRight(this.mt * this.m.radix);
-  if (x.greaterEquals(this.m)) x = x.sub(this.m);
-  return x.trim().normalize().reduce();
-};
-
-Montgomery.prototype.square = function (x)
-{
-  return this.reduce(x.square());
-};
-
-Montgomery.prototype.multiply = function (x, y)
-{
-  return this.reduce(x.mul(y));
-};
-
-Montgomery.prototype.convert = function (x)
-{
-  return x.abs().shiftLeft(this.mt * this.m.radix).mod(this.m);
-};
-
-Montgomery.prototype.revert = function (x)
-{
-  return this.reduce(x.copy());
-};
-
-sjcl.bn.prototype.powermodMontgomery = function (e, m)
-{
-  var i = e.bitLength(), k, r = new this._class(1);
-
-  if (i <= 0) return r;
-  else if (i < 18) k = 1;
-  else if (i < 48) k = 3;
-  else if (i < 144) k = 4;
-  else if (i < 768) k = 5;
-  else k = 6;
-
-  if (i < 8 || !m.testBit(0)) {
-    // For small exponents and even moduli, use a simple square-and-multiply
-    // algorithm.
-    return this.powermod(e, m);
-  }
-
-  var z = new Montgomery(m);
-
-  e.trim().normalize();
-
-  // precomputation
-  var g = new Array(), n = 3, k1 = k-1, km = (1<<k)-1;
-  g[1] = z.convert(this);
-  if (k > 1) {
-    var g2 = z.square(g[1]);
-
-    while (n <= km) {
-      g[n] = z.multiply(g2, g[n-2]);
-      n += 2;
-    }
-  }
-
-  var j = e.limbs.length-1, w, is1 = true, r2 = new this._class(), t;
-  i = nbits(e.limbs[j])-1;
-  while (j >= 0) {
-    if (i >= k1) w = (e.limbs[j]>>(i-k1))&km;
-    else {
-      w = (e.limbs[j]&((1<<(i+1))-1))<<(k1-i);
-      if (j > 0) w |= e.limbs[j-1]>>(this.radix+i-k1);
-    }
-
-    n = k;
-    while ((w&1) == 0) { w >>= 1; --n; }
-    if ((i -= n) < 0) { i += this.radix; --j; }
-    if (is1) {	// ret == 1, don't bother squaring or multiplying it
-      r = g[w].copy();
-      is1 = false;
-    } else {
-      while (n > 1) { r2 = z.square(r); r = z.square(r2); n -= 2; }
-      if (n > 0) r2 = z.square(r); else { t = r; r = r2; r2 = t; }
-      r = z.multiply(r2,g[w]);
-    }
-
-    while (j >= 0 && (e.limbs[j]&(1<<i)) == 0) {
-      r2 = z.square(r); t = r; r = r2; r2 = t;
-      if (--i < 0) { i = this.radix-1; --j; }
-    }
-  }
-  return z.revert(r);
-}

src/js/sjcl-custom/sjcl-ripemd160.js

@@ -1,207 +0,0 @@
-/** @fileOverview Javascript RIPEMD-160 implementation.
- *
- * @author Artem S Vybornov <vybornov@gmail.com>
- */
-(function() {
-
-/**
- * Context for a RIPEMD-160 operation in progress.
- * @constructor
- * @class RIPEMD, 160 bits.
- */
-sjcl.hash.ripemd160 = function (hash) {
-    if (hash) {
-        this._h = hash._h.slice(0);
-        this._buffer = hash._buffer.slice(0);
-        this._length = hash._length;
-    } else {
-        this.reset();
-    }
-};
-
-/**
- * Hash a string or an array of words.
- * @static
- * @param {bitArray|String} data the data to hash.
- * @return {bitArray} The hash value, an array of 5 big-endian words.
- */
-sjcl.hash.ripemd160.hash = function (data) {
-  return (new sjcl.hash.ripemd160()).update(data).finalize();
-};
-
-sjcl.hash.ripemd160.prototype = {
-    /**
-     * Reset the hash state.
-     * @return this
-     */
-    reset: function () {
-        this._h = _h0.slice(0);
-        this._buffer = [];
-        this._length = 0;
-        return this;
-    },
-
-    /**
-     * Reset the hash state.
-     * @param {bitArray|String} data the data to hash.
-     * @return this
-     */
-    update: function (data) {
-        if ( typeof data === "string" )
-            data = sjcl.codec.utf8String.toBits(data);
-
-        var i, b = this._buffer = sjcl.bitArray.concat(this._buffer, data),
-            ol = this._length,
-            nl = this._length = ol + sjcl.bitArray.bitLength(data);
-        for (i = 512+ol & -512; i <= nl; i+= 512) {
-            var words = b.splice(0,16);
-            for ( var w = 0; w < 16; ++w )
-                words[w] = _cvt(words[w]);
-
-            _block.call( this, words );
-        }
-
-        return this;
-    },
-
-    /**
-     * Complete hashing and output the hash value.
-     * @return {bitArray} The hash value, an array of 5 big-endian words.
-     */
-    finalize: function () {
-        var b = sjcl.bitArray.concat( this._buffer, [ sjcl.bitArray.partial(1,1) ] ),
-            l = ( this._length + 1 ) % 512,
-            z = ( l > 448 ? 512 : 448 ) - l % 448,
-            zp = z % 32;
-
-        if ( zp > 0 )
-            b = sjcl.bitArray.concat( b, [ sjcl.bitArray.partial(zp,0) ] )
-        for ( ; z >= 32; z -= 32 )
-            b.push(0);
-
-        b.push( _cvt( this._length | 0 ) );
-        b.push( _cvt( Math.floor(this._length / 0x100000000) ) );
-
-        while ( b.length ) {
-            var words = b.splice(0,16);
-            for ( var w = 0; w < 16; ++w )
-                words[w] = _cvt(words[w]);
-
-            _block.call( this, words );
-        }
-
-        var h = this._h;
-        this.reset();
-
-        for ( var w = 0; w < 5; ++w )
-            h[w] = _cvt(h[w]);
-
-        return h;
-    }
-};
-
-var _h0 = [ 0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0 ];
-
-var _k1 = [ 0x00000000, 0x5a827999, 0x6ed9eba1, 0x8f1bbcdc, 0xa953fd4e ];
-var _k2 = [ 0x50a28be6, 0x5c4dd124, 0x6d703ef3, 0x7a6d76e9, 0x00000000 ];
-for ( var i = 4; i >= 0; --i ) {
-    for ( var j = 1; j < 16; ++j ) {
-        _k1.splice(i,0,_k1[i]);
-        _k2.splice(i,0,_k2[i]);
-    }
-}
-
-var _r1 = [  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
-             7,  4, 13,  1, 10,  6, 15,  3, 12,  0,  9,  5,  2, 14, 11,  8,
-             3, 10, 14,  4,  9, 15,  8,  1,  2,  7,  0,  6, 13, 11,  5, 12,
-             1,  9, 11, 10,  0,  8, 12,  4, 13,  3,  7, 15, 14,  5,  6,  2,
-             4,  0,  5,  9,  7, 12,  2, 10, 14,  1,  3,  8, 11,  6, 15, 13 ];
-var _r2 = [  5, 14,  7,  0,  9,  2, 11,  4, 13,  6, 15,  8,  1, 10,  3, 12,
-             6, 11,  3,  7,  0, 13,  5, 10, 14, 15,  8, 12,  4,  9,  1,  2,
-            15,  5,  1,  3,  7, 14,  6,  9, 11,  8, 12,  2, 10,  0,  4, 13,
-             8,  6,  4,  1,  3, 11, 15,  0,  5, 12,  2, 13,  9,  7, 10, 14,
-            12, 15, 10,  4,  1,  5,  8,  7,  6,  2, 13, 14,  0,  3,  9, 11 ];
-
-var _s1 = [ 11, 14, 15, 12,  5,  8,  7,  9, 11, 13, 14, 15,  6,  7,  9,  8,
-             7,  6,  8, 13, 11,  9,  7, 15,  7, 12, 15,  9, 11,  7, 13, 12,
-            11, 13,  6,  7, 14,  9, 13, 15, 14,  8, 13,  6,  5, 12,  7,  5,
-            11, 12, 14, 15, 14, 15,  9,  8,  9, 14,  5,  6,  8,  6,  5, 12,
-             9, 15,  5, 11,  6,  8, 13, 12,  5, 12, 13, 14, 11,  8,  5,  6 ];
-var _s2 = [  8,  9,  9, 11, 13, 15, 15,  5,  7,  7,  8, 11, 14, 14, 12,  6,
-             9, 13, 15,  7, 12,  8,  9, 11,  7,  7, 12,  7,  6, 15, 13, 11,
-             9,  7, 15, 11,  8,  6,  6, 14, 12, 13,  5, 14, 13, 13,  7,  5,
-            15,  5,  8, 11, 14, 14,  6, 14,  6,  9, 12,  9, 12,  5, 15,  8,
-             8,  5, 12,  9, 12,  5, 14,  6,  8, 13,  6,  5, 15, 13, 11, 11 ];
-
-function _f0(x,y,z) {
-    return x ^ y ^ z;
-};
-
-function _f1(x,y,z) {
-    return (x & y) | (~x & z);
-};
-
-function _f2(x,y,z) {
-    return (x | ~y) ^ z;
-};
-
-function _f3(x,y,z) {
-    return (x & z) | (y & ~z);
-};
-
-function _f4(x,y,z) {
-    return x ^ (y | ~z);
-};
-
-function _rol(n,l) {
-    return (n << l) | (n >>> (32-l));
-}
-
-function _cvt(n) {
-    return ( (n & 0xff <<  0) <<  24 )
-         | ( (n & 0xff <<  8) <<   8 )
-         | ( (n & 0xff << 16) >>>  8 )
-         | ( (n & 0xff << 24) >>> 24 );
-}
-
-function _block(X) {
-    var A1 = this._h[0], B1 = this._h[1], C1 = this._h[2], D1 = this._h[3], E1 = this._h[4],
-        A2 = this._h[0], B2 = this._h[1], C2 = this._h[2], D2 = this._h[3], E2 = this._h[4];
-
-    var j = 0, T;
-
-    for ( ; j < 16; ++j ) {
-        T = _rol( A1 + _f0(B1,C1,D1) + X[_r1[j]] + _k1[j], _s1[j] ) + E1;
-        A1 = E1; E1 = D1; D1 = _rol(C1,10); C1 = B1; B1 = T;
-        T = _rol( A2 + _f4(B2,C2,D2) + X[_r2[j]] + _k2[j], _s2[j] ) + E2;
-        A2 = E2; E2 = D2; D2 = _rol(C2,10); C2 = B2; B2 = T; }
-    for ( ; j < 32; ++j ) {
-        T = _rol( A1 + _f1(B1,C1,D1) + X[_r1[j]] + _k1[j], _s1[j] ) + E1;
-        A1 = E1; E1 = D1; D1 = _rol(C1,10); C1 = B1; B1 = T;
-        T = _rol( A2 + _f3(B2,C2,D2) + X[_r2[j]] + _k2[j], _s2[j] ) + E2;
-        A2 = E2; E2 = D2; D2 = _rol(C2,10); C2 = B2; B2 = T; }
-    for ( ; j < 48; ++j ) {
-        T = _rol( A1 + _f2(B1,C1,D1) + X[_r1[j]] + _k1[j], _s1[j] ) + E1;
-        A1 = E1; E1 = D1; D1 = _rol(C1,10); C1 = B1; B1 = T;
-        T = _rol( A2 + _f2(B2,C2,D2) + X[_r2[j]] + _k2[j], _s2[j] ) + E2;
-        A2 = E2; E2 = D2; D2 = _rol(C2,10); C2 = B2; B2 = T; }
-    for ( ; j < 64; ++j ) {
-        T = _rol( A1 + _f3(B1,C1,D1) + X[_r1[j]] + _k1[j], _s1[j] ) + E1;
-        A1 = E1; E1 = D1; D1 = _rol(C1,10); C1 = B1; B1 = T;
-        T = _rol( A2 + _f1(B2,C2,D2) + X[_r2[j]] + _k2[j], _s2[j] ) + E2;
-        A2 = E2; E2 = D2; D2 = _rol(C2,10); C2 = B2; B2 = T; }
-    for ( ; j < 80; ++j ) {
-        T = _rol( A1 + _f4(B1,C1,D1) + X[_r1[j]] + _k1[j], _s1[j] ) + E1;
-        A1 = E1; E1 = D1; D1 = _rol(C1,10); C1 = B1; B1 = T;
-        T = _rol( A2 + _f0(B2,C2,D2) + X[_r2[j]] + _k2[j], _s2[j] ) + E2;
-        A2 = E2; E2 = D2; D2 = _rol(C2,10); C2 = B2; B2 = T; }
-
-    T = this._h[1] + C1 + D2;
-    this._h[1] = this._h[2] + D1 + E2;
-    this._h[2] = this._h[3] + E1 + A2;
-    this._h[3] = this._h[4] + A1 + B2;
-    this._h[4] = this._h[0] + B1 + C2;
-    this._h[0] = T;
-}
-
-})();

src/js/sjcl-custom/sjcl-validecc.js

@@ -1,38 +0,0 @@
-sjcl.ecc.ecdsa.secretKey.prototype.sign = function(hash, paranoia, k_for_testing) {
-  var R = this._curve.r,
-      l = R.bitLength();
-
-  // k_for_testing should ONLY BE SPECIFIED FOR TESTING
-  // specifying it will make the signature INSECURE
-  var k;
-  if (typeof k_for_testing === 'object' && k_for_testing.length > 0 && typeof k_for_testing[0] === 'number') {
-    k = k_for_testing;
-  } else if (typeof k_for_testing === 'string' && /^[0-9a-fA-F]+$/.test(k_for_testing)) {
-    k = sjcl.bn.fromBits(sjcl.codec.hex.toBits(k_for_testing));        
-  } else {
-    // This is the only option that should be used in production
-    k = sjcl.bn.random(R.sub(1), paranoia).add(1);
-  }
-
-  var r = this._curve.G.mult(k).x.mod(R);
-  var s = sjcl.bn.fromBits(hash).add(r.mul(this._exponent)).mul(k.inverseMod(R)).mod(R);
-
-  return sjcl.bitArray.concat(r.toBits(l), s.toBits(l));
-};
-
-sjcl.ecc.ecdsa.publicKey.prototype.verify = function(hash, rs) {
-  var w = sjcl.bitArray,
-      R = this._curve.r,
-      l = R.bitLength(),
-      r = sjcl.bn.fromBits(w.bitSlice(rs,0,l)),
-      s = sjcl.bn.fromBits(w.bitSlice(rs,l,2*l)),
-      sInv = s.inverseMod(R),
-      hG = sjcl.bn.fromBits(hash).mul(sInv).mod(R),
-      hA = r.mul(sInv).mod(R),
-      r2 = this._curve.G.mult2(hG, hA, this._point).x;
-
-  if (r.equals(0) || s.equals(0) || r.greaterEquals(R) || s.greaterEquals(R) || !r2.equals(r)) {
-    throw (new sjcl.exception.corrupt("signature didn't check out"));
-  }
-  return true;
-};

src/js/sjcl/.gitignore

@@ -1,2 +0,0 @@
-core.js
-core_closure.js

src/js/sjcl/.travis.yml

@@ -1,9 +0,0 @@
-before_script: ./configure --with-all
-
-language: node_js
-node_js:
-  - "0.11"
-  - "0.10"
-  - "0.8"
-# 0.6 appears to be unreliable on Travis at the moment.
-#  - "0.6"

src/js/sjcl/Makefile

@@ -1,93 +0,0 @@
-JSDOCSTYLE= codeview
-JSDOCDIR= jsdoc_toolkit-2.3.3-beta
-JSDOC= $(JSDOCDIR)/jsrun.sh
-JSTEMPLATEDIR= $(JSDOCDIR)/templates/$(JSDOCSTYLE)/
-
-YUICOMPRESSOR= yuicompressor-2.4.2.jar
-
-include config.mk
-
-.PHONY: all test test_yui test_closure test_uncompressed lint compression_stats
-
-all: sjcl.js
-
-sjcl.js: $(COMPRESS)
-	cp $^ $@
-
-core.js: $(SOURCES) config.mk
-	cat $(SOURCES) > $@
-
-# compressed targets
-core_closure.js: core.js compress/compress_with_closure.sh compress/*.pl
-	compress/compress_with_closure.sh $< > $@
-
-core_yui.js: core.js compress/compress_with_yui.sh compress/*.pl
-	compress/compress_with_yui.sh $< > $@
-
-compression_stats: core.js core_closure.js core_yui.js
-	gzip -c core.js > core.js.gz
-	gzip -c core_yui.js > core_yui.js.gz
-	gzip -c core_closure.js > core_closure.js.gz
-
-	@echo
-	@echo
-	@echo Compression stats:
-	@echo
-	@wc -c core.js core_closure.js core_yui.js | head -n -1
-	@echo
-	@wc -c core*.js.gz | head -n -1
-	@echo
-	@echo
-
-	rm -f core*.js.gz
-
-doc: $(SOURCES)
-	rm -fr $@
-	JSDOCDIR=$(JSDOCDIR) $(JSDOC) -t=$(JSTEMPLATEDIR) $(SOURCES) -d=$@
-
-doc_private: $(SOURCES)
-	rm -fr $@
-	JSDOCDIR=$(JSDOCDIR) $(JSDOC) -t=$(JSTEMPLATEDIR) $(SOURCES) --private -d=$@
-
-lint: core.js core/*.js test/*.js browserTest/*.js lint/coding_guidelines.pl
-	rhino lint/jslint_rhino.js core.js
-	lint/coding_guidelines.pl core/*.js test/*.js browserTest/*.js
-
-
-TEST_COMMON=  browserTest/nodeUtil.js test/test.js
-
-TEST_SCRIPTS= $(TEST_COMMON) \
-              test/aes_vectors.js test/aes_test.js \
-              test/bitArray_vectors.js test/bitArray_test.js \
-              test/ocb2_vectors.js test/ocb2_test.js  \
-              test/ccm_vectors.js test/ccm_test.js  \
-              test/cbc_vectors.js test/cbc_test.js  \
-              test/gcm_vectors.js test/gcm_test.js  \
-              test/sha256_vectors.js test/sha256_test.js \
-              test/sha256_test_brute_force.js \
-              test/sha512_vectors.js test/sha512_test.js \
-              test/sha512_test_brute_force.js \
-              test/sha1_vectors.js test/sha1_test.js \
-              test/hmac_vectors.js test/hmac_test.js \
-              test/pbkdf2_test.js \
-              test/bn_vectors.js test/bn_test.js \
-              test/ecdsa_test.js test/ecdsa_vectors.js test/ecdh_test.js \
-              test/srp_vectors.js test/srp_test.js \
-              test/json_test.js
-
-# Run all tests in node.js.
-
-test: sjcl.js $(TEST_SCRIPTS) test/run_tests_node.js
-	node test/run_tests_node.js $< $(TEST_SCRIPTS)
-
-tidy:
-	find . -name '*~' -delete
-	rm -f core.js core_*.js
-
-clean: tidy
-	rm -fr sjcl.js doc doc_private
-
-distclean: clean
-	./configure
-	make sjcl.js tidy
-

src/js/sjcl/README.md

@@ -1,21 +0,0 @@
-sjcl
-====
-
-[![Build Status](https://travis-ci.org/bitwiseshiftleft/sjcl.png)](https://travis-ci.org/bitwiseshiftleft/sjcl)
-
-Stanford Javascript Crypto Library
-
-Security Advisories
-===
-* 12.02.2014: the current development version has a paranoia bug in the ecc module. The bug was introduced in commit [ac0b3fe0](https://github.com/bitwiseshiftleft/sjcl/commit/ac0b3fe0) and might affect ecc key generation on platforms without a platform random number generator.
-* 
-
-Security Contact
-====
-Security Mail: sjcl@ovt.me  
-OpenPGP-Key Fingerprint: 0D54 3E52 87B4 EC06 3FA9 0115 72ED A6C7 7AAF 48ED  
-Keyserver: pool.sks-keyservers.net  
-
-Documentation
-====
-The documentation is available [here](http://bitwiseshiftleft.github.io/sjcl/doc/)

src/js/sjcl/README/COPYRIGHT

@@ -1,32 +0,0 @@
-SJCL used to be in the public domain.  Now it's:
-
-Copyright 2009-2010 Emily Stark, Mike Hamburg, Dan Boneh, Stanford University.
-
-This is for liability reasons.  (Speaking of which, SJCL comes with NO
-WARRANTY WHATSOEVER, express or implied, to the limit of applicable
-law.)
-
-SJCL is dual-licensed under the GNU GPL version 2.0 or higher, and a
-2-clause BSD license.  You may use SJCL under the terms of either of
-these licenses.  For your convenience, the GPL versions 2.0 and 3.0
-and the 2-clause BSD license are included here.  Additionally, you may
-serve "crunched" copies of sjcl (i.e. those with comments removed,
-and other transformations to reduce code size) without any copyright
-notice.
-
-SJCL includes JsDoc toolkit, YUI compressor, Closure compressor,
-JSLint and the CodeView template in its build system.  These programs'
-copyrights are owned by other people.  They are distributed here under
-the MPL, MIT, BSD, Apache and JSLint licenses.  Codeview is "free for
-download" but has no license attached; it is Copyright 2010 Wouter Bos.
-
-The BSD license is (almost?) strictly more permissive, but the
-additionally licensing under the GPL allows us to use OCB 2.0 code
-royalty-free (at least, if OCB 2.0's creator Phil Rogaway has anything
-to say about it).  Note that if you redistribute SJCL under a license
-other than the GPL, you or your users may need to pay patent licensing
-fees for OCB 2.0.
-
-There may be patents which apply to SJCL other than Phil Rogaway's OCB
-patents.  We suggest that you consult legal counsel before using SJCL
-in a commercial project.

src/js/sjcl/README/INSTALL

@@ -1,36 +0,0 @@
-SJCL comes with a file sjcl.js pre-built.  This default build includes
-all the modules except for sjcl.codec.bytes (because the demo site doesn't
-use it).  All you need to do to install is copy this file to your web
-server and start using it.
-
-SJCL is divided into modules implementing various cryptographic and
-convenience functions.  If you don't need them all for your application,
-you can reconfigure SJCL for a smaller code size.  To do this, you can
-run
-
-./configure --without-all --with-aes --with-sha256 ...
-
-Then type
-
-make
-
-to rebuild sjcl.js.  This will also create a few intermediate files
-core*.js; you can delete these automatically by typing
-
-make sjcl.js tidy
-
-instead.  You will need make, perl, bash and java to rebuild SJCL.
-
-Some of the modules depend on other modules; configure should handle this
-automatically unless you tell it --without-FOO --with-BAR, where BAR
-depends on FOO.  If you do this, configure will yell at you.
-
-SJCL is compressed by stripping comments, shortening variable names, etc.
-You can also pass a --compress argument to configure to change the
-compressor.  By default SJCL uses some perl/sh scripts and Google's
-Closure compressor.
-
-If you reconfigure SJCL, it is recommended that you run the included test
-suite by typing "make test".  If this prints "FAIL" or segfaults, SJCL
-doesn't work; please file a bug.
-

src/js/sjcl/README/bsd.txt

@@ -1,30 +0,0 @@
-Copyright 2009-2010 Emily Stark, Mike Hamburg, Dan Boneh.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   1. Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-
-   2. Redistributions in binary form must reproduce the above
-      copyright notice, this list of conditions and the following
-      disclaimer in the documentation and/or other materials provided
-      with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
-IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
-BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
-WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
-IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-The views and conclusions contained in the software and documentation
-are those of the authors and should not be interpreted as representing
-official policies, either expressed or implied, of the authors.

src/js/sjcl/README/gpl-2.0.txt

@@ -1,339 +0,0 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 2, June 1991
-
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users.  This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it.  (Some other Free Software Foundation software is covered by
-the GNU Lesser General Public License instead.)  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it
-in new free programs; and that you know you can do these things.
-
-  To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have.  You must make sure that they, too, receive or can get the
-source code.  And you must show them these terms so they know their
-rights.
-
-  We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
-  Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software.  If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary.  To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                    GNU GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License.  The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language.  (Hereinafter, translation is included without limitation in
-the term "modification".)  Each licensee is addressed as "you".
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
-  1. You may copy and distribute verbatim copies of the Program's
-source code as you receive it, in any medium, provided that you
-conspicuously and appropriately publish on each copy an appropriate
-copyright notice and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
-  2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) You must cause the modified files to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    b) You must cause any work that you distribute or publish, that in
-    whole or in part contains or is derived from the Program or any
-    part thereof, to be licensed as a whole at no charge to all third
-    parties under the terms of this License.
-
-    c) If the modified program normally reads commands interactively
-    when run, you must cause it, when started running for such
-    interactive use in the most ordinary way, to print or display an
-    announcement including an appropriate copyright notice and a
-    notice that there is no warranty (or else, saying that you provide
-    a warranty) and that users may redistribute the program under
-    these conditions, and telling the user how to view a copy of this
-    License.  (Exception: if the Program itself is interactive but
-    does not normally print such an announcement, your work based on
-    the Program is not required to print an announcement.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
-    a) Accompany it with the complete corresponding machine-readable
-    source code, which must be distributed under the terms of Sections
-    1 and 2 above on a medium customarily used for software interchange; or,
-
-    b) Accompany it with a written offer, valid for at least three
-    years, to give any third party, for a charge no more than your
-    cost of physically performing source distribution, a complete
-    machine-readable copy of the corresponding source code, to be
-    distributed under the terms of Sections 1 and 2 above on a medium
-    customarily used for software interchange; or,
-
-    c) Accompany it with the information you received as to the offer
-    to distribute corresponding source code.  (This alternative is
-    allowed only for noncommercial distribution and only if you
-    received the program in object code or executable form with such
-    an offer, in accord with Subsection b above.)
-
-The source code for a work means the preferred form of the work for
-making modifications to it.  For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable.  However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License.  Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
-  5. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Program or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
-  6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded.  In such case, this License incorporates
-the limitation as if written in the body of this License.
-
-  9. The Free Software Foundation may publish revised and/or new versions
-of the General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Program
-specifies a version number of this License which applies to it and "any
-later version", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation.  If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
-  10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission.  For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this.  Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
-                            NO WARRANTY
-
-  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
-PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
-REPAIR OR CORRECTION.
-
-  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGES.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-convey the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with this program; if not, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
-    Gnomovision version 69, Copyright (C) year name of author
-    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, the commands you use may
-be called something other than `show w' and `show c'; they could even be
-mouse-clicks or menu items--whatever suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-  `Gnomovision' (which makes passes at compilers) written by James Hacker.
-
-  <signature of Ty Coon>, 1 April 1989
-  Ty Coon, President of Vice
-
-This General Public License does not permit incorporating your program into
-proprietary programs.  If your program is a subroutine library, you may
-consider it more useful to permit linking proprietary applications with the
-library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.

src/js/sjcl/README/gpl-3.0.txt

@@ -1,674 +0,0 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU General Public License from time to time.  Such new versions will
-be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<http://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<http://www.gnu.org/philosophy/why-not-lgpl.html>.

src/js/sjcl/bower.json

@@ -1,12 +0,0 @@
-{
-	"name": "sjcl",
-	"version": "1.0.0",
-	"main": ["./sjcl.js"],
-	"ignore": [
-		"**/*",
-		"!README.md",
-		"!README/*",
-		"!bower.json",
-		"!sjcl.js"
-	]
-}

src/js/sjcl/browserTest/browserTest.html

@@ -1,16 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-        
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-  <title>SJCL browser test</title>
-  <link rel="stylesheet" type="text/css" href="test.css"/>
-  <script type="text/javascript" src="browserUtil.js"></script>
-  <script type="text/javascript" src="../test/run_tests_browser.js"></script>
-</head>
-<body onload="testCores(['sjcl.js'])">
-  <h1>SJCL browser test</h1>
-  <div id="status">Waiting for tests to begin...</div>
-  <div id="print"></div>
-</body>
-</html>

src/js/sjcl/browserTest/browserUtil.js

@@ -1,133 +0,0 @@
-browserUtil = {};
-
-browserUtil.isNodeJS = (typeof(window) === 'undefined');
-
-/**
- * Pause (for the graphics to update and the script timer to clear), then run the
- * specified action.
- */
-browserUtil.pauseAndThen = function (cb) {
-  cb && window.setTimeout(cb, 1);
-};
-
-/**
- * Iterate using continuation-passing style.
- */
-browserUtil.cpsIterate = function (f, start, end, pause, callback) {
-  var pat = pause ? browserUtil.pauseAndThen : function (cb) { cb && cb(); };
-  function go() {
-    var called = false;
-    if (start >= end) {
-      pat(callback);
-    } else {
-      pat(function () { f(start, function () {
-        if (!called) { called = true; start++; go(); }
-      }); });
-    }
-  }
-  go (start);
-};
-
-/**
- * Map a function over an array using continuation-passing style.
- */
-browserUtil.cpsMap = function (map, list, pause, callback) {
-  browserUtil.cpsIterate(function (i, cb) { map(list[i], i, list.length, cb); },
-                         0, list.length, pause, callback);
-}
-
-/** Cache for remotely loaded scripts. */
-browserUtil.scriptCache = {}
-
-/** Load several scripts, then call back */
-browserUtil.loadScripts = function(scriptNames, cbSuccess, cbError) {
-  var head = document.getElementsByTagName('head')[0];
-  browserUtil.cpsMap(function (script, i, n, cb) {
-    var scriptE = document.createElement('script'), xhr, loaded = false;
-    
-    browserUtil.status("Loading script " + script);
-    
-    if (window.location.protocol === "file:") {
-      /* Can't make an AJAX request for files.
-       * But, we know the load time will be short, so timeout-based error
-       * detection is fine.
-       */
-      scriptE.onload = function () {
-        loaded = true;
-        cb();
-      };
-      scriptE.onerror = function(err) {
-        cbError && cbError(script, err, cb);
-      };
-      script.onreadystatechange = function() {
-        if (this.readyState == 'complete' || this.readyState == 'loaded') {
-          loaded = true;
-          cb();
-        }
-      };
-      scriptE.type = 'text/javascript';
-      scriptE.src = script+"?"+(new Date().valueOf());
-      window.setTimeout(function () {
-        loaded || cbError && cbError(script, "timeout expired", cb);
-      }, 100);
-      head.appendChild(scriptE);
-    } else if (browserUtil.scriptCache[script] !== undefined) {
-      try {
-        scriptE.appendChild(document.createTextNode(browserUtil.scriptCache[script]));
-      } catch (e) {
-        scriptE.text = browserUtil.scriptCache[script];
-      }
-      head.appendChild(scriptE);
-      cb();
-    } else {
-      var xhr;
-      if (window.XMLHttpRequest) {
-        xhr = new XMLHttpRequest;
-      } else if (window.ActiveXObject) {
-        xhr = new ActiveXObject("Microsoft.XMLHTTP");
-      }
-      xhr.onreadystatechange = function() {
-        if (xhr.readyState == 4) {
-          if (xhr.status == 200) {
-            browserUtil.scriptCache[script] = xhr.responseText;
-            try {
-              scriptE.appendChild(document.createTextNode(xhr.responseText));
-            } catch (e) {
-              scriptE.text = xhr.responseText;
-            }
-            head.appendChild(scriptE);
-            cb();
-          } else {
-            cbError && cbError(script, xhr.status, cb);
-          }
-        }
-      }
-      xhr.open("GET", script+"?"+(new Date().valueOf()), true);
-      xhr.send();
-    }
-  }, scriptNames, false, cbSuccess);
-};
-
-/** Write a message to the console */
-browserUtil.write = function(type, message) {
-  var d1 = document.getElementById("print"), d2 = document.createElement("div"), d3 = document.createElement("div");
-  d3.className = type;
-  d3.appendChild(document.createTextNode(message));
-  d2.appendChild(d3);
-  d1.appendChild(d2);
-  return { update: function (type2, message2) {
-    var d4 = document.createElement("div");
-    d4.className = type2 + " also";
-    d4.appendChild(document.createTextNode(message2));
-    d2.insertBefore(d4, d3);
-  }};
-};
-
-/** Write a newline.  Does nothing in the browser. */
-browserUtil.writeNewline = function () { };
-
-/** Write a message to the status line */
-browserUtil.status = function(message) {
-  var d1 = document.getElementById("status");
-  d1.replaceChild(document.createTextNode(message), d1.firstChild);
-};

src/js/sjcl/browserTest/entropy.html

@@ -1,88 +0,0 @@
-<html>
-<head>
-
-<title>Entropy Generator Progress</title>
-<!-- ProgressBar source: http://stackoverflow.com/questions/7190898/progress-bar-with-html-and-css -->
-
-<style>
-#progressbar {
-  background-color: black;
-  border-radius: 13px; /* (height of inner div) / 2 + padding */
-  padding: 3px;
-}
-#progressbar > div {
-   background-color: orange;
-   width: 0%; /* Adjust with JavaScript */
-   height: 20px;
-   border-radius: 10px;
-}
-</style>
-
-<script type="text/javascript" src="../sjcl.js">
-</script>
-
-<script type="text/javascript">
-
-var busy = 0;
-var collecting = 0;
-
-function showprogress () {
-	var barwidth = document.getElementById ("progresswidth");
-	var paranoia = parseInt (document.getElementById ("paranoialevel").value);
-	var progress = 100 * sjcl.random.getProgress (paranoia);
-	barwidth.style.width = progress+"%";
-	if (!sjcl.random.isReady (paranoia)) {
-		setTimeout ("showprogress()", 10, "JavaScript");
-	} else {
-		busy = 0;
-		document.getElementById ("startbutton").style.disabled = 1;
-	}
-}
-
-function startup () {
-	if (collecting == 0) {
-		sjcl.random.startCollectors ();
-		collecting = 1;
-	}
-	if (busy == 0) {
-		busy = 1;
-		document.getElementById ("startbutton").style.disabled = 1;
-		showprogress ();
-	}
-}
-
-function consume (numbits) {
-	var collector = document.getElementById ("collector");
-	collector.value = "retrieving random data";
-	var paranoia = document.getElementById ("paranoialevel").value;
-	var numwords = Math.ceil (numbits / 32);
-	var bits = sjcl.random.randomWords (numwords, paranoia);
-	collector.value = '';
-	for (var i=0; i<numwords; i++) {
-		var hi = (bits [i] >> 16) & 0x0000ffff;
-		var lo =  bits [i]        & 0x0000ffff;
-		collector.value = collector.value + hi.toString (16) + lo.toString (16);
-	}
-	startup ();
-}
-
-</script>
-
-</head>
-<body>
-<h1>Entropy Generator Progress</h1>
-
-<p>Target: 192 bits, available at paranoia level 5.</p>
-
-<p>Corresponding paranoia level from [0,1..10]: <input type="text" value="5" id="paranoialevel"/> <input type=button onclick="startup ()" id="startbutton" value=" Start &gt;&gt; "> (the idea being that you can see the progress bar advance gently from empty/black to full/yellow after you press this)</p>
-
-<p><input type=button onclick="consume (192)" value=" Consume 192 bits &gt;&gt; "><input type=text id=collector size=50 value="" onkeypress="consume (192)"> (also consumes 192 bits with every keypress in the text field; use key repeat to consume swiftly)</p>
-
-<div id="progressbar">
-  <div id="progresswidth"></div>
-</div>
-
-<p>Please move your mouse, play around and generally introduce entropy into your environment.</p>
-
-</body>
-</html>

src/js/sjcl/browserTest/nodeUtil.js

@@ -1,44 +0,0 @@
-browserUtil = {
-  isNodeJS: true,
-  
-  pauseAndThen: function (cb) { cb(); },
-  
-  cpsIterate: function (f, start, end, pause, callback) {
-    function go() {
-      var called = false;
-      if (start >= end) {
-        callback && callback();
-      } else {
-        f(start, function () {
-          if (!called) { called = true; start++; go(); }
-        });
-      }
-    }
-    go (start);
-  },
-  
-  cpsMap: function (map, list, pause, callback) {
-    browserUtil.cpsIterate(function (i, cb) { map(list[i], i, list.length, cb); },
-                           0, list.length, pause, callback);
-  },
-
-  loadScripts: function(scriptNames, callback) {
-    for (i=0; i<scriptNames.length; i++) {
-      load(scriptNames[i]);
-      callback && callback();
-    }
-  },
-  
-  write: function(type, message) {
-    console.log(message);
-    return { update: function (type2, message2) {
-      if (type2 === 'pass') { console.log("  + " + message2); }
-      else if (type2 === 'unimplemented') { console.log("  ? " + message2); }
-      else { console.log("  - " + message2); }
-    }};
-  },
-  
-  writeNewline: function () { console.log(""); },
-  
-  status: function(message) {}
-};

src/js/sjcl/browserTest/rhinoUtil.js

@@ -1,44 +0,0 @@
-browserUtil = {
-  isRhino: true,
-  
-  pauseAndThen: function (cb) { cb(); },
-  
-  cpsIterate: function (f, start, end, pause, callback) {
-    function go() {
-      var called = false;
-      if (start >= end) {
-        callback && callback();
-      } else {
-        f(start, function () {
-          if (!called) { called = true; start++; go(); }
-        });
-      }
-    }
-    go (start);
-  },
-  
-  cpsMap: function (map, list, pause, callback) {
-    browserUtil.cpsIterate(function (i, cb) { map(list[i], i, list.length, cb); },
-                           0, list.length, pause, callback);
-  },
-
-  loadScripts: function(scriptNames, callback) {
-    for (i=0; i<scriptNames.length; i++) {
-      load(scriptNames[i]);
-      callback && callback();
-    }
-  },
-  
-  write: function(type, message) {
-    print(message);
-    return { update: function (type2, message2) {
-      if (type2 === 'pass') { print("  + " + message2); }
-      else if (type2 === 'unimplemented') { print("  ? " + message2); }
-      else { print("  - " + message2); }
-    }};
-  },
-  
-  writeNewline: function () { print(""); },
-  
-  status: function(message) {}
-};

src/js/sjcl/browserTest/test.css

@@ -1,59 +0,0 @@
-* {
-  margin: 0px;
-  padding: 0px;
-  font-family: Arial, Helvetica, FreeSans, sans;
-}
-
-#print {
-  position: relative;
-  width: 40em;
-  margin: 0px auto;
-  padding: 5px;
-}
-
-#print div {
-  position: relative;
-}
-
-.pass { color: #0A0; }
-.fail { color: #A00; }
-.unimplemented { color: #F80; }
-
-.begin {
-  text-align: center;
-  padding-bottom: 2px;
-  border-bottom: 1px solid #aaa;
-  margin: 0px auto 2px auto;
-}
-
-.all {
-  text-align: center;
-  font-weight: bold;
-}
-
-*+* > .begin, *+* > .all {
-  margin-top: 1em;
-}
-
-.also {
-  float: right;
-  width: 17em;
-  text-align: right;
-}
-
-h1 {
-  text-align: center;
-  background: #8A0000;
-  padding: 5px;
-  color: white;
-}
-
-#status {
-  padding: 3px 10px 3px 5px;
-  background: #d5c490;
-  color: #444;
-  font-size: 0.8em;
-  margin-bottom: 1em;
-  height: 1.3em;
-  vertical-align: middle;
-}

src/js/sjcl/component.json

@@ -1,5 +0,0 @@
-{
-	"name": "sjcl",
-	"version": "1.0.0",
-	"main": ["./sjcl.js"]
-}

src/js/sjcl/compress/compress_with_closure.sh

@@ -1,15 +0,0 @@
-#!/bin/bash
-
-DIR=`dirname $0`
-
-$DIR/remove_constants.pl $1 | $DIR/opacify.pl > ._tmpRC.js
-
-echo -n '"use strict";'
-java -jar $DIR/compiler.jar --compilation_level ADVANCED_OPTIMIZATIONS \
-     --js ._tmpRC.js \
-     | $DIR/digitize.pl \
-     | $DIR/dewindowize.pl
-     
-
-rm -f ._tmpRC.js
-

src/js/sjcl/compress/compress_with_yui.sh

@@ -1,13 +0,0 @@
-#!/bin/bash
-
-# Compress $1 with YUI Compressor 2.4.2, returning the compressed script on stdout
-
-DIR=`dirname $0`
-
-$DIR/remove_constants.pl $1 > ._tmpRC.js
-
-java -jar $DIR/yuicompressor-2.4.2.jar ._tmpRC.js \
-  | $DIR/digitize.pl
-
-rm -f ._tmpRC.js
-

src/js/sjcl/compress/dewindowize.pl

@@ -1,8 +0,0 @@
-#!/usr/bin/env perl
-
-while (<>) {
-  s/window\.sjcl\s*=/var sjcl=/g;
-  s/window\.sjcl/sjcl/g;
-  print;
-}
-

src/js/sjcl/compress/digitize.pl

@@ -1,22 +0,0 @@
-#!/usr/bin/env perl
-
-# Convert numbers to hex, when doing so is likely to increase compressibility.
-# This actually makes the script slightly longer, but generally makes it compress
-# to something shorter.
-#
-# Here we're targeting constants like 0xFF, 0xFFFF0000, 0x10101, 0x100000000, etc.
-
-sub digitize {
-    my $number = shift;
-    if ($number >= 256) {
-	my $nn = `printf "%x" $number`;
-	if ($nn =~ /^[01f]+$/i) { return "0x$nn"; }
-    }
-    return $number;
-}
-
-while (<>) {
-    s/([^a-zA-Z0-9_"])(\d+)/$1 . digitize $2/eg;
-    print;
-}
-

src/js/sjcl/compress/opacify.pl

@@ -1,39 +0,0 @@
-#!/usr/bin/env perl
-
-# This script is a hack.
-#
-# Opacify all non-private names by turning them into strings.
-# That way, the Google compressor won't rename them.
-#
-# The script ignores properties whose names begin with _, because they
-# are believed to be private.
-#
-# XXX TODO FIXME: this messes with strings, so it screws up exceptions.
-
-my $script = join '', <>;
-
-# remove comments
-#$script =~ s=/\*([^\*]|\*+[^\/])*\*/==g;
-#$script =~ s=//.*==g;
-
-# stringify property names
-$script =~ s=\.([a-zA-Z][_a-zA-Z0-9]*)=['$1']=g;
-
-# destringify 'prototype'
-$script =~ s=\['prototype'\]=.prototype=g;
-
-# stringify sjcl
-$script =~ s=(?:var\s+)?sjcl(\.|\s*\=)=window['sjcl']$1=g;
-
-# stringify object notation
-$script =~ s=([\{,]
-              \s*
-              (?:/\*(?:[^\*]|\*+[^\/])*\*/\s* # preserve C-style comments
-              |//[^\n]*\n\s*)*) 
-             ([a-zA-Z0-9][_a-zA-Z0-9]*):=$1'$2':=xg;
-
-# Export sjcl.  This is a bit of a hack, and might get replaced later.
-print $script;
-
-# not necessary with windowization.
-# print "window\['sjcl'\] = sjcl;\n";

src/js/sjcl/compress/remove_constants.pl

@@ -1,69 +0,0 @@
-#!/usr/bin/env perl
-
-# This script is a hack.  It identifies things which it believes to be
-# constant, then replaces them throughout the code.
-#
-# Constants are identified as properties declared in object notation
-# with values consisting only of capital letters and underscores.  If
-# the first character is an underscore, the constant is private, and
-# can be removed entirely.
-#
-# The script dies if any two constants have the same property name but
-# different values.
-my $script = join '', <>;
-
-# remove comments
-#$script =~ s=/\*([^\*]|\*+[^\/])*\*/==g;
-#$script =~ s=//.*==g;
-
-sub preserve {
-  my $stuff = shift;
-  $stuff =~ s/,//;
-  return $stuff;
-}
-
-my %constants = ();
-
-sub add_constant {
-  my ($name, $value) = @_;
-  if (defined $constants{$name} && $constants{$name} ne $value) {
-    print STDERR "variant constant $name = $value";
-    die;
-  } else {
-    $constants{$name} = $value;
-    #print STDERR "constant: $name = $value\n";
-  }
-}
-
-# find private constants
-while ($script =~
-  s/([,\{]) \s*              # indicator that this is part of an object
-    (_[A-Z0-9_]+) \s* : \s*  # all-caps variable name beginning with _
-    (\d+|0x[0-9A-Fa-f]+) \s* # numeric value
-    ([,\}])                  # next part of object
-   /preserve "$1$4"/ex) {
-   add_constant $2, $3;
-}
-
-my $script2 = '';
-
-# find public constants
-while ($script =~
-  s/^(.*?)                   # beginning of script
-    ([,\{]) \s*              # indicator that this is part of an object
-    ([A-Z0-9_]+) \s* : \s*   # all-caps variable name
-    (\d+|0x[0-9A-Fa-f]+) \s* # numeric value
-    ([,\}])                  # next part of object([,\{]) \s*
-   /$5/esx) {
-   $script2 .= "$1$2$3:$4";
-   add_constant $3, $4;
-}
-
-$script = "$script2$script";
-
-foreach (keys %constants) {
-  my $value = $constants{$_};
-  $script =~ s/(?:[a-zA-Z0-9_]+\.)+$_(?=[^a-zA-Z0-9_])/$value/g;
-}
-
-print $script;

src/js/sjcl/config.mk

@@ -1,2 +0,0 @@
-SOURCES= core/sjcl.js core/aes.js core/bitArray.js core/codecString.js core/codecHex.js core/codecBase64.js core/sha256.js core/ccm.js core/ocb2.js core/gcm.js core/hmac.js core/pbkdf2.js core/random.js core/convenience.js 
-COMPRESS= core_closure.js

src/js/sjcl/configure

@@ -1,144 +0,0 @@
-#!/usr/bin/env perl
-
-use strict;
-
-my ($arg, $i, $j, $targ);
-
-my @targets = qw/sjcl aes bitArray codecString codecHex codecBase32 codecBase64 codecBytes sha256 sha512 sha1 ccm cbc ocb2 gcm hmac pbkdf2 random convenience bn ecc srp/;
-my %deps = ('aes'=>'sjcl',
-            'bitArray'=>'sjcl',
-            'codecString'=>'bitArray',
-            'codecHex'=>'bitArray',
-            'codecBase64'=>'bitArray',
-            'codecBase32'=>'bitArray',
-            'codecBytes'=>'bitArray',
-            'sha256'=>'codecString',
-            'sha512'=>'codecString',
-            'sha1'=>'codecString',
-            'ccm'=>'bitArray,aes',
-            'ocb2'=>'bitArray,aes',
-            'gcm'=>'bitArray,aes',
-            'hmac'=>'sha256',
-            'pbkdf2'=>'hmac',
-            'srp'=>'sha1,bn,bitArray',
-            'bn'=>'bitArray,random',
-            'ecc'=>'bn',
-            'cbc'=>'bitArray,aes',
-            'random'=>'sha256,aes',
-            'convenience'=>'ccm,pbkdf2,random,codecBase64');
-            
-my $compress = "closure";
-            
-my %enabled = ();
-$enabled{$_} = 0 foreach (@targets);
-
-# by default, all but codecBytes, srp, bn
-$enabled{$_} = 1 foreach (qw/aes bitArray codecString codecHex codecBase32 codecBase64 sha256 ccm ocb2 gcm hmac pbkdf2 random convenience/);
-
-# argument parsing
-while (my $arg = shift @ARGV) {
-  if ($arg =~ /^--?with-all$/) {
-    foreach (@targets) {
-      if ($enabled{$_} == 0) {
-        $enabled{$_} = 1;
-      }
-    }
-  } elsif ($arg =~ /^--?without-all$/) {
-    foreach (@targets) {
-      if ($enabled{$_} == 1) {
-        $enabled{$_} = 0;
-      }
-    }
-  } elsif ($arg =~ /^--?with-(.*)$/) {
-    $targ = $1;
-    $targ =~ s/-(.)/uc $1/ge;
-    if (!defined $deps{$targ}) {
-      print STDERR "No such target $targ\n";
-      exit 1;
-    }
-    $enabled{$targ} = 2;
-  } elsif ($arg =~ /^--?without-(.*)$/) {
-    $targ = $1;
-    $targ =~ s/-(.)/uc $1/ge;
-    if (!defined $deps{$targ}) {
-      print STDERR "No such target $targ\n";
-      exit 1;
-    }
-    $enabled{$targ} = -1;
-  } elsif ($arg =~ /^--?compress(?:or|ion)?=(none|closure|yui)$/) {
-    $compress = $1;
-  } else {
-    my $targets = join " ", @targets;
-    $targets =~ s/sjcl //;
-    $targets =~ s/(.{50})\s+/$1\n    /g;
-    print STDERR <<EOT;
-Usage: $0 arguments...
-
-Valid arguments are:
-  --with-all: by default, include all targets
-  --without-all: by default, include no targets
-  
-  --compress=none|closure|yui
-  
-  --with-TARGET: require TARGET
-  --without-TARGET: forbid TARGET
-  
-  --help: show this message
-  
-  Valid targets are:
-    $targets
-
-EOT
-    exit 1 unless $arg =~ /^--?help$/;
-    exit 0;
-  }
-}
-
-my $config = '';
-my $pconfig;
-
-# dependency analysis: forbidden
-foreach my $i (@targets) {
-  if ($enabled{$i} > 0) {
-    foreach $j (split /,/, $deps{$i}) {
-      if ($enabled{$j} == -1) {
-        if ($enabled{$i} == 2) {
-          print STDERR "Conflicting options: $i depends on $j\n";
-          exit 1;
-        } else {
-          $enabled{$i} = -1;
-          last;
-        }
-      }
-    }
-  }
-}
-
-# reverse
-foreach my $i (reverse @targets) {
-  if ($enabled{$i} > 0) {
-    foreach $j (split /,/, $deps{$i}) {
-      if ($enabled{$j} < $enabled{$i}) {
-        $enabled{$j} = $enabled{$i};
-      }
-    }
-    $config = "$i $config";
-  }
-}
-
-open CONFIG, "> config.mk" or die "$!";
-
-
-($pconfig = $config) =~ s/^sjcl //;
-$pconfig =~ s/ /\n  /g;
-print "Enabled components:\n  $pconfig\n";
-print "Compression: $compress\n";
-
-$config =~ s=\S+=core/$&.js=g;
-print CONFIG "SOURCES= $config\n";
-
-$compress = "core_$compress.js";
-$compress = 'core.js' if ($compress eq 'core_none.js');
-
-print CONFIG "COMPRESS= $compress\n";
-

src/js/sjcl/core/aes.js

@@ -1,208 +0,0 @@
-/** @fileOverview Low-level AES implementation.
- *
- * This file contains a low-level implementation of AES, optimized for
- * size and for efficiency on several browsers.  It is based on
- * OpenSSL's aes_core.c, a public-domain implementation by Vincent
- * Rijmen, Antoon Bosselaers and Paulo Barreto.
- *
- * An older version of this implementation is available in the public
- * domain, but this one is (c) Emily Stark, Mike Hamburg, Dan Boneh,
- * Stanford University 2008-2010 and BSD-licensed for liability
- * reasons.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-/**
- * Schedule out an AES key for both encryption and decryption.  This
- * is a low-level class.  Use a cipher mode to do bulk encryption.
- *
- * @constructor
- * @param {Array} key The key as an array of 4, 6 or 8 words.
- *
- * @class Advanced Encryption Standard (low-level interface)
- */
-sjcl.cipher.aes = function (key) {
-  if (!this._tables[0][0][0]) {
-    this._precompute();
-  }
-  
-  var i, j, tmp,
-    encKey, decKey,
-    sbox = this._tables[0][4], decTable = this._tables[1],
-    keyLen = key.length, rcon = 1;
-  
-  if (keyLen !== 4 && keyLen !== 6 && keyLen !== 8) {
-    throw new sjcl.exception.invalid("invalid aes key size");
-  }
-  
-  this._key = [encKey = key.slice(0), decKey = []];
-  
-  // schedule encryption keys
-  for (i = keyLen; i < 4 * keyLen + 28; i++) {
-    tmp = encKey[i-1];
-    
-    // apply sbox
-    if (i%keyLen === 0 || (keyLen === 8 && i%keyLen === 4)) {
-      tmp = sbox[tmp>>>24]<<24 ^ sbox[tmp>>16&255]<<16 ^ sbox[tmp>>8&255]<<8 ^ sbox[tmp&255];
-      
-      // shift rows and add rcon
-      if (i%keyLen === 0) {
-        tmp = tmp<<8 ^ tmp>>>24 ^ rcon<<24;
-        rcon = rcon<<1 ^ (rcon>>7)*283;
-      }
-    }
-    
-    encKey[i] = encKey[i-keyLen] ^ tmp;
-  }
-  
-  // schedule decryption keys
-  for (j = 0; i; j++, i--) {
-    tmp = encKey[j&3 ? i : i - 4];
-    if (i<=4 || j<4) {
-      decKey[j] = tmp;
-    } else {
-      decKey[j] = decTable[0][sbox[tmp>>>24      ]] ^
-                  decTable[1][sbox[tmp>>16  & 255]] ^
-                  decTable[2][sbox[tmp>>8   & 255]] ^
-                  decTable[3][sbox[tmp      & 255]];
-    }
-  }
-};
-
-sjcl.cipher.aes.prototype = {
-  // public
-  /* Something like this might appear here eventually
-  name: "AES",
-  blockSize: 4,
-  keySizes: [4,6,8],
-  */
-  
-  /**
-   * Encrypt an array of 4 big-endian words.
-   * @param {Array} data The plaintext.
-   * @return {Array} The ciphertext.
-   */
-  encrypt:function (data) { return this._crypt(data,0); },
-  
-  /**
-   * Decrypt an array of 4 big-endian words.
-   * @param {Array} data The ciphertext.
-   * @return {Array} The plaintext.
-   */
-  decrypt:function (data) { return this._crypt(data,1); },
-  
-  /**
-   * The expanded S-box and inverse S-box tables.  These will be computed
-   * on the client so that we don't have to send them down the wire.
-   *
-   * There are two tables, _tables[0] is for encryption and
-   * _tables[1] is for decryption.
-   *
-   * The first 4 sub-tables are the expanded S-box with MixColumns.  The
-   * last (_tables[01][4]) is the S-box itself.
-   *
-   * @private
-   */
-  _tables: [[[],[],[],[],[]],[[],[],[],[],[]]],
-
-  /**
-   * Expand the S-box tables.
-   *
-   * @private
-   */
-  _precompute: function () {
-   var encTable = this._tables[0], decTable = this._tables[1],
-       sbox = encTable[4], sboxInv = decTable[4],
-       i, x, xInv, d=[], th=[], x2, x4, x8, s, tEnc, tDec;
-
-    // Compute double and third tables
-   for (i = 0; i < 256; i++) {
-     th[( d[i] = i<<1 ^ (i>>7)*283 )^i]=i;
-   }
-   
-   for (x = xInv = 0; !sbox[x]; x ^= x2 || 1, xInv = th[xInv] || 1) {
-     // Compute sbox
-     s = xInv ^ xInv<<1 ^ xInv<<2 ^ xInv<<3 ^ xInv<<4;
-     s = s>>8 ^ s&255 ^ 99;
-     sbox[x] = s;
-     sboxInv[s] = x;
-     
-     // Compute MixColumns
-     x8 = d[x4 = d[x2 = d[x]]];
-     tDec = x8*0x1010101 ^ x4*0x10001 ^ x2*0x101 ^ x*0x1010100;
-     tEnc = d[s]*0x101 ^ s*0x1010100;
-     
-     for (i = 0; i < 4; i++) {
-       encTable[i][x] = tEnc = tEnc<<24 ^ tEnc>>>8;
-       decTable[i][s] = tDec = tDec<<24 ^ tDec>>>8;
-     }
-   }
-   
-   // Compactify.  Considerable speedup on Firefox.
-   for (i = 0; i < 5; i++) {
-     encTable[i] = encTable[i].slice(0);
-     decTable[i] = decTable[i].slice(0);
-   }
-  },
-  
-  /**
-   * Encryption and decryption core.
-   * @param {Array} input Four words to be encrypted or decrypted.
-   * @param dir The direction, 0 for encrypt and 1 for decrypt.
-   * @return {Array} The four encrypted or decrypted words.
-   * @private
-   */
-  _crypt:function (input, dir) {
-    if (input.length !== 4) {
-      throw new sjcl.exception.invalid("invalid aes block size");
-    }
-    
-    var key = this._key[dir],
-        // state variables a,b,c,d are loaded with pre-whitened data
-        a = input[0]           ^ key[0],
-        b = input[dir ? 3 : 1] ^ key[1],
-        c = input[2]           ^ key[2],
-        d = input[dir ? 1 : 3] ^ key[3],
-        a2, b2, c2,
-        
-        nInnerRounds = key.length/4 - 2,
-        i,
-        kIndex = 4,
-        out = [0,0,0,0],
-        table = this._tables[dir],
-        
-        // load up the tables
-        t0    = table[0],
-        t1    = table[1],
-        t2    = table[2],
-        t3    = table[3],
-        sbox  = table[4];
- 
-    // Inner rounds.  Cribbed from OpenSSL.
-    for (i = 0; i < nInnerRounds; i++) {
-      a2 = t0[a>>>24] ^ t1[b>>16 & 255] ^ t2[c>>8 & 255] ^ t3[d & 255] ^ key[kIndex];
-      b2 = t0[b>>>24] ^ t1[c>>16 & 255] ^ t2[d>>8 & 255] ^ t3[a & 255] ^ key[kIndex + 1];
-      c2 = t0[c>>>24] ^ t1[d>>16 & 255] ^ t2[a>>8 & 255] ^ t3[b & 255] ^ key[kIndex + 2];
-      d  = t0[d>>>24] ^ t1[a>>16 & 255] ^ t2[b>>8 & 255] ^ t3[c & 255] ^ key[kIndex + 3];
-      kIndex += 4;
-      a=a2; b=b2; c=c2;
-    }
-        
-    // Last round.
-    for (i = 0; i < 4; i++) {
-      out[dir ? 3&-i : i] =
-        sbox[a>>>24      ]<<24 ^ 
-        sbox[b>>16  & 255]<<16 ^
-        sbox[c>>8   & 255]<<8  ^
-        sbox[d      & 255]     ^
-        key[kIndex++];
-      a2=a; a=b; b=c; c=d; d=a2;
-    }
-    
-    return out;
-  }
-};
-

src/js/sjcl/core/bitArray.js

@@ -1,201 +0,0 @@
-/** @fileOverview Arrays of bits, encoded as arrays of Numbers.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-/** @namespace Arrays of bits, encoded as arrays of Numbers.
- *
- * @description
- * <p>
- * These objects are the currency accepted by SJCL's crypto functions.
- * </p>
- *
- * <p>
- * Most of our crypto primitives operate on arrays of 4-byte words internally,
- * but many of them can take arguments that are not a multiple of 4 bytes.
- * This library encodes arrays of bits (whose size need not be a multiple of 8
- * bits) as arrays of 32-bit words.  The bits are packed, big-endian, into an
- * array of words, 32 bits at a time.  Since the words are double-precision
- * floating point numbers, they fit some extra data.  We use this (in a private,
- * possibly-changing manner) to encode the number of bits actually  present
- * in the last word of the array.
- * </p>
- *
- * <p>
- * Because bitwise ops clear this out-of-band data, these arrays can be passed
- * to ciphers like AES which want arrays of words.
- * </p>
- */
-sjcl.bitArray = {
-  /**
-   * Array slices in units of bits.
-   * @param {bitArray} a The array to slice.
-   * @param {Number} bstart The offset to the start of the slice, in bits.
-   * @param {Number} bend The offset to the end of the slice, in bits.  If this is undefined,
-   * slice until the end of the array.
-   * @return {bitArray} The requested slice.
-   */
-  bitSlice: function (a, bstart, bend) {
-    a = sjcl.bitArray._shiftRight(a.slice(bstart/32), 32 - (bstart & 31)).slice(1);
-    return (bend === undefined) ? a : sjcl.bitArray.clamp(a, bend-bstart);
-  },
-
-  /**
-   * Extract a number packed into a bit array.
-   * @param {bitArray} a The array to slice.
-   * @param {Number} bstart The offset to the start of the slice, in bits.
-   * @param {Number} length The length of the number to extract.
-   * @return {Number} The requested slice.
-   */
-  extract: function(a, bstart, blength) {
-    // FIXME: this Math.floor is not necessary at all, but for some reason
-    // seems to suppress a bug in the Chromium JIT.
-    var x, sh = Math.floor((-bstart-blength) & 31);
-    if ((bstart + blength - 1 ^ bstart) & -32) {
-      // it crosses a boundary
-      x = (a[bstart/32|0] << (32 - sh)) ^ (a[bstart/32+1|0] >>> sh);
-    } else {
-      // within a single word
-      x = a[bstart/32|0] >>> sh;
-    }
-    return x & ((1<<blength) - 1);
-  },
-
-  /**
-   * Concatenate two bit arrays.
-   * @param {bitArray} a1 The first array.
-   * @param {bitArray} a2 The second array.
-   * @return {bitArray} The concatenation of a1 and a2.
-   */
-  concat: function (a1, a2) {
-    if (a1.length === 0 || a2.length === 0) {
-      return a1.concat(a2);
-    }
-    
-    var last = a1[a1.length-1], shift = sjcl.bitArray.getPartial(last);
-    if (shift === 32) {
-      return a1.concat(a2);
-    } else {
-      return sjcl.bitArray._shiftRight(a2, shift, last|0, a1.slice(0,a1.length-1));
-    }
-  },
-
-  /**
-   * Find the length of an array of bits.
-   * @param {bitArray} a The array.
-   * @return {Number} The length of a, in bits.
-   */
-  bitLength: function (a) {
-    var l = a.length, x;
-    if (l === 0) { return 0; }
-    x = a[l - 1];
-    return (l-1) * 32 + sjcl.bitArray.getPartial(x);
-  },
-
-  /**
-   * Truncate an array.
-   * @param {bitArray} a The array.
-   * @param {Number} len The length to truncate to, in bits.
-   * @return {bitArray} A new array, truncated to len bits.
-   */
-  clamp: function (a, len) {
-    if (a.length * 32 < len) { return a; }
-    a = a.slice(0, Math.ceil(len / 32));
-    var l = a.length;
-    len = len & 31;
-    if (l > 0 && len) {
-      a[l-1] = sjcl.bitArray.partial(len, a[l-1] & 0x80000000 >> (len-1), 1);
-    }
-    return a;
-  },
-
-  /**
-   * Make a partial word for a bit array.
-   * @param {Number} len The number of bits in the word.
-   * @param {Number} x The bits.
-   * @param {Number} [0] _end Pass 1 if x has already been shifted to the high side.
-   * @return {Number} The partial word.
-   */
-  partial: function (len, x, _end) {
-    if (len === 32) { return x; }
-    return (_end ? x|0 : x << (32-len)) + len * 0x10000000000;
-  },
-
-  /**
-   * Get the number of bits used by a partial word.
-   * @param {Number} x The partial word.
-   * @return {Number} The number of bits used by the partial word.
-   */
-  getPartial: function (x) {
-    return Math.round(x/0x10000000000) || 32;
-  },
-
-  /**
-   * Compare two arrays for equality in a predictable amount of time.
-   * @param {bitArray} a The first array.
-   * @param {bitArray} b The second array.
-   * @return {boolean} true if a == b; false otherwise.
-   */
-  equal: function (a, b) {
-    if (sjcl.bitArray.bitLength(a) !== sjcl.bitArray.bitLength(b)) {
-      return false;
-    }
-    var x = 0, i;
-    for (i=0; i<a.length; i++) {
-      x |= a[i]^b[i];
-    }
-    return (x === 0);
-  },
-
-  /** Shift an array right.
-   * @param {bitArray} a The array to shift.
-   * @param {Number} shift The number of bits to shift.
-   * @param {Number} [carry=0] A byte to carry in
-   * @param {bitArray} [out=[]] An array to prepend to the output.
-   * @private
-   */
-  _shiftRight: function (a, shift, carry, out) {
-    var i, last2=0, shift2;
-    if (out === undefined) { out = []; }
-    
-    for (; shift >= 32; shift -= 32) {
-      out.push(carry);
-      carry = 0;
-    }
-    if (shift === 0) {
-      return out.concat(a);
-    }
-    
-    for (i=0; i<a.length; i++) {
-      out.push(carry | a[i]>>>shift);
-      carry = a[i] << (32-shift);
-    }
-    last2 = a.length ? a[a.length-1] : 0;
-    shift2 = sjcl.bitArray.getPartial(last2);
-    out.push(sjcl.bitArray.partial(shift+shift2 & 31, (shift + shift2 > 32) ? carry : out.pop(),1));
-    return out;
-  },
-  
-  /** xor a block of 4 words together.
-   * @private
-   */
-  _xor4: function(x,y) {
-    return [x[0]^y[0],x[1]^y[1],x[2]^y[2],x[3]^y[3]];
-  },
-
-  /** byteswap a word array inplace.
-   * (does not handle partial words)
-   * @param {sjcl.bitArray} a word array
-   * @return {sjcl.bitArray} byteswapped array
-   */
-  byteswapM: function(a) {
-    var i, v, m = 0xff00;
-    for (i = 0; i < a.length; ++i) {
-      v = a[i];
-      a[i] = (v >>> 24) | ((v >>> 8) & m) | ((v & m) << 8) | (v << 24);
-    }
-    return a;
-  }
-};

src/js/sjcl/core/bn.js

@@ -1,568 +0,0 @@
-/**
- * @constructor
- * Constructs a new bignum from another bignum, a number or a hex string.
- */
-sjcl.bn = function(it) {
-  this.initWith(it);
-};
-
-sjcl.bn.prototype = {
-  radix: 24,
-  maxMul: 8,
-  _class: sjcl.bn,
-  
-  copy: function() {
-    return new this._class(this);
-  },
-
-  /**
-   * Initializes this with it, either as a bn, a number, or a hex string.
-   */
-  initWith: function(it) {
-    var i=0, k;
-    switch(typeof it) {
-    case "object":
-      this.limbs = it.limbs.slice(0);
-      break;
-      
-    case "number":
-      this.limbs = [it];
-      this.normalize();
-      break;
-      
-    case "string":
-      it = it.replace(/^0x/, '');
-      this.limbs = [];
-      // hack
-      k = this.radix / 4;
-      for (i=0; i < it.length; i+=k) {
-        this.limbs.push(parseInt(it.substring(Math.max(it.length - i - k, 0), it.length - i),16));
-      }
-      break;
-
-    default:
-      this.limbs = [0];
-    }
-    return this;
-  },
-
-  /**
-   * Returns true if "this" and "that" are equal.  Calls fullReduce().
-   * Equality test is in constant time.
-   */
-  equals: function(that) {
-    if (typeof that === "number") { that = new this._class(that); }
-    var difference = 0, i;
-    this.fullReduce();
-    that.fullReduce();
-    for (i = 0; i < this.limbs.length || i < that.limbs.length; i++) {
-      difference |= this.getLimb(i) ^ that.getLimb(i);
-    }
-    return (difference === 0);
-  },
-  
-  /**
-   * Get the i'th limb of this, zero if i is too large.
-   */
-  getLimb: function(i) {
-    return (i >= this.limbs.length) ? 0 : this.limbs[i];
-  },
-  
-  /**
-   * Constant time comparison function.
-   * Returns 1 if this >= that, or zero otherwise.
-   */
-  greaterEquals: function(that) {
-    if (typeof that === "number") { that = new this._class(that); }
-    var less = 0, greater = 0, i, a, b;
-    i = Math.max(this.limbs.length, that.limbs.length) - 1;
-    for (; i>= 0; i--) {
-      a = this.getLimb(i);
-      b = that.getLimb(i);
-      greater |= (b - a) & ~less;
-      less |= (a - b) & ~greater;
-    }
-    return (greater | ~less) >>> 31;
-  },
-  
-  /**
-   * Convert to a hex string.
-   */
-  toString: function() {
-    this.fullReduce();
-    var out="", i, s, l = this.limbs;
-    for (i=0; i < this.limbs.length; i++) {
-      s = l[i].toString(16);
-      while (i < this.limbs.length - 1 && s.length < 6) {
-        s = "0" + s;
-      }
-      out = s + out;
-    }
-    return "0x"+out;
-  },
-  
-  /** this += that.  Does not normalize. */
-  addM: function(that) {
-    if (typeof(that) !== "object") { that = new this._class(that); }
-    var i, l=this.limbs, ll=that.limbs;
-    for (i=l.length; i<ll.length; i++) {
-      l[i] = 0;
-    }
-    for (i=0; i<ll.length; i++) {
-      l[i] += ll[i];
-    }
-    return this;
-  },
-  
-  /** this *= 2.  Requires normalized; ends up normalized. */
-  doubleM: function() {
-    var i, carry=0, tmp, r=this.radix, m=this.radixMask, l=this.limbs;
-    for (i=0; i<l.length; i++) {
-      tmp = l[i];
-      tmp = tmp+tmp+carry;
-      l[i] = tmp & m;
-      carry = tmp >> r;
-    }
-    if (carry) {
-      l.push(carry);
-    }
-    return this;
-  },
-  
-  /** this /= 2, rounded down.  Requires normalized; ends up normalized. */
-  halveM: function() {
-    var i, carry=0, tmp, r=this.radix, l=this.limbs;
-    for (i=l.length-1; i>=0; i--) {
-      tmp = l[i];
-      l[i] = (tmp+carry)>>1;
-      carry = (tmp&1) << r;
-    }
-    if (!l[l.length-1]) {
-      l.pop();
-    }
-    return this;
-  },
-
-  /** this -= that.  Does not normalize. */
-  subM: function(that) {
-    if (typeof(that) !== "object") { that = new this._class(that); }
-    var i, l=this.limbs, ll=that.limbs;
-    for (i=l.length; i<ll.length; i++) {
-      l[i] = 0;
-    }
-    for (i=0; i<ll.length; i++) {
-      l[i] -= ll[i];
-    }
-    return this;
-  },
-  
-  mod: function(that) {
-    var neg = !this.greaterEquals(new sjcl.bn(0));
-    
-    that = new sjcl.bn(that).normalize(); // copy before we begin
-    var out = new sjcl.bn(this).normalize(), ci=0;
-    
-    if (neg) out = (new sjcl.bn(0)).subM(out).normalize();
-    
-    for (; out.greaterEquals(that); ci++) {
-      that.doubleM();
-    }
-    
-    if (neg) out = that.sub(out).normalize();
-    
-    for (; ci > 0; ci--) {
-      that.halveM();
-      if (out.greaterEquals(that)) {
-        out.subM(that).normalize();
-      }
-    }
-    return out.trim();
-  },
-  
-  /** return inverse mod prime p.  p must be odd. Binary extended Euclidean algorithm mod p. */
-  inverseMod: function(p) {
-    var a = new sjcl.bn(1), b = new sjcl.bn(0), x = new sjcl.bn(this), y = new sjcl.bn(p), tmp, i, nz=1;
-    
-    if (!(p.limbs[0] & 1)) {
-      throw (new sjcl.exception.invalid("inverseMod: p must be odd"));
-    }
-    
-    // invariant: y is odd
-    do {
-      if (x.limbs[0] & 1) {
-        if (!x.greaterEquals(y)) {
-          // x < y; swap everything
-          tmp = x; x = y; y = tmp;
-          tmp = a; a = b; b = tmp;
-        }
-        x.subM(y);
-        x.normalize();
-        
-        if (!a.greaterEquals(b)) {
-          a.addM(p);
-        }
-        a.subM(b);
-      }
-      
-      // cut everything in half
-      x.halveM();
-      if (a.limbs[0] & 1) {
-        a.addM(p);
-      }
-      a.normalize();
-      a.halveM();
-      
-      // check for termination: x ?= 0
-      for (i=nz=0; i<x.limbs.length; i++) {
-        nz |= x.limbs[i];
-      }
-    } while(nz);
-    
-    if (!y.equals(1)) {
-      throw (new sjcl.exception.invalid("inverseMod: p and x must be relatively prime"));
-    }
-    
-    return b;
-  },
-  
-  /** this + that.  Does not normalize. */
-  add: function(that) {
-    return this.copy().addM(that);
-  },
-
-  /** this - that.  Does not normalize. */
-  sub: function(that) {
-    return this.copy().subM(that);
-  },
-  
-  /** this * that.  Normalizes and reduces. */
-  mul: function(that) {
-    if (typeof(that) === "number") { that = new this._class(that); }
-    var i, j, a = this.limbs, b = that.limbs, al = a.length, bl = b.length, out = new this._class(), c = out.limbs, ai, ii=this.maxMul;
-
-    for (i=0; i < this.limbs.length + that.limbs.length + 1; i++) {
-      c[i] = 0;
-    }
-    for (i=0; i<al; i++) {
-      ai = a[i];
-      for (j=0; j<bl; j++) {
-        c[i+j] += ai * b[j];
-      }
-     
-      if (!--ii) {
-        ii = this.maxMul;
-        out.cnormalize();
-      }
-    }
-    return out.cnormalize().reduce();
-  },
-
-  /** this ^ 2.  Normalizes and reduces. */
-  square: function() {
-    return this.mul(this);
-  },
-
-  /** this ^ n.  Uses square-and-multiply.  Normalizes and reduces. */
-  power: function(l) {
-    if (typeof(l) === "number") {
-      l = [l];
-    } else if (l.limbs !== undefined) {
-      l = l.normalize().limbs;
-    }
-    var i, j, out = new this._class(1), pow = this;
-
-    for (i=0; i<l.length; i++) {
-      for (j=0; j<this.radix; j++) {
-        if (l[i] & (1<<j)) {
-          out = out.mul(pow);
-        }
-        pow = pow.square();
-      }
-    }
-    
-    return out;
-  },
-
-  /** this * that mod N */
-  mulmod: function(that, N) {
-    return this.mod(N).mul(that.mod(N)).mod(N);
-  },
-
-  /** this ^ x mod N */
-  powermod: function(x, N) {
-    var result = new sjcl.bn(1), a = new sjcl.bn(this), k = new sjcl.bn(x);
-    while (true) {
-      if (k.limbs[0] & 1) { result = result.mulmod(a, N); }
-      k.halveM();
-      if (k.equals(0)) { break; }
-      a = a.mulmod(a, N);
-    }
-    return result.normalize().reduce();
-  },
-
-  trim: function() {
-    var l = this.limbs, p;
-    do {
-      p = l.pop();
-    } while (l.length && p === 0);
-    l.push(p);
-    return this;
-  },
-  
-  /** Reduce mod a modulus.  Stubbed for subclassing. */
-  reduce: function() {
-    return this;
-  },
-
-  /** Reduce and normalize. */
-  fullReduce: function() {
-    return this.normalize();
-  },
-  
-  /** Propagate carries. */
-  normalize: function() {
-    var carry=0, i, pv = this.placeVal, ipv = this.ipv, l, m, limbs = this.limbs, ll = limbs.length, mask = this.radixMask;
-    for (i=0; i < ll || (carry !== 0 && carry !== -1); i++) {
-      l = (limbs[i]||0) + carry;
-      m = limbs[i] = l & mask;
-      carry = (l-m)*ipv;
-    }
-    if (carry === -1) {
-      limbs[i-1] -= pv;
-    }
-    return this;
-  },
-
-  /** Constant-time normalize. Does not allocate additional space. */
-  cnormalize: function() {
-    var carry=0, i, ipv = this.ipv, l, m, limbs = this.limbs, ll = limbs.length, mask = this.radixMask;
-    for (i=0; i < ll-1; i++) {
-      l = limbs[i] + carry;
-      m = limbs[i] = l & mask;
-      carry = (l-m)*ipv;
-    }
-    limbs[i] += carry;
-    return this;
-  },
-  
-  /** Serialize to a bit array */
-  toBits: function(len) {
-    this.fullReduce();
-    len = len || this.exponent || this.bitLength();
-    var i = Math.floor((len-1)/24), w=sjcl.bitArray, e = (len + 7 & -8) % this.radix || this.radix,
-        out = [w.partial(e, this.getLimb(i))];
-    for (i--; i >= 0; i--) {
-      out = w.concat(out, [w.partial(Math.min(this.radix,len), this.getLimb(i))]);
-      len -= this.radix;
-    }
-    return out;
-  },
-  
-  /** Return the length in bits, rounded up to the nearest byte. */
-  bitLength: function() {
-    this.fullReduce();
-    var out = this.radix * (this.limbs.length - 1),
-        b = this.limbs[this.limbs.length - 1];
-    for (; b; b >>>= 1) {
-      out ++;
-    }
-    return out+7 & -8;
-  }
-};
-
-/** @memberOf sjcl.bn
-* @this { sjcl.bn }
-*/
-sjcl.bn.fromBits = function(bits) {
-  var Class = this, out = new Class(), words=[], w=sjcl.bitArray, t = this.prototype,
-      l = Math.min(this.bitLength || 0x100000000, w.bitLength(bits)), e = l % t.radix || t.radix;
-  
-  words[0] = w.extract(bits, 0, e);
-  for (; e < l; e += t.radix) {
-    words.unshift(w.extract(bits, e, t.radix));
-  }
-
-  out.limbs = words;
-  return out;
-};
-
-
-
-sjcl.bn.prototype.ipv = 1 / (sjcl.bn.prototype.placeVal = Math.pow(2,sjcl.bn.prototype.radix));
-sjcl.bn.prototype.radixMask = (1 << sjcl.bn.prototype.radix) - 1;
-
-/**
- * Creates a new subclass of bn, based on reduction modulo a pseudo-Mersenne prime,
- * i.e. a prime of the form 2^e + sum(a * 2^b),where the sum is negative and sparse.
- */
-sjcl.bn.pseudoMersennePrime = function(exponent, coeff) {
-  /** @constructor 
-  * @private
-  */
-  function p(it) {
-    this.initWith(it);
-    /*if (this.limbs[this.modOffset]) {
-      this.reduce();
-    }*/
-  }
-
-  var ppr = p.prototype = new sjcl.bn(), i, tmp, mo;
-  mo = ppr.modOffset = Math.ceil(tmp = exponent / ppr.radix);
-  ppr.exponent = exponent;
-  ppr.offset = [];
-  ppr.factor = [];
-  ppr.minOffset = mo;
-  ppr.fullMask = 0;
-  ppr.fullOffset = [];
-  ppr.fullFactor = [];
-  ppr.modulus = p.modulus = new sjcl.bn(Math.pow(2,exponent));
-  
-  ppr.fullMask = 0|-Math.pow(2, exponent % ppr.radix);
-
-  for (i=0; i<coeff.length; i++) {
-    ppr.offset[i] = Math.floor(coeff[i][0] / ppr.radix - tmp);
-    ppr.fullOffset[i] = Math.ceil(coeff[i][0] / ppr.radix - tmp);
-    ppr.factor[i] = coeff[i][1] * Math.pow(1/2, exponent - coeff[i][0] + ppr.offset[i] * ppr.radix);
-    ppr.fullFactor[i] = coeff[i][1] * Math.pow(1/2, exponent - coeff[i][0] + ppr.fullOffset[i] * ppr.radix);
-    ppr.modulus.addM(new sjcl.bn(Math.pow(2,coeff[i][0])*coeff[i][1]));
-    ppr.minOffset = Math.min(ppr.minOffset, -ppr.offset[i]); // conservative
-  }
-  ppr._class = p;
-  ppr.modulus.cnormalize();
-
-  /** Approximate reduction mod p.  May leave a number which is negative or slightly larger than p.
-   * @memberof sjcl.bn
-   * @this { sjcl.bn }
-   */
-  ppr.reduce = function() {
-    var i, k, l, mo = this.modOffset, limbs = this.limbs, off = this.offset, ol = this.offset.length, fac = this.factor, ll;
-
-    i = this.minOffset;
-    while (limbs.length > mo) {
-      l = limbs.pop();
-      ll = limbs.length;
-      for (k=0; k<ol; k++) {
-        limbs[ll+off[k]] -= fac[k] * l;
-      }
-      
-      i--;
-      if (!i) {
-        limbs.push(0);
-        this.cnormalize();
-        i = this.minOffset;
-      }
-    }
-    this.cnormalize();
-
-    return this;
-  };
-  
-  /** @memberof sjcl.bn
-  * @this { sjcl.bn }
-  */
-  ppr._strongReduce = (ppr.fullMask === -1) ? ppr.reduce : function() {
-    var limbs = this.limbs, i = limbs.length - 1, k, l;
-    this.reduce();
-    if (i === this.modOffset - 1) {
-      l = limbs[i] & this.fullMask;
-      limbs[i] -= l;
-      for (k=0; k<this.fullOffset.length; k++) {
-        limbs[i+this.fullOffset[k]] -= this.fullFactor[k] * l;
-      }
-      this.normalize();
-    }
-  };
-
-  /** mostly constant-time, very expensive full reduction.
-   * @memberof sjcl.bn
-   * @this { sjcl.bn }
-   */
-  ppr.fullReduce = function() {
-    var greater, i;
-    // massively above the modulus, may be negative
-    
-    this._strongReduce();
-    // less than twice the modulus, may be negative
-
-    this.addM(this.modulus);
-    this.addM(this.modulus);
-    this.normalize();
-    // probably 2-3x the modulus
-    
-    this._strongReduce();
-    // less than the power of 2.  still may be more than
-    // the modulus
-
-    // HACK: pad out to this length
-    for (i=this.limbs.length; i<this.modOffset; i++) {
-      this.limbs[i] = 0;
-    }
-    
-    // constant-time subtract modulus
-    greater = this.greaterEquals(this.modulus);
-    for (i=0; i<this.limbs.length; i++) {
-      this.limbs[i] -= this.modulus.limbs[i] * greater;
-    }
-    this.cnormalize();
-
-    return this;
-  };
-
-
-  /** @memberof sjcl.bn
-  * @this { sjcl.bn }
-  */
-  ppr.inverse = function() {
-    return (this.power(this.modulus.sub(2)));
-  };
-
-  p.fromBits = sjcl.bn.fromBits;
-
-  return p;
-};
-
-// a small Mersenne prime
-var sbp = sjcl.bn.pseudoMersennePrime;
-sjcl.bn.prime = {
-  p127: sbp(127, [[0,-1]]),
-
-  // Bernstein's prime for Curve25519
-  p25519: sbp(255, [[0,-19]]),
-
-  // Koblitz primes
-  p192k: sbp(192, [[32,-1],[12,-1],[8,-1],[7,-1],[6,-1],[3,-1],[0,-1]]),
-  p224k: sbp(224, [[32,-1],[12,-1],[11,-1],[9,-1],[7,-1],[4,-1],[1,-1],[0,-1]]),
-  p256k: sbp(256, [[32,-1],[9,-1],[8,-1],[7,-1],[6,-1],[4,-1],[0,-1]]),
-
-  // NIST primes
-  p192: sbp(192, [[0,-1],[64,-1]]),
-  p224: sbp(224, [[0,1],[96,-1]]),
-  p256: sbp(256, [[0,-1],[96,1],[192,1],[224,-1]]),
-  p384: sbp(384, [[0,-1],[32,1],[96,-1],[128,-1]]),
-  p521: sbp(521, [[0,-1]])
-};
-
-sjcl.bn.random = function(modulus, paranoia) {
-  if (typeof modulus !== "object") { modulus = new sjcl.bn(modulus); }
-  var words, i, l = modulus.limbs.length, m = modulus.limbs[l-1]+1, out = new sjcl.bn();
-  while (true) {
-    // get a sequence whose first digits make sense
-    do {
-      words = sjcl.random.randomWords(l, paranoia);
-      if (words[l-1] < 0) { words[l-1] += 0x100000000; }
-    } while (Math.floor(words[l-1] / m) === Math.floor(0x100000000 / m));
-    words[l-1] %= m;
-
-    // mask off all the limbs
-    for (i=0; i<l-1; i++) {
-      words[i] &= modulus.radixMask;
-    }
-
-    // check the rest of the digitssj
-    out.limbs = words;
-    if (!out.greaterEquals(modulus)) {
-      return out;
-    }
-  }
-};
-

src/js/sjcl/core/cbc.js

@@ -1,115 +0,0 @@
-/** @fileOverview CBC mode implementation
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-if (sjcl.beware === undefined) {
-  sjcl.beware = {};
-}
-sjcl.beware["CBC mode is dangerous because it doesn't protect message integrity."
-] = function() {
-  /** @namespace
-   * Dangerous: CBC mode with PKCS#5 padding.
-   *
-   * @author Emily Stark
-   * @author Mike Hamburg
-   * @author Dan Boneh
-   */
-  sjcl.mode.cbc = {
-    /** The name of the mode.
-     * @constant
-     */
-    name: "cbc",
-    
-    /** Encrypt in CBC mode with PKCS#5 padding.
-     * @param {Object} prp The block cipher.  It must have a block size of 16 bytes.
-     * @param {bitArray} plaintext The plaintext data.
-     * @param {bitArray} iv The initialization value.
-     * @param {bitArray} [adata=[]] The authenticated data.  Must be empty.
-     * @return The encrypted data, an array of bytes.
-     * @throws {sjcl.exception.invalid} if the IV isn't exactly 128 bits, or if any adata is specified.
-     */
-    encrypt: function(prp, plaintext, iv, adata) {
-      if (adata && adata.length) {
-        throw new sjcl.exception.invalid("cbc can't authenticate data");
-      }
-      if (sjcl.bitArray.bitLength(iv) !== 128) {
-        throw new sjcl.exception.invalid("cbc iv must be 128 bits");
-      }
-      var i,
-          w = sjcl.bitArray,
-          xor = w._xor4,
-          bl = w.bitLength(plaintext),
-          bp = 0,
-          output = [];
-
-      if (bl&7) {
-        throw new sjcl.exception.invalid("pkcs#5 padding only works for multiples of a byte");
-      }
-    
-      for (i=0; bp+128 <= bl; i+=4, bp+=128) {
-        /* Encrypt a non-final block */
-        iv = prp.encrypt(xor(iv, plaintext.slice(i,i+4)));
-        output.splice(i,0,iv[0],iv[1],iv[2],iv[3]);
-      }
-      
-      /* Construct the pad. */
-      bl = (16 - ((bl >> 3) & 15)) * 0x1010101;
-
-      /* Pad and encrypt. */
-      iv = prp.encrypt(xor(iv,w.concat(plaintext,[bl,bl,bl,bl]).slice(i,i+4)));
-      output.splice(i,0,iv[0],iv[1],iv[2],iv[3]);
-      return output;
-    },
-    
-    /** Decrypt in CBC mode.
-     * @param {Object} prp The block cipher.  It must have a block size of 16 bytes.
-     * @param {bitArray} ciphertext The ciphertext data.
-     * @param {bitArray} iv The initialization value.
-     * @param {bitArray} [adata=[]] The authenticated data.  It must be empty.
-     * @return The decrypted data, an array of bytes.
-     * @throws {sjcl.exception.invalid} if the IV isn't exactly 128 bits, or if any adata is specified.
-     * @throws {sjcl.exception.corrupt} if if the message is corrupt.
-     */
-    decrypt: function(prp, ciphertext, iv, adata) {
-      if (adata && adata.length) {
-        throw new sjcl.exception.invalid("cbc can't authenticate data");
-      }
-      if (sjcl.bitArray.bitLength(iv) !== 128) {
-        throw new sjcl.exception.invalid("cbc iv must be 128 bits");
-      }
-      if ((sjcl.bitArray.bitLength(ciphertext) & 127) || !ciphertext.length) {
-        throw new sjcl.exception.corrupt("cbc ciphertext must be a positive multiple of the block size");
-      }
-      var i,
-          w = sjcl.bitArray,
-          xor = w._xor4,
-          bi, bo,
-          output = [];
-          
-      adata = adata || [];
-    
-      for (i=0; i<ciphertext.length; i+=4) {
-        bi = ciphertext.slice(i,i+4);
-        bo = xor(iv,prp.decrypt(bi));
-        output.splice(i,0,bo[0],bo[1],bo[2],bo[3]);
-        iv = bi;
-      }
-
-      /* check and remove the pad */
-      bi = output[i-1] & 255;
-      if (bi === 0 || bi > 16) {
-        throw new sjcl.exception.corrupt("pkcs#5 padding corrupt");
-      }
-      bo = bi * 0x1010101;
-      if (!w.equal(w.bitSlice([bo,bo,bo,bo], 0, bi*8),
-                   w.bitSlice(output, output.length*32 - bi*8, output.length*32))) {
-        throw new sjcl.exception.corrupt("pkcs#5 padding corrupt");
-      }
-
-      return w.bitSlice(output, 0, output.length*32 - bi*8);
-    }
-  };
-};

src/js/sjcl/core/ccm.js

@@ -1,185 +0,0 @@
-/** @fileOverview CCM mode implementation.
- *
- * Special thanks to Roy Nicholson for pointing out a bug in our
- * implementation.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-/** @namespace CTR mode with CBC MAC. */
-sjcl.mode.ccm = {
-  /** The name of the mode.
-   * @constant
-   */
-  name: "ccm",
-  
-  /** Encrypt in CCM mode.
-   * @static
-   * @param {Object} prf The pseudorandom function.  It must have a block size of 16 bytes.
-   * @param {bitArray} plaintext The plaintext data.
-   * @param {bitArray} iv The initialization value.
-   * @param {bitArray} [adata=[]] The authenticated data.
-   * @param {Number} [tlen=64] the desired tag length, in bits.
-   * @return {bitArray} The encrypted data, an array of bytes.
-   */
-  encrypt: function(prf, plaintext, iv, adata, tlen) {
-    var L, out = plaintext.slice(0), tag, w=sjcl.bitArray, ivl = w.bitLength(iv) / 8, ol = w.bitLength(out) / 8;
-    tlen = tlen || 64;
-    adata = adata || [];
-    
-    if (ivl < 7) {
-      throw new sjcl.exception.invalid("ccm: iv must be at least 7 bytes");
-    }
-    
-    // compute the length of the length
-    for (L=2; L<4 && ol >>> 8*L; L++) {}
-    if (L < 15 - ivl) { L = 15-ivl; }
-    iv = w.clamp(iv,8*(15-L));
-    
-    // compute the tag
-    tag = sjcl.mode.ccm._computeTag(prf, plaintext, iv, adata, tlen, L);
-    
-    // encrypt
-    out = sjcl.mode.ccm._ctrMode(prf, out, iv, tag, tlen, L);
-    
-    return w.concat(out.data, out.tag);
-  },
-  
-  /** Decrypt in CCM mode.
-   * @static
-   * @param {Object} prf The pseudorandom function.  It must have a block size of 16 bytes.
-   * @param {bitArray} ciphertext The ciphertext data.
-   * @param {bitArray} iv The initialization value.
-   * @param {bitArray} [[]] adata The authenticated data.
-   * @param {Number} [64] tlen the desired tag length, in bits.
-   * @return {bitArray} The decrypted data.
-   */
-  decrypt: function(prf, ciphertext, iv, adata, tlen) {
-    tlen = tlen || 64;
-    adata = adata || [];
-    var L,
-        w=sjcl.bitArray,
-        ivl = w.bitLength(iv) / 8,
-        ol = w.bitLength(ciphertext), 
-        out = w.clamp(ciphertext, ol - tlen),
-        tag = w.bitSlice(ciphertext, ol - tlen), tag2;
-    
-
-    ol = (ol - tlen) / 8;
-        
-    if (ivl < 7) {
-      throw new sjcl.exception.invalid("ccm: iv must be at least 7 bytes");
-    }
-    
-    // compute the length of the length
-    for (L=2; L<4 && ol >>> 8*L; L++) {}
-    if (L < 15 - ivl) { L = 15-ivl; }
-    iv = w.clamp(iv,8*(15-L));
-    
-    // decrypt
-    out = sjcl.mode.ccm._ctrMode(prf, out, iv, tag, tlen, L);
-    
-    // check the tag
-    tag2 = sjcl.mode.ccm._computeTag(prf, out.data, iv, adata, tlen, L);
-    if (!w.equal(out.tag, tag2)) {
-      throw new sjcl.exception.corrupt("ccm: tag doesn't match");
-    }
-    
-    return out.data;
-  },
-
-  /* Compute the (unencrypted) authentication tag, according to the CCM specification
-   * @param {Object} prf The pseudorandom function.
-   * @param {bitArray} plaintext The plaintext data.
-   * @param {bitArray} iv The initialization value.
-   * @param {bitArray} adata The authenticated data.
-   * @param {Number} tlen the desired tag length, in bits.
-   * @return {bitArray} The tag, but not yet encrypted.
-   * @private
-   */
-  _computeTag: function(prf, plaintext, iv, adata, tlen, L) {
-    // compute B[0]
-    var mac, tmp, i, macData = [], w=sjcl.bitArray, xor = w._xor4;
-
-    tlen /= 8;
-  
-    // check tag length and message length
-    if (tlen % 2 || tlen < 4 || tlen > 16) {
-      throw new sjcl.exception.invalid("ccm: invalid tag length");
-    }
-  
-    if (adata.length > 0xFFFFFFFF || plaintext.length > 0xFFFFFFFF) {
-      // I don't want to deal with extracting high words from doubles.
-      throw new sjcl.exception.bug("ccm: can't deal with 4GiB or more data");
-    }
-
-    // mac the flags
-    mac = [w.partial(8, (adata.length ? 1<<6 : 0) | (tlen-2) << 2 | L-1)];
-
-    // mac the iv and length
-    mac = w.concat(mac, iv);
-    mac[3] |= w.bitLength(plaintext)/8;
-    mac = prf.encrypt(mac);
-    
-  
-    if (adata.length) {
-      // mac the associated data.  start with its length...
-      tmp = w.bitLength(adata)/8;
-      if (tmp <= 0xFEFF) {
-        macData = [w.partial(16, tmp)];
-      } else if (tmp <= 0xFFFFFFFF) {
-        macData = w.concat([w.partial(16,0xFFFE)], [tmp]);
-      } // else ...
-    
-      // mac the data itself
-      macData = w.concat(macData, adata);
-      for (i=0; i<macData.length; i += 4) {
-        mac = prf.encrypt(xor(mac, macData.slice(i,i+4).concat([0,0,0])));
-      }
-    }
-  
-    // mac the plaintext
-    for (i=0; i<plaintext.length; i+=4) {
-      mac = prf.encrypt(xor(mac, plaintext.slice(i,i+4).concat([0,0,0])));
-    }
-
-    return w.clamp(mac, tlen * 8);
-  },
-
-  /** CCM CTR mode.
-   * Encrypt or decrypt data and tag with the prf in CCM-style CTR mode.
-   * May mutate its arguments.
-   * @param {Object} prf The PRF.
-   * @param {bitArray} data The data to be encrypted or decrypted.
-   * @param {bitArray} iv The initialization vector.
-   * @param {bitArray} tag The authentication tag.
-   * @param {Number} tlen The length of th etag, in bits.
-   * @param {Number} L The CCM L value.
-   * @return {Object} An object with data and tag, the en/decryption of data and tag values.
-   * @private
-   */
-  _ctrMode: function(prf, data, iv, tag, tlen, L) {
-    var enc, i, w=sjcl.bitArray, xor = w._xor4, ctr, l = data.length, bl=w.bitLength(data);
-
-    // start the ctr
-    ctr = w.concat([w.partial(8,L-1)],iv).concat([0,0,0]).slice(0,4);
-    
-    // en/decrypt the tag
-    tag = w.bitSlice(xor(tag,prf.encrypt(ctr)), 0, tlen);
-  
-    // en/decrypt the data
-    if (!l) { return {tag:tag, data:[]}; }
-    
-    for (i=0; i<l; i+=4) {
-      ctr[3]++;
-      enc = prf.encrypt(ctr);
-      data[i]   ^= enc[0];
-      data[i+1] ^= enc[1];
-      data[i+2] ^= enc[2];
-      data[i+3] ^= enc[3];
-    }
-    return { tag:tag, data:w.clamp(data,bl) };
-  }
-};

src/js/sjcl/core/codecBase32.js

@@ -1,64 +0,0 @@
-/** @fileOverview Bit array codec implementations.
- *
- * @author Nils Kenneweg
- */
-
-/** @namespace Base32 encoding/decoding */
-sjcl.codec.base32 = {
-  /** The base32 alphabet.
-   * @private
-   */
-  _chars: "0123456789abcdefghjkmnpqrstvwxyz",
-
-  /* bits in an array */
-  BITS: 32,
-  /* base to encode at (2^x) */
-  BASE: 5,
-  /* bits - base */
-  REMAINING: 27,
-  
-  /** Convert from a bitArray to a base32 string. */
-  fromBits: function (arr, _noEquals) {
-    var BITS = sjcl.codec.base32.BITS, BASE = sjcl.codec.base32.BASE, REMAINING = sjcl.codec.base32.REMAINING;
-    var out = "", i, bits=0, c = sjcl.codec.base32._chars, ta=0, bl = sjcl.bitArray.bitLength(arr);
-
-    for (i=0; out.length * BASE <= bl; ) {
-      out += c.charAt((ta ^ arr[i]>>>bits) >>> REMAINING);
-      if (bits < BASE) {
-        ta = arr[i] << (BASE-bits);
-        bits += REMAINING;
-        i++;
-      } else {
-        ta <<= BASE;
-        bits -= BASE;
-      }
-    }
-
-    return out;
-  },
-  
-  /** Convert from a base32 string to a bitArray */
-  toBits: function(str) {
-    var BITS = sjcl.codec.base32.BITS, BASE = sjcl.codec.base32.BASE, REMAINING = sjcl.codec.base32.REMAINING;
-    var out = [], i, bits=0, c = sjcl.codec.base32._chars, ta=0, x;
-
-    for (i=0; i<str.length; i++) {
-      x = c.indexOf(str.charAt(i));
-      if (x < 0) {
-        throw new sjcl.exception.invalid("this isn't base32!");
-      }
-      if (bits > REMAINING) {
-        bits -= REMAINING;
-        out.push(ta ^ x>>>bits);
-        ta  = x << (BITS-bits);
-      } else {
-        bits += BASE;
-        ta ^= x << (BITS-bits);
-      }
-    }
-    if (bits&56) {
-      out.push(sjcl.bitArray.partial(bits&56, ta, 1));
-    }
-    return out;
-  }
-};

src/js/sjcl/core/codecBase64.js

@@ -1,67 +0,0 @@
-/** @fileOverview Bit array codec implementations.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-/** @namespace Base64 encoding/decoding */
-sjcl.codec.base64 = {
-  /** The base64 alphabet.
-   * @private
-   */
-  _chars: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
-  
-  /** Convert from a bitArray to a base64 string. */
-  fromBits: function (arr, _noEquals, _url) {
-    var out = "", i, bits=0, c = sjcl.codec.base64._chars, ta=0, bl = sjcl.bitArray.bitLength(arr);
-    if (_url) {
-      c = c.substr(0,62) + '-_';
-    }
-    for (i=0; out.length * 6 < bl; ) {
-      out += c.charAt((ta ^ arr[i]>>>bits) >>> 26);
-      if (bits < 6) {
-        ta = arr[i] << (6-bits);
-        bits += 26;
-        i++;
-      } else {
-        ta <<= 6;
-        bits -= 6;
-      }
-    }
-    while ((out.length & 3) && !_noEquals) { out += "="; }
-    return out;
-  },
-  
-  /** Convert from a base64 string to a bitArray */
-  toBits: function(str, _url) {
-    str = str.replace(/\s|=/g,'');
-    var out = [], i, bits=0, c = sjcl.codec.base64._chars, ta=0, x;
-    if (_url) {
-      c = c.substr(0,62) + '-_';
-    }
-    for (i=0; i<str.length; i++) {
-      x = c.indexOf(str.charAt(i));
-      if (x < 0) {
-        throw new sjcl.exception.invalid("this isn't base64!");
-      }
-      if (bits > 26) {
-        bits -= 26;
-        out.push(ta ^ x>>>bits);
-        ta  = x << (32-bits);
-      } else {
-        bits += 6;
-        ta ^= x << (32-bits);
-      }
-    }
-    if (bits&56) {
-      out.push(sjcl.bitArray.partial(bits&56, ta, 1));
-    }
-    return out;
-  }
-};
-
-sjcl.codec.base64url = {
-  fromBits: function (arr) { return sjcl.codec.base64.fromBits(arr,1,1); },
-  toBits: function (str) { return sjcl.codec.base64.toBits(str,1); }
-};

src/js/sjcl/core/codecBytes.js

@@ -1,37 +0,0 @@
-/** @fileOverview Bit array codec implementations.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-/** @namespace Arrays of bytes */
-sjcl.codec.bytes = {
-  /** Convert from a bitArray to an array of bytes. */
-  fromBits: function (arr) {
-    var out = [], bl = sjcl.bitArray.bitLength(arr), i, tmp;
-    for (i=0; i<bl/8; i++) {
-      if ((i&3) === 0) {
-        tmp = arr[i/4];
-      }
-      out.push(tmp >>> 24);
-      tmp <<= 8;
-    }
-    return out;
-  },
-  /** Convert from an array of bytes to a bitArray. */
-  toBits: function (bytes) {
-    var out = [], i, tmp=0;
-    for (i=0; i<bytes.length; i++) {
-      tmp = tmp << 8 | bytes[i];
-      if ((i&3) === 3) {
-        out.push(tmp);
-        tmp = 0;
-      }
-    }
-    if (i&3) {
-      out.push(sjcl.bitArray.partial(8*(i&3), tmp));
-    }
-    return out;
-  }
-};

src/js/sjcl/core/codecHex.js

@@ -1,30 +0,0 @@
-/** @fileOverview Bit array codec implementations.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-/** @namespace Hexadecimal */
-sjcl.codec.hex = {
-  /** Convert from a bitArray to a hex string. */
-  fromBits: function (arr) {
-    var out = "", i;
-    for (i=0; i<arr.length; i++) {
-      out += ((arr[i]|0)+0xF00000000000).toString(16).substr(4);
-    }
-    return out.substr(0, sjcl.bitArray.bitLength(arr)/4);//.replace(/(.{8})/g, "$1 ");
-  },
-  /** Convert from a hex string to a bitArray. */
-  toBits: function (str) {
-    var i, out=[], len;
-    str = str.replace(/\s|0x/g, "");
-    len = str.length;
-    str = str + "00000000";
-    for (i=0; i<str.length; i+=8) {
-      out.push(parseInt(str.substr(i,8),16)^0);
-    }
-    return sjcl.bitArray.clamp(out, len*4);
-  }
-};
-

src/js/sjcl/core/codecString.js

@@ -1,39 +0,0 @@
-/** @fileOverview Bit array codec implementations.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
- 
-/** @namespace UTF-8 strings */
-sjcl.codec.utf8String = {
-  /** Convert from a bitArray to a UTF-8 string. */
-  fromBits: function (arr) {
-    var out = "", bl = sjcl.bitArray.bitLength(arr), i, tmp;
-    for (i=0; i<bl/8; i++) {
-      if ((i&3) === 0) {
-        tmp = arr[i/4];
-      }
-      out += String.fromCharCode(tmp >>> 24);
-      tmp <<= 8;
-    }
-    return decodeURIComponent(escape(out));
-  },
-  
-  /** Convert from a UTF-8 string to a bitArray. */
-  toBits: function (str) {
-    str = unescape(encodeURIComponent(str));
-    var out = [], i, tmp=0;
-    for (i=0; i<str.length; i++) {
-      tmp = tmp << 8 | str.charCodeAt(i);
-      if ((i&3) === 3) {
-        out.push(tmp);
-        tmp = 0;
-      }
-    }
-    if (i&3) {
-      out.push(sjcl.bitArray.partial(8*(i&3), tmp));
-    }
-    return out;
-  }
-};

src/js/sjcl/core/convenience.js

@@ -1,318 +0,0 @@
-/** @fileOverview Convenince functions centered around JSON encapsulation.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
- 
- /** @namespace JSON encapsulation */
- sjcl.json = {
-  /** Default values for encryption */
-  defaults: { v:1, iter:1000, ks:128, ts:64, mode:"ccm", adata:"", cipher:"aes" },
-
-  /** Simple encryption function.
-   * @param {String|bitArray} password The password or key.
-   * @param {String} plaintext The data to encrypt.
-   * @param {Object} [params] The parameters including tag, iv and salt.
-   * @param {Object} [rp] A returned version with filled-in parameters.
-   * @return {Object} The cipher raw data.
-   * @throws {sjcl.exception.invalid} if a parameter is invalid.
-   */
-  _encrypt: function (password, plaintext, params, rp) {
-    params = params || {};
-    rp = rp || {};
-
-    var j = sjcl.json, p = j._add({ iv: sjcl.random.randomWords(4,0) },
-                                  j.defaults), tmp, prp, adata;
-    j._add(p, params);
-    adata = p.adata;
-    if (typeof p.salt === "string") {
-      p.salt = sjcl.codec.base64.toBits(p.salt);
-    }
-    if (typeof p.iv === "string") {
-      p.iv = sjcl.codec.base64.toBits(p.iv);
-    }
-
-    if (!sjcl.mode[p.mode] ||
-        !sjcl.cipher[p.cipher] ||
-        (typeof password === "string" && p.iter <= 100) ||
-        (p.ts !== 64 && p.ts !== 96 && p.ts !== 128) ||
-        (p.ks !== 128 && p.ks !== 192 && p.ks !== 256) ||
-        (p.iv.length < 2 || p.iv.length > 4)) {
-      throw new sjcl.exception.invalid("json encrypt: invalid parameters");
-    }
-
-    if (typeof password === "string") {
-      tmp = sjcl.misc.cachedPbkdf2(password, p);
-      password = tmp.key.slice(0,p.ks/32);
-      p.salt = tmp.salt;
-    } else if (sjcl.ecc && password instanceof sjcl.ecc.elGamal.publicKey) {
-      tmp = password.kem();
-      p.kemtag = tmp.tag;
-      password = tmp.key.slice(0,p.ks/32);
-    }
-    if (typeof plaintext === "string") {
-      plaintext = sjcl.codec.utf8String.toBits(plaintext);
-    }
-    if (typeof adata === "string") {
-      adata = sjcl.codec.utf8String.toBits(adata);
-    }
-    prp = new sjcl.cipher[p.cipher](password);
-
-    /* return the json data */
-    j._add(rp, p);
-    rp.key = password;
-
-    /* do the encryption */
-    p.ct = sjcl.mode[p.mode].encrypt(prp, plaintext, p.iv, adata, p.ts);
-
-    //return j.encode(j._subtract(p, j.defaults));
-    return p;
-  },
-
-  /** Simple encryption function.
-   * @param {String|bitArray} password The password or key.
-   * @param {String} plaintext The data to encrypt.
-   * @param {Object} [params] The parameters including tag, iv and salt.
-   * @param {Object} [rp] A returned version with filled-in parameters.
-   * @return {String} The ciphertext serialized data.
-   * @throws {sjcl.exception.invalid} if a parameter is invalid.
-   */
-  encrypt: function (password, plaintext, params, rp) {
-    var j = sjcl.json, p = j._encrypt.apply(j, arguments);
-    return j.encode(p);
-  },
-
-  /** Simple decryption function.
-   * @param {String|bitArray} password The password or key.
-   * @param {Object} ciphertext The cipher raw data to decrypt.
-   * @param {Object} [params] Additional non-default parameters.
-   * @param {Object} [rp] A returned object with filled parameters.
-   * @return {String} The plaintext.
-   * @throws {sjcl.exception.invalid} if a parameter is invalid.
-   * @throws {sjcl.exception.corrupt} if the ciphertext is corrupt.
-   */
-  _decrypt: function (password, ciphertext, params, rp) {
-    params = params || {};
-    rp = rp || {};
-
-    var j = sjcl.json, p = j._add(j._add(j._add({},j.defaults),ciphertext), params, true), ct, tmp, prp, adata=p.adata;
-    if (typeof p.salt === "string") {
-      p.salt = sjcl.codec.base64.toBits(p.salt);
-    }
-    if (typeof p.iv === "string") {
-      p.iv = sjcl.codec.base64.toBits(p.iv);
-    }
-
-    if (!sjcl.mode[p.mode] ||
-        !sjcl.cipher[p.cipher] ||
-        (typeof password === "string" && p.iter <= 100) ||
-        (p.ts !== 64 && p.ts !== 96 && p.ts !== 128) ||
-        (p.ks !== 128 && p.ks !== 192 && p.ks !== 256) ||
-        (!p.iv) ||
-        (p.iv.length < 2 || p.iv.length > 4)) {
-      throw new sjcl.exception.invalid("json decrypt: invalid parameters");
-    }
-
-    if (typeof password === "string") {
-      tmp = sjcl.misc.cachedPbkdf2(password, p);
-      password = tmp.key.slice(0,p.ks/32);
-      p.salt  = tmp.salt;
-    } else if (sjcl.ecc && password instanceof sjcl.ecc.elGamal.secretKey) {
-      password = password.unkem(sjcl.codec.base64.toBits(p.kemtag)).slice(0,p.ks/32);
-    }
-    if (typeof adata === "string") {
-      adata = sjcl.codec.utf8String.toBits(adata);
-    }
-    prp = new sjcl.cipher[p.cipher](password);
-
-    /* do the decryption */
-    ct = sjcl.mode[p.mode].decrypt(prp, p.ct, p.iv, adata, p.ts);
-
-    /* return the json data */
-    j._add(rp, p);
-    rp.key = password;
-
-    if (params.raw === 1) {
-      return ct;
-    } else {
-      return sjcl.codec.utf8String.fromBits(ct);
-    }
-  },
-
-  /** Simple decryption function.
-   * @param {String|bitArray} password The password or key.
-   * @param {String} ciphertext The ciphertext to decrypt.
-   * @param {Object} [params] Additional non-default parameters.
-   * @param {Object} [rp] A returned object with filled parameters.
-   * @return {String} The plaintext.
-   * @throws {sjcl.exception.invalid} if a parameter is invalid.
-   * @throws {sjcl.exception.corrupt} if the ciphertext is corrupt.
-   */
-  decrypt: function (password, ciphertext, params, rp) {
-    var j = sjcl.json;
-    return j._decrypt(password, j.decode(ciphertext), params, rp);
-  },
-  
-  /** Encode a flat structure into a JSON string.
-   * @param {Object} obj The structure to encode.
-   * @return {String} A JSON string.
-   * @throws {sjcl.exception.invalid} if obj has a non-alphanumeric property.
-   * @throws {sjcl.exception.bug} if a parameter has an unsupported type.
-   */
-  encode: function (obj) {
-    var i, out='{', comma='';
-    for (i in obj) {
-      if (obj.hasOwnProperty(i)) {
-        if (!i.match(/^[a-z0-9]+$/i)) {
-          throw new sjcl.exception.invalid("json encode: invalid property name");
-        }
-        out += comma + '"' + i + '":';
-        comma = ',';
-
-        switch (typeof obj[i]) {
-          case 'number':
-          case 'boolean':
-            out += obj[i];
-            break;
-
-          case 'string':
-            out += '"' + escape(obj[i]) + '"';
-            break;
-
-          case 'object':
-            out += '"' + sjcl.codec.base64.fromBits(obj[i],0) + '"';
-            break;
-
-          default:
-            throw new sjcl.exception.bug("json encode: unsupported type");
-        }
-      }
-    }
-    return out+'}';
-  },
-  
-  /** Decode a simple (flat) JSON string into a structure.  The ciphertext,
-   * adata, salt and iv will be base64-decoded.
-   * @param {String} str The string.
-   * @return {Object} The decoded structure.
-   * @throws {sjcl.exception.invalid} if str isn't (simple) JSON.
-   */
-  decode: function (str) {
-    str = str.replace(/\s/g,'');
-    if (!str.match(/^\{.*\}$/)) { 
-      throw new sjcl.exception.invalid("json decode: this isn't json!");
-    }
-    var a = str.replace(/^\{|\}$/g, '').split(/,/), out={}, i, m;
-    for (i=0; i<a.length; i++) {
-      if (!(m=a[i].match(/^\s*(?:(["']?)([a-z][a-z0-9]*)\1)\s*:\s*(?:(-?\d+)|"([a-z0-9+\/%*_.@=\-]*)"|(true|false))$/i))) {
-        throw new sjcl.exception.invalid("json decode: this isn't json!");
-      }
-      if (m[3]) {
-        out[m[2]] = parseInt(m[3],10);
-      } else if (m[4]) {
-        out[m[2]] = m[2].match(/^(ct|salt|iv)$/) ? sjcl.codec.base64.toBits(m[4]) : unescape(m[4]);
-      } else if (m[5]) {
-        out[m[2]] = m[5] === 'true';
-      }
-    }
-    return out;
-  },
-  
-  /** Insert all elements of src into target, modifying and returning target.
-   * @param {Object} target The object to be modified.
-   * @param {Object} src The object to pull data from.
-   * @param {boolean} [requireSame=false] If true, throw an exception if any field of target differs from corresponding field of src.
-   * @return {Object} target.
-   * @private
-   */
-  _add: function (target, src, requireSame) {
-    if (target === undefined) { target = {}; }
-    if (src === undefined) { return target; }
-    var i;
-    for (i in src) {
-      if (src.hasOwnProperty(i)) {
-        if (requireSame && target[i] !== undefined && target[i] !== src[i]) {
-          throw new sjcl.exception.invalid("required parameter overridden");
-        }
-        target[i] = src[i];
-      }
-    }
-    return target;
-  },
-  
-  /** Remove all elements of minus from plus.  Does not modify plus.
-   * @private
-   */
-  _subtract: function (plus, minus) {
-    var out = {}, i;
-
-    for (i in plus) {
-      if (plus.hasOwnProperty(i) && plus[i] !== minus[i]) {
-        out[i] = plus[i];
-      }
-    }
-
-    return out;
-  },
-  
-  /** Return only the specified elements of src.
-   * @private
-   */
-  _filter: function (src, filter) {
-    var out = {}, i;
-    for (i=0; i<filter.length; i++) {
-      if (src[filter[i]] !== undefined) {
-        out[filter[i]] = src[filter[i]];
-      }
-    }
-    return out;
-  }
-};
-
-/** Simple encryption function; convenient shorthand for sjcl.json.encrypt.
- * @param {String|bitArray} password The password or key.
- * @param {String} plaintext The data to encrypt.
- * @param {Object} [params] The parameters including tag, iv and salt.
- * @param {Object} [rp] A returned version with filled-in parameters.
- * @return {String} The ciphertext.
- */
-sjcl.encrypt = sjcl.json.encrypt;
-
-/** Simple decryption function; convenient shorthand for sjcl.json.decrypt.
- * @param {String|bitArray} password The password or key.
- * @param {String} ciphertext The ciphertext to decrypt.
- * @param {Object} [params] Additional non-default parameters.
- * @param {Object} [rp] A returned object with filled parameters.
- * @return {String} The plaintext.
- */
-sjcl.decrypt = sjcl.json.decrypt;
-
-/** The cache for cachedPbkdf2.
- * @private
- */
-sjcl.misc._pbkdf2Cache = {};
-
-/** Cached PBKDF2 key derivation.
- * @param {String} password The password.
- * @param {Object} [obj] The derivation params (iteration count and optional salt).
- * @return {Object} The derived data in key, the salt in salt.
- */
-sjcl.misc.cachedPbkdf2 = function (password, obj) {
-  var cache = sjcl.misc._pbkdf2Cache, c, cp, str, salt, iter;
-  
-  obj = obj || {};
-  iter = obj.iter || 1000;
-  
-  /* open the cache for this password and iteration count */
-  cp = cache[password] = cache[password] || {};
-  c = cp[iter] = cp[iter] || { firstSalt: (obj.salt && obj.salt.length) ?
-                     obj.salt.slice(0) : sjcl.random.randomWords(2,0) };
-          
-  salt = (obj.salt === undefined) ? c.firstSalt : obj.salt;
-  
-  c[salt] = c[salt] || sjcl.misc.pbkdf2(password, salt, obj.iter);
-  return { key: c[salt].slice(0), salt:salt.slice(0) };
-};
-
-

src/js/sjcl/core/ecc.js

@@ -1,543 +0,0 @@
-/**
- * base class for all ecc operations.
- */
-sjcl.ecc = {};
-
-/**
- * Represents a point on a curve in affine coordinates.
- * @constructor
- * @param {sjcl.ecc.curve} curve The curve that this point lies on.
- * @param {bigInt} x The x coordinate.
- * @param {bigInt} y The y coordinate.
- */
-sjcl.ecc.point = function(curve,x,y) {
-  if (x === undefined) {
-    this.isIdentity = true;
-  } else {
-    if (x instanceof sjcl.bn) {
-      x = new curve.field(x);
-    }
-    if (y instanceof sjcl.bn) {
-      y = new curve.field(y);
-    }
-
-    this.x = x;
-    this.y = y;
-
-    this.isIdentity = false;
-  }
-  this.curve = curve;
-};
-
-
-
-sjcl.ecc.point.prototype = {
-  toJac: function() {
-    return new sjcl.ecc.pointJac(this.curve, this.x, this.y, new this.curve.field(1));
-  },
-
-  mult: function(k) {
-    return this.toJac().mult(k, this).toAffine();
-  },
-  
-  /**
-   * Multiply this point by k, added to affine2*k2, and return the answer in Jacobian coordinates.
-   * @param {bigInt} k The coefficient to multiply this by.
-   * @param {bigInt} k2 The coefficient to multiply affine2 this by.
-   * @param {sjcl.ecc.point} affine The other point in affine coordinates.
-   * @return {sjcl.ecc.pointJac} The result of the multiplication and addition, in Jacobian coordinates.
-   */
-  mult2: function(k, k2, affine2) {
-    return this.toJac().mult2(k, this, k2, affine2).toAffine();
-  },
-  
-  multiples: function() {
-    var m, i, j;
-    if (this._multiples === undefined) {
-      j = this.toJac().doubl();
-      m = this._multiples = [new sjcl.ecc.point(this.curve), this, j.toAffine()];
-      for (i=3; i<16; i++) {
-        j = j.add(this);
-        m.push(j.toAffine());
-      }
-    }
-    return this._multiples;
-  },
-
-  isValid: function() {
-    return this.y.square().equals(this.curve.b.add(this.x.mul(this.curve.a.add(this.x.square()))));
-  },
-
-  toBits: function() {
-    return sjcl.bitArray.concat(this.x.toBits(), this.y.toBits());
-  }
-};
-
-/**
- * Represents a point on a curve in Jacobian coordinates. Coordinates can be specified as bigInts or strings (which
- * will be converted to bigInts).
- *
- * @constructor
- * @param {bigInt/string} x The x coordinate.
- * @param {bigInt/string} y The y coordinate.
- * @param {bigInt/string} z The z coordinate.
- * @param {sjcl.ecc.curve} curve The curve that this point lies on.
- */
-sjcl.ecc.pointJac = function(curve, x, y, z) {
-  if (x === undefined) {
-    this.isIdentity = true;
-  } else {
-    this.x = x;
-    this.y = y;
-    this.z = z;
-    this.isIdentity = false;
-  }
-  this.curve = curve;
-};
-
-sjcl.ecc.pointJac.prototype = {
-  /**
-   * Adds S and T and returns the result in Jacobian coordinates. Note that S must be in Jacobian coordinates and T must be in affine coordinates.
-   * @param {sjcl.ecc.pointJac} S One of the points to add, in Jacobian coordinates.
-   * @param {sjcl.ecc.point} T The other point to add, in affine coordinates.
-   * @return {sjcl.ecc.pointJac} The sum of the two points, in Jacobian coordinates. 
-   */
-  add: function(T) {
-    var S = this, sz2, c, d, c2, x1, x2, x, y1, y2, y, z;
-    if (S.curve !== T.curve) {
-      throw("sjcl.ecc.add(): Points must be on the same curve to add them!");
-    }
-
-    if (S.isIdentity) {
-      return T.toJac();
-    } else if (T.isIdentity) {
-      return S;
-    }
-
-    sz2 = S.z.square();
-    c = T.x.mul(sz2).subM(S.x);
-
-    if (c.equals(0)) {
-      if (S.y.equals(T.y.mul(sz2.mul(S.z)))) {
-        // same point
-        return S.doubl();
-      } else {
-        // inverses
-        return new sjcl.ecc.pointJac(S.curve);
-      }
-    }
-    
-    d = T.y.mul(sz2.mul(S.z)).subM(S.y);
-    c2 = c.square();
-
-    x1 = d.square();
-    x2 = c.square().mul(c).addM( S.x.add(S.x).mul(c2) );
-    x  = x1.subM(x2);
-
-    y1 = S.x.mul(c2).subM(x).mul(d);
-    y2 = S.y.mul(c.square().mul(c));
-    y  = y1.subM(y2);
-
-    z  = S.z.mul(c);
-
-    return new sjcl.ecc.pointJac(this.curve,x,y,z);
-  },
-  
-  /**
-   * doubles this point.
-   * @return {sjcl.ecc.pointJac} The doubled point.
-   */
-  doubl: function() {
-    if (this.isIdentity) { return this; }
-
-    var
-      y2 = this.y.square(),
-      a  = y2.mul(this.x.mul(4)),
-      b  = y2.square().mul(8),
-      z2 = this.z.square(),
-      c  = this.curve.a.toString() == (new sjcl.bn(-3)).toString() ?
-                this.x.sub(z2).mul(3).mul(this.x.add(z2)) :
-                this.x.square().mul(3).add(z2.square().mul(this.curve.a)),
-      x  = c.square().subM(a).subM(a),
-      y  = a.sub(x).mul(c).subM(b),
-      z  = this.y.add(this.y).mul(this.z);
-    return new sjcl.ecc.pointJac(this.curve, x, y, z);
-  },
-
-  /**
-   * Returns a copy of this point converted to affine coordinates.
-   * @return {sjcl.ecc.point} The converted point.
-   */
-  toAffine: function() {
-    if (this.isIdentity || this.z.equals(0)) {
-      return new sjcl.ecc.point(this.curve);
-    }
-    var zi = this.z.inverse(), zi2 = zi.square();
-    return new sjcl.ecc.point(this.curve, this.x.mul(zi2).fullReduce(), this.y.mul(zi2.mul(zi)).fullReduce());
-  },
-  
-  /**
-   * Multiply this point by k and return the answer in Jacobian coordinates.
-   * @param {bigInt} k The coefficient to multiply by.
-   * @param {sjcl.ecc.point} affine This point in affine coordinates.
-   * @return {sjcl.ecc.pointJac} The result of the multiplication, in Jacobian coordinates.
-   */
-  mult: function(k, affine) {
-    if (typeof(k) === "number") {
-      k = [k];
-    } else if (k.limbs !== undefined) {
-      k = k.normalize().limbs;
-    }
-    
-    var i, j, out = new sjcl.ecc.point(this.curve).toJac(), multiples = affine.multiples();
-
-    for (i=k.length-1; i>=0; i--) {
-      for (j=sjcl.bn.prototype.radix-4; j>=0; j-=4) {
-        out = out.doubl().doubl().doubl().doubl().add(multiples[k[i]>>j & 0xF]);
-      }
-    }
-    
-    return out;
-  },
-  
-  /**
-   * Multiply this point by k, added to affine2*k2, and return the answer in Jacobian coordinates.
-   * @param {bigInt} k The coefficient to multiply this by.
-   * @param {sjcl.ecc.point} affine This point in affine coordinates.
-   * @param {bigInt} k2 The coefficient to multiply affine2 this by.
-   * @param {sjcl.ecc.point} affine The other point in affine coordinates.
-   * @return {sjcl.ecc.pointJac} The result of the multiplication and addition, in Jacobian coordinates.
-   */
-  mult2: function(k1, affine, k2, affine2) {
-    if (typeof(k1) === "number") {
-      k1 = [k1];
-    } else if (k1.limbs !== undefined) {
-      k1 = k1.normalize().limbs;
-    }
-    
-    if (typeof(k2) === "number") {
-      k2 = [k2];
-    } else if (k2.limbs !== undefined) {
-      k2 = k2.normalize().limbs;
-    }
-    
-    var i, j, out = new sjcl.ecc.point(this.curve).toJac(), m1 = affine.multiples(),
-        m2 = affine2.multiples(), l1, l2;
-
-    for (i=Math.max(k1.length,k2.length)-1; i>=0; i--) {
-      l1 = k1[i] | 0;
-      l2 = k2[i] | 0;
-      for (j=sjcl.bn.prototype.radix-4; j>=0; j-=4) {
-        out = out.doubl().doubl().doubl().doubl().add(m1[l1>>j & 0xF]).add(m2[l2>>j & 0xF]);
-      }
-    }
-    
-    return out;
-  },
-
-  isValid: function() {
-    var z2 = this.z.square(), z4 = z2.square(), z6 = z4.mul(z2);
-    return this.y.square().equals(
-             this.curve.b.mul(z6).add(this.x.mul(
-               this.curve.a.mul(z4).add(this.x.square()))));
-  }
-};
-
-/**
- * Construct an elliptic curve. Most users will not use this and instead start with one of the NIST curves defined below.
- *
- * @constructor
- * @param {bigInt} p The prime modulus.
- * @param {bigInt} r The prime order of the curve.
- * @param {bigInt} a The constant a in the equation of the curve y^2 = x^3 + ax + b (for NIST curves, a is always -3).
- * @param {bigInt} x The x coordinate of a base point of the curve.
- * @param {bigInt} y The y coordinate of a base point of the curve.
- */
-sjcl.ecc.curve = function(Field, r, a, b, x, y) {
-  this.field = Field;
-  this.r = new sjcl.bn(r);
-  this.a = new Field(a);
-  this.b = new Field(b);
-  this.G = new sjcl.ecc.point(this, new Field(x), new Field(y));
-};
-
-sjcl.ecc.curve.prototype.fromBits = function (bits) {
-  var w = sjcl.bitArray, l = this.field.prototype.exponent + 7 & -8,
-      p = new sjcl.ecc.point(this, this.field.fromBits(w.bitSlice(bits, 0, l)),
-                             this.field.fromBits(w.bitSlice(bits, l, 2*l)));
-  if (!p.isValid()) {
-    throw new sjcl.exception.corrupt("not on the curve!");
-  }
-  return p;
-};
-
-sjcl.ecc.curves = {
-  c192: new sjcl.ecc.curve(
-    sjcl.bn.prime.p192,
-    "0xffffffffffffffffffffffff99def836146bc9b1b4d22831",
-    -3,
-    "0x64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1",
-    "0x188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012",
-    "0x07192b95ffc8da78631011ed6b24cdd573f977a11e794811"),
-
-  c224: new sjcl.ecc.curve(
-    sjcl.bn.prime.p224,
-    "0xffffffffffffffffffffffffffff16a2e0b8f03e13dd29455c5c2a3d",
-    -3,
-    "0xb4050a850c04b3abf54132565044b0b7d7bfd8ba270b39432355ffb4",
-    "0xb70e0cbd6bb4bf7f321390b94a03c1d356c21122343280d6115c1d21",
-    "0xbd376388b5f723fb4c22dfe6cd4375a05a07476444d5819985007e34"),
-
-  c256: new sjcl.ecc.curve(
-    sjcl.bn.prime.p256,
-    "0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551",
-    -3,
-    "0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b",
-    "0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296",
-    "0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5"),
-
-  c384: new sjcl.ecc.curve(
-    sjcl.bn.prime.p384,
-    "0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973",
-    -3,
-    "0xb3312fa7e23ee7e4988e056be3f82d19181d9c6efe8141120314088f5013875ac656398d8a2ed19d2a85c8edd3ec2aef",
-    "0xaa87ca22be8b05378eb1c71ef320ad746e1d3b628ba79b9859f741e082542a385502f25dbf55296c3a545e3872760ab7",
-    "0x3617de4a96262c6f5d9e98bf9292dc29f8f41dbd289a147ce9da3113b5f0b8c00a60b1ce1d7e819d7a431d7c90ea0e5f"),
-
-  k192: new sjcl.ecc.curve(
-    sjcl.bn.prime.p192k,
-    "0xfffffffffffffffffffffffe26f2fc170f69466a74defd8d",
-    0,
-    3,
-    "0xdb4ff10ec057e9ae26b07d0280b7f4341da5d1b1eae06c7d",
-    "0x9b2f2f6d9c5628a7844163d015be86344082aa88d95e2f9d"),
-
-  k224: new sjcl.ecc.curve(
-    sjcl.bn.prime.p224k,
-    "0x010000000000000000000000000001dce8d2ec6184caf0a971769fb1f7",
-    0,
-    5,
-    "0xa1455b334df099df30fc28a169a467e9e47075a90f7e650eb6b7a45c",
-    "0x7e089fed7fba344282cafbd6f7e319f7c0b0bd59e2ca4bdb556d61a5"),
-
-  k256: new sjcl.ecc.curve(
-    sjcl.bn.prime.p256k,
-    "0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141",
-    0,
-    7,
-    "0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
-    "0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8")
-
-};
-
-/** our basicKey classes
-*/
-sjcl.ecc.basicKey = {
-  /** ecc publicKey. 
-  * @constructor
-  * @param {curve} curve the elliptic curve
-  * @param {point} point the point on the curve
-  */
-  publicKey: function(curve, point) {
-    this._curve = curve;
-    this._curveBitLength = curve.r.bitLength();
-    if (point instanceof Array) {
-      this._point = curve.fromBits(point);
-    } else {
-      this._point = point;
-    }
-
-    /** get this keys point data
-    * @return x and y as bitArrays
-    */
-    this.get = function() {
-      var pointbits = this._point.toBits();
-      var len = sjcl.bitArray.bitLength(pointbits);
-      var x = sjcl.bitArray.bitSlice(pointbits, 0, len/2);
-      var y = sjcl.bitArray.bitSlice(pointbits, len/2);
-      return { x: x, y: y };
-    };
-  },
-
-  /** ecc secretKey
-  * @constructor
-  * @param {curve} curve the elliptic curve
-  * @param exponent
-  */
-  secretKey: function(curve, exponent) {
-    this._curve = curve;
-    this._curveBitLength = curve.r.bitLength();
-    this._exponent = exponent;
-
-    /** get this keys exponent data
-    * @return {bitArray} exponent
-    */
-    this.get = function () {
-      return this._exponent.toBits();
-    };
-  }
-};
-
-/** @private */
-sjcl.ecc.basicKey.generateKeys = function(cn) {
-  return function generateKeys(curve, paranoia, sec) {
-    curve = curve || 256;
-
-    if (typeof curve === "number") {
-      curve = sjcl.ecc.curves['c'+curve];
-      if (curve === undefined) {
-        throw new sjcl.exception.invalid("no such curve");
-      }
-    }
-    sec = sec || sjcl.bn.random(curve.r, paranoia);
-
-    var pub = curve.G.mult(sec);
-    return { pub: new sjcl.ecc[cn].publicKey(curve, pub),
-             sec: new sjcl.ecc[cn].secretKey(curve, sec) };
-  };
-};
-
-/** elGamal keys */
-sjcl.ecc.elGamal = {
-  /** generate keys
-  * @function
-  * @param curve
-  * @param {int} paranoia Paranoia for generation (default 6)
-  * @param {secretKey} sec secret Key to use. used to get the publicKey for ones secretKey
-  */
-  generateKeys: sjcl.ecc.basicKey.generateKeys("elGamal"),
-  /** elGamal publicKey. 
-  * @constructor
-  * @augments sjcl.ecc.basicKey.publicKey
-  */
-  publicKey: function (curve, point) {
-    sjcl.ecc.basicKey.publicKey.apply(this, arguments);
-  },
-  /** elGamal secretKey
-  * @constructor
-  * @augments sjcl.ecc.basicKey.secretKey
-  */
-  secretKey: function (curve, exponent) {
-    sjcl.ecc.basicKey.secretKey.apply(this, arguments);
-  }
-};
-
-sjcl.ecc.elGamal.publicKey.prototype = {
-  /** Kem function of elGamal Public Key
-  * @param paranoia paranoia to use for randomization.
-  * @return {object} key and tag. unkem(tag) with the corresponding secret key results in the key returned.
-  */
-  kem: function(paranoia) {
-    var sec = sjcl.bn.random(this._curve.r, paranoia),
-        tag = this._curve.G.mult(sec).toBits(),
-        key = sjcl.hash.sha256.hash(this._point.mult(sec).toBits());
-    return { key: key, tag: tag };
-  }
-};
-
-sjcl.ecc.elGamal.secretKey.prototype = {
-  /** UnKem function of elGamal Secret Key
-  * @param {bitArray} tag The Tag to decrypt.
-  * @return {bitArray} decrypted key.
-  */
-  unkem: function(tag) {
-    return sjcl.hash.sha256.hash(this._curve.fromBits(tag).mult(this._exponent).toBits());
-  },
-
-  /** Diffie-Hellmann function
-  * @param {elGamal.publicKey} pk The Public Key to do Diffie-Hellmann with
-  * @return {bitArray} diffie-hellmann result for this key combination.
-  */
-  dh: function(pk) {
-    return sjcl.hash.sha256.hash(pk._point.mult(this._exponent).toBits());
-  },
-  
-  /** Diffie-Hellmann function, compatible with Java generateSecret
-   * @param {elGamal.publicKey} pk The Public Key to do Diffie-Hellmann with
-   * @return {bitArray} undigested X value, diffie-hellmann result for this key combination,
-   * compatible with Java generateSecret().
-   */
-   dhJavaEc: function(pk) {
-     return pk._point.mult(this._exponent).x.toBits();
-   }
-};
-
-/** ecdsa keys */
-sjcl.ecc.ecdsa = {
-  /** generate keys
-  * @function
-  * @param curve
-  * @param {int} paranoia Paranoia for generation (default 6)
-  * @param {secretKey} sec secret Key to use. used to get the publicKey for ones secretKey
-  */
-  generateKeys: sjcl.ecc.basicKey.generateKeys("ecdsa")
-};
-
-/** ecdsa publicKey. 
-* @constructor
-* @augments sjcl.ecc.basicKey.publicKey
-*/
-sjcl.ecc.ecdsa.publicKey = function (curve, point) {
-  sjcl.ecc.basicKey.publicKey.apply(this, arguments);
-};
-
-/** specific functions for ecdsa publicKey. */
-sjcl.ecc.ecdsa.publicKey.prototype = {
-  /** Diffie-Hellmann function
-  * @param {bitArray} hash hash to verify. 
-  * @param {bitArray} rs signature bitArray.
-  * @param {boolean}  fakeLegacyVersion use old legacy version
-  */
-  verify: function(hash, rs, fakeLegacyVersion) {
-    if (sjcl.bitArray.bitLength(hash) > this._curveBitLength) {
-      hash = sjcl.bitArray.clamp(hash, this._curveBitLength);
-    }
-    var w = sjcl.bitArray,
-        R = this._curve.r,
-        l = this._curveBitLength,
-        r = sjcl.bn.fromBits(w.bitSlice(rs,0,l)),
-        ss = sjcl.bn.fromBits(w.bitSlice(rs,l,2*l)),
-        s = fakeLegacyVersion ? ss : ss.inverseMod(R),
-        hG = sjcl.bn.fromBits(hash).mul(s).mod(R),
-        hA = r.mul(s).mod(R),
-        r2 = this._curve.G.mult2(hG, hA, this._point).x;
-    if (r.equals(0) || ss.equals(0) || r.greaterEquals(R) || ss.greaterEquals(R) || !r2.equals(r)) {
-      if (fakeLegacyVersion === undefined) {
-        return this.verify(hash, rs, true);
-      } else {
-        throw (new sjcl.exception.corrupt("signature didn't check out"));
-      }
-    }
-    return true;
-  }
-};
-
-/** ecdsa secretKey
-* @constructor
-* @augments sjcl.ecc.basicKey.publicKey
-*/
-sjcl.ecc.ecdsa.secretKey = function (curve, exponent) {
-  sjcl.ecc.basicKey.secretKey.apply(this, arguments);
-};
-
-/** specific functions for ecdsa secretKey. */
-sjcl.ecc.ecdsa.secretKey.prototype = {
-  /** Diffie-Hellmann function
-  * @param {bitArray} hash hash to sign. 
-  * @param {int} paranoia paranoia for random number generation
-  * @param {boolean} fakeLegacyVersion use old legacy version
-  */
-  sign: function(hash, paranoia, fakeLegacyVersion, fixedKForTesting) {
-    if (sjcl.bitArray.bitLength(hash) > this._curveBitLength) {
-      hash = sjcl.bitArray.clamp(hash, this._curveBitLength);
-    }
-    var R  = this._curve.r,
-        l  = R.bitLength(),
-        k  = fixedKForTesting || sjcl.bn.random(R.sub(1), paranoia).add(1),
-        r  = this._curve.G.mult(k).x.mod(R),
-        ss = sjcl.bn.fromBits(hash).add(r.mul(this._exponent)),
-        s  = fakeLegacyVersion ? ss.inverseMod(R).mul(k).mod(R)
-             : ss.mul(k.inverseMod(R)).mod(R);
-    return sjcl.bitArray.concat(r.toBits(l), s.toBits(l));
-  }
-};

src/js/sjcl/core/gcm.js

@@ -1,183 +0,0 @@
-/** @fileOverview GCM mode implementation.
- *
- * @author Juho Vähä-Herttua
- */
-
-/** @namespace Galois/Counter mode. */
-sjcl.mode.gcm = {
-  /** The name of the mode.
-   * @constant
-   */
-  name: "gcm",
-  
-  /** Encrypt in GCM mode.
-   * @static
-   * @param {Object} prf The pseudorandom function.  It must have a block size of 16 bytes.
-   * @param {bitArray} plaintext The plaintext data.
-   * @param {bitArray} iv The initialization value.
-   * @param {bitArray} [adata=[]] The authenticated data.
-   * @param {Number} [tlen=128] The desired tag length, in bits.
-   * @return {bitArray} The encrypted data, an array of bytes.
-   */
-  encrypt: function (prf, plaintext, iv, adata, tlen) {
-    var out, data = plaintext.slice(0), w=sjcl.bitArray;
-    tlen = tlen || 128;
-    adata = adata || [];
-
-    // encrypt and tag
-    out = sjcl.mode.gcm._ctrMode(true, prf, data, adata, iv, tlen);
-
-    return w.concat(out.data, out.tag);
-  },
-  
-  /** Decrypt in GCM mode.
-   * @static
-   * @param {Object} prf The pseudorandom function.  It must have a block size of 16 bytes.
-   * @param {bitArray} ciphertext The ciphertext data.
-   * @param {bitArray} iv The initialization value.
-   * @param {bitArray} [adata=[]] The authenticated data.
-   * @param {Number} [tlen=128] The desired tag length, in bits.
-   * @return {bitArray} The decrypted data.
-   */
-  decrypt: function (prf, ciphertext, iv, adata, tlen) {
-    var out, data = ciphertext.slice(0), tag, w=sjcl.bitArray, l=w.bitLength(data);
-    tlen = tlen || 128;
-    adata = adata || [];
-
-    // Slice tag out of data
-    if (tlen <= l) {
-      tag = w.bitSlice(data, l-tlen);
-      data = w.bitSlice(data, 0, l-tlen);
-    } else {
-      tag = data;
-      data = [];
-    }
-
-    // decrypt and tag
-    out = sjcl.mode.gcm._ctrMode(false, prf, data, adata, iv, tlen);
-
-    if (!w.equal(out.tag, tag)) {
-      throw new sjcl.exception.corrupt("gcm: tag doesn't match");
-    }
-    return out.data;
-  },
-
-  /* Compute the galois multiplication of X and Y
-   * @private
-   */
-  _galoisMultiply: function (x, y) {
-    var i, j, xi, Zi, Vi, lsb_Vi, w=sjcl.bitArray, xor=w._xor4;
-
-    Zi = [0,0,0,0];
-    Vi = y.slice(0);
-
-    // Block size is 128 bits, run 128 times to get Z_128
-    for (i=0; i<128; i++) {
-      xi = (x[Math.floor(i/32)] & (1 << (31-i%32))) !== 0;
-      if (xi) {
-        // Z_i+1 = Z_i ^ V_i
-        Zi = xor(Zi, Vi);
-      }
-
-      // Store the value of LSB(V_i)
-      lsb_Vi = (Vi[3] & 1) !== 0;
-
-      // V_i+1 = V_i >> 1
-      for (j=3; j>0; j--) {
-        Vi[j] = (Vi[j] >>> 1) | ((Vi[j-1]&1) << 31);
-      }
-      Vi[0] = Vi[0] >>> 1;
-
-      // If LSB(V_i) is 1, V_i+1 = (V_i >> 1) ^ R
-      if (lsb_Vi) {
-        Vi[0] = Vi[0] ^ (0xe1 << 24);
-      }
-    }
-    return Zi;
-  },
-
-  _ghash: function(H, Y0, data) {
-    var Yi, i, l = data.length;
-
-    Yi = Y0.slice(0);
-    for (i=0; i<l; i+=4) {
-      Yi[0] ^= 0xffffffff&data[i];
-      Yi[1] ^= 0xffffffff&data[i+1];
-      Yi[2] ^= 0xffffffff&data[i+2];
-      Yi[3] ^= 0xffffffff&data[i+3];
-      Yi = sjcl.mode.gcm._galoisMultiply(Yi, H);
-    }
-    return Yi;
-  },
-
-  /** GCM CTR mode.
-   * Encrypt or decrypt data and tag with the prf in GCM-style CTR mode.
-   * @param {Boolean} encrypt True if encrypt, false if decrypt.
-   * @param {Object} prf The PRF.
-   * @param {bitArray} data The data to be encrypted or decrypted.
-   * @param {bitArray} iv The initialization vector.
-   * @param {bitArray} adata The associated data to be tagged.
-   * @param {Number} tlen The length of the tag, in bits.
-   */
-  _ctrMode: function(encrypt, prf, data, adata, iv, tlen) {
-    var H, J0, S0, enc, i, ctr, tag, last, l, bl, abl, ivbl, w=sjcl.bitArray;
-
-    // Calculate data lengths
-    l = data.length;
-    bl = w.bitLength(data);
-    abl = w.bitLength(adata);
-    ivbl = w.bitLength(iv);
-
-    // Calculate the parameters
-    H = prf.encrypt([0,0,0,0]);
-    if (ivbl === 96) {
-      J0 = iv.slice(0);
-      J0 = w.concat(J0, [1]);
-    } else {
-      J0 = sjcl.mode.gcm._ghash(H, [0,0,0,0], iv);
-      J0 = sjcl.mode.gcm._ghash(H, J0, [0,0,Math.floor(ivbl/0x100000000),ivbl&0xffffffff]);
-    }
-    S0 = sjcl.mode.gcm._ghash(H, [0,0,0,0], adata);
-
-    // Initialize ctr and tag
-    ctr = J0.slice(0);
-    tag = S0.slice(0);
-
-    // If decrypting, calculate hash
-    if (!encrypt) {
-      tag = sjcl.mode.gcm._ghash(H, S0, data);
-    }
-
-    // Encrypt all the data
-    for (i=0; i<l; i+=4) {
-       ctr[3]++;
-       enc = prf.encrypt(ctr);
-       data[i]   ^= enc[0];
-       data[i+1] ^= enc[1];
-       data[i+2] ^= enc[2];
-       data[i+3] ^= enc[3];
-    }
-    data = w.clamp(data, bl);
-
-    // If encrypting, calculate hash
-    if (encrypt) {
-      tag = sjcl.mode.gcm._ghash(H, S0, data);
-    }
-
-    // Calculate last block from bit lengths, ugly because bitwise operations are 32-bit
-    last = [
-      Math.floor(abl/0x100000000), abl&0xffffffff,
-      Math.floor(bl/0x100000000), bl&0xffffffff
-    ];
-
-    // Calculate the final tag block
-    tag = sjcl.mode.gcm._ghash(H, tag, last);
-    enc = prf.encrypt(J0);
-    tag[0] ^= enc[0];
-    tag[1] ^= enc[1];
-    tag[2] ^= enc[2];
-    tag[3] ^= enc[3];
-
-    return { tag:w.bitSlice(tag, 0, tlen), data:data };
-  }
-};

src/js/sjcl/core/hmac.js

@@ -1,61 +0,0 @@
-/** @fileOverview HMAC implementation.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-/** HMAC with the specified hash function.
- * @constructor
- * @param {bitArray} key the key for HMAC.
- * @param {Object} [hash=sjcl.hash.sha256] The hash function to use.
- */
-sjcl.misc.hmac = function (key, Hash) {
-  this._hash = Hash = Hash || sjcl.hash.sha256;
-  var exKey = [[],[]], i,
-      bs = Hash.prototype.blockSize / 32;
-  this._baseHash = [new Hash(), new Hash()];
-
-  if (key.length > bs) {
-    key = Hash.hash(key);
-  }
-  
-  for (i=0; i<bs; i++) {
-    exKey[0][i] = key[i]^0x36363636;
-    exKey[1][i] = key[i]^0x5C5C5C5C;
-  }
-  
-  this._baseHash[0].update(exKey[0]);
-  this._baseHash[1].update(exKey[1]);
-  this._resultHash = new Hash(this._baseHash[0]);
-};
-
-/** HMAC with the specified hash function.  Also called encrypt since it's a prf.
- * @param {bitArray|String} data The data to mac.
- */
-sjcl.misc.hmac.prototype.encrypt = sjcl.misc.hmac.prototype.mac = function (data) {
-  if (!this._updated) {
-    this.update(data);
-    return this.digest(data);
-  } else {
-    throw new sjcl.exception.invalid("encrypt on already updated hmac called!");
-  }
-};
-
-sjcl.misc.hmac.prototype.reset = function () {
-  this._resultHash = new this._hash(this._baseHash[0]);
-  this._updated = false;
-};
-
-sjcl.misc.hmac.prototype.update = function (data) {
-  this._updated = true;
-  this._resultHash.update(data);
-};
-
-sjcl.misc.hmac.prototype.digest = function () {
-  var w = this._resultHash.finalize(), result = new (this._hash)(this._baseHash[1]).update(w).finalize();
-
-  this.reset();
-
-  return result;
-};

src/js/sjcl/core/ocb2.js

@@ -1,171 +0,0 @@
-/** @fileOverview OCB 2.0 implementation
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-/** @namespace
- * Phil Rogaway's Offset CodeBook mode, version 2.0.
- * May be covered by US and international patents.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-sjcl.mode.ocb2 = {
-  /** The name of the mode.
-   * @constant
-   */
-  name: "ocb2",
-  
-  /** Encrypt in OCB mode, version 2.0.
-   * @param {Object} prp The block cipher.  It must have a block size of 16 bytes.
-   * @param {bitArray} plaintext The plaintext data.
-   * @param {bitArray} iv The initialization value.
-   * @param {bitArray} [adata=[]] The authenticated data.
-   * @param {Number} [tlen=64] the desired tag length, in bits.
-   * @param [false] premac 1 if the authentication data is pre-macced with PMAC.
-   * @return The encrypted data, an array of bytes.
-   * @throws {sjcl.exception.invalid} if the IV isn't exactly 128 bits.
-   */
-  encrypt: function(prp, plaintext, iv, adata, tlen, premac) {
-    if (sjcl.bitArray.bitLength(iv) !== 128) {
-      throw new sjcl.exception.invalid("ocb iv must be 128 bits");
-    }
-    var i,
-        times2 = sjcl.mode.ocb2._times2,
-        w = sjcl.bitArray,
-        xor = w._xor4,
-        checksum = [0,0,0,0],
-        delta = times2(prp.encrypt(iv)),
-        bi, bl,
-        output = [],
-        pad;
-        
-    adata = adata || [];
-    tlen  = tlen || 64;
-  
-    for (i=0; i+4 < plaintext.length; i+=4) {
-      /* Encrypt a non-final block */
-      bi = plaintext.slice(i,i+4);
-      checksum = xor(checksum, bi);
-      output = output.concat(xor(delta,prp.encrypt(xor(delta, bi))));
-      delta = times2(delta);
-    }
-    
-    /* Chop out the final block */
-    bi = plaintext.slice(i);
-    bl = w.bitLength(bi);
-    pad = prp.encrypt(xor(delta,[0,0,0,bl]));
-    bi = w.clamp(xor(bi.concat([0,0,0]),pad), bl);
-    
-    /* Checksum the final block, and finalize the checksum */
-    checksum = xor(checksum,xor(bi.concat([0,0,0]),pad));
-    checksum = prp.encrypt(xor(checksum,xor(delta,times2(delta))));
-    
-    /* MAC the header */
-    if (adata.length) {
-      checksum = xor(checksum, premac ? adata : sjcl.mode.ocb2.pmac(prp, adata));
-    }
-    
-    return output.concat(w.concat(bi, w.clamp(checksum, tlen)));
-  },
-  
-  /** Decrypt in OCB mode.
-   * @param {Object} prp The block cipher.  It must have a block size of 16 bytes.
-   * @param {bitArray} ciphertext The ciphertext data.
-   * @param {bitArray} iv The initialization value.
-   * @param {bitArray} [adata=[]] The authenticated data.
-   * @param {Number} [tlen=64] the desired tag length, in bits.
-   * @param {boolean} [premac=false] true if the authentication data is pre-macced with PMAC.
-   * @return The decrypted data, an array of bytes.
-   * @throws {sjcl.exception.invalid} if the IV isn't exactly 128 bits.
-   * @throws {sjcl.exception.corrupt} if if the message is corrupt.
-   */
-  decrypt: function(prp, ciphertext, iv, adata, tlen, premac) {
-    if (sjcl.bitArray.bitLength(iv) !== 128) {
-      throw new sjcl.exception.invalid("ocb iv must be 128 bits");
-    }
-    tlen  = tlen || 64;
-    var i,
-        times2 = sjcl.mode.ocb2._times2,
-        w = sjcl.bitArray,
-        xor = w._xor4,
-        checksum = [0,0,0,0],
-        delta = times2(prp.encrypt(iv)),
-        bi, bl,
-        len = sjcl.bitArray.bitLength(ciphertext) - tlen,
-        output = [],
-        pad;
-        
-    adata = adata || [];
-  
-    for (i=0; i+4 < len/32; i+=4) {
-      /* Decrypt a non-final block */
-      bi = xor(delta, prp.decrypt(xor(delta, ciphertext.slice(i,i+4))));
-      checksum = xor(checksum, bi);
-      output = output.concat(bi);
-      delta = times2(delta);
-    }
-    
-    /* Chop out and decrypt the final block */
-    bl = len-i*32;
-    pad = prp.encrypt(xor(delta,[0,0,0,bl]));
-    bi = xor(pad, w.clamp(ciphertext.slice(i),bl).concat([0,0,0]));
-    
-    /* Checksum the final block, and finalize the checksum */
-    checksum = xor(checksum, bi);
-    checksum = prp.encrypt(xor(checksum, xor(delta, times2(delta))));
-    
-    /* MAC the header */
-    if (adata.length) {
-      checksum = xor(checksum, premac ? adata : sjcl.mode.ocb2.pmac(prp, adata));
-    }
-    
-    if (!w.equal(w.clamp(checksum, tlen), w.bitSlice(ciphertext, len))) {
-      throw new sjcl.exception.corrupt("ocb: tag doesn't match");
-    }
-    
-    return output.concat(w.clamp(bi,bl));
-  },
-  
-  /** PMAC authentication for OCB associated data.
-   * @param {Object} prp The block cipher.  It must have a block size of 16 bytes.
-   * @param {bitArray} adata The authenticated data.
-   */
-  pmac: function(prp, adata) {
-    var i,
-        times2 = sjcl.mode.ocb2._times2,
-        w = sjcl.bitArray,
-        xor = w._xor4,
-        checksum = [0,0,0,0],
-        delta = prp.encrypt([0,0,0,0]),
-        bi;
-        
-    delta = xor(delta,times2(times2(delta)));
- 
-    for (i=0; i+4<adata.length; i+=4) {
-      delta = times2(delta);
-      checksum = xor(checksum, prp.encrypt(xor(delta, adata.slice(i,i+4))));
-    }
-    
-    bi = adata.slice(i);
-    if (w.bitLength(bi) < 128) {
-      delta = xor(delta,times2(delta));
-      bi = w.concat(bi,[0x80000000|0,0,0,0]);
-    }
-    checksum = xor(checksum, bi);
-    return prp.encrypt(xor(times2(xor(delta,times2(delta))), checksum));
-  },
-  
-  /** Double a block of words, OCB style.
-   * @private
-   */
-  _times2: function(x) {
-    return [x[0]<<1 ^ x[1]>>>31,
-            x[1]<<1 ^ x[2]>>>31,
-            x[2]<<1 ^ x[3]>>>31,
-            x[3]<<1 ^ (x[0]>>>31)*0x87];
-  }
-};

src/js/sjcl/core/pbkdf2.js

@@ -1,58 +0,0 @@
-/** @fileOverview Password-based key-derivation function, version 2.0.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-/** Password-Based Key-Derivation Function, version 2.0.
- *
- * Generate keys from passwords using PBKDF2-HMAC-SHA256.
- *
- * This is the method specified by RSA's PKCS #5 standard.
- *
- * @param {bitArray|String} password  The password.
- * @param {bitArray|String} salt The salt.  Should have lots of entropy.
- * @param {Number} [count=1000] The number of iterations.  Higher numbers make the function slower but more secure.
- * @param {Number} [length] The length of the derived key.  Defaults to the
-                            output size of the hash function.
- * @param {Object} [Prff=sjcl.misc.hmac] The pseudorandom function family.
- * @return {bitArray} the derived key.
- */
-sjcl.misc.pbkdf2 = function (password, salt, count, length, Prff) {
-  count = count || 1000;
-  
-  if (length < 0 || count < 0) {
-    throw sjcl.exception.invalid("invalid params to pbkdf2");
-  }
-  
-  if (typeof password === "string") {
-    password = sjcl.codec.utf8String.toBits(password);
-  }
-  
-  if (typeof salt === "string") {
-    salt = sjcl.codec.utf8String.toBits(salt);
-  }
-  
-  Prff = Prff || sjcl.misc.hmac;
-  
-  var prf = new Prff(password),
-      u, ui, i, j, k, out = [], b = sjcl.bitArray;
-
-  for (k = 1; 32 * out.length < (length || 1); k++) {
-    u = ui = prf.encrypt(b.concat(salt,[k]));
-    
-    for (i=1; i<count; i++) {
-      ui = prf.encrypt(ui);
-      for (j=0; j<ui.length; j++) {
-        u[j] ^= ui[j];
-      }
-    }
-    
-    out = out.concat(u);
-  }
-
-  if (length) { out = b.clamp(out, length); }
-
-  return out;
-};

src/js/sjcl/core/random.js

@@ -1,522 +0,0 @@
-/** @fileOverview Random number generator.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- * @author Michael Brooks
- */
-
-/** @constructor
- * @class Random number generator
- * @description
- * <b>Use sjcl.random as a singleton for this class!</b>
- * <p>
- * This random number generator is a derivative of Ferguson and Schneier's
- * generator Fortuna.  It collects entropy from various events into several
- * pools, implemented by streaming SHA-256 instances.  It differs from
- * ordinary Fortuna in a few ways, though.
- * </p>
- *
- * <p>
- * Most importantly, it has an entropy estimator.  This is present because
- * there is a strong conflict here between making the generator available
- * as soon as possible, and making sure that it doesn't "run on empty".
- * In Fortuna, there is a saved state file, and the system is likely to have
- * time to warm up.
- * </p>
- *
- * <p>
- * Second, because users are unlikely to stay on the page for very long,
- * and to speed startup time, the number of pools increases logarithmically:
- * a new pool is created when the previous one is actually used for a reseed.
- * This gives the same asymptotic guarantees as Fortuna, but gives more
- * entropy to early reseeds.
- * </p>
- *
- * <p>
- * The entire mechanism here feels pretty klunky.  Furthermore, there are
- * several improvements that should be made, including support for
- * dedicated cryptographic functions that may be present in some browsers;
- * state files in local storage; cookies containing randomness; etc.  So
- * look for improvements in future versions.
- * </p>
- */
-sjcl.prng = function(defaultParanoia) {
-  
-  /* private */
-  this._pools                   = [new sjcl.hash.sha256()];
-  this._poolEntropy             = [0];
-  this._reseedCount             = 0;
-  this._robins                  = {};
-  this._eventId                 = 0;
-  
-  this._collectorIds            = {};
-  this._collectorIdNext         = 0;
-  
-  this._strength                = 0;
-  this._poolStrength            = 0;
-  this._nextReseed              = 0;
-  this._key                     = [0,0,0,0,0,0,0,0];
-  this._counter                 = [0,0,0,0];
-  this._cipher                  = undefined;
-  this._defaultParanoia         = defaultParanoia;
-  
-  /* event listener stuff */
-  this._collectorsStarted       = false;
-  this._callbacks               = {progress: {}, seeded: {}};
-  this._callbackI               = 0;
-  
-  /* constants */
-  this._NOT_READY               = 0;
-  this._READY                   = 1;
-  this._REQUIRES_RESEED         = 2;
-
-  this._MAX_WORDS_PER_BURST     = 65536;
-  this._PARANOIA_LEVELS         = [0,48,64,96,128,192,256,384,512,768,1024];
-  this._MILLISECONDS_PER_RESEED = 30000;
-  this._BITS_PER_RESEED         = 80;
-};
- 
-sjcl.prng.prototype = {
-  /** Generate several random words, and return them in an array.
-   * A word consists of 32 bits (4 bytes)
-   * @param {Number} nwords The number of words to generate.
-   */
-  randomWords: function (nwords, paranoia) {
-    var out = [], i, readiness = this.isReady(paranoia), g;
-  
-    if (readiness === this._NOT_READY) {
-      throw new sjcl.exception.notReady("generator isn't seeded");
-    } else if (readiness & this._REQUIRES_RESEED) {
-      this._reseedFromPools(!(readiness & this._READY));
-    }
-  
-    for (i=0; i<nwords; i+= 4) {
-      if ((i+1) % this._MAX_WORDS_PER_BURST === 0) {
-        this._gate();
-      }
-   
-      g = this._gen4words();
-      out.push(g[0],g[1],g[2],g[3]);
-    }
-    this._gate();
-  
-    return out.slice(0,nwords);
-  },
-  
-  setDefaultParanoia: function (paranoia, allowZeroParanoia) {
-    if (paranoia === 0 && allowZeroParanoia !== "Setting paranoia=0 will ruin your security; use it only for testing") {
-      throw "Setting paranoia=0 will ruin your security; use it only for testing";
-    }
-
-    this._defaultParanoia = paranoia;
-  },
-  
-  /**
-   * Add entropy to the pools.
-   * @param data The entropic value.  Should be a 32-bit integer, array of 32-bit integers, or string
-   * @param {Number} estimatedEntropy The estimated entropy of data, in bits
-   * @param {String} source The source of the entropy, eg "mouse"
-   */
-  addEntropy: function (data, estimatedEntropy, source) {
-    source = source || "user";
-  
-    var id,
-      i, tmp,
-      t = (new Date()).valueOf(),
-      robin = this._robins[source],
-      oldReady = this.isReady(), err = 0, objName;
-      
-    id = this._collectorIds[source];
-    if (id === undefined) { id = this._collectorIds[source] = this._collectorIdNext ++; }
-      
-    if (robin === undefined) { robin = this._robins[source] = 0; }
-    this._robins[source] = ( this._robins[source] + 1 ) % this._pools.length;
-  
-    switch(typeof(data)) {
-      
-    case "number":
-      if (estimatedEntropy === undefined) {
-        estimatedEntropy = 1;
-      }
-      this._pools[robin].update([id,this._eventId++,1,estimatedEntropy,t,1,data|0]);
-      break;
-      
-    case "object":
-      objName = Object.prototype.toString.call(data);
-      if (objName === "[object Uint32Array]") {
-        tmp = [];
-        for (i = 0; i < data.length; i++) {
-          tmp.push(data[i]);
-        }
-        data = tmp;
-      } else {
-        if (objName !== "[object Array]") {
-          err = 1;
-        }
-        for (i=0; i<data.length && !err; i++) {
-          if (typeof(data[i]) !== "number") {
-            err = 1;
-          }
-        }
-      }
-      if (!err) {
-        if (estimatedEntropy === undefined) {
-          /* horrible entropy estimator */
-          estimatedEntropy = 0;
-          for (i=0; i<data.length; i++) {
-            tmp= data[i];
-            while (tmp>0) {
-              estimatedEntropy++;
-              tmp = tmp >>> 1;
-            }
-          }
-        }
-        this._pools[robin].update([id,this._eventId++,2,estimatedEntropy,t,data.length].concat(data));
-      }
-      break;
-      
-    case "string":
-      if (estimatedEntropy === undefined) {
-       /* English text has just over 1 bit per character of entropy.
-        * But this might be HTML or something, and have far less
-        * entropy than English...  Oh well, let's just say one bit.
-        */
-       estimatedEntropy = data.length;
-      }
-      this._pools[robin].update([id,this._eventId++,3,estimatedEntropy,t,data.length]);
-      this._pools[robin].update(data);
-      break;
-      
-    default:
-      err=1;
-    }
-    if (err) {
-      throw new sjcl.exception.bug("random: addEntropy only supports number, array of numbers or string");
-    }
-  
-    /* record the new strength */
-    this._poolEntropy[robin] += estimatedEntropy;
-    this._poolStrength += estimatedEntropy;
-  
-    /* fire off events */
-    if (oldReady === this._NOT_READY) {
-      if (this.isReady() !== this._NOT_READY) {
-        this._fireEvent("seeded", Math.max(this._strength, this._poolStrength));
-      }
-      this._fireEvent("progress", this.getProgress());
-    }
-  },
-  
-  /** Is the generator ready? */
-  isReady: function (paranoia) {
-    var entropyRequired = this._PARANOIA_LEVELS[ (paranoia !== undefined) ? paranoia : this._defaultParanoia ];
-  
-    if (this._strength && this._strength >= entropyRequired) {
-      return (this._poolEntropy[0] > this._BITS_PER_RESEED && (new Date()).valueOf() > this._nextReseed) ?
-        this._REQUIRES_RESEED | this._READY :
-        this._READY;
-    } else {
-      return (this._poolStrength >= entropyRequired) ?
-        this._REQUIRES_RESEED | this._NOT_READY :
-        this._NOT_READY;
-    }
-  },
-  
-  /** Get the generator's progress toward readiness, as a fraction */
-  getProgress: function (paranoia) {
-    var entropyRequired = this._PARANOIA_LEVELS[ paranoia ? paranoia : this._defaultParanoia ];
-  
-    if (this._strength >= entropyRequired) {
-      return 1.0;
-    } else {
-      return (this._poolStrength > entropyRequired) ?
-        1.0 :
-        this._poolStrength / entropyRequired;
-    }
-  },
-  
-  /** start the built-in entropy collectors */
-  startCollectors: function () {
-    if (this._collectorsStarted) { return; }
-  
-    this._eventListener = {
-      loadTimeCollector: this._bind(this._loadTimeCollector),
-      mouseCollector: this._bind(this._mouseCollector),
-      keyboardCollector: this._bind(this._keyboardCollector),
-      accelerometerCollector: this._bind(this._accelerometerCollector),
-      touchCollector: this._bind(this._touchCollector)
-    };
-
-    if (window.addEventListener) {
-      window.addEventListener("load", this._eventListener.loadTimeCollector, false);
-      window.addEventListener("mousemove", this._eventListener.mouseCollector, false);
-      window.addEventListener("keypress", this._eventListener.keyboardCollector, false);
-      window.addEventListener("devicemotion", this._eventListener.accelerometerCollector, false);
-      window.addEventListener("touchmove", this._eventListener.touchCollector, false);
-    } else if (document.attachEvent) {
-      document.attachEvent("onload", this._eventListener.loadTimeCollector);
-      document.attachEvent("onmousemove", this._eventListener.mouseCollector);
-      document.attachEvent("keypress", this._eventListener.keyboardCollector);
-    } else {
-      throw new sjcl.exception.bug("can't attach event");
-    }
-  
-    this._collectorsStarted = true;
-  },
-  
-  /** stop the built-in entropy collectors */
-  stopCollectors: function () {
-    if (!this._collectorsStarted) { return; }
-  
-    if (window.removeEventListener) {
-      window.removeEventListener("load", this._eventListener.loadTimeCollector, false);
-      window.removeEventListener("mousemove", this._eventListener.mouseCollector, false);
-      window.removeEventListener("keypress", this._eventListener.keyboardCollector, false);
-      window.removeEventListener("devicemotion", this._eventListener.accelerometerCollector, false);
-      window.removeEventListener("touchmove", this._eventListener.touchCollector, false);
-    } else if (document.detachEvent) {
-      document.detachEvent("onload", this._eventListener.loadTimeCollector);
-      document.detachEvent("onmousemove", this._eventListener.mouseCollector);
-      document.detachEvent("keypress", this._eventListener.keyboardCollector);
-    }
-
-    this._collectorsStarted = false;
-  },
-  
-  /* use a cookie to store entropy.
-  useCookie: function (all_cookies) {
-      throw new sjcl.exception.bug("random: useCookie is unimplemented");
-  },*/
-  
-  /** add an event listener for progress or seeded-ness. */
-  addEventListener: function (name, callback) {
-    this._callbacks[name][this._callbackI++] = callback;
-  },
-  
-  /** remove an event listener for progress or seeded-ness */
-  removeEventListener: function (name, cb) {
-    var i, j, cbs=this._callbacks[name], jsTemp=[];
-
-    /* I'm not sure if this is necessary; in C++, iterating over a
-     * collection and modifying it at the same time is a no-no.
-     */
-
-    for (j in cbs) {
-      if (cbs.hasOwnProperty(j) && cbs[j] === cb) {
-        jsTemp.push(j);
-      }
-    }
-
-    for (i=0; i<jsTemp.length; i++) {
-      j = jsTemp[i];
-      delete cbs[j];
-    }
-  },
-  
-  _bind: function (func) {
-    var that = this;
-    return function () {
-      func.apply(that, arguments);
-    };
-  },
-
-  /** Generate 4 random words, no reseed, no gate.
-   * @private
-   */
-  _gen4words: function () {
-    for (var i=0; i<4; i++) {
-      this._counter[i] = this._counter[i]+1 | 0;
-      if (this._counter[i]) { break; }
-    }
-    return this._cipher.encrypt(this._counter);
-  },
-  
-  /* Rekey the AES instance with itself after a request, or every _MAX_WORDS_PER_BURST words.
-   * @private
-   */
-  _gate: function () {
-    this._key = this._gen4words().concat(this._gen4words());
-    this._cipher = new sjcl.cipher.aes(this._key);
-  },
-  
-  /** Reseed the generator with the given words
-   * @private
-   */
-  _reseed: function (seedWords) {
-    this._key = sjcl.hash.sha256.hash(this._key.concat(seedWords));
-    this._cipher = new sjcl.cipher.aes(this._key);
-    for (var i=0; i<4; i++) {
-      this._counter[i] = this._counter[i]+1 | 0;
-      if (this._counter[i]) { break; }
-    }
-  },
-  
-  /** reseed the data from the entropy pools
-   * @param full If set, use all the entropy pools in the reseed.
-   */
-  _reseedFromPools: function (full) {
-    var reseedData = [], strength = 0, i;
-  
-    this._nextReseed = reseedData[0] =
-      (new Date()).valueOf() + this._MILLISECONDS_PER_RESEED;
-    
-    for (i=0; i<16; i++) {
-      /* On some browsers, this is cryptographically random.  So we might
-       * as well toss it in the pot and stir...
-       */
-      reseedData.push(Math.random()*0x100000000|0);
-    }
-    
-    for (i=0; i<this._pools.length; i++) {
-     reseedData = reseedData.concat(this._pools[i].finalize());
-     strength += this._poolEntropy[i];
-     this._poolEntropy[i] = 0;
-   
-     if (!full && (this._reseedCount & (1<<i))) { break; }
-    }
-  
-    /* if we used the last pool, push a new one onto the stack */
-    if (this._reseedCount >= 1 << this._pools.length) {
-     this._pools.push(new sjcl.hash.sha256());
-     this._poolEntropy.push(0);
-    }
-  
-    /* how strong was this reseed? */
-    this._poolStrength -= strength;
-    if (strength > this._strength) {
-      this._strength = strength;
-    }
-  
-    this._reseedCount ++;
-    this._reseed(reseedData);
-  },
-  
-  _keyboardCollector: function () {
-    this._addCurrentTimeToEntropy(1);
-  },
-  
-  _mouseCollector: function (ev) {
-    var x, y;
-
-    try {
-      x = ev.x || ev.clientX || ev.offsetX || 0;
-      y = ev.y || ev.clientY || ev.offsetY || 0;
-    } catch (err) {
-      // Event originated from a secure element. No mouse position available.
-      x = 0;
-      y = 0;
-    }
-
-    if (x != 0 && y!= 0) {
-      sjcl.random.addEntropy([x,y], 2, "mouse");
-    }
-
-    this._addCurrentTimeToEntropy(0);
-  },
-
-  _touchCollector: function(ev) {
-    var touch = ev.touches[0] || ev.changedTouches[0];
-    var x = touch.pageX || touch.clientX,
-        y = touch.pageY || touch.clientY;
-
-    sjcl.random.addEntropy([x,y],1,"touch");
-
-    this._addCurrentTimeToEntropy(0);
-  },
-  
-  _loadTimeCollector: function () {
-    this._addCurrentTimeToEntropy(2);
-  },
-
-  _addCurrentTimeToEntropy: function (estimatedEntropy) {
-    if (typeof window !== 'undefined' && window.performance && typeof window.performance.now === "function") {
-      //how much entropy do we want to add here?
-      sjcl.random.addEntropy(window.performance.now(), estimatedEntropy, "loadtime");
-    } else {
-      sjcl.random.addEntropy((new Date()).valueOf(), estimatedEntropy, "loadtime");
-    }
-  },
-  _accelerometerCollector: function (ev) {
-    var ac = ev.accelerationIncludingGravity.x||ev.accelerationIncludingGravity.y||ev.accelerationIncludingGravity.z;
-    if(window.orientation){
-      var or = window.orientation;
-      if (typeof or === "number") {
-        sjcl.random.addEntropy(or, 1, "accelerometer");
-      }
-    }
-    if (ac) {
-      sjcl.random.addEntropy(ac, 2, "accelerometer");
-    }
-    this._addCurrentTimeToEntropy(0);
-  },
-
-  _fireEvent: function (name, arg) {
-    var j, cbs=sjcl.random._callbacks[name], cbsTemp=[];
-    /* TODO: there is a race condition between removing collectors and firing them */
-
-    /* I'm not sure if this is necessary; in C++, iterating over a
-     * collection and modifying it at the same time is a no-no.
-     */
-
-    for (j in cbs) {
-      if (cbs.hasOwnProperty(j)) {
-        cbsTemp.push(cbs[j]);
-      }
-    }
-
-    for (j=0; j<cbsTemp.length; j++) {
-      cbsTemp[j](arg);
-    }
-  }
-};
-
-/** an instance for the prng.
-* @see sjcl.prng
-*/
-sjcl.random = new sjcl.prng(6);
-
-(function(){
-  // function for getting nodejs crypto module. catches and ignores errors.
-  function getCryptoModule() {
-    try {
-      return require('crypto');
-    }
-    catch (e) {
-      return null;
-    }
-  }
-
-  try {
-    var buf, crypt, ab;
-
-    // get cryptographically strong entropy depending on runtime environment
-    if (typeof module !== 'undefined' && module.exports && (crypt = getCryptoModule()) && crypt.randomBytes) {
-      buf = crypt.randomBytes(1024/8);
-      buf = new Uint32Array(new Uint8Array(buf).buffer);
-      sjcl.random.addEntropy(buf, 1024, "crypto.randomBytes");
-
-    } else if (typeof window !== 'undefined' && typeof Uint32Array !== 'undefined') {
-      ab = new Uint32Array(32);
-      if (window.crypto && window.crypto.getRandomValues) {
-        window.crypto.getRandomValues(ab);
-      } else if (window.msCrypto && window.msCrypto.getRandomValues) {
-        window.msCrypto.getRandomValues(ab);
-      } else {
-        return;
-      }
-
-      // get cryptographically strong entropy in Webkit
-      sjcl.random.addEntropy(ab, 1024, "crypto.getRandomValues");
-
-    } else {
-      // no getRandomValues :-(
-    }
-  } catch (e) {
-    if (typeof window !== 'undefined' && window.console) {
-      console.log("There was an error collecting entropy from the browser:");
-      console.log(e);
-      //we do not want the library to fail due to randomness not being maintained.
-    }
-  }
-}());

src/js/sjcl/core/sha1.js

@@ -1,164 +0,0 @@
-/** @fileOverview Javascript SHA-1 implementation.
- *
- * Based on the implementation in RFC 3174, method 1, and on the SJCL
- * SHA-256 implementation.
- *
- * @author Quinn Slack
- */
-
-/**
- * Context for a SHA-1 operation in progress.
- * @constructor
- * @class Secure Hash Algorithm, 160 bits.
- */
-sjcl.hash.sha1 = function (hash) {
-  if (hash) {
-    this._h = hash._h.slice(0);
-    this._buffer = hash._buffer.slice(0);
-    this._length = hash._length;
-  } else {
-    this.reset();
-  }
-};
-
-/**
- * Hash a string or an array of words.
- * @static
- * @param {bitArray|String} data the data to hash.
- * @return {bitArray} The hash value, an array of 5 big-endian words.
- */
-sjcl.hash.sha1.hash = function (data) {
-  return (new sjcl.hash.sha1()).update(data).finalize();
-};
-
-sjcl.hash.sha1.prototype = {
-  /**
-   * The hash's block size, in bits.
-   * @constant
-   */
-  blockSize: 512,
-   
-  /**
-   * Reset the hash state.
-   * @return this
-   */
-  reset:function () {
-    this._h = this._init.slice(0);
-    this._buffer = [];
-    this._length = 0;
-    return this;
-  },
-  
-  /**
-   * Input several words to the hash.
-   * @param {bitArray|String} data the data to hash.
-   * @return this
-   */
-  update: function (data) {
-    if (typeof data === "string") {
-      data = sjcl.codec.utf8String.toBits(data);
-    }
-    var i, b = this._buffer = sjcl.bitArray.concat(this._buffer, data),
-        ol = this._length,
-        nl = this._length = ol + sjcl.bitArray.bitLength(data);
-    for (i = this.blockSize+ol & -this.blockSize; i <= nl;
-         i+= this.blockSize) {
-      this._block(b.splice(0,16));
-    }
-    return this;
-  },
-  
-  /**
-   * Complete hashing and output the hash value.
-   * @return {bitArray} The hash value, an array of 5 big-endian words. TODO
-   */
-  finalize:function () {
-    var i, b = this._buffer, h = this._h;
-
-    // Round out and push the buffer
-    b = sjcl.bitArray.concat(b, [sjcl.bitArray.partial(1,1)]);
-    // Round out the buffer to a multiple of 16 words, less the 2 length words.
-    for (i = b.length + 2; i & 15; i++) {
-      b.push(0);
-    }
-
-    // append the length
-    b.push(Math.floor(this._length / 0x100000000));
-    b.push(this._length | 0);
-
-    while (b.length) {
-      this._block(b.splice(0,16));
-    }
-
-    this.reset();
-    return h;
-  },
-
-  /**
-   * The SHA-1 initialization vector.
-   * @private
-   */
-  _init:[0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0],
-
-  /**
-   * The SHA-1 hash key.
-   * @private
-   */
-  _key:[0x5A827999, 0x6ED9EBA1, 0x8F1BBCDC, 0xCA62C1D6],
-
-  /**
-   * The SHA-1 logical functions f(0), f(1), ..., f(79).
-   * @private
-   */
-  _f:function(t, b, c, d) {
-    if (t <= 19) {
-      return (b & c) | (~b & d);
-    } else if (t <= 39) {
-      return b ^ c ^ d;
-    } else if (t <= 59) {
-      return (b & c) | (b & d) | (c & d);
-    } else if (t <= 79) {
-      return b ^ c ^ d;
-    }
-  },
-
-  /**
-   * Circular left-shift operator.
-   * @private
-   */
-  _S:function(n, x) {
-    return (x << n) | (x >>> 32-n);
-  },
-  
-  /**
-   * Perform one cycle of SHA-1.
-   * @param {bitArray} words one block of words.
-   * @private
-   */
-  _block:function (words) {  
-    var t, tmp, a, b, c, d, e,
-    w = words.slice(0),
-    h = this._h;
-   
-    a = h[0]; b = h[1]; c = h[2]; d = h[3]; e = h[4]; 
-
-    for (t=0; t<=79; t++) {
-      if (t >= 16) {
-        w[t] = this._S(1, w[t-3] ^ w[t-8] ^ w[t-14] ^ w[t-16]);
-      }
-      tmp = (this._S(5, a) + this._f(t, b, c, d) + e + w[t] +
-             this._key[Math.floor(t/20)]) | 0;
-      e = d;
-      d = c;
-      c = this._S(30, b);
-      b = a;
-      a = tmp;
-   }
-
-   h[0] = (h[0]+a) |0;
-   h[1] = (h[1]+b) |0;
-   h[2] = (h[2]+c) |0;
-   h[3] = (h[3]+d) |0;
-   h[4] = (h[4]+e) |0;
-  }
-};

src/js/sjcl/core/sha256.js

@@ -1,216 +0,0 @@
-/** @fileOverview Javascript SHA-256 implementation.
- *
- * An older version of this implementation is available in the public
- * domain, but this one is (c) Emily Stark, Mike Hamburg, Dan Boneh,
- * Stanford University 2008-2010 and BSD-licensed for liability
- * reasons.
- *
- * Special thanks to Aldo Cortesi for pointing out several bugs in
- * this code.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-/**
- * Context for a SHA-256 operation in progress.
- * @constructor
- * @class Secure Hash Algorithm, 256 bits.
- */
-sjcl.hash.sha256 = function (hash) {
-  if (!this._key[0]) { this._precompute(); }
-  if (hash) {
-    this._h = hash._h.slice(0);
-    this._buffer = hash._buffer.slice(0);
-    this._length = hash._length;
-  } else {
-    this.reset();
-  }
-};
-
-/**
- * Hash a string or an array of words.
- * @static
- * @param {bitArray|String} data the data to hash.
- * @return {bitArray} The hash value, an array of 16 big-endian words.
- */
-sjcl.hash.sha256.hash = function (data) {
-  return (new sjcl.hash.sha256()).update(data).finalize();
-};
-
-sjcl.hash.sha256.prototype = {
-  /**
-   * The hash's block size, in bits.
-   * @constant
-   */
-  blockSize: 512,
-   
-  /**
-   * Reset the hash state.
-   * @return this
-   */
-  reset:function () {
-    this._h = this._init.slice(0);
-    this._buffer = [];
-    this._length = 0;
-    return this;
-  },
-  
-  /**
-   * Input several words to the hash.
-   * @param {bitArray|String} data the data to hash.
-   * @return this
-   */
-  update: function (data) {
-    if (typeof data === "string") {
-      data = sjcl.codec.utf8String.toBits(data);
-    }
-    var i, b = this._buffer = sjcl.bitArray.concat(this._buffer, data),
-        ol = this._length,
-        nl = this._length = ol + sjcl.bitArray.bitLength(data);
-    for (i = 512+ol & -512; i <= nl; i+= 512) {
-      this._block(b.splice(0,16));
-    }
-    return this;
-  },
-  
-  /**
-   * Complete hashing and output the hash value.
-   * @return {bitArray} The hash value, an array of 8 big-endian words.
-   */
-  finalize:function () {
-    var i, b = this._buffer, h = this._h;
-
-    // Round out and push the buffer
-    b = sjcl.bitArray.concat(b, [sjcl.bitArray.partial(1,1)]);
-    
-    // Round out the buffer to a multiple of 16 words, less the 2 length words.
-    for (i = b.length + 2; i & 15; i++) {
-      b.push(0);
-    }
-    
-    // append the length
-    b.push(Math.floor(this._length / 0x100000000));
-    b.push(this._length | 0);
-
-    while (b.length) {
-      this._block(b.splice(0,16));
-    }
-
-    this.reset();
-    return h;
-  },
-
-  /**
-   * The SHA-256 initialization vector, to be precomputed.
-   * @private
-   */
-  _init:[],
-  /*
-  _init:[0x6a09e667,0xbb67ae85,0x3c6ef372,0xa54ff53a,0x510e527f,0x9b05688c,0x1f83d9ab,0x5be0cd19],
-  */
-  
-  /**
-   * The SHA-256 hash key, to be precomputed.
-   * @private
-   */
-  _key:[],
-  /*
-  _key:
-    [0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
-     0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
-     0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
-     0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
-     0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
-     0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
-     0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
-     0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2],
-  */
-
-
-  /**
-   * Function to precompute _init and _key.
-   * @private
-   */
-  _precompute: function () {
-    var i = 0, prime = 2, factor;
-
-    function frac(x) { return (x-Math.floor(x)) * 0x100000000 | 0; }
-
-    outer: for (; i<64; prime++) {
-      for (factor=2; factor*factor <= prime; factor++) {
-        if (prime % factor === 0) {
-          // not a prime
-          continue outer;
-        }
-      }
-      
-      if (i<8) {
-        this._init[i] = frac(Math.pow(prime, 1/2));
-      }
-      this._key[i] = frac(Math.pow(prime, 1/3));
-      i++;
-    }
-  },
-  
-  /**
-   * Perform one cycle of SHA-256.
-   * @param {bitArray} words one block of words.
-   * @private
-   */
-  _block:function (words) {  
-    var i, tmp, a, b,
-      w = words.slice(0),
-      h = this._h,
-      k = this._key,
-      h0 = h[0], h1 = h[1], h2 = h[2], h3 = h[3],
-      h4 = h[4], h5 = h[5], h6 = h[6], h7 = h[7];
-
-    /* Rationale for placement of |0 :
-     * If a value can overflow is original 32 bits by a factor of more than a few
-     * million (2^23 ish), there is a possibility that it might overflow the
-     * 53-bit mantissa and lose precision.
-     *
-     * To avoid this, we clamp back to 32 bits by |'ing with 0 on any value that
-     * propagates around the loop, and on the hash state h[].  I don't believe
-     * that the clamps on h4 and on h0 are strictly necessary, but it's close
-     * (for h4 anyway), and better safe than sorry.
-     *
-     * The clamps on h[] are necessary for the output to be correct even in the
-     * common case and for short inputs.
-     */
-    for (i=0; i<64; i++) {
-      // load up the input word for this round
-      if (i<16) {
-        tmp = w[i];
-      } else {
-        a   = w[(i+1 ) & 15];
-        b   = w[(i+14) & 15];
-        tmp = w[i&15] = ((a>>>7  ^ a>>>18 ^ a>>>3  ^ a<<25 ^ a<<14) + 
-                         (b>>>17 ^ b>>>19 ^ b>>>10 ^ b<<15 ^ b<<13) +
-                         w[i&15] + w[(i+9) & 15]) | 0;
-      }
-      
-      tmp = (tmp + h7 + (h4>>>6 ^ h4>>>11 ^ h4>>>25 ^ h4<<26 ^ h4<<21 ^ h4<<7) +  (h6 ^ h4&(h5^h6)) + k[i]); // | 0;
-      
-      // shift register
-      h7 = h6; h6 = h5; h5 = h4;
-      h4 = h3 + tmp | 0;
-      h3 = h2; h2 = h1; h1 = h0;
-
-      h0 = (tmp +  ((h1&h2) ^ (h3&(h1^h2))) + (h1>>>2 ^ h1>>>13 ^ h1>>>22 ^ h1<<30 ^ h1<<19 ^ h1<<10)) | 0;
-    }
-
-    h[0] = h[0]+h0 | 0;
-    h[1] = h[1]+h1 | 0;
-    h[2] = h[2]+h2 | 0;
-    h[3] = h[3]+h3 | 0;
-    h[4] = h[4]+h4 | 0;
-    h[5] = h[5]+h5 | 0;
-    h[6] = h[6]+h6 | 0;
-    h[7] = h[7]+h7 | 0;
-  }
-};
-
-

src/js/sjcl/core/sha512.js

@@ -1,348 +0,0 @@
-/** @fileOverview Javascript SHA-512 implementation.
- *
- * This implementation was written for CryptoJS by Jeff Mott and adapted for
- * SJCL by Stefan Thomas.
- *
- * CryptoJS (c) 2009–2012 by Jeff Mott. All rights reserved.
- * Released with New BSD License
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- * @author Jeff Mott
- * @author Stefan Thomas
- */
-
-/**
- * Context for a SHA-512 operation in progress.
- * @constructor
- * @class Secure Hash Algorithm, 512 bits.
- */
-sjcl.hash.sha512 = function (hash) {
-  if (!this._key[0]) { this._precompute(); }
-  if (hash) {
-    this._h = hash._h.slice(0);
-    this._buffer = hash._buffer.slice(0);
-    this._length = hash._length;
-  } else {
-    this.reset();
-  }
-};
-
-/**
- * Hash a string or an array of words.
- * @static
- * @param {bitArray|String} data the data to hash.
- * @return {bitArray} The hash value, an array of 16 big-endian words.
- */
-sjcl.hash.sha512.hash = function (data) {
-  return (new sjcl.hash.sha512()).update(data).finalize();
-};
-
-sjcl.hash.sha512.prototype = {
-  /**
-   * The hash's block size, in bits.
-   * @constant
-   */
-  blockSize: 1024,
-   
-  /**
-   * Reset the hash state.
-   * @return this
-   */
-  reset:function () {
-    this._h = this._init.slice(0);
-    this._buffer = [];
-    this._length = 0;
-    return this;
-  },
-  
-  /**
-   * Input several words to the hash.
-   * @param {bitArray|String} data the data to hash.
-   * @return this
-   */
-  update: function (data) {
-    if (typeof data === "string") {
-      data = sjcl.codec.utf8String.toBits(data);
-    }
-    var i, b = this._buffer = sjcl.bitArray.concat(this._buffer, data),
-        ol = this._length,
-        nl = this._length = ol + sjcl.bitArray.bitLength(data);
-    for (i = 1024+ol & -1024; i <= nl; i+= 1024) {
-      this._block(b.splice(0,32));
-    }
-    return this;
-  },
-  
-  /**
-   * Complete hashing and output the hash value.
-   * @return {bitArray} The hash value, an array of 16 big-endian words.
-   */
-  finalize:function () {
-    var i, b = this._buffer, h = this._h;
-
-    // Round out and push the buffer
-    b = sjcl.bitArray.concat(b, [sjcl.bitArray.partial(1,1)]);
-
-    // Round out the buffer to a multiple of 32 words, less the 4 length words.
-    for (i = b.length + 4; i & 31; i++) {
-      b.push(0);
-    }
-
-    // append the length
-    b.push(0);
-    b.push(0);
-    b.push(Math.floor(this._length / 0x100000000));
-    b.push(this._length | 0);
-
-    while (b.length) {
-      this._block(b.splice(0,32));
-    }
-
-    this.reset();
-    return h;
-  },
-
-  /**
-   * The SHA-512 initialization vector, to be precomputed.
-   * @private
-   */
-  _init:[],
-
-  /**
-   * Least significant 24 bits of SHA512 initialization values.
-   *
-   * Javascript only has 53 bits of precision, so we compute the 40 most
-   * significant bits and add the remaining 24 bits as constants.
-   *
-   * @private
-   */
-  _initr: [ 0xbcc908, 0xcaa73b, 0x94f82b, 0x1d36f1, 0xe682d1, 0x3e6c1f, 0x41bd6b, 0x7e2179 ],
-
-  /*
-  _init:
-  [0x6a09e667, 0xf3bcc908, 0xbb67ae85, 0x84caa73b, 0x3c6ef372, 0xfe94f82b, 0xa54ff53a, 0x5f1d36f1,
-   0x510e527f, 0xade682d1, 0x9b05688c, 0x2b3e6c1f, 0x1f83d9ab, 0xfb41bd6b, 0x5be0cd19, 0x137e2179],
-  */
-
-  /**
-   * The SHA-512 hash key, to be precomputed.
-   * @private
-   */
-  _key:[],
-
-  /**
-   * Least significant 24 bits of SHA512 key values.
-   * @private
-   */
-  _keyr:
-  [0x28ae22, 0xef65cd, 0x4d3b2f, 0x89dbbc, 0x48b538, 0x05d019, 0x194f9b, 0x6d8118,
-   0x030242, 0x706fbe, 0xe4b28c, 0xffb4e2, 0x7b896f, 0x1696b1, 0xc71235, 0x692694,
-   0xf14ad2, 0x4f25e3, 0x8cd5b5, 0xac9c65, 0x2b0275, 0xa6e483, 0x41fbd4, 0x1153b5,
-   0x66dfab, 0xb43210, 0xfb213f, 0xef0ee4, 0xa88fc2, 0x0aa725, 0x03826f, 0x0e6e70,
-   0xd22ffc, 0x26c926, 0xc42aed, 0x95b3df, 0xaf63de, 0x77b2a8, 0xedaee6, 0x82353b,
-   0xf10364, 0x423001, 0xf89791, 0x54be30, 0xef5218, 0x65a910, 0x71202a, 0xbbd1b8,
-   0xd2d0c8, 0x41ab53, 0x8eeb99, 0x9b48a8, 0xc95a63, 0x418acb, 0x63e373, 0xb2b8a3,
-   0xefb2fc, 0x172f60, 0xf0ab72, 0x6439ec, 0x631e28, 0x82bde9, 0xc67915, 0x72532b,
-   0x26619c, 0xc0c207, 0xe0eb1e, 0x6ed178, 0x176fba, 0xc898a6, 0xf90dae, 0x1c471b,
-   0x047d84, 0xc72493, 0xc9bebc, 0x100d4c, 0x3e42b6, 0x657e2a, 0xd6faec, 0x475817],
-
-  /*
-  _key:
-  [0x428a2f98, 0xd728ae22, 0x71374491, 0x23ef65cd, 0xb5c0fbcf, 0xec4d3b2f, 0xe9b5dba5, 0x8189dbbc,
-   0x3956c25b, 0xf348b538, 0x59f111f1, 0xb605d019, 0x923f82a4, 0xaf194f9b, 0xab1c5ed5, 0xda6d8118,
-   0xd807aa98, 0xa3030242, 0x12835b01, 0x45706fbe, 0x243185be, 0x4ee4b28c, 0x550c7dc3, 0xd5ffb4e2,
-   0x72be5d74, 0xf27b896f, 0x80deb1fe, 0x3b1696b1, 0x9bdc06a7, 0x25c71235, 0xc19bf174, 0xcf692694,
-   0xe49b69c1, 0x9ef14ad2, 0xefbe4786, 0x384f25e3, 0x0fc19dc6, 0x8b8cd5b5, 0x240ca1cc, 0x77ac9c65,
-   0x2de92c6f, 0x592b0275, 0x4a7484aa, 0x6ea6e483, 0x5cb0a9dc, 0xbd41fbd4, 0x76f988da, 0x831153b5,
-   0x983e5152, 0xee66dfab, 0xa831c66d, 0x2db43210, 0xb00327c8, 0x98fb213f, 0xbf597fc7, 0xbeef0ee4,
-   0xc6e00bf3, 0x3da88fc2, 0xd5a79147, 0x930aa725, 0x06ca6351, 0xe003826f, 0x14292967, 0x0a0e6e70,
-   0x27b70a85, 0x46d22ffc, 0x2e1b2138, 0x5c26c926, 0x4d2c6dfc, 0x5ac42aed, 0x53380d13, 0x9d95b3df,
-   0x650a7354, 0x8baf63de, 0x766a0abb, 0x3c77b2a8, 0x81c2c92e, 0x47edaee6, 0x92722c85, 0x1482353b,
-   0xa2bfe8a1, 0x4cf10364, 0xa81a664b, 0xbc423001, 0xc24b8b70, 0xd0f89791, 0xc76c51a3, 0x0654be30,
-   0xd192e819, 0xd6ef5218, 0xd6990624, 0x5565a910, 0xf40e3585, 0x5771202a, 0x106aa070, 0x32bbd1b8,
-   0x19a4c116, 0xb8d2d0c8, 0x1e376c08, 0x5141ab53, 0x2748774c, 0xdf8eeb99, 0x34b0bcb5, 0xe19b48a8,
-   0x391c0cb3, 0xc5c95a63, 0x4ed8aa4a, 0xe3418acb, 0x5b9cca4f, 0x7763e373, 0x682e6ff3, 0xd6b2b8a3,
-   0x748f82ee, 0x5defb2fc, 0x78a5636f, 0x43172f60, 0x84c87814, 0xa1f0ab72, 0x8cc70208, 0x1a6439ec,
-   0x90befffa, 0x23631e28, 0xa4506ceb, 0xde82bde9, 0xbef9a3f7, 0xb2c67915, 0xc67178f2, 0xe372532b,
-   0xca273ece, 0xea26619c, 0xd186b8c7, 0x21c0c207, 0xeada7dd6, 0xcde0eb1e, 0xf57d4f7f, 0xee6ed178,
-   0x06f067aa, 0x72176fba, 0x0a637dc5, 0xa2c898a6, 0x113f9804, 0xbef90dae, 0x1b710b35, 0x131c471b,
-   0x28db77f5, 0x23047d84, 0x32caab7b, 0x40c72493, 0x3c9ebe0a, 0x15c9bebc, 0x431d67c4, 0x9c100d4c,
-   0x4cc5d4be, 0xcb3e42b6, 0x597f299c, 0xfc657e2a, 0x5fcb6fab, 0x3ad6faec, 0x6c44198c, 0x4a475817],
-  */
-
-  /**
-   * Function to precompute _init and _key.
-   * @private
-   */
-  _precompute: function () {
-    // XXX: This code is for precomputing the SHA256 constants, change for
-    //      SHA512 and re-enable.
-    var i = 0, prime = 2, factor;
-
-    function frac(x)  { return (x-Math.floor(x)) * 0x100000000 | 0; }
-    function frac2(x) { return (x-Math.floor(x)) * 0x10000000000 & 0xff; }
-
-    outer: for (; i<80; prime++) {
-      for (factor=2; factor*factor <= prime; factor++) {
-        if (prime % factor === 0) {
-          // not a prime
-          continue outer;
-        }
-      }
-
-      if (i<8) {
-        this._init[i*2] = frac(Math.pow(prime, 1/2));
-        this._init[i*2+1] = (frac2(Math.pow(prime, 1/2)) << 24) | this._initr[i];
-      }
-      this._key[i*2] = frac(Math.pow(prime, 1/3));
-      this._key[i*2+1] = (frac2(Math.pow(prime, 1/3)) << 24) | this._keyr[i];
-      i++;
-    }
-  },
-
-  /**
-   * Perform one cycle of SHA-512.
-   * @param {bitArray} words one block of words.
-   * @private
-   */
-  _block:function (words) {
-    var i, wrh, wrl,
-        w = words.slice(0),
-        h = this._h,
-        k = this._key,
-        h0h = h[ 0], h0l = h[ 1], h1h = h[ 2], h1l = h[ 3],
-        h2h = h[ 4], h2l = h[ 5], h3h = h[ 6], h3l = h[ 7],
-        h4h = h[ 8], h4l = h[ 9], h5h = h[10], h5l = h[11],
-        h6h = h[12], h6l = h[13], h7h = h[14], h7l = h[15];
-
-    // Working variables
-    var ah = h0h, al = h0l, bh = h1h, bl = h1l,
-        ch = h2h, cl = h2l, dh = h3h, dl = h3l,
-        eh = h4h, el = h4l, fh = h5h, fl = h5l,
-        gh = h6h, gl = h6l, hh = h7h, hl = h7l;
-
-    for (i=0; i<80; i++) {
-      // load up the input word for this round
-      if (i<16) {
-        wrh = w[i * 2];
-        wrl = w[i * 2 + 1];
-      } else {
-        // Gamma0
-        var gamma0xh = w[(i-15) * 2];
-        var gamma0xl = w[(i-15) * 2 + 1];
-        var gamma0h =
-          ((gamma0xl << 31) | (gamma0xh >>> 1)) ^
-          ((gamma0xl << 24) | (gamma0xh >>> 8)) ^
-           (gamma0xh >>> 7);
-        var gamma0l =
-          ((gamma0xh << 31) | (gamma0xl >>> 1)) ^
-          ((gamma0xh << 24) | (gamma0xl >>> 8)) ^
-          ((gamma0xh << 25) | (gamma0xl >>> 7));
-
-        // Gamma1
-        var gamma1xh = w[(i-2) * 2];
-        var gamma1xl = w[(i-2) * 2 + 1];
-        var gamma1h =
-          ((gamma1xl << 13) | (gamma1xh >>> 19)) ^
-          ((gamma1xh << 3)  | (gamma1xl >>> 29)) ^
-           (gamma1xh >>> 6);
-        var gamma1l =
-          ((gamma1xh << 13) | (gamma1xl >>> 19)) ^
-          ((gamma1xl << 3)  | (gamma1xh >>> 29)) ^
-          ((gamma1xh << 26) | (gamma1xl >>> 6));
-
-        // Shortcuts
-        var wr7h = w[(i-7) * 2];
-        var wr7l = w[(i-7) * 2 + 1];
-
-        var wr16h = w[(i-16) * 2];
-        var wr16l = w[(i-16) * 2 + 1];
-
-        // W(round) = gamma0 + W(round - 7) + gamma1 + W(round - 16)
-        wrl = gamma0l + wr7l;
-        wrh = gamma0h + wr7h + ((wrl >>> 0) < (gamma0l >>> 0) ? 1 : 0);
-        wrl += gamma1l;
-        wrh += gamma1h + ((wrl >>> 0) < (gamma1l >>> 0) ? 1 : 0);
-        wrl += wr16l;
-        wrh += wr16h + ((wrl >>> 0) < (wr16l >>> 0) ? 1 : 0);
-      }
-
-      w[i*2]     = wrh |= 0;
-      w[i*2 + 1] = wrl |= 0;
-
-      // Ch
-      var chh = (eh & fh) ^ (~eh & gh);
-      var chl = (el & fl) ^ (~el & gl);
-
-      // Maj
-      var majh = (ah & bh) ^ (ah & ch) ^ (bh & ch);
-      var majl = (al & bl) ^ (al & cl) ^ (bl & cl);
-
-      // Sigma0
-      var sigma0h = ((al << 4) | (ah >>> 28)) ^ ((ah << 30) | (al >>> 2)) ^ ((ah << 25) | (al >>> 7));
-      var sigma0l = ((ah << 4) | (al >>> 28)) ^ ((al << 30) | (ah >>> 2)) ^ ((al << 25) | (ah >>> 7));
-
-      // Sigma1
-      var sigma1h = ((el << 18) | (eh >>> 14)) ^ ((el << 14) | (eh >>> 18)) ^ ((eh << 23) | (el >>> 9));
-      var sigma1l = ((eh << 18) | (el >>> 14)) ^ ((eh << 14) | (el >>> 18)) ^ ((el << 23) | (eh >>> 9));
-
-      // K(round)
-      var krh = k[i*2];
-      var krl = k[i*2+1];
-
-      // t1 = h + sigma1 + ch + K(round) + W(round)
-      var t1l = hl + sigma1l;
-      var t1h = hh + sigma1h + ((t1l >>> 0) < (hl >>> 0) ? 1 : 0);
-      t1l += chl;
-      t1h += chh + ((t1l >>> 0) < (chl >>> 0) ? 1 : 0);
-      t1l += krl;
-      t1h += krh + ((t1l >>> 0) < (krl >>> 0) ? 1 : 0);
-      t1l = t1l + wrl|0;   // FF32..FF34 perf issue https://bugzilla.mozilla.org/show_bug.cgi?id=1054972
-      t1h += wrh + ((t1l >>> 0) < (wrl >>> 0) ? 1 : 0);
-
-      // t2 = sigma0 + maj
-      var t2l = sigma0l + majl;
-      var t2h = sigma0h + majh + ((t2l >>> 0) < (sigma0l >>> 0) ? 1 : 0);
-
-      // Update working variables
-      hh = gh;
-      hl = gl;
-      gh = fh;
-      gl = fl;
-      fh = eh;
-      fl = el;
-      el = (dl + t1l) | 0;
-      eh = (dh + t1h + ((el >>> 0) < (dl >>> 0) ? 1 : 0)) | 0;
-      dh = ch;
-      dl = cl;
-      ch = bh;
-      cl = bl;
-      bh = ah;
-      bl = al;
-      al = (t1l + t2l) | 0;
-      ah = (t1h + t2h + ((al >>> 0) < (t1l >>> 0) ? 1 : 0)) | 0;
-    }
-
-    // Intermediate hash
-    h0l = h[1] = (h0l + al) | 0;
-    h[0] = (h0h + ah + ((h0l >>> 0) < (al >>> 0) ? 1 : 0)) | 0;
-    h1l = h[3] = (h1l + bl) | 0;
-    h[2] = (h1h + bh + ((h1l >>> 0) < (bl >>> 0) ? 1 : 0)) | 0;
-    h2l = h[5] = (h2l + cl) | 0;
-    h[4] = (h2h + ch + ((h2l >>> 0) < (cl >>> 0) ? 1 : 0)) | 0;
-    h3l = h[7] = (h3l + dl) | 0;
-    h[6] = (h3h + dh + ((h3l >>> 0) < (dl >>> 0) ? 1 : 0)) | 0;
-    h4l = h[9] = (h4l + el) | 0;
-    h[8] = (h4h + eh + ((h4l >>> 0) < (el >>> 0) ? 1 : 0)) | 0;
-    h5l = h[11] = (h5l + fl) | 0;
-    h[10] = (h5h + fh + ((h5l >>> 0) < (fl >>> 0) ? 1 : 0)) | 0;
-    h6l = h[13] = (h6l + gl) | 0;
-    h[12] = (h6h + gh + ((h6l >>> 0) < (gl >>> 0) ? 1 : 0)) | 0;
-    h7l = h[15] = (h7l + hl) | 0;
-    h[14] = (h7h + hh + ((h7l >>> 0) < (hl >>> 0) ? 1 : 0)) | 0;
-  }
-};
-
-

src/js/sjcl/core/sjcl.js

@@ -1,78 +0,0 @@
-/** @fileOverview Javascript cryptography implementation.
- *
- * Crush to remove comments, shorten variable names and
- * generally reduce transmission size.
- *
- * @author Emily Stark
- * @author Mike Hamburg
- * @author Dan Boneh
- */
-
-"use strict";
-/*jslint indent: 2, bitwise: false, nomen: false, plusplus: false, white: false, regexp: false */
-/*global document, window, escape, unescape, module, require, Uint32Array */
-
-/** @namespace The Stanford Javascript Crypto Library, top-level namespace. */
-var sjcl = {
-  /** @namespace Symmetric ciphers. */
-  cipher: {},
-
-  /** @namespace Hash functions.  Right now only SHA256 is implemented. */
-  hash: {},
-
-  /** @namespace Key exchange functions.  Right now only SRP is implemented. */
-  keyexchange: {},
-  
-  /** @namespace Block cipher modes of operation. */
-  mode: {},
-
-  /** @namespace Miscellaneous.  HMAC and PBKDF2. */
-  misc: {},
-  
-  /**
-   * @namespace Bit array encoders and decoders.
-   *
-   * @description
-   * The members of this namespace are functions which translate between
-   * SJCL's bitArrays and other objects (usually strings).  Because it
-   * isn't always clear which direction is encoding and which is decoding,
-   * the method names are "fromBits" and "toBits".
-   */
-  codec: {},
-  
-  /** @namespace Exceptions. */
-  exception: {
-    /** @constructor Ciphertext is corrupt. */
-    corrupt: function(message) {
-      this.toString = function() { return "CORRUPT: "+this.message; };
-      this.message = message;
-    },
-    
-    /** @constructor Invalid parameter. */
-    invalid: function(message) {
-      this.toString = function() { return "INVALID: "+this.message; };
-      this.message = message;
-    },
-    
-    /** @constructor Bug or missing feature in SJCL. @constructor */
-    bug: function(message) {
-      this.toString = function() { return "BUG: "+this.message; };
-      this.message = message;
-    },
-
-    /** @constructor Something isn't ready. */
-    notReady: function(message) {
-      this.toString = function() { return "NOT READY: "+this.message; };
-      this.message = message;
-    }
-  }
-};
-
-if(typeof module !== 'undefined' && module.exports){
-  module.exports = sjcl;
-}
-if (typeof define === "function") {
-    define([], function () {
-        return sjcl;
-    });
-}

src/js/sjcl/core/srp.js

@@ -1,113 +0,0 @@
-/** @fileOverview Javascript SRP implementation.
- *
- * This file contains a partial implementation of the SRP (Secure Remote
- * Password) password-authenticated key exchange protocol. Given a user
- * identity, salt, and SRP group, it generates the SRP verifier that may
- * be sent to a remote server to establish and SRP account.
- *
- * For more information, see http://srp.stanford.edu/.
- *
- * @author Quinn Slack
- */
-
-/**
- * Compute the SRP verifier from the username, password, salt, and group.
- * @class SRP
- */
-sjcl.keyexchange.srp = {
-  /**
-   * Calculates SRP v, the verifier. 
-   *   v = g^x mod N [RFC 5054]
-   * @param {String} I The username.
-   * @param {String} P The password.
-   * @param {Object} s A bitArray of the salt.
-   * @param {Object} group The SRP group. Use sjcl.keyexchange.srp.knownGroup
-                           to obtain this object.
-   * @return {Object} A bitArray of SRP v.
-   */
-  makeVerifier: function(I, P, s, group) {
-    var x;
-    x = sjcl.keyexchange.srp.makeX(I, P, s);
-    x = sjcl.bn.fromBits(x);
-    return group.g.powermod(x, group.N);
-  },
-
-  /**
-   * Calculates SRP x.
-   *   x = SHA1(<salt> | SHA(<username> | ":" | <raw password>)) [RFC 2945]
-   * @param {String} I The username.
-   * @param {String} P The password.
-   * @param {Object} s A bitArray of the salt.
-   * @return {Object} A bitArray of SRP x.
-   */
-  makeX: function(I, P, s) {
-    var inner = sjcl.hash.sha1.hash(I + ':' + P);
-    return sjcl.hash.sha1.hash(sjcl.bitArray.concat(s, inner));
-  },
-
-  /**
-   * Returns the known SRP group with the given size (in bits).
-   * @param {String} i The size of the known SRP group.
-   * @return {Object} An object with "N" and "g" properties.
-   */
-  knownGroup:function(i) {
-    if (typeof i !== "string") { i = i.toString(); }
-    if (!sjcl.keyexchange.srp._didInitKnownGroups) { sjcl.keyexchange.srp._initKnownGroups(); }
-    return sjcl.keyexchange.srp._knownGroups[i];
-  },
-
-  /**
-   * Initializes bignum objects for known group parameters.
-   * @private
-   */
-  _didInitKnownGroups: false,
-  _initKnownGroups:function() {
-    var i, size, group;
-    for (i=0; i < sjcl.keyexchange.srp._knownGroupSizes.length; i++) {
-      size = sjcl.keyexchange.srp._knownGroupSizes[i].toString();
-      group = sjcl.keyexchange.srp._knownGroups[size];
-      group.N = new sjcl.bn(group.N);
-      group.g = new sjcl.bn(group.g);
-    }
-    sjcl.keyexchange.srp._didInitKnownGroups = true;
-  },
-
-  _knownGroupSizes: [1024, 1536, 2048],
-  _knownGroups: {
-    1024: {
-      N: "EEAF0AB9ADB38DD69C33F80AFA8FC5E86072618775FF3C0B9EA2314C" +
-         "9C256576D674DF7496EA81D3383B4813D692C6E0E0D5D8E250B98BE4" +
-         "8E495C1D6089DAD15DC7D7B46154D6B6CE8EF4AD69B15D4982559B29" +
-         "7BCF1885C529F566660E57EC68EDBC3C05726CC02FD4CBF4976EAA9A" +
-         "FD5138FE8376435B9FC61D2FC0EB06E3",
-      g:2
-    },
-
-    1536: {
-      N: "9DEF3CAFB939277AB1F12A8617A47BBBDBA51DF499AC4C80BEEEA961" +
-         "4B19CC4D5F4F5F556E27CBDE51C6A94BE4607A291558903BA0D0F843" +
-         "80B655BB9A22E8DCDF028A7CEC67F0D08134B1C8B97989149B609E0B" +
-         "E3BAB63D47548381DBC5B1FC764E3F4B53DD9DA1158BFD3E2B9C8CF5" +
-         "6EDF019539349627DB2FD53D24B7C48665772E437D6C7F8CE442734A" +
-         "F7CCB7AE837C264AE3A9BEB87F8A2FE9B8B5292E5A021FFF5E91479E" +
-         "8CE7A28C2442C6F315180F93499A234DCF76E3FED135F9BB",
-      g: 2
-    },
-
-    2048: {
-      N: "AC6BDB41324A9A9BF166DE5E1389582FAF72B6651987EE07FC319294" +
-         "3DB56050A37329CBB4A099ED8193E0757767A13DD52312AB4B03310D" +
-         "CD7F48A9DA04FD50E8083969EDB767B0CF6095179A163AB3661A05FB" +
-         "D5FAAAE82918A9962F0B93B855F97993EC975EEAA80D740ADBF4FF74" +
-         "7359D041D5C33EA71D281E446B14773BCA97B43A23FB801676BD207A" +
-         "436C6481F1D2B9078717461A5B9D32E688F87748544523B524B0D57D" +
-         "5EA77A2775D2ECFA032CFBDBF52FB3786160279004E57AE6AF874E73" +
-         "03CE53299CCC041C7BC308D82A5698F3A8D0C38271AE35F8E9DBFBB6" +
-         "94B5C803D89F7AE435DE236D525F54759B65E372FCD68EF20FA7111F" +
-         "9E4AFF73",
-      g: 2
-    }
-  }
-
-};
-

src/js/sjcl/demo/example.css

@@ -1,179 +0,0 @@
-* {
-  margin: 0px;
-  padding: 0px;
-  font-family: Arial, Helvetica, FreeSans, sans;
-}
-
-h1 {
-  text-align: center;
-  background: #eee;
-  padding: 5px;
-  margin-bottom: 0.6em;
-  font-size: 1.5em;
-}
-
-.header {
-  width: 650px;
-  margin: 0px auto 1em;
-}
-
-p+p {
-  margin-top: 1em;
-}
-
-.explanation {
-  color: #555;
-  margin-top: 0.3em;
-}
-
-.section+.section, .explanation+.section {
-  margin-top: 1.5em;
-}
-
-.hex {
-  text-transform: uppercase;
-}
-
-.hex, .base64, #ciphertext {
-  font-family: 'Courier', mono;
-}
-
-.wide, textarea {
-  width: 100%;
-  margin: 0px -4px;
-  font-size: inherit;
-  text-align: left;
-}
-
-textarea+*, .wide+* {
-  margin-top: 0.3em;
-}
-
-/* bulk object placement */
-#theForm {
-  position: relative;
-  width: 940px;
-  margin: 0px auto;
-  font-size: 0.8em;
-}
-
-.column {
-  top: 0px;
-  width: 300px;
-}
-
-.box {
-  border: 2px solid #999;
-  padding: 7px;
-  margin-bottom: 20px;
-  -moz-border-radius: 7px;
-  -webkit-border-radius: 7px;
-}
-
-#cmode { position: absolute; left: 640px; }
-#ctexts { position: absolute; left: 320px; }
-
-.floatright {
-  float: right;
-  text-align: right;
-}
-
-a {
-  cursor: pointer;
-  color: #282;
-}
-
-a.random, #buttons a { text-decoration: none; }
-a.random:hover, a.random:focus { text-decoration: underline; }
-
-h2 {
-  margin: -7px -7px 3px -7px;
-  text-align: center;
-  font-size: 1.2em;
-  color: white;
-  background: #999;
-}
-
-#pplaintext { border-color: #f65; }
-#pplaintext h2 { background: #f65; }
-
-#ppassword { border-color: #4a4; }
-#ppassword h2 { background: #4a4; }
-
-#pciphertext { border-color: #78f; }
-#pciphertext h2 { background: #78f; }
-
-#buttons { text-align: center; margin-top: -20px; }
-
-a#doPbkdf2, a#encrypt, a#decrypt {
-  display: inline-block;
-  text-align: center;
-  height: 43px;
-  padding-top: 20px;
-  width: 50px;
-  background: url('alpha-arrow.png') no-repeat bottom center;
-  vertical-align: middle;
-  border: none;
-  color: white;
-  overflow: hidden;
-}
-
-.turnDown {
-  display: inline-block;
-  padding-bottom: 3px;
-  -moz-transform: rotate(90deg);	
-  -webkit-transform: rotate(90deg);	
-  transform: rotate(90deg);
-  background-color: inherit;
-}
-
-.turnUp {
-  display: inline-block;
-  padding-bottom: 3px;
-  -moz-transform: rotate(-90deg);	
-  -webkit-transform: rotate(-90deg);	
-  transform: rotate(-90deg);
-  background-color: inherit;	
-}
-
-.buttons a.disabled {
-  background-color: #ccc ! important;
-  cursor: inherit ! important;
-}
-
-a#encrypt { background-color: #f65; margin-bottom: 2px; }
-a#encrypt:hover, a#encrypt:focus { background-color: #f76; }
-a#encrypt:active { background-color: #f87; }
-
-a#decrypt {
-  height: 36px;
-  padding-top: 27px;
-  background: url('alpha-arrow.png') no-repeat top center;
-  background-color: #78f;
-  margin-top: 2px;
-}
-a#decrypt:hover { background-color: #89f; }
-a#decrypt:focus { background-color: #89f; }
-a#decrypt:active { background-color: #9af; }
-
-#ppassword, #pkey, #pmode, #pplaintext, #pciphertext {
-  -moz-border-radius: 7px;
-  -webkit-border-radius: 7px;
-}
-input[type='text'], input[type='password'], textarea {
-  -moz-border-radius: 3px;
-  -webkit-border-radius: 3px;
-  font-size: inherit;
-  border: 1px solid #444;
-  padding: 3px;
-}
-
-input[type='text']:focus,  input[type='password']:focus, textarea:focus {
-  border-color: red;
-}
-
-input[type="radio"], input[type="checkbox"] {
-  position: relative;
-  top: 0.15em;
-  margin-right: -0.15em;
-}

src/js/sjcl/demo/example.js

@@ -1,153 +0,0 @@
-/* keep track of which salts have been used. */
-var form, usedIvs = {'':1}, usedSalts = {'':1};
-
-/* enter actions */
-var enterActions = {
-  password: doPbkdf2,
-  salt: doPbkdf2,
-  iter: doPbkdf2
-};
-
-function loaded() {
-  form = new formHandler('theForm', enterActions);
-  form._extendedKey = [];
-  sjcl.random.startCollectors();
-  document.getElementById("password").focus();
-}
-
-/* there's probaby a better way to tell the user something, but oh well */
-function error(x) {
-  alert(x);
-}
-
-/* compute PBKDF2 on the password. */
-function doPbkdf2(decrypting) {
-  var v = form.get(), salt=v.salt, key, hex = sjcl.codec.hex.fromBits, p={},
-      password = v.password;
-  
-  p.iter = v.iter;
-  
-  if (password.length == 0) {
-    if (decrypting) { error("Can't decrypt: need a password!"); }
-    return;
-  }
-  
-  if (salt.length === 0 && decrypting) {
-    error("Can't decrypt: need a salt for PBKDF2!");
-    return;
-  }
-  
-  if (decrypting || !v.freshsalt || !usedSalts[v.salt]) {
-    p.salt = v.salt;
-  }
-  
-  p = sjcl.misc.cachedPbkdf2(password, p);
-  form._extendedKey = p.key;
-  v.key = p.key.slice(0, v.keysize/32);
-  v.salt = p.salt;
-  
-  form.set(v);
-  form.plaintext.el.select();
-}
-/* Encrypt a message */
-function doEncrypt() {
-  var v = form.get(), iv = v.iv, password = v.password, key = v.key, adata = v.adata, aes, plaintext=v.plaintext, rp = {}, ct, p;
-  
-  if (plaintext === '' && v.ciphertext.length) { return; }
-  if (key.length == 0 && password.length == 0) {
-    error("need a password or key!");
-    return;
-  }
-  
-  p = { adata:v.adata,
-        iter:v.iter,
-        mode:v.mode,
-        ts:parseInt(v.tag),
-        ks:parseInt(v.keysize) };
-  if (!v.freshiv || !usedIvs[v.iv]) { p.iv = v.iv; }
-  if (!v.freshsalt || !usedSalts[v.salt]) { p.salt = v.salt; }
-  ct = sjcl.encrypt(password || key, plaintext, p, rp).replace(/,/g,",\n");
-
-  v.iv = rp.iv;
-  usedIvs[rp.iv] = 1;
-  if (rp.salt) {
-    v.salt = rp.salt;
-    usedSalts[rp.salt] = 1;
-  }
-  v.key = rp.key;
-  
-  if (v.json) {
-    v.ciphertext = ct;
-    v.adata = '';
-  } else {
-    v.ciphertext = ct.match(/"ct":"([^"]*)"/)[1]; //"
-  }
-  
-  v.plaintext = '';
-  
-  form.set(v);
-  form.ciphertext.el.select();
-}
-
-/* Decrypt a message */
-function doDecrypt() {
-  var v = form.get(), iv = v.iv, key = v.key, adata = v.adata, aes, ciphertext=v.ciphertext, rp = {};
-  
-  if (ciphertext.length === 0) { return; }
-  if (!v.password && !v.key.length) {
-    error("Can't decrypt: need a password or key!"); return;
-  }
-  
-  if (ciphertext.match("{")) {
-    /* it's jsonized */
-    try {
-      v.plaintext = sjcl.decrypt(v.password || v.key, ciphertext, {}, rp);
-    } catch(e) {
-      error("Can't decrypt: "+e);
-      return;
-    }
-    v.mode = rp.mode;
-    v.iv = rp.iv;
-    v.adata = rp.adata;
-    if (v.password) {
-      v.salt = rp.salt;
-      v.iter = rp.iter;
-      v.keysize = rp.ks;
-      v.tag = rp.ts;
-    }
-    v.key = rp.key;
-    v.ciphertext = "";
-    document.getElementById('plaintext').select();
-  } else {
-    /* it's raw */
-    ciphertext = sjcl.codec.base64.toBits(ciphertext);
-    if (iv.length === 0) {
-      error("Can't decrypt: need an IV!"); return;
-    }
-    if (key.length === 0) {
-      if (v.password.length) {
-        doPbkdf2(true);
-        key = v.key;
-      }
-    }
-    aes = new sjcl.cipher.aes(key);
-    
-    try {
-      v.plaintext = sjcl.codec.utf8String.fromBits(sjcl.mode[v.mode].decrypt(aes, ciphertext, iv, v.adata, v.tag));
-      v.ciphertext = "";
-      document.getElementById('plaintext').select();
-    } catch (e) {
-      error("Can't decrypt: " + e);
-    }
-  }
-  form.set(v);
-}
-
-function extendKey(size) {
-  form.key.set(form._extendedKey.slice(0,size));
-}
-
-function randomize(field, words, paranoia) {
-  form[field].set(sjcl.random.randomWords(words, paranoia));
-  if (field == 'salt') { form.key.set([]); }
-}

src/js/sjcl/demo/form.js

@@ -1,137 +0,0 @@
-/* Hackish form handling system. */
-function hasClass(e, cl) {
-  return (" "+e.className+" ").match(" "+cl+" ");
-}
-
-function stopPropagation(e) {
-  e.preventDefault && e.preventDefault();
-  e.cancelBubble = true;
-}
-
-/* proxy for a form object, with appropriate encoder/decoder */
-function formElement(el) {
-  this.el = el;
-}
-formElement.prototype = {
-  get: function() {
-    var el = this.el;
-    if (el.type == "checkbox") {
-      return el.checked;
-    } else if (hasClass(el, "numeric")) {
-      return parseInt(el.value);
-    } else if (hasClass(el, "hex")) {
-      return sjcl.codec.hex.toBits(el.value);
-    } else if (hasClass(el, "base64")) {
-      return sjcl.codec.base64.toBits(el.value);
-    } else {
-      return el.value;
-    }
-  },
-  
-  set: function(x) {
-    var el = this.el;
-    if (el.type == "checkbox") {
-      el.checked = x; return;
-    } else if (hasClass(el, "hex")) {
-      if (typeof x !== 'string') {
-        x = sjcl.codec.hex.fromBits(x);
-      }
-      x = x.toUpperCase().replace(/ /g,'').replace(/(.{8})/g, "$1 ").replace(/ $/, '');
-    } else if (hasClass(el, "base64")) {
-      if (typeof x !== 'string') {
-        x = sjcl.codec.base64.fromBits(x);
-      }
-      x = x.replace(/\s/g,'').replace(/(.{32})/g, "$1\n").replace(/\n$/, '');
-    }
-    el.value = x;
-  }
-}
-
-function radioGroup(name) {
-  this.name = name;
-}
-radioGroup.prototype = {
-  get: function() {
-    var els = document.getElementsByName(this.name), i;
-    for (i=0; i<els.length; i++) {
-      if (els[i].checked) {
-        return els[i].value;
-      }
-    }
-  },
-  
-  set: function(x) {
-    var els = document.getElementsByName(this.name), i;
-    for (i=0; i<els.length; i++) {
-      els[i].checked = (els[i].value == x);
-    }
-  }
-}
-
-function formHandler(formName, enterActions) {
-  var i, els = [], tmp, name;
-  this._elNames = [];
-  
-  tmp = document.getElementById(formName).getElementsByTagName('input');
-  for (i=0; i<tmp.length; i++) { els.push(tmp[i]); }
-  
-  tmp = document.getElementById(formName).getElementsByTagName('textarea');
-  for (i=0; i<tmp.length; i++) { els.push(tmp[i]); }
-  
-  for (i=0; i<els.length; i++) {
-    name = els[i].name  || els[i].id;
-    
-    /* enforce numeric properties of element */
-    els[i].onkeypress = (function(e) {
-      return function(ev) {
-        ev = ev || window.event;
-        var key = ev.keyCode || ev.which,
-            keyst = String.fromCharCode(ev.charCode || ev.keyCode),
-            ente = enterActions[e.name||e.id];
-        
-        if (ev.ctrlKey || ev.metaKey) {
-          return;
-        }
-        
-        (key == 13) && ente && ente();
-        
-        if (hasClass(e, 'numeric') && ev.charCode && !keyst.match(/[0-9]/)) {
-          stopPropagation(ev); return false;
-        } else if (hasClass(e, 'hex') && ev.charCode && !keyst.match(/[0-9a-fA-F ]/)) {
-          stopPropagation(ev); return false;
-        }
-      }
-    })(els[i]);
-    
-    if (els[i].type == 'radio') {
-      if (this[name] === undefined) {
-        this[name] = new radioGroup(name);
-        this._elNames.push(name);
-      }
-    } else {
-      /* code to get the value of an element */
-      this[name] = new formElement(els[i]);
-      this._elNames.push(name);
-    }
-  }
-}
-
-formHandler.prototype = {
-  get:function() {
-    var i, out = {}, en = this._elNames;
-    for (i=0; i<en.length; i++) {
-      out[en[i]] = this[en[i]].get();
-    }
-    return out;
-  },
-  
-  set:function(o) {
-    var i;
-    for (i in o) {
-      if (o.hasOwnProperty(i) && this.hasOwnProperty(i)) {
-        this[i].set(o[i]);
-      }
-    }
-  }
-}
-

src/js/sjcl/demo/index.html

@@ -1,208 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
-        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-        
-<html xmlns="http://www.w3.org/1999/xhtml">
-<head>
-  <title>SJCL demo</title>
-  <link rel="stylesheet" type="text/css" href="example.css"/>
-  <script type="text/javascript" src="../sjcl.js"></script>
-  <script type="text/javascript" src="form.js"></script>
-  <script type="text/javascript" src="example.js"></script>
-</head>
-<body onload="loaded()">
-  <h1>SJCL demo</h1>
-
-  <div class="header">
-  <p>This page is a demo of the Stanford Javascript Crypto Library. To get started, just type in a password in the left pane and a secret message in the middle pane, then click "encrypt". Encryption takes place in your browser and we never see the plaintext.</p>
-  
-  <p>SJCL has lots of other options, many of which are shown in the grey boxes.</p>
-  </div>
-
-  <form id="theForm" onsubmit="return false;">
-  <div class="column" id="ckey">
-    <!-- Password and pbkdf2 parameters -->
-    <div class="box" id="ppassword">
-      <h2>Password</h2>
-      <div class="section">
-        <label for="password">Password:</label>
-        <input type="password" class="wide" name="password" id="password" autocomplete="off" tabindex="1"/>
-        <p class="explanation">
-          Choose a strong, random password.
-        </p>
-      </div>
-    </div>
-    
-    <div class="box" id="pkey">
-      <h2>Key Derivation</h2>
-      <div class="section">
-        <div>
-          <label for="salt">Salt:</label>
-          <a class="random floatright" href="javascript:randomize('salt',2,0)">random</a>
-        </div>
-        <input type="text" id="salt" class="wide hex" autocomplete="off" size="17" maxlength="35"/>
-        <input type="checkbox" name="freshsalt" id="freshsalt" autocomplete="off" checked="checked"/>
-        <label for="freshsalt">Use fresh random salt for each new password</label>
-        <p class="explanation">
-          Salt adds more variability to your key, and prevents attackers
-          from using <a href="http://en.wikipedia.org/wiki/Rainbow_table">rainbow tables</a> to attack it.
-        </p>     
-      </div>
-
-      <div class="section">
-        <label for="iter">Strengthen by a factor of:</label>
-        <input type="text" name="iter" id="iter" value="1000" class="numeric" size="5" maxlength="5" autocomplete="off"/>
-        <p class="explanation">
-          Strengthening makes it slower to compute the key corresponding to your
-          password.  This makes it take much longer for an attacker to guess it.
-        </p>
-      </div>
-
-      <div class="section">
-        Key size:
-        <input type="radio" name="keysize" value="128" id="key128" checked="checked" autocomplete="off" onclick="extendKey(4)"/>
-        <label for="key128">128</label>
-        <input type="radio" name="keysize" value="192" id="key192" autocomplete="off" onclick="extendKey(6)"/>
-        <label for="key192">192</label>
-        <input type="radio" name="keysize" value="256" id="key256" autocomplete="off" onclick="extendKey(8)"/>
-        <label for="key256">256</label>
-        <p class="explanation">
-          128 bits should be secure enough, but you can generate a longer
-          key if you wish.
-        </p>
-      </div>
-
-      <!-- cipher key -->
-      <div class="section">
-        <div>
-          <label for="key">Key:</label>
-          <!--
-          <a class="random floatright" href="javascript:randomizeKey()">random</a>
-          -->
-        </div>
-        <textarea id="key" name="key" class="hex" rows="2" autocomplete="off"></textarea>
-        <p class="explanation">
-          This key is computed from your password, salt and strengthening factor.  It
-          will be used internally by the cipher.  Instead of using a password, you can
-          enter a key here directly.  If you do, it should be 32, 48 or 64 hexadecimal
-          digits (128, 192 or 256 bits).
-        </p>
-      </div>
-     
-    </div>
-  </div>
-    
-    <!-- mode controls -->
-  <div class="column" id="cmode">
-    <div class="box">
-      <h2>Cipher Parameters</h2>
-      <p class="explanation">
-        SJCL encrypts your data with the <a href="http://en.wikipedia.org/wiki/Advanced_Encryption_Standard"><acronym title="Advanced Encryption Standard">AES</acronym></a> block cipher.
-      </p>
-      <div class="section">
-        Cipher mode:
-        <input type="radio" name="mode" value="ccm" id="ccm" checked="checked" autocomplete="off"/>
-        <label for="ccm"><acronym title="Counter mode with Cipher block chaining Message authentication code">CCM</acronym></label>
-        <input type="radio" name="mode" value="ocb2" id="ocb2" autocomplete="off"/>
-        <label for="ocb2"><acronym title="Offset CodeBook mode, version 2.0">OCB2</acronym></label>
-        <p class="explanation">
-          The cipher mode is a standard for how to use AES and other
-          algorithms to encrypt and authenticate your message.
-          <a href="http://en.wikipedia.org/wiki/OCB_mode">OCB2 mode</a>
-          is slightly faster and has more features, but
-          <a href="http://en.wikipedia.org/wiki/CCM_mode">CCM mode</a> has wider
-          support because it is not patented.
-        </p>
-      </div>
-      
-      <div class="section">
-        <div>
-          <label for="iv">Initialization vector:</label>
-          <a class="random floatright" href="javascript:randomize('iv',4,0)">random</a>
-        </div>
-        <input type="text" name="iv" id="iv" class="wide hex" size="32" maxlength="35" autocomplete="off"/>
-        <input type="checkbox" id="freshiv" autocomplete="off" checked="checked"/>
-        <label for="freshiv">Choose a new random IV for every message.</label>
-        <p class="explanation">
-          The IV needs to be different for every message you send.  It adds
-          randomness to your message, so that the same message will look
-          different each time you send it.
-        </p>
-        <p class="explanation">
-          Be careful: CCM mode doesn't use
-          the whole IV, so changing just part of it isn't enough.
-        </p>
-      </div>
-      
-      <div class="section">
-        Authentication strength:
-        <input type="radio" name="tag" value="64" id="tag64" autocomplete="off" checked="checked"/>
-        <label for="tag64">64</label>
-        <input type="radio" name="tag" value="96" id="tag96" autocomplete="off"/>
-        <label for="tag96">96</label>
-        <input type="radio" name="tag" value="128" id="tag128" autocomplete="off"/>
-        <label for="tag128">128</label>
-        <p class="explanation">
-          SJCL adds a an authentication tag to your message to make sure
-          nobody changes it.  The longer the authentication tag, the harder it is
-          for somebody to change your encrypted message without you noticing.  64
-          bits is probably enough.
-        </p>
-      </div>
-      
-      <div class="section">
-        <input type="checkbox" name="json" id="json" autocomplete="off" checked="checked"/>
-        <label for="json">Send the parameters and authenticated data along
-          with the message.</label>
-         <p class="explanation">
-           These parameters are required to decrypt your message later.  If the
-           person you're sending the message to knows them, you don't need to send
-           them so your message will be shorter.
-         </p>
-         <p class="explanation">
-           Default parameters won't be sent.  Your password won't be sent, either.
-           The salt and iv will be encoded in base64 instead of hex, so they'll
-           look different from what's in the box.
-         </p>
-      </div>
-    </div>
-  </div>
-  
-  <div class="column" id="ctexts">
-    <div id="pplaintext" class="box">
-      <h2>Plaintext</h2>
-      <div class="section">
-        <label for="plaintext">Secret message:</label>
-        <textarea id="plaintext" autocomplete="off" rows="5" tabindex="2"></textarea>
-        <div class="explanation">
-          This message will be encrypted, so that nobody can read it or change it
-          without your password.
-        </div>
-      </div>  
-   
-      <div class="section">
-        <label for="adata">Authenticated data:</label>
-        <textarea id="adata" autocomplete="off" tabindex="3"></textarea>
-        <div class="explanation">
-          This auxilliary message isn't secret, but its integrity will be checked
-          along with the integrity of the message.
-        </div>
-      </div>
-    </div>
-    
-    <div id="buttons">
-      <a href="javascript:doEncrypt()" id="encrypt" tabindex="4"><span class="turnDown">encrypt</span></a>
-      <a href="javascript:doDecrypt()" id="decrypt" tabindex="6"><span class="turnUp">decrypt</span></a>
-    </div>
-    
-    <div id="pciphertext" class="box">
-      <h2>Ciphertext</h2>
-      <label for="ciphertext">Ciphertext:</label>
-      <textarea id="ciphertext" autocomplete="off" rows="7" tabindex="5"></textarea>
-      <div class="explanation">
-        Your message, encrypted and authenticated so that nobody can read it
-        or change it without your password.
-      </div>
-    </div>
-  </form>
-</body>
-</html>

src/js/sjcl/jsdoc_toolkit-2.3.3-beta/README.txt

@@ -1,183 +0,0 @@
-======================================================================
-
-DESCRIPTION:
-
-This is the source code for JsDoc Toolkit, an automatic documentation
-generation tool for JavaScript. It is written in JavaScript and is run
-from a command line (or terminal) using Java and Mozilla's Rhino
-JavaScript runtime engine.
-
-Using this tool you can automatically turn JavaDoc-like comments in
-your JavaScript source code into published output files, such as HTML
-or XML.
-
-For more information, to report a bug, or to browse the technical
-documentation for this tool please visit the official JsDoc Toolkit
-project homepage at http://code.google.com/p/jsdoc-toolkit/
-
-For the most up-to-date documentation on JsDoc Toolkit see the 
-official wiki at http://code.google.com/p/jsdoc-toolkit/w/list
-
-======================================================================
-
-REQUIREMENTS:
-
-JsDoc Toolkit is known to work with:
-java version "1.6.0_03"
-Java(TM) SE Runtime Environment (build 1.6.0_03-b05)
-on Windows XP,
-and java version "1.5.0_19"
-Java(TM) 2 Runtime Environment, Standard Edition (build 1.5.0_19-b02-304)
-on Mac OS X 10.5.
-
-Other versions of java may or may not work with JsDoc Toolkit.
-
-======================================================================
-
-USAGE:
-
-Running JsDoc Toolkit requires you to have Java installed on your
-computer. For more information see http://www.java.com/getjava/
-
-Before running the JsDoc Toolkit app you should change your current
-working directory to the jsdoc-toolkit folder. Then follow the
-examples below, or as shown on the project wiki.
-
-On a computer running Windows a valid command line to run JsDoc
-Toolkit might look like this:
-
-> java -jar jsrun.jar app\run.js -a -t=templates\jsdoc mycode.js
-
-On Mac OS X or Linux the same command would look like this:
-
-$ java -jar jsrun.jar app/run.js -a -t=templates/jsdoc mycode.js
-
-The above assumes your current working directory contains jsrun.jar,
-the "app" and "templates" subdirectories from the standard JsDoc
-Toolkit distribution and that the relative path to the code you wish
-to document is "mycode.js".
-
-The output documentation files will be saved to a new directory named
-"out" (by default) in the current directory, or if you specify a
--d=somewhere_else option, to the somewhere_else directory.
-
-For help (usage notes) enter this on the command line:
-
-$ java -jar jsrun.jar app/run.js --help
-
-More information about the various command line options used by JsDoc
-Toolkit are available on the project wiki.
-
-======================================================================
-
-RUNNING VIA SHELL SCRIPT
-
-Avi Deitcher has contributed the file jsrun.sh with the following usage notes:
-
-A script to simplify running jsdoc from the command-line, especially when
-running from within a development or build environment such as ant.
-
-Normally, to run jsdoc, you need a command-line as the following:
-java -Djsdoc.dir=/some/long/dir/path/to/jsdoc -jar
-/some/long/dir/path/to/jsdoc/jsrun.jar /some/long/dir/path/to/jsdoc/app/run.js
--t=template -r=4 /some/long/dir/path/to/my/src/code
-
-This can get tedious to redo time and again, and difficult to use from within a build environment.
-
-To simplify the process, jsrun.sh will automatically run this path, as well as passing through any arguments.
-
-Usage: jsrun.sh <run.js arguments>
-
-All <run.js arguments> will be passed through.
-Additionally, jsrun.sh will take the following actions:
-1) If the environment variable JSDOCDIR is set, it will add
-"-Djsdoc.dir=$JSDOCDIR" to the command-line
-2) If the environment variable JSDOCTEMPLATEDIR is set, it will add
-"-Djsdoc.template.dir=$JSDOCTEMPLATEDIR" to the command-line
-3) java with the appropriate path to jsrun.jar and run.js will be instantiated
-
-If not variables are set, it is assumed that the path to jsrun.jar and app/ is in the current working directory.
-
-Example:
-# jsrun.sh ./src/
-Assuming JSDOCDIR=/some/path/to/my/jsdoc will cause the following command to
-execute:
-java -Djsdoc.dir=/some/path/to/my/jsdoc -jar /some/path/to/my/jsdoc/jsrun.jar
-/some/path/to/my/jsdoc/app/run.js ./src/
-
-======================================================================
-
-TESTING:
-
-To run the suite of unit tests included with JsDoc Toolkit enter this
-on the command line:
-
-$ java -jar jsrun.jar app/run.js -T
-
-To see a dump of the internal data structure that JsDoc Toolkit has
-built from your source files use this command:
-
-$ java -jar jsrun.jar app/run.js mycode.js -Z
-
-======================================================================
-
-LICENSE:
-
-JSDoc.pm
-
-This project is based on the JSDoc.pm tool, created by Michael
-Mathews and Gabriel Reid. More information on JsDoc.pm can
-be found on the JSDoc.pm homepage: http://jsdoc.sourceforge.net/
-
-Complete documentation on JsDoc Toolkit can be found on the project
-wiki at http://code.google.com/p/jsdoc-toolkit/w/list
-
-Rhino
-
-Rhino (JavaScript in Java) is open source and licensed by Mozilla
-under the MPL 1.1 or later/GPL 2.0 or later licenses, the text of
-which is available at http://www.mozilla.org/MPL/
-
-You can obtain the source code for Rhino from the Mozilla web site at
-http://www.mozilla.org/rhino/download.html
-
-JsDoc Toolkit is a larger work that uses the Rhino JavaScript engine
-but is not derived from it in any way. The Rhino library is used 
-without modification and without any claims whatsoever.
-
-The Rhino Debugger
-
-You can obtain more information about the Rhino Debugger from the 
-Mozilla web site at http://www.mozilla.org/rhino/debugger.html
-
-JsDoc Toolkit is a larger work that uses the Rhino Debugger but
-is not derived from it in any way. The Rhino Debugger is used
-without modification and without any claims whatsoever.
-
-JsDoc Toolkit
-
-All code specific to JsDoc Toolkit are free, open source and licensed
-for use under the X11/MIT License.
-
-JsDoc Toolkit is Copyright (c)2009 Michael Mathews <micmath@gmail.com>
-
-This program is free software; you can redistribute it and/or
-modify it under the terms below.
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions: The above copyright notice and this
-permission notice must be included in all copies or substantial
-portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

src/js/sjcl/jsdoc_toolkit-2.3.3-beta/app/frame.js

@@ -1,33 +0,0 @@
-IO.include("frame/Opt.js");
-IO.include("frame/Chain.js");
-IO.include("frame/Link.js");
-IO.include("frame/String.js");
-IO.include("frame/Hash.js");
-IO.include("frame/Namespace.js");
-//IO.include("frame/Reflection.js");
-
-/** A few helper functions to make life a little easier. */
-
-function defined(o) {
-	return (o !== undefined);
-}
-
-function copy(o) { // todo check for circular refs
-	if (o == null || typeof(o) != 'object') return o;
-	var c = new o.constructor();
-	for(var p in o)	c[p] = copy(o[p]);
-	return c;
-}
-
-function isUnique(arr) {
-	var l = arr.length;
-	for(var i = 0; i < l; i++ ) {
-		if (arr.lastIndexOf(arr[i]) > i) return false;
-	}
-	return true;
-}
-
-/** Returns the given string with all regex meta characters backslashed. */
-RegExp.escapeMeta = function(str) {
-	return str.replace(/([$^\\\/()|?+*\[\]{}.-])/g, "\\$1");
-}

src/js/sjcl/jsdoc_toolkit-2.3.3-beta/app/frame/Chain.js

@@ -1,102 +0,0 @@
-/**@constructor*/
-function ChainNode(object, link) {
-	this.value = object;
-	this.link = link; // describes this node's relationship to the previous node
-}
-
-/**@constructor*/
-function Chain(valueLinks) {
-	this.nodes = [];
-	this.cursor = -1;
-	
-	if (valueLinks && valueLinks.length > 0) {
-		this.push(valueLinks[0], "//");
-		for (var i = 1, l = valueLinks.length; i < l; i+=2) {
-			this.push(valueLinks[i+1], valueLinks[i]);
-		}
-	}
-}
-
-Chain.prototype.push = function(o, link) {
-	if (this.nodes.length > 0 && link) this.nodes.push(new ChainNode(o, link));
-	else this.nodes.push(new ChainNode(o));
-}
-
-Chain.prototype.unshift = function(o, link) {
-	if (this.nodes.length > 0 && link) this.nodes[0].link = link;
-	this.nodes.unshift(new ChainNode(o));
-	this.cursor++;
-}
-
-Chain.prototype.get = function() {
-	if (this.cursor < 0 || this.cursor > this.nodes.length-1) return null;
-	return this.nodes[this.cursor];
-}
-
-Chain.prototype.first = function() {
-	this.cursor = 0;
-	return this.get();
-}
-
-Chain.prototype.last = function() {
-	this.cursor = this.nodes.length-1;
-	return this.get();
-}
-
-Chain.prototype.next = function() {
-	this.cursor++;
-	return this.get();
-}
-
-Chain.prototype.prev = function() {
-	this.cursor--;
-	return this.get();
-}
-
-Chain.prototype.toString = function() {
-	var string = "";
-	for (var i = 0, l = this.nodes.length; i < l; i++) {
-		if (this.nodes[i].link) string += " -("+this.nodes[i].link+")-> ";
-		string += this.nodes[i].value.toString();
-	}
-	return string;
-}
-
-Chain.prototype.joinLeft = function() {
-	var result = "";
-	for (var i = 0, l = this.cursor; i < l; i++) {
-		if (result && this.nodes[i].link) result += this.nodes[i].link;
-		result += this.nodes[i].value.toString();
-	}
-	return result;
-}
-
-
-/* USAGE:
-
-var path = "one/two/three.four/five-six";
-var pathChain = new Chain(path.split(/([\/.-])/));
-print(pathChain);
-
-var lineage = new Chain();
-lineage.push("Port");
-lineage.push("Les", "son");
-lineage.push("Dawn", "daughter");
-lineage.unshift("Purdie", "son");
-
-print(lineage);
-
-// walk left
-for (var node = lineage.last(); node !== null; node = lineage.prev()) {
-	print("< "+node.value);
-}
-
-// walk right
-var node = lineage.first()
-while (node !== null) {
-	print(node.value);
-	node = lineage.next();
-	if (node && node.link) print("had a "+node.link+" named");
-}
-
-*/

src/js/sjcl/jsdoc_toolkit-2.3.3-beta/app/frame/Dumper.js

@@ -1,144 +0,0 @@
-/**
- * @class
-<pre>
-This is a lightly modified version of Kevin Jones' JavaScript
-library Data.Dump. To download the original visit:
-    <a href="http://openjsan.org/doc/k/ke/kevinj/Data/Dump/">http://openjsan.org/doc/k/ke/kevinj/Data/Dump/</a>
-
-AUTHORS
-
-The Data.Dump JavaScript module is written by Kevin Jones 
-(kevinj@cpan.org), based on Data::Dump by Gisle Aas (gisle@aas.no),
-based on Data::Dumper by Gurusamy Sarathy (gsar@umich.edu).
-
-COPYRIGHT
-
-Copyright 2007 Kevin Jones. Copyright 1998-2000,2003-2004 Gisle Aas.
-Copyright 1996-1998 Gurusamy Sarathy.
-
-This program is free software; you can redistribute it and/or modify
-it under the terms of the Perl Artistic License
-
-See http://www.perl.com/perl/misc/Artistic.html
-</pre>
- * @static
- */
-Dumper = {
-	/** @param [...] The objects to dump. */
-	dump: function () {
-	    if (arguments.length > 1)
-	        return this._dump(arguments);
-	    else if (arguments.length == 1)
-	        return this._dump(arguments[0]);
-	    else
-	        return "()";
-	},
-	
-	_dump: function (obj) {
-		if (typeof obj == 'undefined') return 'undefined';
-		var out;
-		if (obj.serialize) { return obj.serialize(); }
-		var type = this._typeof(obj);
-		if (obj.circularReference) obj.circularReference++;
-		switch (type) {
-			case 'circular':
-				out = "{ //circularReference\n}";
-				break;
-			case 'object':
-				var pairs = new Array;
-				
-				for (var prop in obj) {
-					if (prop != "circularReference" && obj.hasOwnProperty(prop)) { //hide inherited properties
-						pairs.push(prop + ': ' + this._dump(obj[prop]));
-					}
-				}
-	
-				out = '{' + this._format_list(pairs) + '}';
-				break;
-	
-			case 'string':
-				for (var prop in Dumper.ESC) {
-					if (Dumper.ESC.hasOwnProperty(prop)) {
-						obj = obj.replace(prop, Dumper.ESC[prop]);
-					}
-				}
-	
-			// Escape UTF-8 Strings
-				if (obj.match(/^[\x00-\x7f]*$/)) {
-					out = '"' + obj.replace(/\"/g, "\\\"").replace(/([\n\r]+)/g, "\\$1") + '"';
-				}
-				else {
-					out = "unescape('"+escape(obj)+"')";
-				}
-				break;
-	
-			case 'array':
-				var elems = new Array;
-	
-				for (var i=0; i<obj.length; i++) {
-					elems.push( this._dump(obj[i]) );
-				}
-	
-				out = '[' + this._format_list(elems) + ']';
-				break;
-	
-			case 'date':
-			// firefox returns GMT strings from toUTCString()...
-			var utc_string = obj.toUTCString().replace(/GMT/,'UTC');
-				out = 'new Date("' + utc_string + '")';
-				break;
-	
-			case 'element':
-				// DOM element
-				out = this._dump_dom(obj);
-				break;
-		
-				default:
-					out = obj;
-		}
-	
-		out = String(out).replace(/\n/g, '\n    ');
-		out = out.replace(/\n    (.*)$/,"\n$1");
-	
-		return out;
-	},
-	
-	_format_list: function (list) {
-		if (!list.length) return '';
-		var nl = list.toString().length > 60 ? '\n' : ' ';
-		return nl + list.join(',' + nl) + nl;
-    },
-    
-    _typeof: function (obj) {
-    	if (obj && obj.circularReference && obj.circularReference > 1) return 'circular';
-		if (Array.prototype.isPrototypeOf(obj)) return 'array';
-		if (Date.prototype.isPrototypeOf(obj)) return 'date';
-		if (typeof obj.nodeType != 'undefined') return 'element';
-		return typeof(obj);
-	},
-	
-	_dump_dom: function (obj) {
-		return '"' + Dumper.nodeTypes[obj.nodeType] + '"';
-	}
-};
-
-Dumper.ESC = {
-    "\t": "\\t",
-    "\n": "\\n",
-    "\f": "\\f"
-};
-
-Dumper.nodeTypes = {
-    1: "ELEMENT_NODE",
-    2: "ATTRIBUTE_NODE",
-    3: "TEXT_NODE",
-    4: "CDATA_SECTION_NODE",
-    5: "ENTITY_REFERENCE_NODE",
-    6: "ENTITY_NODE",
-    7: "PROCESSING_INSTRUCTION_NODE",
-    8: "COMMENT_NODE",
-    9: "DOCUMENT_NODE",
-    10: "DOCUMENT_TYPE_NODE",
-    11: "DOCUMENT_FRAGMENT_NODE",
-    12: "NOTATION_NODE"
-};