@steemit/steem-js 0.7.10 → 0.8.0

package/lib/auth/ecc/src/aes.js

@@ -1,48 +1,19 @@
-'use strict';
+"use strict";
 
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.encrypt = encrypt;
-exports.decrypt = decrypt;
-
-var _secureRandom = require('secure-random');
-
-var _secureRandom2 = _interopRequireDefault(_secureRandom);
-
-var _bytebuffer = require('bytebuffer');
-
-var _bytebuffer2 = _interopRequireDefault(_bytebuffer);
-
-var _browserifyAes = require('browserify-aes');
-
-var _browserifyAes2 = _interopRequireDefault(_browserifyAes);
-
-var _assert = require('assert');
-
-var _assert2 = _interopRequireDefault(_assert);
-
-var _key_public = require('./key_public');
-
-var _key_public2 = _interopRequireDefault(_key_public);
-
-var _key_private = require('./key_private');
-
-var _key_private2 = _interopRequireDefault(_key_private);
-
-var _hash = require('./hash');
-
-var _hash2 = _interopRequireDefault(_hash);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-var Long = _bytebuffer2.default.Long;
+const secureRandom = require('secure-random');
+const ByteBuffer = require('bytebuffer');
+const crypto = require('browserify-aes');
+const assert = require('assert');
+const PublicKey = require('./key_public');
+const PrivateKey = require('./key_private');
+const hash = require('./hash');
+const Long = ByteBuffer.Long;
 
 /**
     Spec: http://localhost:3002/steem/@dantheman/how-to-encrypt-a-memo-when-transferring-steem
     @throws {Error|TypeError} - "Invalid Key, ..."
     @arg {PrivateKey} private_key - required and used for decryption
-    @arg {PublicKey} public_key - required and used to calcualte the shared secret
+    @arg {PublicKey} public_key - required and used to calculate the shared secret
     @arg {string} [nonce = uniqueNonce()] - assigned a random unique uint64
 
     @return {object}
@@ -50,16 +21,14 @@ var Long = _bytebuffer2.default.Long;
     @property {Buffer} message - Plain text message
     @property {number} checksum - shared secret checksum
 */
