@airgap/coinlib-core 0.13.11-beta.1 → 0.13.11-beta.3

package/dependencies/src/groestl-hash-js-ef6a04f1c4d2f0448f0882b5f213ef7a0659baee/lib/helper.js

@@ -0,0 +1,253 @@
+'use strict';
+// String functions
+
+var op = require('./op.js');
+
+module.exports.int8ArrayToHexString = function toString(array) {
+	var string = '';
+
+	for (var i = 0; i < array.length; i++) {
+		if (array[i] < 16) {
+			string += '0' + array[i].toString(16);
+		}
+		else {
+			string += array[i].toString(16);
+		}
+	}
+	return string;
+}
+
+module.exports.int32ArrayToHexString = function toString(array) {
+	var string = '';
+	var len = array.length;
+	for (var i = 0; i < len; i++) {
+		var s = array[i];
+		if (s < 0) {
+			s = 0xFFFFFFFF + array[i] + 1;
+		}
+		var l = s.toString(16);
+		var padding = 8;
+		while (l.length < padding) {
+			l = "0" + l;
+		}
+		string += l;
+	}
+	return string;
+}
+
+module.exports.hex2string = function toString(s) {
+	for (var c = [], len = s.length, i = 0; i < len; i += 2)
+		c.push(String.fromCharCode(parseInt(s.substring(i, i + 2), 16)));
+	return c.join('');
+}
+
+module.exports.hex2bytes = function toString(s) {
+	for (var c = [], len = s.length, i = 0; i < len; i += 2)
+		c.push(parseInt(s.substring(i, i + 2), 16));
+	return c;
+}
+/*
+module.exports.string2hex = function toString(s) {
+
+	for (var p = [], len = s.length, i = 0; i < len; i++) {
+		p.push((256 + s.charCodeAt(i)).toString(16).substring(1));
+	}
+	return p.join('');
+}
+*/
+module.exports.string2bytes = function(s) {
+	var len = s.length;
+	var b = new Array(len);
+	var i = 0;
+	while (i < len) {
+		b[i] = s.charCodeAt(i);
+		i++;
+	}
+	return b;
+}
+/*
+module.exports.bytes2Int16Buffer = function(b) {
+	var len = b.length;
+	var bufferLength = len ? (((len - 1) >>> 1) + 1) : 0;
+	var buffer = new Array(bufferLength);
+	var i = 0;
+	var j = 0;
+	while (i < len) {
+		buffer[j] = (buffer[j] << 8) | b[i];
+		i++;
+		if (!(i % 2)) j++;
+	}
+	return buffer;
+}
+*/
+
+module.exports.bytes2Int32Buffer = function(b) {
+	if (!b) return [];
+	var len = b.length ? (((b.length - 1) >>> 2) + 1) : 0;
+	var buffer = new Array(len);
+	var j = 0;
+	while (j < len) {
+		buffer[j] = (b[j * 4] << 24) | (b[j * 4 + 1] << 16) | (b[j * 4 + 2] << 8) | b[j * 4 + 3];
+		j++;
+	}
+	return buffer;
+}
+/*
+module.exports.bytes2Int32BufferLeAligned = function(b) {
+	var len = b.length;
+	if (!len) return [];
+	var len2 = len ? (((len - 1) >>> 2) + 1) : 0;
+	var buffer = new Array(len);
+	var j = 0;
+	while (j < len2) {
+		buffer[j] = (b[j * 4 + 3] << 24) | (b[j * 4 + 2] << 16) | (b[j * 4 + 1] << 8) | b[j * 4];
+		j++;
+	};
+	return buffer;
+}
+*/
+module.exports.bytes2Int64Buffer = function(b) {
+	if (!b) return [];
+	var len = b.length ? (((b.length - 1) >>> 3) + 1) : 0;
+	var buffer = new Array(len);
+	var j = 0;
+	while (j < len) {
+		buffer[j] = new op.u64((b[j * 8] << 24) | (b[j * 8 + 1] << 16) | (b[j * 8 + 2] << 8) | b[j * 8 + 3], (b[j * 8 + 4] << 24) | (b[j * 8 + 5] << 16) | (b[j * 8 + 6] << 8) | b[j * 8 + 7]);
+		j++;
+	}
+	return buffer;
+}
+
+module.exports.bytes2Int64BufferLeAligned = function(b) {
+	if (!b) return [];
+	var len =  b.length ? ((( b.length - 1) >>> 3) + 1) : 0;
+	var buffer = new Array(len);
+	var j = 0;
+	while (j < len) {
+		buffer[j] = new op.u64((b[j * 8 + 7] << 24) | (b[j * 8 + 6] << 16) | (b[j * 8 + 5] << 8) | b[j * 8 + 4], (b[j * 8 + 3] << 24) | (b[j * 8 + 2] << 16) | (b[j * 8 + 1] << 8) | b[j * 8]);
+		j++;
+	}
+	return buffer;
+}
+
+module.exports.bufferEncode64leAligned = function(buffer, offset, uint64) {
+	buffer[offset + 7] = uint64.hi >>> 24;
+	buffer[offset + 6] = uint64.hi >>> 16 & 0xFF;
+	buffer[offset + 5] = uint64.hi >>> 8 & 0xFF;
+	buffer[offset + 4] = uint64.hi & 0xFF;
+	buffer[offset + 3] = uint64.lo >>> 24;
+	buffer[offset + 2] = uint64.lo >>> 16 & 0xFF;
+	buffer[offset + 1] = uint64.lo >>> 8 & 0xFF;
+	buffer[offset + 0] = uint64.lo & 0xFF;
+}
+
+module.exports.bufferEncode64 = function(buffer, offset, uint64) {
+	buffer[offset] = uint64.hi >>> 24;
+	buffer[offset + 1] = uint64.hi >>> 16 & 0xFF;
+	buffer[offset + 2] = uint64.hi >>> 8 & 0xFF;
+	buffer[offset + 3] = uint64.hi & 0xFF;
+	buffer[offset + 4] = uint64.lo >>> 24;
+	buffer[offset + 5] = uint64.lo >>> 16 & 0xFF;
+	buffer[offset + 6] = uint64.lo >>> 8 & 0xFF;
+	buffer[offset + 7] = uint64.lo & 0xFF;
+}
+
+module.exports.int32Buffer2Bytes = function(b) {
+	var buffer = new Array(b.length);
+	var len = b.length;
+	var i = 0;
+	while (i < len) {
+		buffer[i * 4] = (b[i] & 0xFF000000) >>> 24;
+		buffer[i * 4 + 1] = (b[i] & 0x00FF0000) >>> 16;
+		buffer[i * 4 + 2] = (b[i] & 0x0000FF00) >>> 8;
+		buffer[i * 4 + 3] = (b[i] & 0x000000FF);
+		i++;
+	}
+	return buffer;
+}
+/*
+module.exports.int64Buffer2Bytes = function(b) {
+	var buffer = new Array(b.length);
+	var i = 0;
+	while (i < b.length) {
+		buffer[i * 8] = (b[i].hi & 0xFF000000) >>> 24;
+		buffer[i * 8 + 1] = (b[i].hi & 0x00FF0000) >>> 16;
+		buffer[i * 8 + 2] = (b[i].hi & 0x0000FF00) >>> 8;
+		buffer[i * 8 + 3] = (b[i].hi & 0x000000FF);
+		buffer[i * 8 + 4] = (b[i].lo & 0xFF000000) >>> 24;
+		buffer[i * 8 + 5] = (b[i].lo & 0x00FF0000) >>> 16;
+		buffer[i * 8 + 6] = (b[i].lo & 0x0000FF00) >>> 8;
+		buffer[i * 8 + 7] = (b[i].lo & 0x000000FF);
+		i++;
+	}
+	return buffer;
+}
+*/
+
+module.exports.string2Int32Buffer = function(s) {
+	return this.bytes2Int32Buffer(this.string2bytes(s));
+}
+
+var keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+
+module.exports.b64Encode = function(input) {
+	var output = "";
+	var chr1, chr2, chr3, enc1, enc2, enc3, enc4;
+	var i = 0;
+
+	while (i < input.length) {
+
+		chr1 = input[i++];
+		chr2 = input[i++];
+		chr3 = input[i++];
+
+		enc1 = chr1 >> 2;
+		enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
+		enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
+		enc4 = chr3 & 63;
+
+		if (isNaN(chr2)) {
+			enc3 = enc4 = 64;
+		}
+		else if (isNaN(chr3)) {
+			enc4 = 64;
+		}
+
+		output +=
+			keyStr.charAt(enc1) + keyStr.charAt(enc2) +
+			keyStr.charAt(enc3) + keyStr.charAt(enc4);
+	}
+
+	return output;
+};
+
+module.exports.b64Decode = function(input) {
+	var output = [];
+	var chr1, chr2, chr3;
+	var enc1, enc2, enc3, enc4;
+	var i = 0;
+
+	input = input.replace(/[^A-Za-z0-9\+\/\=]/g, "");
+
+	while (i < input.length) {
+
+		enc1 = keyStr.indexOf(input.charAt(i++));
+		enc2 = keyStr.indexOf(input.charAt(i++));
+		enc3 = keyStr.indexOf(input.charAt(i++));
+		enc4 = keyStr.indexOf(input.charAt(i++));
+
+		chr1 = (enc1 << 2) | (enc2 >> 4);
+		chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+		chr3 = ((enc3 & 3) << 6) | enc4;
+
+		output.push(chr1);
+
+		if (enc3 != 64) {
+			output.push(chr2);
+		}
+		if (enc4 != 64) {
+			output.push(chr3);
+		}
+	}
+	return output;
+};