-function encrypt(private_key, public_key, message) {
-    var nonce = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : uniqueNonce();
-
-    return crypt(private_key, public_key, nonce, message);
+function encrypt(private_key, public_key, message, nonce = uniqueNonce()) {
+  return crypt(private_key, public_key, nonce, message);
 }
 
 /**
     Spec: http://localhost:3002/steem/@dantheman/how-to-encrypt-a-memo-when-transferring-steem
     @arg {PrivateKey} private_key - required and used for decryption
-    @arg {PublicKey} public_key - required and used to calcualte the shared secret
+    @arg {PublicKey} public_key - required and used to calculate the shared secret
     @arg {string} nonce - random or unique uint64, provides entropy when re-using the same private/public keys.
     @arg {Buffer} message - Encrypted or plain text message
     @arg {number} checksum - shared secret checksum
@@ -67,7 +36,7 @@ function encrypt(private_key, public_key, message) {
     @return {Buffer} - message
 */
 function decrypt(private_key, public_key, nonce, message, checksum) {
-    return crypt(private_key, public_key, nonce, message, checksum).message;
+  return crypt(private_key, public_key, nonce, message, checksum).message;
 }
 
 /**
@@ -75,55 +44,54 @@ function decrypt(private_key, public_key, nonce, message, checksum) {
     @arg {number} checksum - shared secret checksum (null to encrypt, non-null to decrypt)
 */
 function crypt(private_key, public_key, nonce, message, checksum) {
-    private_key = toPrivateObj(private_key);
-    if (!private_key) throw new TypeError('private_key is required');
-
-    public_key = toPublicObj(public_key);
-    if (!public_key) throw new TypeError('public_key is required');
-
-    nonce = toLongObj(nonce);
-    if (!nonce) throw new TypeError('nonce is required');
-
-    if (!Buffer.isBuffer(message)) {
-        if (typeof message !== 'string') throw new TypeError('message should be buffer or string');
-        message = new Buffer(message, 'binary');
-    }
-    if (checksum && typeof checksum !== 'number') throw new TypeError('checksum should be a number');
-
-    var S = private_key.get_shared_secret(public_key);
-    var ebuf = new _bytebuffer2.default(_bytebuffer2.default.DEFAULT_CAPACITY, _bytebuffer2.default.LITTLE_ENDIAN);
-    ebuf.writeUint64(nonce);
-    ebuf.append(S.toString('binary'), 'binary');
-    ebuf = new Buffer(ebuf.copy(0, ebuf.offset).toBinary(), 'binary');
-    var encryption_key = _hash2.default.sha512(ebuf);
-
-    // D E B U G
-    // console.log('crypt', {
-    //     priv_to_pub: private_key.toPublicKey().toString(),
-    //     pub: public_key.toString(),
-    //     nonce: nonce.toString(),
-    //     message: message.length,
-    //     checksum,
-    //     S: S.toString('hex'),
-    //     encryption_key: encryption_key.toString('hex'),
-    // })
-
-    var iv = encryption_key.slice(32, 48);
-    var key = encryption_key.slice(0, 32);
-
-    // check is first 64 bit of sha256 hash treated as uint64_t truncated to 32 bits.
-    var check = _hash2.default.sha256(encryption_key);
-    check = check.slice(0, 4);
-    var cbuf = _bytebuffer2.default.fromBinary(check.toString('binary'), _bytebuffer2.default.DEFAULT_CAPACITY, _bytebuffer2.default.LITTLE_ENDIAN);
-    check = cbuf.readUint32();
-
-    if (checksum) {
-        if (check !== checksum) throw new Error('Invalid key');
-        message = cryptoJsDecrypt(message, key, iv);
-    } else {
-        message = cryptoJsEncrypt(message, key, iv);
-    }
-    return { nonce: nonce, message: message, checksum: check };
+  private_key = toPrivateObj(private_key);
+  if (!private_key) throw new TypeError('private_key is required');
+  public_key = toPublicObj(public_key);
+  if (!public_key) throw new TypeError('public_key is required');
+  nonce = toLongObj(nonce);
+  if (!nonce) throw new TypeError('nonce is required');
+  if (!Buffer.isBuffer(message)) {
+    if (typeof message !== 'string') throw new TypeError('message should be buffer or string');
+    message = new Buffer.from(message, 'binary');
+  }
+  if (checksum && typeof checksum !== 'number') throw new TypeError('checksum should be a number');
+  const S = private_key.get_shared_secret(public_key);
+  let ebuf = new ByteBuffer(ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
+  ebuf.writeUint64(nonce);
+  ebuf.append(S.toString('binary'), 'binary');
+  ebuf = new Buffer.from(ebuf.copy(0, ebuf.offset).toBinary(), 'binary');
+  const encryption_key = hash.sha512(ebuf);
+
+  // D E B U G
+  // console.log('crypt', {
+  //     priv_to_pub: private_key.toPublicKey().toString(),
+  //     pub: public_key.toString(),
+  //     nonce: nonce.toString(),
+  //     message: message.length,
+  //     checksum,
+  //     S: S.toString('hex'),
+  //     encryption_key: encryption_key.toString('hex'),
+  // })
+
+  const iv = encryption_key.slice(32, 48);
+  const key = encryption_key.slice(0, 32);
+
+  // check is first 64 bit of sha256 hash treated as uint64_t truncated to 32 bits.
+  let check = hash.sha256(encryption_key);
+  check = check.slice(0, 4);
+  const cbuf = ByteBuffer.fromBinary(check.toString('binary'), ByteBuffer.DEFAULT_CAPACITY, ByteBuffer.LITTLE_ENDIAN);
+  check = cbuf.readUint32();
+  if (checksum) {
+    if (check !== checksum) throw new Error('Invalid key');
+    message = cryptoJsDecrypt(message, key, iv);
+  } else {
+    message = cryptoJsEncrypt(message, key, iv);
+  }
+  return {
+    nonce,
+    message,
+    checksum: check
+  };
 }
 
 /** This method does not use a checksum, the returned data must be validated some other way.
@@ -131,12 +99,12 @@ function crypt(private_key, public_key, nonce, message, checksum) {
     @return {Buffer}
 */
 function cryptoJsDecrypt(message, key, iv) {
-    (0, _assert2.default)(message, "Missing cipher text");
-    message = toBinaryBuffer(message);
-    var decipher = _browserifyAes2.default.createDecipheriv('aes-256-cbc', key, iv);
-    // decipher.setAutoPadding(true)
-    message = Buffer.concat([decipher.update(message), decipher.final()]);
-    return message;
+  assert(message, "Missing cipher text");
+  message = toBinaryBuffer(message);
+  const decipher = crypto.createDecipheriv('aes-256-cbc', key, iv);
+  // decipher.setAutoPadding(true)
+  message = Buffer.concat([decipher.update(message), decipher.final()]);
+  return message;
 }
 
 /** This method does not use a checksum, the returned data must be validated some other way.
@@ -144,41 +112,37 @@ function cryptoJsDecrypt(message, key, iv) {
     @return {Buffer} binary
 */
 function cryptoJsEncrypt(message, key, iv) {
-    (0, _assert2.default)(message, "Missing plain text");
-    message = toBinaryBuffer(message);
-    var cipher = _browserifyAes2.default.createCipheriv('aes-256-cbc', key, iv);
-    // cipher.setAutoPadding(true)
-    message = Buffer.concat([cipher.update(message), cipher.final()]);
-    return message;
+  assert(message, "Missing plain text");
+  message = toBinaryBuffer(message);
+  const cipher = crypto.createCipheriv('aes-256-cbc', key, iv);
+  // cipher.setAutoPadding(true)
+  message = Buffer.concat([cipher.update(message), cipher.final()]);
+  return message;
 }
 
 /** @return {string} unique 64 bit unsigned number string.  Being time based, this is careful to never choose the same nonce twice.  This value could be recorded in the blockchain for a long time.
 */
 function uniqueNonce() {
-    if (unique_nonce_entropy === null) {
-        var b = _secureRandom2.default.randomUint8Array(2);
-        unique_nonce_entropy = parseInt(b[0] << 8 | b[1], 10);
-    }
-    var long = Long.fromNumber(Date.now());
-    var entropy = ++unique_nonce_entropy % 0xFFFF;
-    // console.log('uniqueNonce date\t', ByteBuffer.allocate(8).writeUint64(long).toHex(0))
-    // console.log('uniqueNonce entropy\t', ByteBuffer.allocate(8).writeUint64(Long.fromNumber(entropy)).toHex(0))
-    long = long.shiftLeft(16).or(Long.fromNumber(entropy));
-    // console.log('uniqueNonce final\t', ByteBuffer.allocate(8).writeUint64(long).toHex(0))
-    return long.toString();
+  if (unique_nonce_entropy === null) {
+    const b = secureRandom.randomUint8Array(2);
+    unique_nonce_entropy = parseInt(b[0] << 8 | b[1], 10);
+  }
+  let long = Long.fromNumber(Date.now());
+  const entropy = ++unique_nonce_entropy % 0xFFFF;
+  // console.log('uniqueNonce date\t', ByteBuffer.allocate(8).writeUint64(long).toHex(0))
+  // console.log('uniqueNonce entropy\t', ByteBuffer.allocate(8).writeUint64(Long.fromNumber(entropy)).toHex(0))
+  long = long.shiftLeft(16).or(Long.fromNumber(entropy));
+  // console.log('uniqueNonce final\t', ByteBuffer.allocate(8).writeUint64(long).toHex(0))
+  return long.toString();
 }
-var unique_nonce_entropy = null;
+let unique_nonce_entropy = null;
 // for(let i=1; i < 10; i++) key.uniqueNonce()
 
-var toPrivateObj = function toPrivateObj(o) {
-    return o ? o.d ? o : _key_private2.default.fromWif(o) : o /*null or undefined*/;
-};
-var toPublicObj = function toPublicObj(o) {
-    return o ? o.Q ? o : _key_public2.default.fromString(o) : o /*null or undefined*/;
-};
-var toLongObj = function toLongObj(o) {
-    return o ? Long.isLong(o) ? o : Long.fromString(o) : o;
-};
-var toBinaryBuffer = function toBinaryBuffer(o) {
-    return o ? Buffer.isBuffer(o) ? o : new Buffer(o, 'binary') : o;
+const toPrivateObj = o => o ? o.d ? o : PrivateKey.fromWif(o) : o /*null or undefined*/;
+const toPublicObj = o => o ? o.Q ? o : PublicKey.fromString(o) : o /*null or undefined*/;
+const toLongObj = o => o ? Long.isLong(o) ? o : Long.fromString(o) : o;
+const toBinaryBuffer = o => o ? Buffer.isBuffer(o) ? o : new Buffer.from(o, 'binary') : o;
+module.exports = {
+  encrypt,
+  decrypt
 };

package/lib/auth/ecc/src/brain_key.js

@@ -1,13 +1,13 @@
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
-    value: true
+  value: true
 });
 exports.normalize = normalize;
 function normalize(brain_key) {
-    if (typeof brain_key !== 'string') {
-        throw new Error("string required for brain_key");
-    }
-    brain_key = brain_key.trim();
-    return brain_key.split(/[\t\n\v\f\r ]+/).join(' ');
+  if (typeof brain_key !== 'string') {
+    throw new Error("string required for brain_key");
+  }
+  brain_key = brain_key.trim();
+  return brain_key.split(/[\t\n\v\f\r ]+/).join(' ');
 }

package/lib/auth/ecc/src/ecdsa.js

@@ -1,28 +1,24 @@
-'use strict';
+"use strict";
 
 var assert = require('assert'); // from github.com/bitcoinjs/bitcoinjs-lib from github.com/cryptocoinjs/ecdsa
 var crypto = require('./hash');
 var enforceType = require('./enforce_types');
-
 var BigInteger = require('bigi');
 var ECSignature = require('./ecsignature');
 
 // https://tools.ietf.org/html/rfc6979#section-3.2
 function deterministicGenerateK(curve, hash, d, checkSig, nonce) {
-
   enforceType('Buffer', hash);
   enforceType(BigInteger, d);
-
   if (nonce) {
-    hash = crypto.sha256(Buffer.concat([hash, new Buffer(nonce)]));
+    hash = crypto.sha256(Buffer.concat([hash, new Buffer.alloc(nonce)]));
   }
 
   // sanity check
   assert.equal(hash.length, 32, 'Hash must be 256 bit');
-
   var x = d.toBuffer(32);
-  var k = new Buffer(32);
-  var v = new Buffer(32);
+  var k = new Buffer.alloc(32);
+  var v = new Buffer.alloc(32);
 
   // Step B
   v.fill(1);
@@ -31,13 +27,13 @@ function deterministicGenerateK(curve, hash, d, checkSig, nonce) {
   k.fill(0);
 
   // Step D
-  k = crypto.HmacSHA256(Buffer.concat([v, new Buffer([0]), x, hash]), k);
+  k = crypto.HmacSHA256(Buffer.concat([v, new Buffer.from([0]), x, hash]), k);
 
   // Step E
   v = crypto.HmacSHA256(v, k);
 
   // Step F
-  k = crypto.HmacSHA256(Buffer.concat([v, new Buffer([1]), x, hash]), k);
+  k = crypto.HmacSHA256(Buffer.concat([v, new Buffer.from([1]), x, hash]), k);
 
   // Step G
   v = crypto.HmacSHA256(v, k);
@@ -45,60 +41,46 @@ function deterministicGenerateK(curve, hash, d, checkSig, nonce) {
   // Step H1/H2a, ignored as tlen === qlen (256 bit)
   // Step H2b
   v = crypto.HmacSHA256(v, k);
-
   var T = BigInteger.fromBuffer(v);
 
   // Step H3, repeat until T is within the interval [1, n - 1]
   while (T.signum() <= 0 || T.compareTo(curve.n) >= 0 || !checkSig(T)) {
-    k = crypto.HmacSHA256(Buffer.concat([v, new Buffer([0])]), k);
+    k = crypto.HmacSHA256(Buffer.concat([v, new Buffer.from([0])]), k);
     v = crypto.HmacSHA256(v, k);
 
     // Step H1/H2a, again, ignored as tlen === qlen (256 bit)
     // Step H2b again
     v = crypto.HmacSHA256(v, k);
-
     T = BigInteger.fromBuffer(v);
   }
-
   return T;
 }
-
 function sign(curve, hash, d, nonce) {
-
   var e = BigInteger.fromBuffer(hash);
   var n = curve.n;
   var G = curve.G;
-
   var r, s;
   var k = deterministicGenerateK(curve, hash, d, function (k) {
     // find canonically valid signature
     var Q = G.multiply(k);
-
     if (curve.isInfinity(Q)) return false;
-
     r = Q.affineX.mod(n);
     if (r.signum() === 0) return false;
-
     s = k.modInverse(n).multiply(e.add(d.multiply(r))).mod(n);
     if (s.signum() === 0) return false;
-
     return true;
   }, nonce);
-
   var N_OVER_TWO = n.shiftRight(1);
 
   // enforce low S values, see bip62: 'low s values in signatures'
   if (s.compareTo(N_OVER_TWO) > 0) {
     s = n.subtract(s);
   }
-
   return new ECSignature(r, s);
 }
-
 function verifyRaw(curve, e, signature, Q) {
   var n = curve.n;
   var G = curve.G;
-
   var r = signature.r;
   var s = signature.s;
 
@@ -129,7 +111,6 @@ function verifyRaw(curve, e, signature, Q) {
   // 1.4.8 If v = r, output "valid", and if v != r, output "invalid"
   return v.equals(r);
 }
-
 function verify(curve, hash, signature, Q) {
   // 1.4.2 H = Hash(M), already done by the user
   // 1.4.3 e = H
@@ -147,13 +128,10 @@ function verify(curve, hash, signature, Q) {
   */
 function recoverPubKey(curve, e, signature, i) {
   assert.strictEqual(i & 3, i, 'Recovery param is more than two bits');
-
   var n = curve.n;
   var G = curve.G;
-
   var r = signature.r;
   var s = signature.s;
-
   assert(r.signum() > 0 && r.compareTo(n) < 0, 'Invalid r value');
   assert(s.signum() > 0 && s.compareTo(n) < 0, 'Invalid s value');
 
@@ -178,10 +156,8 @@ function recoverPubKey(curve, e, signature, i) {
   // 1.6.1 Compute Q = r^-1 (sR -  eG)
   //               Q = r^-1 (sR + -eG)
   var rInv = r.modInverse(n);
-
   var Q = R.multiplyTwo(s, G, eNeg).multiply(rInv);
   curve.validate(Q);
-
   return Q;
 }
 
@@ -205,10 +181,8 @@ function calcPubKeyRecoveryParam(curve, e, signature, Q) {
       return i;
     }
   }
-
   throw new Error('Unable to find valid recovery factor');
 }
-
 module.exports = {
   calcPubKeyRecoveryParam: calcPubKeyRecoveryParam,
   deterministicGenerateK: deterministicGenerateK,

package/lib/auth/ecc/src/ecsignature.js

@@ -1,14 +1,11 @@
-'use strict';
+"use strict";
 
 var assert = require('assert'); // from https://github.com/bitcoinjs/bitcoinjs-lib
 var enforceType = require('./enforce_types');
-
 var BigInteger = require('bigi');
-
 function ECSignature(r, s) {
   enforceType(BigInteger, r);
   enforceType(BigInteger, s);
-
   this.r = r;
   this.s = s;
 }
@@ -24,50 +21,38 @@ ECSignature.parseCompact = function (buffer) {
 
   // Recovery param only
   i = i & 3;
-
   var r = BigInteger.fromBuffer(buffer.slice(1, 33));
   var s = BigInteger.fromBuffer(buffer.slice(33));
-
   return {
     compressed: compressed,
     i: i,
     signature: new ECSignature(r, s)
   };
 };
-
 ECSignature.fromDER = function (buffer) {
   assert.equal(buffer.readUInt8(0), 0x30, 'Not a DER sequence');
   assert.equal(buffer.readUInt8(1), buffer.length - 2, 'Invalid sequence length');
   assert.equal(buffer.readUInt8(2), 0x02, 'Expected a DER integer');
-
   var rLen = buffer.readUInt8(3);
   assert(rLen > 0, 'R length is zero');
-
   var offset = 4 + rLen;
   assert.equal(buffer.readUInt8(offset), 0x02, 'Expected a DER integer (2)');
-
   var sLen = buffer.readUInt8(offset + 1);
   assert(sLen > 0, 'S length is zero');
-
   var rB = buffer.slice(4, offset);
   var sB = buffer.slice(offset + 2);
   offset += 2 + sLen;
-
   if (rLen > 1 && rB.readUInt8(0) === 0x00) {
     assert(rB.readUInt8(1) & 0x80, 'R value excessively padded');
   }
-
   if (sLen > 1 && sB.readUInt8(0) === 0x00) {
     assert(sB.readUInt8(1) & 0x80, 'S value excessively padded');
   }
-
   assert.equal(offset, buffer.length, 'Invalid DER encoding');
   var r = BigInteger.fromDERInteger(rB);
   var s = BigInteger.fromDERInteger(sB);
-
   assert(r.signum() >= 0, 'R value is negative');
   assert(s.signum() >= 0, 'S value is negative');
-
   return new ECSignature(r, s);
 };
 
@@ -75,9 +60,7 @@ ECSignature.fromDER = function (buffer) {
 ECSignature.parseScriptSignature = function (buffer) {
   var hashType = buffer.readUInt8(buffer.length - 1);
   var hashTypeMod = hashType & ~0x80;
-
   assert(hashTypeMod > 0x00 && hashTypeMod < 0x04, 'Invalid hashType');
-
   return {
     signature: ECSignature.fromDER(buffer.slice(0, -1)),
     hashType: hashType
@@ -88,20 +71,15 @@ ECSignature.parseScriptSignature = function (buffer) {
 ECSignature.prototype.toCompact = function (i, compressed) {
   if (compressed) i += 4;
   i += 27;
-
-  var buffer = new Buffer(65);
+  var buffer = new Buffer.alloc(65);
   buffer.writeUInt8(i, 0);
-
   this.r.toBuffer(32).copy(buffer, 1);
   this.s.toBuffer(32).copy(buffer, 33);
-
   return buffer;
 };
-
 ECSignature.prototype.toDER = function () {
   var rBa = this.r.toDERInteger();
   var sBa = this.s.toDERInteger();
-
   var sequence = [];
 
   // INTEGER
@@ -114,15 +92,11 @@ ECSignature.prototype.toDER = function () {
 
   // SEQUENCE
   sequence.unshift(0x30, sequence.length);
-
-  return new Buffer(sequence);
+  return new Buffer.from(sequence);
 };
-
 ECSignature.prototype.toScriptSignature = function (hashType) {
-  var hashTypeBuffer = new Buffer(1);
+  var hashTypeBuffer = new Buffer.alloc(1);
   hashTypeBuffer.writeUInt8(hashType, 0);
-
   return Buffer.concat([this.toDER(), hashTypeBuffer]);
 };
-
 module.exports = ECSignature;

package/lib/auth/ecc/src/enforce_types.js

@@ -1,4 +1,4 @@
-'use strict';
+"use strict";
 
 module.exports = function enforce(type, value) {
   // Copied from https://github.com/bitcoinjs/bitcoinjs-lib
@@ -8,40 +8,33 @@ module.exports = function enforce(type, value) {
         if (Array.isArray(value)) return;
         break;
       }
-
     case 'Boolean':
       {
         if (typeof value === 'boolean') return;
         break;
       }
-
     case 'Buffer':
       {
         if (Buffer.isBuffer(value)) return;
         break;
       }
-
     case 'Number':
       {
         if (typeof value === 'number') return;
         break;
       }
-
     case 'String':
       {
         if (typeof value === 'string') return;
         break;
       }
-
     default:
       {
         if (getName(value.constructor) === getName(type)) return;
       }
   }
-
   throw new TypeError('Expected ' + (getName(type) || type) + ', got ' + value);
 };
-
 function getName(fn) {
   // Why not fn.name: https://kangax.github.io/compat-table/es6/#function_name_property
   var match = fn.toString().match(/function (.*?)\(/);