package/dependencies/src/groestl-hash-js-ef6a04f1c4d2f0448f0882b5f213ef7a0659baee/lib/op.js

@@ -0,0 +1,462 @@
+'use strict';
+//the right shift is important, it has to do with 32 bit operations in javascript, it will make things faster
+function u64(h, l) {
+  this.hi = h >>> 0;
+  this.lo = l >>> 0;
+}
+
+u64.prototype.set = function(oWord) {
+  this.lo = oWord.lo;
+  this.hi = oWord.hi;
+}
+
+u64.prototype.add = function(oWord) {
+  var lowest, lowMid, highMid, highest; //four parts of the whole 64 bit number..
+
+  //need to add the respective parts from each number and the carry if on is present..
+  lowest = (this.lo & 0XFFFF) + (oWord.lo & 0XFFFF);
+  lowMid = (this.lo >>> 16) + (oWord.lo >>> 16) + (lowest >>> 16);
+  highMid = (this.hi & 0XFFFF) + (oWord.hi & 0XFFFF) + (lowMid >>> 16);
+  highest = (this.hi >>> 16) + (oWord.hi >>> 16) + (highMid >>> 16);
+
+  //now set the hgih and the low accordingly..
+  this.lo = (lowMid << 16) | (lowest & 0XFFFF);
+  this.hi = (highest << 16) | (highMid & 0XFFFF);
+
+  return this; //for chaining..
+};
+
+u64.prototype.addOne = function() {
+  if (this.lo === -1 || this.lo === 0xFFFFFFFF) {
+    this.lo = 0;
+    this.hi++;
+  }
+  else {
+    this.lo++;
+  }
+}
+
+u64.prototype.plus = function(oWord) {
+  var c = new u64(0, 0);
+  var lowest, lowMid, highMid, highest; //four parts of the whole 64 bit number..
+
+  //need to add the respective parts from each number and the carry if on is present..
+  lowest = (this.lo & 0XFFFF) + (oWord.lo & 0XFFFF);
+  lowMid = (this.lo >>> 16) + (oWord.lo >>> 16) + (lowest >>> 16);
+  highMid = (this.hi & 0XFFFF) + (oWord.hi & 0XFFFF) + (lowMid >>> 16);
+  highest = (this.hi >>> 16) + (oWord.hi >>> 16) + (highMid >>> 16);
+
+  //now set the hgih and the low accordingly..
+  c.lo = (lowMid << 16) | (lowest & 0XFFFF);
+  c.hi = (highest << 16) | (highMid & 0XFFFF);
+
+  return c; //for chaining..
+};
+
+u64.prototype.not = function() {
+  return new u64(~this.hi, ~this.lo);
+}
+
+u64.prototype.one = function() {
+  return new u64(0x0, 0x1);
+}
+
+u64.prototype.zero = function() {
+  return new u64(0x0, 0x0);
+}
+
+u64.prototype.neg = function() {
+  return this.not().plus(this.one());
+}
+
+u64.prototype.minus = function(oWord) {
+  return this.plus(oWord.neg());
+};
+
+u64.prototype.isZero = function() {
+  return (this.lo === 0) && (this.hi === 0);
+}
+
+function isLong(obj) {
+  return (obj && obj["__isLong__"]) === true;
+}
+
+function fromNumber(value) {
+  if (isNaN(value) || !isFinite(value))
+    return this.zero();
+  var pow32 = (1 << 32);
+  return new u64((value % pow32) | 0, (value / pow32) | 0);
+}
+
+u64.prototype.multiply = function(multiplier) {
+  if (this.isZero())
+    return this.zero();
+  if (!isLong(multiplier))
+    multiplier = fromNumber(multiplier);
+  if (multiplier.isZero())
+    return this.zero();
+
+  // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.
+  // We can skip products that would overflow.
+
+  var a48 = this.hi >>> 16;
+  var a32 = this.hi & 0xFFFF;
+  var a16 = this.lo >>> 16;
+  var a00 = this.lo & 0xFFFF;
+
+  var b48 = multiplier.hi >>> 16;
+  var b32 = multiplier.hi & 0xFFFF;
+  var b16 = multiplier.lo >>> 16;
+  var b00 = multiplier.lo & 0xFFFF;
+
+  var c48 = 0,
+    c32 = 0,
+    c16 = 0,
+    c00 = 0;
+  c00 += a00 * b00;
+  c16 += c00 >>> 16;
+  c00 &= 0xFFFF;
+  c16 += a16 * b00;
+  c32 += c16 >>> 16;
+  c16 &= 0xFFFF;
+  c16 += a00 * b16;
+  c32 += c16 >>> 16;
+  c16 &= 0xFFFF;
+  c32 += a32 * b00;
+  c48 += c32 >>> 16;
+  c32 &= 0xFFFF;
+  c32 += a16 * b16;
+  c48 += c32 >>> 16;
+  c32 &= 0xFFFF;
+  c32 += a00 * b32;
+  c48 += c32 >>> 16;
+  c32 &= 0xFFFF;
+  c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
+  c48 &= 0xFFFF;
+  return new u64((c48 << 16) | c32, (c16 << 16) | c00);
+};
+
+u64.prototype.shiftLeft = function(bits) {
+  bits = bits % 64;
+  var c = new u64(0, 0);
+  if (bits === 0) {
+    return this.clone();
+  }
+  else if (bits > 31) {
+    c.lo = 0;
+    c.hi = this.lo << (bits - 32);
+  }
+  else {
+    var toMoveUp = this.lo >>> 32 - bits;
+    c.lo = this.lo << bits;
+    c.hi = (this.hi << bits) | toMoveUp;
+  }
+  return c; //for chaining..
+};
+
+u64.prototype.setShiftLeft = function(bits) {
+  if (bits === 0) {
+    return this;
+  }
+  if (bits > 63) {
+    bits = bits % 64;
+  }
+  
+  if (bits > 31) {
+    this.hi = this.lo << (bits - 32);
+    this.lo = 0;
+  }
+  else {
+    var toMoveUp = this.lo >>> 32 - bits;
+    this.lo <<= bits;
+    this.hi = (this.hi << bits) | toMoveUp;
+  }
+  return this; //for chaining..
+};
+//Shifts this word by the given number of bits to the right (max 32)..
+u64.prototype.shiftRight = function(bits) {
+  bits = bits % 64;
+  var c = new u64(0, 0);
+  if (bits === 0) {
+    return this.clone();
+  }
+  else if (bits >= 32) {
+    c.hi = 0;
+    c.lo = this.hi >>> (bits - 32);
+  }
+  else {
+    var bitsOff32 = 32 - bits,
+      toMoveDown = this.hi << bitsOff32 >>> bitsOff32;
+    c.hi = this.hi >>> bits;
+    c.lo = this.lo >>> bits | (toMoveDown << bitsOff32);
+  }
+  return c; //for chaining..
+};
+//Rotates the bits of this word round to the left (max 32)..
+u64.prototype.rotateLeft = function(bits) {
+  if (bits > 32) {
+    return this.rotateRight(64 - bits);
+  }
+  var c = new u64(0, 0);
+  if (bits === 0) {
+    c.lo = this.lo >>> 0;
+    c.hi = this.hi >>> 0;
+  }
+  else if (bits === 32) { //just switch high and low over in this case..
+    c.lo = this.hi;
+    c.hi = this.lo;
+  }
+  else {
+    c.lo = (this.lo << bits) | (this.hi >>> (32 - bits));
+    c.hi = (this.hi << bits) | (this.lo >>> (32 - bits));
+  }
+  return c; //for chaining..
+};
+
+u64.prototype.setRotateLeft = function(bits) {
+  if (bits > 32) {
+    return this.setRotateRight(64 - bits);
+  }
+  var newHigh;
+  if (bits === 0) {
+    return this;
+  }
+  else if (bits === 32) { //just switch high and low over in this case..
+    newHigh = this.lo;
+    this.lo = this.hi;
+    this.hi = newHigh;
+  }
+  else {
+    newHigh = (this.hi << bits) | (this.lo >>> (32 - bits));
+    this.lo = (this.lo << bits) | (this.hi >>> (32 - bits));
+    this.hi = newHigh;
+  }
+  return this; //for chaining..
+};
+//Rotates the bits of this word round to the right (max 32)..
+u64.prototype.rotateRight = function(bits) {
+  if (bits > 32) {
+    return this.rotateLeft(64 - bits);
+  }
+  var c = new u64(0, 0);
+  if (bits === 0) {
+    c.lo = this.lo >>> 0;
+    c.hi = this.hi >>> 0;
+  }
+  else if (bits === 32) { //just switch high and low over in this case..
+    c.lo = this.hi;
+    c.hi = this.lo;
+  }
+  else {
+    c.lo = (this.hi << (32 - bits)) | (this.lo >>> bits);
+    c.hi = (this.lo << (32 - bits)) | (this.hi >>> bits);
+  }
+  return c; //for chaining..
+};
+u64.prototype.setFlip = function() {
+  var newHigh;
+  newHigh = this.lo;
+  this.lo = this.hi;
+  this.hi = newHigh;
+  return this;
+};
+//Rotates the bits of this word round to the right (max 32)..
+u64.prototype.setRotateRight = function(bits) {
+  if (bits > 32) {
+    return this.setRotateLeft(64 - bits);
+  }
+
+  if (bits === 0) {
+    return this;
+  }
+  else if (bits === 32) { //just switch high and low over in this case..
+    var newHigh;
+    newHigh = this.lo;
+    this.lo = this.hi;
+    this.hi = newHigh;
+  }
+  else {
+    newHigh = (this.lo << (32 - bits)) | (this.hi >>> bits);
+    this.lo = (this.hi << (32 - bits)) | (this.lo >>> bits);
+    this.hi = newHigh;
+  }
+  return this; //for chaining..
+};
+//Xors this word with the given other..
+u64.prototype.xor = function(oWord) {
+  var c = new u64(0, 0);
+  c.hi = this.hi ^ oWord.hi;
+  c.lo = this.lo ^ oWord.lo;
+  return c; //for chaining..
+};
+//Xors this word with the given other..
+u64.prototype.setxorOne = function(oWord) {
+  this.hi ^= oWord.hi;
+  this.lo ^= oWord.lo;
+  return this; //for chaining..
+};
+//Ands this word with the given other..
+u64.prototype.and = function(oWord) {
+  var c = new u64(0, 0);
+  c.hi = this.hi & oWord.hi;
+  c.lo = this.lo & oWord.lo;
+  return c; //for chaining..
+};
+
+//Creates a deep copy of this Word..
+u64.prototype.clone = function() {
+  return new u64(this.hi, this.lo);
+};
+
+u64.prototype.setxor64 = function() {
+  var a = arguments;
+  var i = a.length;
+  while (i--) {
+    this.hi ^= a[i].hi;
+    this.lo ^= a[i].lo;
+  }
+  return this;
+}
+
+module.exports.u64 = u64;
+
+module.exports.u = function(h, l) {
+  return new u64(h, l);
+}
+/*
+module.exports.add64 = function(a, b) {
+  var lowest, lowMid, highMid, highest; //four parts of the whole 64 bit number..
+
+  //need to add the respective parts from each number and the carry if on is present..
+  lowest = (a.lo & 0XFFFF) + (b.lo & 0XFFFF);
+  lowMid = (a.lo >>> 16) + (b.lo >>> 16) + (lowest >>> 16);
+  highMid = (a.hi & 0XFFFF) + (b.hi & 0XFFFF) + (lowMid >>> 16);
+  highest = (a.hi >>> 16) + (b.hi >>> 16) + (highMid >>> 16);
+
+  var r = new this.u64((highest << 16) | (highMid & 0XFFFF), (lowMid << 16) | (lowest & 0XFFFF));
+
+  return r;
+};
+*/
+module.exports.xor64 = function() {
+  var a = arguments,
+    h = a[0].hi,
+    l = a[0].lo;
+      var i = a.length-1;
+  do {
+    h ^= a[i].hi;
+    l ^= a[i].lo;
+    i--;
+  } while (i>0);
+  return new this.u64(h, l);
+}
+
+module.exports.clone64Array = function(array) {
+  var i = 0;
+  var len = array.length;
+  var a = new Array(len);
+  while(i<len) {
+    a[i] = array[i];
+    i++;
+  }
+  return a;
+}
+
+//this shouldn't be a problem, but who knows in the future javascript might support 64bits
+module.exports.t32 = function(x) {
+  return (x & 0xFFFFFFFF)
+}
+
+module.exports.rotl32 = function(x, c) {
+  return (((x) << (c)) | ((x) >>> (32 - (c)))) & (0xFFFFFFFF);
+}
+
+module.exports.rotr32 = function(x, c) {
+  return this.rotl32(x, (32 - (c)));
+}
+
+module.exports.swap32 = function(val) {
+  return ((val & 0xFF) << 24) |
+    ((val & 0xFF00) << 8) |
+    ((val >>> 8) & 0xFF00) |
+    ((val >>> 24) & 0xFF);
+}
+
+module.exports.swap32Array = function(a) {
+  //can't do this with map because of support for IE8 (Don't hate me plz).
+  var i = 0, len = a.length;
+  var r = new Array(i);
+  while (i<len) {
+    r[i] = (this.swap32(a[i]));
+    i++;
+  }
+  return r;
+}
+
+module.exports.xnd64 = function(x, y, z) {
+  return new this.u64(x.hi ^ ((~y.hi) & z.hi), x.lo ^ ((~y.lo) & z.lo));
+}
+/*
+module.exports.load64 = function(x, i) {
+  var l = x[i] | (x[i + 1] << 8) | (x[i + 2] << 16) | (x[i + 3] << 24);
+  var h = x[i + 4] | (x[i + 5] << 8) | (x[i + 6] << 16) | (x[i + 7] << 24);
+  return new this.u64(h, l);
+}
+*/
+module.exports.bufferInsert = function(buffer, bufferOffset, data, len, dataOffset) {
+  dataOffset = dataOffset | 0;
+  var i = 0;
+  while (i < len) {
+    buffer[i + bufferOffset] = data[i + dataOffset];
+    i++;
+  }
+}
+
+module.exports.bufferInsert64 = function(buffer, bufferOffset, data, len) {
+  var i = 0;
+  while (i < len) {
+    buffer[i + bufferOffset] = data[i].clone();
+    i++;
+  }
+}
+/*
+module.exports.buffer2Insert = function(buffer, bufferOffset, bufferOffset2, data, len, len2) {
+  while (len--) {
+    var j = len2;
+    while (j--) {
+      buffer[len + bufferOffset][j + bufferOffset2] = data[len][j];
+    }
+  }
+}
+*/
+module.exports.bufferInsertBackwards = function(buffer, bufferOffset, data, len) {
+  var i = 0;
+  while (i < len) {
+    buffer[i + bufferOffset] = data[len - 1 - i];
+    i++;
+  }
+}
+
+module.exports.bufferSet = function(buffer, bufferOffset, value, len) {
+  var i = 0;
+  while (i < len) {
+    buffer[i + bufferOffset] = value;
+    i++;
+  }
+}
+
+module.exports.bufferXORInsert = function(buffer, bufferOffset, data, dataOffset, len) {
+  var i = 0;
+  while (i < len) {
+    buffer[i + bufferOffset] ^= data[i + dataOffset];
+    i++;
+  }
+}
+
+module.exports.xORTable = function(d, s1, s2, len) {
+  var i = 0;
+  while (i < len) {
+    d[i] = s1[i] ^ s2[i];
+    i++
+  }
+}