Esteban Ordano
10 years ago
78 changed files with 404 additions and 3629 deletions
@ -1,30 +0,0 @@ |
|||||
This software is licensed under the MIT License. |
|
||||
|
|
||||
Copyright (c) 2014 Ryan X. Charles <ryanxcharles@gmail.com> |
|
||||
|
|
||||
Parts of this software are based on bitcore |
|
||||
Copyright (c) 2014 BitPay Inc. |
|
||||
|
|
||||
Parts of this software are based on BitcoinJS |
|
||||
Copyright (c) 2011 Stefan Thomas <justmoon@members.fsf.org> |
|
||||
|
|
||||
Parts of this software are based on BitcoinJ |
|
||||
Copyright (c) 2011 Google Inc. |
|
||||
|
|
||||
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 shall 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. |
|
||||
File diff suppressed because it is too large
@ -1,20 +0,0 @@ |
|||||
var Identity = require('../lib/identity'); |
|
||||
var KeyPair = require('../lib/keypair'); |
|
||||
var Hash = require('../lib/hash'); |
|
||||
|
|
||||
var keypair = new KeyPair().fromRandom(); |
|
||||
|
|
||||
console.log( 'keypair:' , keypair ); |
|
||||
console.log( 'private key:' , keypair.privkey.toString('hex') ); |
|
||||
console.log( 'public key:' , keypair.pubkey.toString('hex') ); |
|
||||
console.log( 'public hash:' , Hash.sha256ripemd160( keypair.pubkey.toBuffer() ).toString('hex') ); |
|
||||
|
|
||||
|
|
||||
var identity = new Identity().fromPubkey( keypair.pubkey ); |
|
||||
|
|
||||
keypair.pubkey.compressed = false; |
|
||||
var identityComp = new Identity().fromPubkey( keypair.pubkey ); |
|
||||
|
|
||||
console.log( 'identity:' , identity ); |
|
||||
console.log( 'identity string:' , identity.toString() ); |
|
||||
console.log( 'identity string, compressed:' , identityComp.toString() ); |
|
||||
@ -1,3 +1,5 @@ |
|||||
|
'use strict'; |
||||
|
|
||||
var _BN = require('bn.js'); |
var _BN = require('bn.js'); |
||||
|
|
||||
var BN = function BN_extended(n) { |
var BN = function BN_extended(n) { |
||||
@ -1,9 +1,11 @@ |
|||||
|
'use strict'; |
||||
|
|
||||
var BN = require('./bn'); |
var BN = require('./bn'); |
||||
var Point = require('./point'); |
var Point = require('./point'); |
||||
var Signature = require('./signature'); |
|
||||
var Keypair = require('./keypair'); |
|
||||
var Pubkey = require('./pubkey'); |
|
||||
var Random = require('./random'); |
var Random = require('./random'); |
||||
|
var Pubkey = require('../pubkey'); |
||||
|
var Keypair = require('../keypair'); |
||||
|
var Signature = require('../signature'); |
||||
|
|
||||
var ECDSA = function ECDSA(obj) { |
var ECDSA = function ECDSA(obj) { |
||||
if (!(this instanceof ECDSA)) |
if (!(this instanceof ECDSA)) |
||||
@ -1,3 +1,5 @@ |
|||||
|
'use strict'; |
||||
|
|
||||
var hashjs = require('hash.js'); |
var hashjs = require('hash.js'); |
||||
var sha512 = require('sha512'); |
var sha512 = require('sha512'); |
||||
|
|
||||
@ -1,3 +1,5 @@ |
|||||
|
'use strict'; |
||||
|
|
||||
var BN = require('./bn'); |
var BN = require('./bn'); |
||||
var elliptic = require('elliptic'); |
var elliptic = require('elliptic'); |
||||
|
|
||||
@ -1,47 +0,0 @@ |
|||||
var aes = require('aes'); |
|
||||
|
|
||||
var AES = function AES() { |
|
||||
}; |
|
||||
|
|
||||
AES.encrypt = function(messagebuf, keybuf) { |
|
||||
var key = AES.buf2words(keybuf); |
|
||||
var message = AES.buf2words(messagebuf); |
|
||||
var a = new aes(key); |
|
||||
var enc = a.encrypt(message); |
|
||||
var encbuf = AES.words2buf(enc); |
|
||||
return encbuf; |
|
||||
}; |
|
||||
|
|
||||
AES.decrypt = function(encbuf, keybuf) { |
|
||||
var enc = AES.buf2words(encbuf); |
|
||||
var key = AES.buf2words(keybuf); |
|
||||
var a = new aes(key); |
|
||||
var message = a.decrypt(enc); |
|
||||
var messagebuf = AES.words2buf(message); |
|
||||
return messagebuf; |
|
||||
}; |
|
||||
|
|
||||
AES.buf2words = function(buf) { |
|
||||
if (buf.length % 4) |
|
||||
throw new Error('buf length must be a multiple of 4'); |
|
||||
|
|
||||
var words = []; |
|
||||
|
|
||||
for (var i = 0; i < buf.length / 4; i++) { |
|
||||
words.push(buf.readUInt32BE(i * 4)); |
|
||||
}; |
|
||||
|
|
||||
return words; |
|
||||
}; |
|
||||
|
|
||||
AES.words2buf = function(words) { |
|
||||
var buf = new Buffer(words.length * 4); |
|
||||
|
|
||||
for (var i = 0; i < words.length; i++) { |
|
||||
buf.writeUInt32BE(words[i], i * 4); |
|
||||
}; |
|
||||
|
|
||||
return buf; |
|
||||
}; |
|
||||
|
|
||||
module.exports = AES; |
|
||||
@ -1,34 +0,0 @@ |
|||||
var AES = require('./aes'); |
|
||||
var CBC = require('./cbc'); |
|
||||
var Random = require('../random'); |
|
||||
var Hash = require('../hash'); |
|
||||
|
|
||||
// Symmetric encryption with AES and CBC convenience class
|
|
||||
var AESCBC = function AESCBC() { |
|
||||
}; |
|
||||
|
|
||||
AESCBC.encrypt = function(messagebuf, passwordstr) { |
|
||||
var cipherkeybuf = Hash.sha256(new Buffer(passwordstr)); |
|
||||
return AESCBC.encryptCipherkey(messagebuf, cipherkeybuf); |
|
||||
}; |
|
||||
|
|
||||
AESCBC.decrypt = function(encbuf, passwordstr) { |
|
||||
var cipherkeybuf = Hash.sha256(new Buffer(passwordstr)); |
|
||||
return AESCBC.decryptCipherkey(encbuf, cipherkeybuf); |
|
||||
}; |
|
||||
|
|
||||
AESCBC.encryptCipherkey = function(messagebuf, cipherkeybuf, ivbuf) { |
|
||||
ivbuf = ivbuf || Random.getRandomBuffer(128 / 8); |
|
||||
var ctbuf = CBC.encrypt(messagebuf, ivbuf, AES, cipherkeybuf); |
|
||||
var encbuf = Buffer.concat([ivbuf, ctbuf]); |
|
||||
return encbuf; |
|
||||
}; |
|
||||
|
|
||||
AESCBC.decryptCipherkey = function(encbuf, cipherkeybuf) { |
|
||||
var ivbuf = encbuf.slice(0, 128 / 8); |
|
||||
var ctbuf = encbuf.slice(128 / 8); |
|
||||
var messagebuf = CBC.decrypt(ctbuf, ivbuf, AES, cipherkeybuf); |
|
||||
return messagebuf; |
|
||||
}; |
|
||||
|
|
||||
module.exports = AESCBC; |
|
||||
@ -1,138 +0,0 @@ |
|||||
var Random = require('../random'); |
|
||||
|
|
||||
// Cipher Block Chaining
|
|
||||
// http://en.wikipedia.org/wiki/Block_cipher_mode_of_operation#Cipher-block_chaining_.28CBC.29
|
|
||||
var CBC = function CBC(blockcipher, cipherkeybuf, ivbuf) { |
|
||||
if (!(this instanceof CBC)) |
|
||||
return new CBC(blockcipher, cipherkeybuf, ivbuf); |
|
||||
|
|
||||
this.blockcipher = blockcipher; |
|
||||
this.cipherkeybuf = cipherkeybuf; |
|
||||
this.ivbuf = ivbuf; |
|
||||
}; |
|
||||
|
|
||||
CBC.buf2blockbufs = function(buf, blocksize) { |
|
||||
var bytesize = blocksize / 8; |
|
||||
var blockbufs = []; |
|
||||
|
|
||||
for (var i = 0; i <= buf.length / bytesize; i++) { |
|
||||
var blockbuf = buf.slice(i * bytesize, i * bytesize + bytesize); |
|
||||
|
|
||||
if (blockbuf.length < blocksize) |
|
||||
blockbuf = CBC.pkcs7pad(blockbuf, blocksize); |
|
||||
|
|
||||
blockbufs.push(blockbuf); |
|
||||
} |
|
||||
|
|
||||
return blockbufs; |
|
||||
}; |
|
||||
|
|
||||
CBC.blockbufs2buf = function(blockbufs, blocksize) { |
|
||||
var bytesize = blocksize / 8; |
|
||||
|
|
||||
var last = blockbufs[blockbufs.length - 1]; |
|
||||
last = CBC.pkcs7unpad(last); |
|
||||
blockbufs[blockbufs.length - 1] = last; |
|
||||
|
|
||||
var buf = Buffer.concat(blockbufs); |
|
||||
|
|
||||
return buf; |
|
||||
}; |
|
||||
|
|
||||
CBC.encrypt = function(messagebuf, ivbuf, blockcipher, cipherkeybuf) { |
|
||||
var blocksize = ivbuf.length * 8; |
|
||||
var blockbufs = CBC.buf2blockbufs(messagebuf, blocksize); |
|
||||
var encbufs = CBC.encryptblocks(blockbufs, ivbuf, blockcipher, cipherkeybuf); |
|
||||
var encbuf = Buffer.concat(encbufs); |
|
||||
return encbuf; |
|
||||
}; |
|
||||
|
|
||||
CBC.decrypt = function(encbuf, ivbuf, blockcipher, cipherkeybuf) { |
|
||||
var blocksize = ivbuf.length * 8; |
|
||||
var bytesize = ivbuf.length; |
|
||||
var encbufs = []; |
|
||||
for (var i = 0; i < encbuf.length / bytesize; i++) { |
|
||||
encbufs.push(encbuf.slice(i * bytesize, i * bytesize + bytesize)); |
|
||||
} |
|
||||
var blockbufs = CBC.decryptblocks(encbufs, ivbuf, blockcipher, cipherkeybuf); |
|
||||
var buf = CBC.blockbufs2buf(blockbufs, blocksize); |
|
||||
return buf; |
|
||||
}; |
|
||||
|
|
||||
CBC.encryptblock = function(blockbuf, ivbuf, blockcipher, cipherkeybuf) { |
|
||||
var xorbuf = CBC.xorbufs(blockbuf, ivbuf); |
|
||||
var encbuf = blockcipher.encrypt(xorbuf, cipherkeybuf); |
|
||||
return encbuf; |
|
||||
}; |
|
||||
|
|
||||
CBC.decryptblock = function(encbuf, ivbuf, blockcipher, cipherkeybuf) { |
|
||||
var xorbuf = blockcipher.decrypt(encbuf, cipherkeybuf); |
|
||||
var blockbuf = CBC.xorbufs(xorbuf, ivbuf); |
|
||||
return blockbuf; |
|
||||
}; |
|
||||
|
|
||||
CBC.encryptblocks = function(blockbufs, ivbuf, blockcipher, cipherkeybuf) { |
|
||||
var encbufs = []; |
|
||||
|
|
||||
for (var i = 0; i < blockbufs.length; i++) { |
|
||||
var blockbuf = blockbufs[i]; |
|
||||
var encbuf = CBC.encryptblock(blockbuf, ivbuf, blockcipher, cipherkeybuf); |
|
||||
|
|
||||
encbufs.push(encbuf); |
|
||||
|
|
||||
ivbuf = encbuf; |
|
||||
} |
|
||||
|
|
||||
return encbufs; |
|
||||
}; |
|
||||
|
|
||||
CBC.decryptblocks = function(encbufs, ivbuf, blockcipher, cipherkeybuf) { |
|
||||
var blockbufs = []; |
|
||||
|
|
||||
for (var i = 0; i < encbufs.length; i++) { |
|
||||
var encbuf = encbufs[i]; |
|
||||
var blockbuf = CBC.decryptblock(encbuf, ivbuf, blockcipher, cipherkeybuf); |
|
||||
|
|
||||
blockbufs.push(blockbuf); |
|
||||
|
|
||||
ivbuf = encbuf; |
|
||||
} |
|
||||
|
|
||||
return blockbufs; |
|
||||
}; |
|
||||
|
|
||||
CBC.pkcs7pad = function(buf, blocksize) { |
|
||||
var bytesize = blocksize / 8; |
|
||||
var padbytesize = bytesize - buf.length; |
|
||||
var pad = new Buffer(padbytesize); |
|
||||
pad.fill(padbytesize); |
|
||||
var paddedbuf = Buffer.concat([buf, pad]); |
|
||||
return paddedbuf; |
|
||||
}; |
|
||||
|
|
||||
CBC.pkcs7unpad = function(paddedbuf, blocksize) { |
|
||||
var bytesize = blocksize / 8; |
|
||||
var padbytesize = bytesize - paddedbuf.length; |
|
||||
var padlength = paddedbuf[paddedbuf.length - 1]; |
|
||||
var padbuf = paddedbuf.slice(paddedbuf.length - padlength, paddedbuf.length); |
|
||||
var padbuf2 = new Buffer(padlength); |
|
||||
padbuf2.fill(padlength); |
|
||||
if (padbuf.toString('hex') !== padbuf2.toString('hex')) |
|
||||
throw new Error('invalid padding'); |
|
||||
return paddedbuf.slice(0, paddedbuf.length - padlength); |
|
||||
}; |
|
||||
|
|
||||
CBC.xorbufs = function(buf1, buf2) { |
|
||||
if (buf1.length !== buf2.length) |
|
||||
throw new Error('bufs must have the same length'); |
|
||||
|
|
||||
var buf = new Buffer(buf1.length); |
|
||||
|
|
||||
for (var i = 0; i < buf1.length; i++) { |
|
||||
buf[i] = buf1[i] ^ buf2[i]; |
|
||||
} |
|
||||
|
|
||||
return buf; |
|
||||
}; |
|
||||
|
|
||||
module.exports = CBC; |
|
||||
@ -1,55 +0,0 @@ |
|||||
var AESCBC = require('./aescbc'); |
|
||||
var Keypair = require('../keypair'); |
|
||||
var Point = require('../point'); |
|
||||
var Hash = require('../hash'); |
|
||||
var Pubkey = require('../pubkey'); |
|
||||
var Privkey = require('../privkey'); |
|
||||
|
|
||||
// http://en.wikipedia.org/wiki/Integrated_Encryption_Scheme
|
|
||||
var ECIES = function ECIES() { |
|
||||
if (!(this instanceof ECIES)) |
|
||||
return new ECIES(); |
|
||||
}; |
|
||||
|
|
||||
ECIES.encrypt = function(messagebuf, topubkey, fromkeypair, ivbuf) { |
|
||||
if (!fromkeypair) |
|
||||
fromkeypair = Keypair().fromRandom(); |
|
||||
var r = fromkeypair.privkey.bn; |
|
||||
var R = fromkeypair.pubkey.point; |
|
||||
var Rpubkey = fromkeypair.pubkey; |
|
||||
var Rbuf = Rpubkey.toDER(true); |
|
||||
var KB = topubkey.point; |
|
||||
var P = KB.mul(r); |
|
||||
var S = P.getX(); |
|
||||
var Sbuf = S.toBuffer({size: 32}); |
|
||||
var kEkM = Hash.sha512(Sbuf); |
|
||||
var kE = kEkM.slice(0, 32); |
|
||||
var kM = kEkM.slice(32, 64); |
|
||||
var c = AESCBC.encryptCipherkey(messagebuf, kE, ivbuf); |
|
||||
var d = Hash.sha256hmac(c, kM); |
|
||||
var encbuf = Buffer.concat([Rbuf, c, d]); |
|
||||
return encbuf; |
|
||||
}; |
|
||||
|
|
||||
ECIES.decrypt = function(encbuf, toprivkey) { |
|
||||
var kB = toprivkey.bn; |
|
||||
var frompubkey = Pubkey().fromDER(encbuf.slice(0, 33)); |
|
||||
var R = frompubkey.point; |
|
||||
var P = R.mul(kB); |
|
||||
if (P.eq(new Point())) |
|
||||
throw new Error('P equals 0'); |
|
||||
var S = P.getX(); |
|
||||
var Sbuf = S.toBuffer({size: 32}); |
|
||||
var kEkM = Hash.sha512(Sbuf); |
|
||||
var kE = kEkM.slice(0, 32); |
|
||||
var kM = kEkM.slice(32, 64); |
|
||||
var c = encbuf.slice(33, encbuf.length - 32); |
|
||||
var d = encbuf.slice(encbuf.length - 32, encbuf.length); |
|
||||
var d2 = Hash.sha256hmac(c, kM); |
|
||||
if (d.toString('hex') !== d2.toString('hex')) |
|
||||
throw new Error('Invalid checksum'); |
|
||||
var messagebuf = AESCBC.decryptCipherkey(c, kE); |
|
||||
return messagebuf; |
|
||||
}; |
|
||||
|
|
||||
module.exports = ECIES; |
|
||||
@ -1,127 +0,0 @@ |
|||||
var Stealthkey = require('./stealthkey'); |
|
||||
var Base58check = require('../base58check'); |
|
||||
var Pubkey = require('../pubkey'); |
|
||||
var KDF = require('../kdf'); |
|
||||
var BufferWriter = require('../bufferwriter'); |
|
||||
var BufferReader = require('../bufferreader'); |
|
||||
|
|
||||
var StealthAddress = function StealthAddress(addrstr) { |
|
||||
if (!(this instanceof StealthAddress)) |
|
||||
return new StealthAddress(addrstr); |
|
||||
|
|
||||
if (typeof addrstr === 'string') { |
|
||||
this.fromString(addrstr) |
|
||||
} |
|
||||
else if (Buffer.isBuffer(addrstr)) { |
|
||||
var buf = addrstr; |
|
||||
this.fromBuffer(buf); |
|
||||
} |
|
||||
else if (addrstr) { |
|
||||
var obj = addrstr; |
|
||||
this.set(obj); |
|
||||
} |
|
||||
}; |
|
||||
|
|
||||
StealthAddress.mainver = 42; |
|
||||
StealthAddress.testver = 43; |
|
||||
|
|
||||
StealthAddress.prototype.set = function(obj) { |
|
||||
this.payloadPubkey = obj.payloadPubkey || this.payloadPubkey; |
|
||||
this.scanPubkey = obj.scanPubkey || this.scanPubkey; |
|
||||
return this; |
|
||||
}; |
|
||||
|
|
||||
StealthAddress.prototype.fromJSON = function(json) { |
|
||||
this.fromString(json); |
|
||||
return this; |
|
||||
}; |
|
||||
|
|
||||
StealthAddress.prototype.toJSON = function() { |
|
||||
return this.toString(); |
|
||||
}; |
|
||||
|
|
||||
StealthAddress.prototype.fromStealthkey = function(stealthkey) { |
|
||||
this.set({ |
|
||||
payloadPubkey: stealthkey.payloadKeypair.pubkey, |
|
||||
scanPubkey: stealthkey.scanKeypair.pubkey |
|
||||
}); |
|
||||
return this; |
|
||||
}; |
|
||||
|
|
||||
StealthAddress.prototype.fromBuffer = function(buf) { |
|
||||
var parsed = StealthAddress.parseDWBuffer(buf); |
|
||||
if ((parsed.version !== StealthAddress.mainver) && (parsed.version !== StealthAddress.testver)) |
|
||||
throw new Error('Invalid version'); |
|
||||
if (parsed.options !== 0) |
|
||||
throw new Error('Invalid options'); |
|
||||
if (!parsed.scanPubkey) |
|
||||
throw new Error('Invalid scanPubkey'); |
|
||||
if (parsed.payloadPubkeys.length !== 1) |
|
||||
throw new Error('Must have exactly one payloadPubkey'); |
|
||||
if (parsed.nSigs !== 1) |
|
||||
throw new Error('Must require exactly one signature'); |
|
||||
if (parsed.prefix.toString() !== "") |
|
||||
throw new Error('Only blank prefixes supported'); |
|
||||
this.scanPubkey = parsed.scanPubkey; |
|
||||
this.payloadPubkey = parsed.payloadPubkeys[0]; |
|
||||
return this; |
|
||||
}; |
|
||||
|
|
||||
StealthAddress.prototype.fromString = function(str) { |
|
||||
return this.fromBuffer(Base58check(str).toBuffer()); |
|
||||
}; |
|
||||
|
|
||||
StealthAddress.prototype.getSharedKeypair = function(senderKeypair) { |
|
||||
var sharedSecretPoint = this.scanPubkey.point.mul(senderKeypair.privkey.bn); |
|
||||
var sharedSecretPubkey = Pubkey(sharedSecretPoint); |
|
||||
var buf = sharedSecretPubkey.toDER(true); |
|
||||
var sharedKeypair = KDF.sha256hmac2keypair(buf); |
|
||||
|
|
||||
return sharedKeypair; |
|
||||
}; |
|
||||
|
|
||||
StealthAddress.prototype.getReceivePubkey = function(senderKeypair) { |
|
||||
var sharedKeypair = this.getSharedKeypair(senderKeypair); |
|
||||
var pubkey = Pubkey(this.payloadPubkey.point.add(sharedKeypair.pubkey.point)); |
|
||||
|
|
||||
return pubkey; |
|
||||
}; |
|
||||
|
|
||||
StealthAddress.prototype.toBuffer = function(networkstr) { |
|
||||
if (networkstr === 'testnet') |
|
||||
var version = StealthAddress.testver; |
|
||||
else |
|
||||
var version = StealthAddress.mainver; |
|
||||
var bw = new BufferWriter(); |
|
||||
bw.writeUInt8(version); |
|
||||
bw.writeUInt8(0); //options
|
|
||||
bw.write(this.scanPubkey.toDER(true)); |
|
||||
bw.writeUInt8(1); //number of payload keys - we only support 1 (not multisig)
|
|
||||
bw.write(this.payloadPubkey.toDER(true)); |
|
||||
bw.writeUInt8(1); //number of signatures - we only support 1 (not multisig)
|
|
||||
bw.writeUInt8(0); //prefix length - we do not support prefix yet
|
|
||||
var buf = bw.concat(); |
|
||||
return buf; |
|
||||
}; |
|
||||
|
|
||||
StealthAddress.prototype.toString = function(networkstr) { |
|
||||
return Base58check(this.toBuffer(networkstr)).toString(); |
|
||||
}; |
|
||||
|
|
||||
StealthAddress.parseDWBuffer = function(buf) { |
|
||||
var br = new BufferReader(buf); |
|
||||
var parsed = {}; |
|
||||
parsed.version = br.readUInt8(); |
|
||||
parsed.options = br.readUInt8(); |
|
||||
parsed.scanPubkey = Pubkey().fromBuffer(br.read(33)); |
|
||||
parsed.nPayloadPubkeys = br.readUInt8(); |
|
||||
parsed.payloadPubkeys = []; |
|
||||
for (var i = 0; i < parsed.nPayloadPubkeys; i++) |
|
||||
parsed.payloadPubkeys.push(Pubkey().fromBuffer(br.read(33))); |
|
||||
parsed.nSigs = br.readUInt8(); |
|
||||
parsed.nPrefix = br.readUInt8(); |
|
||||
parsed.prefix = br.read(parsed.nPrefix / 8); |
|
||||
return parsed; |
|
||||
}; |
|
||||
|
|
||||
module.exports = StealthAddress; |
|
||||
@ -1,88 +0,0 @@ |
|||||
var Keypair = require('../keypair'); |
|
||||
var Privkey = require('../privkey'); |
|
||||
var Pubkey = require('../pubkey'); |
|
||||
var Point = require('../point'); |
|
||||
var Hash = require('../hash'); |
|
||||
var KDF = require('../kdf'); |
|
||||
|
|
||||
var Stealthkey = function Stealthkey(payloadKeypair, scanKeypair) { |
|
||||
if (!(this instanceof Stealthkey)) |
|
||||
return new Stealthkey(payloadKeypair, scanKeypair); |
|
||||
|
|
||||
if (payloadKeypair instanceof Keypair) { |
|
||||
this.set({ |
|
||||
payloadKeypair: payloadKeypair, |
|
||||
scanKeypair: scanKeypair |
|
||||
}); |
|
||||
} |
|
||||
else if (payloadKeypair) { |
|
||||
var obj = payloadKeypair; |
|
||||
this.set(obj); |
|
||||
} |
|
||||
}; |
|
||||
|
|
||||
Stealthkey.prototype.set = function(obj) { |
|
||||
this.payloadKeypair = obj.payloadKeypair || this.payloadKeypair; |
|
||||
this.scanKeypair = obj.scanKeypair || this.scanKeypair; |
|
||||
return this; |
|
||||
}; |
|
||||
|
|
||||
Stealthkey.prototype.fromJSON = function(json) { |
|
||||
this.set({ |
|
||||
payloadKeypair: Keypair().fromJSON(json.payloadKeypair), |
|
||||
scanKeypair: Keypair().fromJSON(json.scanKeypair) |
|
||||
}); |
|
||||
return this; |
|
||||
}; |
|
||||
|
|
||||
Stealthkey.prototype.toJSON = function() { |
|
||||
return { |
|
||||
payloadKeypair: this.payloadKeypair.toJSON(), |
|
||||
scanKeypair: this.scanKeypair.toJSON() |
|
||||
}; |
|
||||
}; |
|
||||
|
|
||||
Stealthkey.prototype.fromRandom = function() { |
|
||||
this.payloadKeypair = Keypair().fromRandom(); |
|
||||
this.scanKeypair = Keypair().fromRandom(); |
|
||||
|
|
||||
return this; |
|
||||
}; |
|
||||
|
|
||||
Stealthkey.prototype.getSharedKeypair = function(senderPubkey) { |
|
||||
var sharedSecretPoint = senderPubkey.point.mul(this.scanKeypair.privkey.bn); |
|
||||
var sharedSecretPubkey = Pubkey({point: sharedSecretPoint}); |
|
||||
var buf = sharedSecretPubkey.toDER(true); |
|
||||
var sharedKeypair = KDF.sha256hmac2keypair(buf); |
|
||||
|
|
||||
return sharedKeypair; |
|
||||
}; |
|
||||
|
|
||||
Stealthkey.prototype.getReceivePubkey = function(senderPubkey) { |
|
||||
var sharedKeypair = this.getSharedKeypair(senderPubkey); |
|
||||
var pubkey = Pubkey({point: this.payloadKeypair.pubkey.point.add(sharedKeypair.pubkey.point)}); |
|
||||
|
|
||||
return pubkey; |
|
||||
}; |
|
||||
|
|
||||
Stealthkey.prototype.getReceiveKeypair = function(senderPubkey) { |
|
||||
var sharedKeypair = this.getSharedKeypair(senderPubkey); |
|
||||
var privkey = Privkey({bn: this.payloadKeypair.privkey.bn.add(sharedKeypair.privkey.bn).mod(Point.getN())}); |
|
||||
var key = Keypair({privkey: privkey}); |
|
||||
key.privkey2pubkey(); |
|
||||
|
|
||||
return key; |
|
||||
}; |
|
||||
|
|
||||
Stealthkey.prototype.isForMe = function(senderPubkey, myPossiblePubkeyhashbuf) { |
|
||||
var pubkey = this.getReceivePubkey(senderPubkey); |
|
||||
var pubkeybuf = pubkey.toDER(true); |
|
||||
var pubkeyhash = Hash.sha256ripemd160(pubkeybuf); |
|
||||
|
|
||||
if (pubkeyhash.toString('hex') === myPossiblePubkeyhashbuf.toString('hex')) |
|
||||
return true; |
|
||||
else |
|
||||
return false; |
|
||||
}; |
|
||||
|
|
||||
module.exports = Stealthkey; |
|
||||
@ -1,85 +0,0 @@ |
|||||
var Stealthkey = require('./stealthkey'); |
|
||||
var StealthAddress = require('./stealthaddress'); |
|
||||
var ECIES = require('./ecies'); |
|
||||
var Message = require('../message'); |
|
||||
var Keypair = require('../keypair'); |
|
||||
var Address = require('../address'); |
|
||||
var Pubkey = require('../pubkey'); |
|
||||
|
|
||||
var StealthMessage = function StealthMessage(obj) { |
|
||||
if (!(this instanceof StealthMessage)) |
|
||||
return new StealthMessage(obj); |
|
||||
if (obj) |
|
||||
this.set(obj); |
|
||||
}; |
|
||||
|
|
||||
StealthMessage.prototype.set = function(obj) { |
|
||||
this.messagebuf = obj.messagebuf || this.messagebuf; |
|
||||
this.encbuf = obj.encbuf || this.encbuf; |
|
||||
this.toStealthAddress = obj.toStealthAddress || this.toStealthAddress; |
|
||||
this.toStealthkey = obj.toStealthkey || this.toStealthkey; |
|
||||
this.fromKeypair = obj.fromKeypair || this.fromKeypair; |
|
||||
this.receiveAddress = obj.receiveAddress || this.receiveAddress; |
|
||||
return this; |
|
||||
}; |
|
||||
|
|
||||
StealthMessage.encrypt = function(messagebuf, toStealthAddress, fromKeypair, ivbuf) { |
|
||||
var sm = StealthMessage().set({ |
|
||||
messagebuf: messagebuf, |
|
||||
toStealthAddress: toStealthAddress, |
|
||||
fromKeypair: fromKeypair |
|
||||
}); |
|
||||
sm.encrypt(ivbuf); |
|
||||
var buf = Buffer.concat([ |
|
||||
sm.receiveAddress.hashbuf, |
|
||||
sm.fromKeypair.pubkey.toDER(true), |
|
||||
sm.encbuf |
|
||||
]); |
|
||||
return buf; |
|
||||
}; |
|
||||
|
|
||||
StealthMessage.decrypt = function(buf, toStealthkey) { |
|
||||
var sm = StealthMessage().set({ |
|
||||
toStealthkey: toStealthkey, |
|
||||
receiveAddress: Address().set({hashbuf: buf.slice(0, 20)}), |
|
||||
fromKeypair: Keypair().set({pubkey: Pubkey().fromDER(buf.slice(20, 20 + 33))}), |
|
||||
encbuf: buf.slice(20 + 33) |
|
||||
}); |
|
||||
return sm.decrypt().messagebuf; |
|
||||
}; |
|
||||
|
|
||||
StealthMessage.isForMe = function(buf, toStealthkey) { |
|
||||
var sm = StealthMessage().set({ |
|
||||
toStealthkey: toStealthkey, |
|
||||
receiveAddress: Address().set({hashbuf: buf.slice(0, 20)}), |
|
||||
fromKeypair: Keypair().set({pubkey: Pubkey().fromDER(buf.slice(20, 20 + 33))}), |
|
||||
encbuf: buf.slice(20 + 33) |
|
||||
}); |
|
||||
return sm.isForMe(); |
|
||||
}; |
|
||||
|
|
||||
StealthMessage.prototype.encrypt = function(ivbuf) { |
|
||||
if (!this.fromKeypair) |
|
||||
this.fromKeypair = Keypair().fromRandom(); |
|
||||
var receivePubkey = this.toStealthAddress.getReceivePubkey(this.fromKeypair); |
|
||||
this.receiveAddress = Address().fromPubkey(receivePubkey); |
|
||||
this.encbuf = ECIES.encrypt(this.messagebuf, receivePubkey, this.fromKeypair, ivbuf); |
|
||||
return this; |
|
||||
}; |
|
||||
|
|
||||
StealthMessage.prototype.decrypt = function() { |
|
||||
var receiveKeypair = this.toStealthkey.getReceiveKeypair(this.fromKeypair.pubkey); |
|
||||
this.messagebuf = ECIES.decrypt(this.encbuf, receiveKeypair.privkey); |
|
||||
return this; |
|
||||
}; |
|
||||
|
|
||||
StealthMessage.prototype.isForMe = function() { |
|
||||
var receivePubkey = this.toStealthkey.getReceivePubkey(this.fromKeypair.pubkey); |
|
||||
var receiveAddress = Address().fromPubkey(receivePubkey); |
|
||||
if (receiveAddress.toString('hex') === this.receiveAddress.toString('hex')) |
|
||||
return true; |
|
||||
else |
|
||||
return false; |
|
||||
}; |
|
||||
|
|
||||
module.exports = StealthMessage; |
|
||||
@ -1,69 +0,0 @@ |
|||||
var StealthAddress = require('./stealthaddress'); |
|
||||
var StealthKey = require('./stealthkey'); |
|
||||
var Transaction = require('../transaction'); |
|
||||
var Pubkey = require('../pubkey'); |
|
||||
|
|
||||
var StealthTx = function StealthTx(tx, sa, sk) { |
|
||||
if (!(this instanceof StealthTx)) |
|
||||
return new StealthTx(tx, sa, sk); |
|
||||
if (tx instanceof Transaction) { |
|
||||
this.tx = tx; |
|
||||
this.sa = sa; |
|
||||
this.sk = sk; |
|
||||
} else if (tx) { |
|
||||
var obj = tx; |
|
||||
this.set(obj); |
|
||||
} |
|
||||
}; |
|
||||
|
|
||||
StealthTx.prototype.set = function(obj) { |
|
||||
this.sk = obj.sk || this.sk; |
|
||||
this.sa = obj.sa || this.sa; |
|
||||
this.tx = obj.tx || this.tx; |
|
||||
return this; |
|
||||
}; |
|
||||
|
|
||||
StealthTx.prototype.isForMe = function() { |
|
||||
if (!this.notMine()) |
|
||||
return true; |
|
||||
else |
|
||||
return false; |
|
||||
}; |
|
||||
|
|
||||
StealthTx.prototype.notMine = function() { |
|
||||
var err; |
|
||||
if (err = this.notStealth()) |
|
||||
return "Not stealth: " + err; |
|
||||
var txopbuf = this.tx.txouts[0].script.chunks[1].buf; |
|
||||
var parsed = StealthTx.parseOpReturnData(txopbuf); |
|
||||
var pubkey = parsed.pubkey; |
|
||||
var pubkeyhashbuf = this.tx.txouts[1].script.chunks[2].buf; |
|
||||
var sk = this.sk; |
|
||||
if (sk.isForMe(pubkey, pubkeyhashbuf)) { |
|
||||
return false; |
|
||||
} else { |
|
||||
return "StealthTx not mine"; |
|
||||
} |
|
||||
}; |
|
||||
|
|
||||
//For now, we only support a very limited variety of stealth tx
|
|
||||
StealthTx.prototype.notStealth = function() { |
|
||||
var txouts = this.tx.txouts; |
|
||||
if (!(txouts.length >= 2)) |
|
||||
return "Not enough txouts"; |
|
||||
if (!txouts[0].script.isOpReturn()) |
|
||||
return "First txout is not OP_RETURN"; |
|
||||
if (!txouts[1].script.isPubkeyhashOut()) |
|
||||
return "Second txout is not pubkeyhash"; |
|
||||
return false; |
|
||||
}; |
|
||||
|
|
||||
StealthTx.parseOpReturnData = function(buf) { |
|
||||
var parsed = {}; |
|
||||
parsed.version = buf[0]; |
|
||||
parsed.noncebuf = buf.slice(1, 5); |
|
||||
parsed.pubkey = Pubkey().fromBuffer(buf.slice(5, 5 + 33)); |
|
||||
return parsed; |
|
||||
}; |
|
||||
|
|
||||
module.exports = StealthTx; |
|
||||
@ -1,117 +0,0 @@ |
|||||
var base58check = require('./base58check'); |
|
||||
var constants = require('./constants'); |
|
||||
var Hash = require('./hash'); |
|
||||
|
|
||||
function Identity(buf) { |
|
||||
// TODO: instantiate identities without providing any configuration
|
|
||||
if (!(this instanceof Identity)) return new Identity(buf); |
|
||||
|
|
||||
if (Buffer.isBuffer(buf)) { |
|
||||
this.fromBuffer(buf); |
|
||||
} else if (typeof buf === 'string') { |
|
||||
var str = buf; |
|
||||
this.fromString(str); |
|
||||
} else if (buf) { |
|
||||
var obj = buf; |
|
||||
this.set(obj); |
|
||||
} |
|
||||
}; |
|
||||
|
|
||||
Identity.prototype.set = function(obj) { |
|
||||
this.hashbuf = obj.hashbuf || this.hashbuf || null; |
|
||||
this.networkstr = obj.networkstr || this.networkstr || 'ephemeral'; |
|
||||
this.typestr = obj.typestr || this.typestr || 'identity'; |
|
||||
return this; |
|
||||
}; |
|
||||
|
|
||||
Identity.prototype.fromBuffer = function(buf) { |
|
||||
// Identities are prefix + type + key
|
|
||||
if (buf.length !== 1 + 1 + 20) |
|
||||
throw new Error('Identity buffers must be exactly 22 bytes (was '+buf.length+')'); |
|
||||
|
|
||||
var prefix = buf[0]; |
|
||||
var version = buf[1]; |
|
||||
|
|
||||
if (version === constants['ephemeral']['identity']) { |
|
||||
this.networkstr = 'ephemeral'; |
|
||||
this.typestr = 'identity'; |
|
||||
} else if (version === constants['mainnet']['identity']) { |
|
||||
this.networkstr = 'mainnet'; |
|
||||
this.typestr = 'identity'; |
|
||||
} else if (version === constants['testnet']['identity']) { |
|
||||
this.networkstr = 'testnet'; |
|
||||
this.typestr = 'identity'; |
|
||||
} else { |
|
||||
this.networkstr = 'unknown'; |
|
||||
this.typestr = 'unknown'; |
|
||||
} |
|
||||
|
|
||||
if (prefix !== constants['ephemeral']['prefix']) |
|
||||
throw new Error('Identity buffers must contain an identity prefix ('+constants['ephemeral']['prefix']+', was '+ prefix.toString() + ')'); |
|
||||
|
|
||||
this.hashbuf = buf.slice( 2 ); |
|
||||
|
|
||||
return this; |
|
||||
}; |
|
||||
|
|
||||
Identity.prototype.fromHashbuf = function(hashbuf, networkstr, typestr) { |
|
||||
if (hashbuf.length !== 20) |
|
||||
throw new Error('hashbuf must be exactly 20 bytes'); |
|
||||
this.hashbuf = hashbuf; |
|
||||
this.networkstr = networkstr || 'ephemeral'; |
|
||||
this.typestr = typestr || 'identity'; |
|
||||
return this; |
|
||||
}; |
|
||||
|
|
||||
Identity.prototype.fromPubkey = function(pubkey, networkstr) { |
|
||||
this.hashbuf = Hash.sha256ripemd160( pubkey.toBuffer() ); |
|
||||
this.networkstr = networkstr || 'ephemeral'; |
|
||||
this.typestr = 'identity'; |
|
||||
return this; |
|
||||
}; |
|
||||
|
|
||||
Identity.prototype.fromString = function(str) { |
|
||||
var buf = base58check.decode(str); |
|
||||
return this.fromBuffer(buf); |
|
||||
} |
|
||||
|
|
||||
Identity.isValid = function(addrstr) { |
|
||||
try { |
|
||||
var address = new Identity().fromString( addrstr ); |
|
||||
} catch (e) { |
|
||||
return false; |
|
||||
} |
|
||||
return address.isValid(); |
|
||||
}; |
|
||||
|
|
||||
Identity.prototype.isValid = function() { |
|
||||
try { |
|
||||
this.validate(); |
|
||||
return true; |
|
||||
} catch (e) { |
|
||||
return false; |
|
||||
} |
|
||||
}; |
|
||||
|
|
||||
Identity.prototype.toBuffer = function() { |
|
||||
var prefix = new Buffer([ constants[ this.networkstr ][ 'prefix' ] ]) |
|
||||
var version = new Buffer([ constants[ this.networkstr ][ this.typestr ] ]);; |
|
||||
var buf = Buffer.concat([ prefix , version, this.hashbuf ]); |
|
||||
return buf; |
|
||||
}; |
|
||||
|
|
||||
Identity.prototype.toString = function() { |
|
||||
return base58check.encode( this.toBuffer() ); |
|
||||
}; |
|
||||
|
|
||||
Identity.prototype.validate = function() { |
|
||||
if (!Buffer.isBuffer(this.hashbuf) || this.hashbuf.length !== 20) |
|
||||
throw new Error('hash must be a buffer of 20 bytes'); |
|
||||
if (['ephemeral', 'mainnet', 'testnet'].indexOf( this.networkstr )) |
|
||||
throw new Error('networkstr must be "ephemeral", "mainnet", or "testnet"'); |
|
||||
if (this.typestr !== 'identity') |
|
||||
throw new Error('typestr must be "identity"'); |
|
||||
return this; |
|
||||
}; |
|
||||
|
|
||||
module.exports = Identity; |
|
||||
@ -1,31 +0,0 @@ |
|||||
var Bn = require('./bn'); |
|
||||
var Privkey = require('./privkey'); |
|
||||
var Point = require('./point'); |
|
||||
var Keypair = require('./keypair'); |
|
||||
var Hash = require('./hash'); |
|
||||
|
|
||||
function KDF() { |
|
||||
}; |
|
||||
|
|
||||
KDF.buf2keypair = function(buf) { |
|
||||
return KDF.sha256hmac2keypair(buf); |
|
||||
}; |
|
||||
|
|
||||
KDF.sha256hmac2keypair = function(buf) { |
|
||||
var privkey = KDF.sha256hmac2privkey(buf); |
|
||||
var keypair = Keypair().fromPrivkey(privkey); |
|
||||
return keypair; |
|
||||
}; |
|
||||
|
|
||||
KDF.sha256hmac2privkey = function(buf) { |
|
||||
var bn; |
|
||||
var concat = new Buffer([]); |
|
||||
do { |
|
||||
var hash = Hash.sha256hmac(buf, concat); |
|
||||
var bn = Bn.fromBuffer(hash); |
|
||||
concat = Buffer.concat([concat, new Buffer(0)]); |
|
||||
} while(!bn.lt(Point.getN())); |
|
||||
return new Privkey({bn: bn}); |
|
||||
}; |
|
||||
|
|
||||
module.exports = KDF; |
|
||||
@ -1,92 +0,0 @@ |
|||||
var ECDSA = require('./ecdsa'); |
|
||||
var Keypair = require('./keypair'); |
|
||||
var BufferWriter = require('./bufferwriter'); |
|
||||
var Hash = require('./hash'); |
|
||||
var Address = require('./address'); |
|
||||
var Signature = require('./signature'); |
|
||||
|
|
||||
var Message = function Message(obj) { |
|
||||
if (!(this instanceof Message)) |
|
||||
return new Message(obj); |
|
||||
if (obj) |
|
||||
this.set(obj); |
|
||||
}; |
|
||||
|
|
||||
Message.prototype.set = function(obj) { |
|
||||
this.messagebuf = obj.messagebuf || this.messagebuf; |
|
||||
this.keypair = obj.keypair || this.keypair; |
|
||||
this.sig = obj.sig || this.sig; |
|
||||
this.address = obj.address || this.address; |
|
||||
this.verified = typeof obj.verified !== 'undefined' ? obj.verified : this.verified; |
|
||||
return this; |
|
||||
}; |
|
||||
|
|
||||
Message.magicBytes = new Buffer('Bitcoin Signed Message:\n'); |
|
||||
|
|
||||
Message.magicHash = function(messagebuf) { |
|
||||
if (!Buffer.isBuffer(messagebuf)) |
|
||||
throw new Error('messagebuf must be a buffer'); |
|
||||
var bw = new BufferWriter(); |
|
||||
bw.writeVarintNum(Message.magicBytes.length); |
|
||||
bw.write(Message.magicBytes); |
|
||||
bw.writeVarintNum(messagebuf.length); |
|
||||
bw.write(messagebuf); |
|
||||
var buf = bw.concat(); |
|
||||
|
|
||||
var hashbuf = Hash.sha256sha256(buf); |
|
||||
|
|
||||
return hashbuf; |
|
||||
}; |
|
||||
|
|
||||
Message.sign = function(messagebuf, keypair) { |
|
||||
var m = Message({messagebuf: messagebuf, keypair: keypair}); |
|
||||
m.sign(); |
|
||||
var sigbuf = m.sig.toCompact(); |
|
||||
var sigstr = sigbuf.toString('base64'); |
|
||||
return sigstr; |
|
||||
}; |
|
||||
|
|
||||
Message.verify = function(messagebuf, sigstr, address) { |
|
||||
var sigbuf = new Buffer(sigstr, 'base64'); |
|
||||
var message = new Message(); |
|
||||
message.messagebuf = messagebuf; |
|
||||
message.sig = Signature().fromCompact(sigbuf); |
|
||||
message.address = address; |
|
||||
|
|
||||
return message.verify().verified; |
|
||||
}; |
|
||||
|
|
||||
Message.prototype.sign = function() { |
|
||||
var hashbuf = Message.magicHash(this.messagebuf); |
|
||||
var ecdsa = ECDSA({hashbuf: hashbuf, keypair: this.keypair}); |
|
||||
ecdsa.signRandomK(); |
|
||||
ecdsa.calci(); |
|
||||
this.sig = ecdsa.sig; |
|
||||
return this; |
|
||||
}; |
|
||||
|
|
||||
Message.prototype.verify = function() { |
|
||||
var hashbuf = Message.magicHash(this.messagebuf); |
|
||||
|
|
||||
var ecdsa = new ECDSA(); |
|
||||
ecdsa.hashbuf = hashbuf; |
|
||||
ecdsa.sig = this.sig; |
|
||||
ecdsa.keypair = new Keypair(); |
|
||||
ecdsa.keypair.pubkey = ecdsa.sig2pubkey(); |
|
||||
|
|
||||
if (!ecdsa.verify()) { |
|
||||
this.verified = false; |
|
||||
return this; |
|
||||
} |
|
||||
|
|
||||
var address = Address().fromPubkey(ecdsa.keypair.pubkey, undefined, this.sig.compressed); |
|
||||
//TODO: what if livenet/testnet mismatch?
|
|
||||
if (address.hashbuf.toString('hex') === this.address.hashbuf.toString('hex')) |
|
||||
this.verified = true; |
|
||||
else |
|
||||
this.verified = false; |
|
||||
|
|
||||
return this; |
|
||||
}; |
|
||||
|
|
||||
module.exports = Message; |
|
||||
@ -1,3 +1,5 @@ |
|||||
|
'use strict'; |
||||
|
|
||||
var bs58 = require('bs58'); |
var bs58 = require('bs58'); |
||||
|
|
||||
var Base58 = function Base58(obj) { |
var Base58 = function Base58(obj) { |
||||
@ -1,5 +1,7 @@ |
|||||
|
'use strict'; |
||||
|
|
||||
var base58 = require('./base58'); |
var base58 = require('./base58'); |
||||
var sha256sha256 = require('./hash').sha256sha256; |
var sha256sha256 = require('../crypto/hash').sha256sha256; |
||||
|
|
||||
var Base58Check = function Base58Check(obj) { |
var Base58Check = function Base58Check(obj) { |
||||
if (!(this instanceof Base58Check)) |
if (!(this instanceof Base58Check)) |
||||
@ -1,4 +1,6 @@ |
|||||
var BN = require('./bn'); |
'use strict'; |
||||
|
|
||||
|
var BN = require('../crypto/bn'); |
||||
|
|
||||
var BufferReader = function BufferReader(buf) { |
var BufferReader = function BufferReader(buf) { |
||||
if (!(this instanceof BufferReader)) |
if (!(this instanceof BufferReader)) |
||||
@ -1,4 +1,4 @@ |
|||||
var BN = require('./bn'); |
'use strict'; |
||||
|
|
||||
var BufferWriter = function BufferWriter(obj) { |
var BufferWriter = function BufferWriter(obj) { |
||||
if (!(this instanceof BufferWriter)) |
if (!(this instanceof BufferWriter)) |
||||
@ -1,6 +1,8 @@ |
|||||
|
'use strict'; |
||||
|
|
||||
var BufferWriter = require('./bufferwriter'); |
var BufferWriter = require('./bufferwriter'); |
||||
var BufferReader = require('./bufferreader'); |
var BufferReader = require('./bufferreader'); |
||||
var BN = require('./bn'); |
var BN = require('../crypto/bn'); |
||||
|
|
||||
var Varint = function Varint(buf) { |
var Varint = function Varint(buf) { |
||||
if (!(this instanceof Varint)) |
if (!(this instanceof Varint)) |
||||
@ -1,85 +0,0 @@ |
|||||
var should = require('chai').should(); |
|
||||
var Hash = require('../lib/hash'); |
|
||||
var AES = require('../lib/expmt/aes'); |
|
||||
|
|
||||
describe('AES', function() { |
|
||||
var m128 = Hash.sha256(new Buffer('test1')).slice(0, 128 / 8); |
|
||||
|
|
||||
var k128 = Hash.sha256(new Buffer('test2')).slice(0, 128 / 8); |
|
||||
var k192 = Hash.sha256(new Buffer('test2')).slice(0, 192 / 8); |
|
||||
var k256 = Hash.sha256(new Buffer('test2')).slice(0, 256 / 8); |
|
||||
|
|
||||
var e128 = new Buffer('3477e13884125038f4dc24e9d2cfbbc7', 'hex'); |
|
||||
var e192 = new Buffer('b670954c0e2da1aaa5f9063de04eb961', 'hex'); |
|
||||
var e256 = new Buffer('dd2ce24581183a4a7c0b1068f8bc79f0', 'hex'); |
|
||||
|
|
||||
|
|
||||
describe('@encrypt', function() { |
|
||||
|
|
||||
it('should encrypt with a 128 bit key', function() { |
|
||||
var encbuf = AES.encrypt(m128, k128); |
|
||||
encbuf.toString('hex').should.equal(e128.toString('hex')); |
|
||||
}); |
|
||||
|
|
||||
it('should encrypt with a 192 bit key', function() { |
|
||||
var encbuf = AES.encrypt(m128, k192); |
|
||||
encbuf.toString('hex').should.equal(e192.toString('hex')); |
|
||||
}); |
|
||||
|
|
||||
it('should encrypt with a 256 bit key', function() { |
|
||||
var encbuf = AES.encrypt(m128, k256); |
|
||||
encbuf.toString('hex').should.equal(e256.toString('hex')); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@decrypt', function() { |
|
||||
|
|
||||
it('should encrypt/decrypt with a 128 bit key', function() { |
|
||||
var encbuf = AES.encrypt(m128, k128); |
|
||||
var m = AES.decrypt(encbuf, k128); |
|
||||
m.toString('hex').should.equal(m128.toString('hex')); |
|
||||
}); |
|
||||
|
|
||||
it('should encrypt/decrypt with a 192 bit key', function() { |
|
||||
var encbuf = AES.encrypt(m128, k192); |
|
||||
var m = AES.decrypt(encbuf, k192); |
|
||||
m.toString('hex').should.equal(m128.toString('hex')); |
|
||||
}); |
|
||||
|
|
||||
it('should encrypt/decrypt with a 256 bit key', function() { |
|
||||
var encbuf = AES.encrypt(m128, k256); |
|
||||
var m = AES.decrypt(encbuf, k256); |
|
||||
m.toString('hex').should.equal(m128.toString('hex')); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@buf2words', function() { |
|
||||
|
|
||||
it('should convert this 4 length buffer into an array', function() { |
|
||||
var buf = new Buffer([0, 0, 0, 0]); |
|
||||
var words = AES.buf2words(buf); |
|
||||
words.length.should.equal(1); |
|
||||
}); |
|
||||
|
|
||||
it('should throw an error on this 5 length buffer', function() { |
|
||||
var buf = new Buffer([0, 0, 0, 0, 0]); |
|
||||
(function() { |
|
||||
var words = AES.buf2words(buf); |
|
||||
}).should.throw(); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@words2buf', function() { |
|
||||
|
|
||||
it('should convert this array into a buffer', function() { |
|
||||
var a = [100, 0]; |
|
||||
var buf = AES.words2buf(a); |
|
||||
buf.length.should.equal(8); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
@ -1,73 +0,0 @@ |
|||||
var should = require('chai').should(); |
|
||||
var AESCBC = require('../lib/expmt/aescbc'); |
|
||||
|
|
||||
describe('AESCBC', function() { |
|
||||
|
|
||||
describe('@encrypt', function() { |
|
||||
|
|
||||
it('should return encrypt one block', function() { |
|
||||
var password = "password"; |
|
||||
var messagebuf = new Buffer(128 / 8 - 1); |
|
||||
messagebuf.fill(0); |
|
||||
var encbuf = AESCBC.encrypt(messagebuf, password); |
|
||||
encbuf.length.should.equal(128 / 8 + 128 / 8); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@decrypt', function() { |
|
||||
|
|
||||
it('should decrypt that which was encrypted', function() { |
|
||||
var password = "password"; |
|
||||
var messagebuf = new Buffer(128 / 8 - 1); |
|
||||
messagebuf.fill(0); |
|
||||
var encbuf = AESCBC.encrypt(messagebuf, password); |
|
||||
var messagebuf2 = AESCBC.decrypt(encbuf, password); |
|
||||
messagebuf2.toString('hex').should.equal(messagebuf.toString('hex')); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@encryptCipherkey', function() { |
|
||||
|
|
||||
it('should return encrypt one block', function() { |
|
||||
var cipherkeybuf = new Buffer(256 / 8); |
|
||||
cipherkeybuf.fill(0x10); |
|
||||
var ivbuf = new Buffer(128 / 8); |
|
||||
ivbuf.fill(0); |
|
||||
var messagebuf = new Buffer(128 / 8 - 1); |
|
||||
messagebuf.fill(0); |
|
||||
var encbuf = AESCBC.encryptCipherkey(messagebuf, cipherkeybuf, ivbuf); |
|
||||
encbuf.length.should.equal(128 / 8 + 128 / 8); |
|
||||
}); |
|
||||
|
|
||||
it('should return encrypt two blocks', function() { |
|
||||
var cipherkeybuf = new Buffer(256 / 8); |
|
||||
cipherkeybuf.fill(0x10); |
|
||||
var ivbuf = new Buffer(128 / 8); |
|
||||
ivbuf.fill(0); |
|
||||
var messagebuf = new Buffer(128 / 8); |
|
||||
messagebuf.fill(0); |
|
||||
var encbuf = AESCBC.encryptCipherkey(messagebuf, cipherkeybuf, ivbuf); |
|
||||
encbuf.length.should.equal(128 / 8 + 128 / 8 + 128 / 8); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@decryptCipherkey', function() { |
|
||||
|
|
||||
it('should decrypt that which was encrypted', function() { |
|
||||
var cipherkeybuf = new Buffer(256 / 8); |
|
||||
cipherkeybuf.fill(0x10); |
|
||||
var ivbuf = new Buffer(128 / 8); |
|
||||
ivbuf.fill(0); |
|
||||
var messagebuf = new Buffer(128 / 8); |
|
||||
messagebuf.fill(0); |
|
||||
var encbuf = AESCBC.encryptCipherkey(messagebuf, cipherkeybuf, ivbuf); |
|
||||
var messagebuf2 = AESCBC.decryptCipherkey(encbuf, cipherkeybuf); |
|
||||
messagebuf2.toString('hex').should.equal(messagebuf.toString('hex')); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
@ -1,317 +0,0 @@ |
|||||
var AES = require('../lib/expmt/aes'); |
|
||||
var should = require('chai').should(); |
|
||||
var CBC = require('../lib/expmt/cbc'); |
|
||||
|
|
||||
describe('CBC', function() { |
|
||||
|
|
||||
it('should return a new CBC', function() { |
|
||||
var cbc = new CBC(); |
|
||||
should.exist(cbc); |
|
||||
}) |
|
||||
|
|
||||
it('should return a new CBC when called without "new"', function() { |
|
||||
var cbc = new CBC(); |
|
||||
should.exist(cbc); |
|
||||
}); |
|
||||
|
|
||||
describe('@buf2blockbufs', function() { |
|
||||
|
|
||||
it('should convert this buffer into one block', function() { |
|
||||
var buf = new Buffer(16 - 1); |
|
||||
buf.fill(0); |
|
||||
var blockbufs = CBC.buf2blockbufs(buf, 16 * 8); |
|
||||
blockbufs.length.should.equal(1); |
|
||||
blockbufs[0].toString('hex').should.equal('00000000000000000000000000000001'); |
|
||||
}); |
|
||||
|
|
||||
it('should convert this buffer into two blocks', function() { |
|
||||
var buf = new Buffer(16); |
|
||||
buf.fill(0); |
|
||||
var blockbufs = CBC.buf2blockbufs(buf, 16 * 8); |
|
||||
blockbufs.length.should.equal(2); |
|
||||
blockbufs[0].toString('hex').should.equal('00000000000000000000000000000000'); |
|
||||
blockbufs[1].toString('hex').should.equal('10101010101010101010101010101010'); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@buf2blockbufs', function() { |
|
||||
|
|
||||
it('should convert this buffer into one block and back into the same buffer', function() { |
|
||||
var buf = new Buffer(16 - 1); |
|
||||
buf.fill(0); |
|
||||
var blockbufs = CBC.buf2blockbufs(buf, 16 * 8); |
|
||||
var buf2 = CBC.blockbufs2buf(blockbufs, 16 * 8); |
|
||||
buf2.toString('hex').should.equal(buf.toString('hex')); |
|
||||
}); |
|
||||
|
|
||||
it('should convert this buffer into two blocks and back into the same buffer', function() { |
|
||||
var buf = new Buffer(16); |
|
||||
buf.fill(0); |
|
||||
var blockbufs = CBC.buf2blockbufs(buf, 16 * 8); |
|
||||
var buf2 = CBC.blockbufs2buf(blockbufs, 16 * 8); |
|
||||
buf2.toString('hex').should.equal(buf.toString('hex')); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@encrypt', function() { |
|
||||
|
|
||||
it('should return this known value', function() { |
|
||||
var messagebuf1 = new Buffer(128 / 8); |
|
||||
messagebuf1.fill(0); |
|
||||
var messagebuf2 = new Buffer(128 / 8); |
|
||||
messagebuf2.fill(0x10); |
|
||||
var messagebuf = Buffer.concat([messagebuf1, messagebuf2]); |
|
||||
var ivbuf = new Buffer(128 / 8); |
|
||||
ivbuf.fill(0x10); |
|
||||
var cipherkeybuf = new Buffer(128 / 8); |
|
||||
cipherkeybuf.fill(0); |
|
||||
var blockcipher = {}; |
|
||||
blockcipher.encrypt = function(messagebuf, cipherkeybuf) { |
|
||||
return messagebuf; |
|
||||
}; |
|
||||
blockcipher.decrypt = function(messagebuf, cipherkeybuf) { |
|
||||
return messagebuf; |
|
||||
}; |
|
||||
var encbuf = CBC.encrypt(messagebuf, ivbuf, blockcipher, cipherkeybuf); |
|
||||
var buf2 = CBC.decrypt(encbuf, ivbuf, blockcipher, cipherkeybuf); |
|
||||
}); |
|
||||
|
|
||||
it('should return this shorter known value', function() { |
|
||||
var messagebuf1 = new Buffer(128 / 8); |
|
||||
messagebuf1.fill(0); |
|
||||
var messagebuf2 = new Buffer(120 / 8); |
|
||||
messagebuf2.fill(0x10); |
|
||||
var messagebuf = Buffer.concat([messagebuf1, messagebuf2]); |
|
||||
var ivbuf = new Buffer(128 / 8); |
|
||||
ivbuf.fill(0x10); |
|
||||
var cipherkeybuf = new Buffer(128 / 8); |
|
||||
cipherkeybuf.fill(0); |
|
||||
var blockcipher = {}; |
|
||||
blockcipher.encrypt = function(messagebuf, cipherkeybuf) { |
|
||||
return messagebuf; |
|
||||
}; |
|
||||
blockcipher.decrypt = function(messagebuf, cipherkeybuf) { |
|
||||
return messagebuf; |
|
||||
}; |
|
||||
var encbuf = CBC.encrypt(messagebuf, ivbuf, blockcipher, cipherkeybuf); |
|
||||
var buf2 = CBC.decrypt(encbuf, ivbuf, blockcipher, cipherkeybuf); |
|
||||
}); |
|
||||
|
|
||||
it('should return this shorter known value', function() { |
|
||||
var messagebuf1 = new Buffer(128 / 8); |
|
||||
messagebuf1.fill(0); |
|
||||
var messagebuf2 = new Buffer(136 / 8); |
|
||||
messagebuf2.fill(0x10); |
|
||||
var messagebuf = Buffer.concat([messagebuf1, messagebuf2]); |
|
||||
var ivbuf = new Buffer(128 / 8); |
|
||||
ivbuf.fill(0x10); |
|
||||
var cipherkeybuf = new Buffer(128 / 8); |
|
||||
cipherkeybuf.fill(0); |
|
||||
var blockcipher = {}; |
|
||||
blockcipher.encrypt = function(messagebuf, cipherkeybuf) { |
|
||||
return messagebuf; |
|
||||
}; |
|
||||
blockcipher.decrypt = function(messagebuf, cipherkeybuf) { |
|
||||
return messagebuf; |
|
||||
}; |
|
||||
var encbuf = CBC.encrypt(messagebuf, ivbuf, blockcipher, cipherkeybuf); |
|
||||
var buf2 = CBC.decrypt(encbuf, ivbuf, blockcipher, cipherkeybuf); |
|
||||
}); |
|
||||
|
|
||||
it('should encrypt something with AES', function() { |
|
||||
var messagebuf1 = new Buffer(128 / 8); |
|
||||
messagebuf1.fill(0); |
|
||||
var messagebuf2 = new Buffer(128 / 8); |
|
||||
messagebuf2.fill(0x10); |
|
||||
var messagebuf = Buffer.concat([messagebuf1, messagebuf2]); |
|
||||
var ivbuf = new Buffer(128 / 8); |
|
||||
ivbuf.fill(0x10); |
|
||||
var cipherkeybuf = new Buffer(128 / 8); |
|
||||
cipherkeybuf.fill(0); |
|
||||
var blockcipher = AES; |
|
||||
var encbuf = CBC.encrypt(messagebuf, ivbuf, blockcipher, cipherkeybuf); |
|
||||
var buf2 = CBC.decrypt(encbuf, ivbuf, blockcipher, cipherkeybuf); |
|
||||
buf2.toString('hex').should.equal(messagebuf.toString('hex')); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@decrypt', function() { |
|
||||
|
|
||||
it('should properly decrypt an encrypted message', function() { |
|
||||
var messagebuf1 = new Buffer(128 / 8); |
|
||||
messagebuf1.fill(0); |
|
||||
var messagebuf2 = new Buffer(128 / 8); |
|
||||
messagebuf2.fill(0x10); |
|
||||
var messagebuf = Buffer.concat([messagebuf1, messagebuf2]); |
|
||||
var ivbuf = new Buffer(128 / 8); |
|
||||
ivbuf.fill(0x10); |
|
||||
var cipherkeybuf = new Buffer(128 / 8); |
|
||||
cipherkeybuf.fill(0); |
|
||||
var blockcipher = {}; |
|
||||
blockcipher.encrypt = function(messagebuf, cipherkeybuf) { |
|
||||
return messagebuf; |
|
||||
}; |
|
||||
blockcipher.decrypt = function(messagebuf, cipherkeybuf) { |
|
||||
return messagebuf; |
|
||||
}; |
|
||||
var encbuf = CBC.encrypt(messagebuf, ivbuf, blockcipher, cipherkeybuf); |
|
||||
var messagebuf2 = CBC.decrypt(encbuf, ivbuf, blockcipher, cipherkeybuf); |
|
||||
messagebuf2.toString('hex').should.equal(messagebuf.toString('hex')); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@encryptblock', function() { |
|
||||
|
|
||||
it('should return this known value', function() { |
|
||||
var messagebuf = new Buffer(128 / 8); |
|
||||
messagebuf.fill(0); |
|
||||
var ivbuf = new Buffer(128 / 8); |
|
||||
ivbuf.fill(0x10); |
|
||||
var cipherkeybuf = new Buffer(128 / 8); |
|
||||
cipherkeybuf.fill(0); |
|
||||
var blockcipher = {}; |
|
||||
blockcipher.encrypt = function(messagebuf, cipherkeybuf) { |
|
||||
return messagebuf; |
|
||||
}; |
|
||||
var enc = CBC.encryptblock(messagebuf, ivbuf, blockcipher, cipherkeybuf); |
|
||||
enc.toString('hex').should.equal(ivbuf.toString('hex')); |
|
||||
}); |
|
||||
|
|
||||
it('should return this other known value', function() { |
|
||||
var messagebuf = new Buffer(128 / 8); |
|
||||
messagebuf.fill(0x10); |
|
||||
var ivbuf = new Buffer(128 / 8); |
|
||||
ivbuf.fill(0x10); |
|
||||
var cipherkeybuf = new Buffer(128 / 8); |
|
||||
cipherkeybuf.fill(0); |
|
||||
var blockcipher = {}; |
|
||||
blockcipher.encrypt = function(messagebuf, cipherkeybuf) { |
|
||||
return messagebuf; |
|
||||
}; |
|
||||
var enc = CBC.encryptblock(messagebuf, ivbuf, blockcipher, cipherkeybuf); |
|
||||
enc.toString('hex').should.equal('00000000000000000000000000000000'); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@decryptblock', function() { |
|
||||
|
|
||||
it('should decrypt an encrypted block', function() { |
|
||||
var messagebuf = new Buffer(128 / 8); |
|
||||
messagebuf.fill(0); |
|
||||
var ivbuf = new Buffer(128 / 8); |
|
||||
ivbuf.fill(0x10); |
|
||||
var cipherkeybuf = new Buffer(128 / 8); |
|
||||
cipherkeybuf.fill(0); |
|
||||
var blockcipher = {}; |
|
||||
blockcipher.encrypt = function(messagebuf, cipherkeybuf) { |
|
||||
return messagebuf; |
|
||||
}; |
|
||||
blockcipher.decrypt = function(messagebuf, cipherkeybuf) { |
|
||||
return messagebuf; |
|
||||
}; |
|
||||
var encbuf = CBC.encryptblock(messagebuf, ivbuf, blockcipher, cipherkeybuf); |
|
||||
var buf = CBC.decryptblock(encbuf, ivbuf, blockcipher, cipherkeybuf); |
|
||||
buf.toString('hex').should.equal(messagebuf.toString('hex')); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@encryptblocks', function() { |
|
||||
|
|
||||
it('should return this known value', function() { |
|
||||
var messagebuf1 = new Buffer(128 / 8); |
|
||||
messagebuf1.fill(0); |
|
||||
var messagebuf2 = new Buffer(128 / 8); |
|
||||
messagebuf2.fill(0x10); |
|
||||
var ivbuf = new Buffer(128 / 8); |
|
||||
ivbuf.fill(0x10); |
|
||||
var cipherkeybuf = new Buffer(128 / 8); |
|
||||
cipherkeybuf.fill(0); |
|
||||
var blockcipher = {} |
|
||||
blockcipher.encrypt = function(messagebuf, cipherkeybuf) { |
|
||||
return messagebuf; |
|
||||
}; |
|
||||
var encbufs = CBC.encryptblocks([messagebuf1, messagebuf2], ivbuf, blockcipher, cipherkeybuf); |
|
||||
encbufs[0].toString('hex').should.equal('10101010101010101010101010101010'); |
|
||||
encbufs[1].toString('hex').should.equal('00000000000000000000000000000000'); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@decryptblocks', function() { |
|
||||
|
|
||||
it('should decrypt encrypted blocks', function() { |
|
||||
var messagebuf1 = new Buffer(128 / 8); |
|
||||
messagebuf1.fill(0); |
|
||||
var messagebuf2 = new Buffer(128 / 8); |
|
||||
messagebuf2.fill(0x10); |
|
||||
var ivbuf = new Buffer(128 / 8); |
|
||||
ivbuf.fill(0x10); |
|
||||
var cipherkeybuf = new Buffer(128 / 8); |
|
||||
cipherkeybuf.fill(0); |
|
||||
var blockcipher = {} |
|
||||
blockcipher.encrypt = function(messagebuf, cipherkeybuf) { |
|
||||
return messagebuf; |
|
||||
}; |
|
||||
blockcipher.decrypt = function(messagebuf, cipherkeybuf) { |
|
||||
return messagebuf; |
|
||||
}; |
|
||||
var encbufs = CBC.encryptblocks([messagebuf1, messagebuf2], ivbuf, blockcipher, cipherkeybuf); |
|
||||
var bufs = CBC.decryptblocks(encbufs, ivbuf, blockcipher, cipherkeybuf); |
|
||||
bufs[0].toString('hex').should.equal(messagebuf1.toString('hex')); |
|
||||
bufs[1].toString('hex').should.equal(messagebuf2.toString('hex')); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@pkcs7pad', function() { |
|
||||
|
|
||||
it('should pad this 32 bit buffer to 128 bits with the number 128/8 - 32/8', function() { |
|
||||
var buf = new Buffer(32 / 8); |
|
||||
buf.fill(0); |
|
||||
var padbuf = CBC.pkcs7pad(buf, 128); |
|
||||
padbuf.length.should.equal(128 / 8); |
|
||||
padbuf[32 / 8].should.equal(128 / 8 - 32 / 8); |
|
||||
padbuf[32 / 8 + 1].should.equal(128 / 8 - 32 / 8); |
|
||||
// ...
|
|
||||
padbuf[32 / 8 + 128 / 8 - 32 / 8 - 1].should.equal(128 / 8 - 32 / 8); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@pkcs7unpad', function() { |
|
||||
|
|
||||
it('should unpad this padded 32 bit buffer', function() { |
|
||||
var buf = new Buffer(32 / 8); |
|
||||
buf.fill(0); |
|
||||
var paddedbuf = CBC.pkcs7pad(buf, 128); |
|
||||
var unpaddedbuf = CBC.pkcs7unpad(paddedbuf, 128); |
|
||||
unpaddedbuf.toString('hex').should.equal(buf.toString('hex')); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@xorbufs', function() { |
|
||||
|
|
||||
it('should xor 1 and 0', function() { |
|
||||
var buf1 = new Buffer([1]); |
|
||||
var buf2 = new Buffer([0]); |
|
||||
var buf = CBC.xorbufs(buf1, buf2); |
|
||||
buf[0].should.equal(1); |
|
||||
}); |
|
||||
|
|
||||
it('should xor 1 and 1', function() { |
|
||||
var buf1 = new Buffer([1]); |
|
||||
var buf2 = new Buffer([1]); |
|
||||
var buf = CBC.xorbufs(buf1, buf2); |
|
||||
buf[0].should.equal(0); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
@ -1,17 +1,21 @@ |
|||||
var ECDSA = require('../lib/ecdsa'); |
'use strict'; |
||||
var Hash = require('../lib/hash'); |
|
||||
var Keypair = require('../lib/keypair'); |
|
||||
var Privkey = require('../lib/privkey'); |
|
||||
var Pubkey = require('../lib/pubkey'); |
|
||||
var Signature = require('../lib/signature'); |
|
||||
var BN = require('../lib/bn'); |
|
||||
var point = require('../lib/point'); |
|
||||
var should = require('chai').should(); |
|
||||
|
|
||||
describe("ECDSA", function() { |
var should = require('chai').should(); |
||||
|
var bitcore = require('../..'); |
||||
|
var ECDSA = bitcore.ECDSA; |
||||
|
var Hash = bitcore.Hash; |
||||
|
var Keypair = bitcore.Keypair; |
||||
|
var Privkey = bitcore.Privkey; |
||||
|
var Pubkey = bitcore.Pubkey; |
||||
|
var Signature = bitcore.Signature; |
||||
|
var BN = bitcore.BN; |
||||
|
var point = bitcore.Point; |
||||
|
|
||||
|
describe('ECDSA', function() { |
||||
|
|
||||
it('should create a blank ecdsa', function() { |
it('should create a blank ecdsa', function() { |
||||
var ecdsa = new ECDSA(); |
var ecdsa = new ECDSA(); |
||||
|
should.exist(ecdsa); |
||||
}); |
}); |
||||
|
|
||||
var ecdsa = new ECDSA(); |
var ecdsa = new ECDSA(); |
||||
@ -1,9 +1,12 @@ |
|||||
var should = require('chai').should(); |
'use strict'; |
||||
var Hash = require('../lib/hash'); |
|
||||
|
require('chai').should(); |
||||
|
var bitcore = require('../..'); |
||||
|
var Hash = bitcore.Hash; |
||||
|
|
||||
describe('Hash', function() { |
describe('Hash', function() { |
||||
var buf = new Buffer([0, 1, 2, 3, 253, 254, 255]); |
var buf = new Buffer([0, 1, 2, 3, 253, 254, 255]); |
||||
var str = "test string"; |
var str = 'test string'; |
||||
|
|
||||
describe('#sha256', function() { |
describe('#sha256', function() { |
||||
|
|
||||
@ -1,6 +1,9 @@ |
|||||
|
'use strict'; |
||||
|
|
||||
var should = require('chai').should(); |
var should = require('chai').should(); |
||||
var point = require('../lib/point'); |
var bitcore = require('../..'); |
||||
var BN = require('../lib/bn'); |
var point = bitcore.Point; |
||||
|
var BN = bitcore.BN; |
||||
|
|
||||
describe('Point', function() { |
describe('Point', function() { |
||||
|
|
||||
@ -1,52 +0,0 @@ |
|||||
var ECIES = require('../lib/expmt/ecies'); |
|
||||
var should = require('chai').should(); |
|
||||
var Keypair = require('../lib/keypair'); |
|
||||
var Hash = require('../lib/hash'); |
|
||||
|
|
||||
describe('#ECIES', function() { |
|
||||
|
|
||||
it('should make a new ECIES object', function() { |
|
||||
var ecies = new ECIES(); |
|
||||
should.exist(ecies); |
|
||||
}); |
|
||||
|
|
||||
it('should make a new ECIES object when called without "new"', function() { |
|
||||
var ecies = ECIES(); |
|
||||
should.exist(ecies); |
|
||||
}); |
|
||||
|
|
||||
var fromkey = Keypair().fromRandom(); |
|
||||
var tokey = Keypair().fromRandom(); |
|
||||
var messagebuf = Hash.sha256(new Buffer('my message is the hash of this string')); |
|
||||
|
|
||||
describe('@encrypt', function() { |
|
||||
|
|
||||
it('should return a buffer', function() { |
|
||||
var encbuf = ECIES.encrypt(messagebuf, tokey.pubkey, fromkey); |
|
||||
Buffer.isBuffer(encbuf).should.equal(true); |
|
||||
}); |
|
||||
|
|
||||
it('should return a buffer if fromkey is not present', function() { |
|
||||
var encbuf = ECIES.encrypt(messagebuf, tokey.pubkey); |
|
||||
Buffer.isBuffer(encbuf).should.equal(true); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@decrypt', function() { |
|
||||
|
|
||||
it('should decrypt that which was encrypted', function() { |
|
||||
var encbuf = ECIES.encrypt(messagebuf, tokey.pubkey, fromkey); |
|
||||
var messagebuf2 = ECIES.decrypt(encbuf, tokey.privkey); |
|
||||
messagebuf2.toString('hex').should.equal(messagebuf.toString('hex')); |
|
||||
}); |
|
||||
|
|
||||
it('should decrypt that which was encrypted if fromkeypair was randomly generated', function() { |
|
||||
var encbuf = ECIES.encrypt(messagebuf, tokey.pubkey); |
|
||||
var messagebuf2 = ECIES.decrypt(encbuf, tokey.privkey); |
|
||||
messagebuf2.toString('hex').should.equal(messagebuf.toString('hex')); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
@ -1,171 +0,0 @@ |
|||||
var should = require('chai').should(); |
|
||||
var constants = require('../lib/constants'); |
|
||||
var PubKey = require('../lib/pubkey'); |
|
||||
var Identity = require('../lib/identity'); |
|
||||
|
|
||||
describe('Identity', function() { |
|
||||
|
|
||||
var knownPrivKey = 'L3e3ZneXzGw2wyyRoUxKGGrHCBhBE3uPMvQDXPaJTom4d4ogRxvC'; |
|
||||
var knownPubKey = '02ff0c643214634691e6f1c5044df79f7002c404407c8db1897484017e1082f182'; |
|
||||
var knownPubKeyHash = 'bceb8b52237d7a6c09e9aaedcf26cf387530d23e'; |
|
||||
var knownIdent = 'TfEmMAA5PSQRRJgiZka8y6B5x1pABHe6BVv'; |
|
||||
var knownIdentComp = 'TfDBCwB4ciatE4Kx3r1TK5kfCTxrrpG1H8J'; |
|
||||
|
|
||||
var pubkeyhash = new Buffer( knownPubKeyHash , 'hex'); |
|
||||
|
|
||||
//var buf = Buffer.concat([ new Buffer([0]), new Buffer([0]), pubkeyhash ]);
|
|
||||
// note: key is wrong string until I figure out how to duplicate the generation of short keys
|
|
||||
//var buf = Buffer.concat([ new Buffer( 0x0f ) , new Buffer( 0x02 ) , pubkeyhash ])
|
|
||||
var buf = Buffer.concat([ new Buffer([0x0f]) , new Buffer([0x02]) , pubkeyhash ]) |
|
||||
var str = knownIdent; |
|
||||
|
|
||||
it('should create a new identity object', function() { |
|
||||
var identity = new Identity(); |
|
||||
should.exist(identity); |
|
||||
identity = Identity(buf); |
|
||||
should.exist(identity); |
|
||||
identity = Identity(str); |
|
||||
should.exist(identity); |
|
||||
}); |
|
||||
|
|
||||
describe('@isValid', function() { |
|
||||
|
|
||||
it('should validate this valid identity string', function() { |
|
||||
Identity.isValid( str ).should.equal( true ); |
|
||||
}); |
|
||||
|
|
||||
it('should invalidate this valid identity string', function() { |
|
||||
Identity.isValid(str.substr(1)).should.equal(false); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#fromBuffer', function() { |
|
||||
|
|
||||
it('should make an identity from a buffer', function() { |
|
||||
Identity().fromBuffer(buf).toString().should.equal(str); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#fromHashbuf', function() { |
|
||||
|
|
||||
it('should make an identity from a hashbuf', function() { |
|
||||
Identity().fromHashbuf(pubkeyhash).toString().should.equal(str); |
|
||||
var a = Identity().fromHashbuf(pubkeyhash, 'testnet', 'scripthash'); |
|
||||
a.networkstr.should.equal('testnet'); |
|
||||
a.typestr.should.equal('scripthash'); |
|
||||
}); |
|
||||
|
|
||||
it('should throw an error for invalid length hashbuf', function() { |
|
||||
(function() { |
|
||||
Identity().fromHashbuf(buf); |
|
||||
}).should.throw('hashbuf must be exactly 20 bytes'); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#fromPubkey', function() { |
|
||||
|
|
||||
it('should make this identity from a compressed pubkey', function() { |
|
||||
var pubkey = new PubKey(); |
|
||||
pubkey.fromDER(new Buffer( knownPubKey , 'hex')); |
|
||||
var identity = new Identity(); |
|
||||
identity.fromPubkey(pubkey); |
|
||||
identity.toString().should.equal( knownIdent ); |
|
||||
}); |
|
||||
|
|
||||
it('should make this identity from an uncompressed pubkey', function() { |
|
||||
var pubkey = new PubKey(); |
|
||||
pubkey.fromDER(new Buffer( knownPubKey , 'hex')); |
|
||||
var identity = new Identity(); |
|
||||
pubkey.compressed = false; |
|
||||
identity.fromPubkey(pubkey, 'ephemeral'); |
|
||||
identity.toString().should.equal( knownIdentComp ); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#fromString', function() { |
|
||||
|
|
||||
it('should derive from this known ephemeral identity string', function() { |
|
||||
var identity = new Identity(); |
|
||||
identity.fromString( str ); |
|
||||
identity.toBuffer().slice(2).toString('hex').should.equal(pubkeyhash.toString('hex')); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#isValid', function() { |
|
||||
|
|
||||
it('should describe this valid identity as valid', function() { |
|
||||
var identity = new Identity(); |
|
||||
identity.fromString( knownIdent ); |
|
||||
identity.isValid().should.equal(true); |
|
||||
}); |
|
||||
|
|
||||
it('should describe this identity with unknown network as invalid', function() { |
|
||||
var identity = new Identity(); |
|
||||
identity.fromString( knownIdent ); |
|
||||
identity.networkstr = 'unknown'; |
|
||||
identity.isValid().should.equal(false); |
|
||||
}); |
|
||||
|
|
||||
it('should describe this identity with unknown type as invalid', function() { |
|
||||
var identity = new Identity(); |
|
||||
identity.fromString( knownIdent ); |
|
||||
identity.typestr = 'unknown'; |
|
||||
identity.isValid().should.equal(false); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#toBuffer', function() { |
|
||||
|
|
||||
it('should output this known hash', function() { |
|
||||
var identity = new Identity(); |
|
||||
identity.fromString(str); |
|
||||
identity.toBuffer().slice(2).toString('hex').should.equal(pubkeyhash.toString('hex')); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#toString', function() { |
|
||||
|
|
||||
it('should output the same thing that was input', function() { |
|
||||
var identity = new Identity(); |
|
||||
identity.fromString(str); |
|
||||
identity.toString().should.equal(str); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#validate', function() { |
|
||||
|
|
||||
it('should not throw an error on this valid identity', function() { |
|
||||
var identity = new Identity(); |
|
||||
identity.fromString(str); |
|
||||
should.exist(identity.validate()); |
|
||||
}); |
|
||||
|
|
||||
it('should throw an error on this invalid network', function() { |
|
||||
var identity = new Identity(); |
|
||||
identity.fromString(str); |
|
||||
identity.networkstr = 'unknown'; |
|
||||
(function() { |
|
||||
identity.validate(); |
|
||||
}).should.throw('networkstr must be "ephemeral", "mainnet", or "testnet"'); |
|
||||
}); |
|
||||
|
|
||||
it('should throw an error on this invalid type', function() { |
|
||||
var identity = new Identity(); |
|
||||
identity.fromString(str); |
|
||||
identity.typestr = 'unknown'; |
|
||||
(function() { |
|
||||
identity.validate(); |
|
||||
}).should.throw('typestr must be "identity"'); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
@ -1,39 +0,0 @@ |
|||||
var should = require('chai').should(); |
|
||||
var KDF = require('../lib/kdf'); |
|
||||
var Hash = require('../lib/hash'); |
|
||||
|
|
||||
describe('KDF', function() { |
|
||||
|
|
||||
describe('#buf2keypair', function() { |
|
||||
|
|
||||
it('should compute these known values', function() { |
|
||||
var buf = Hash.sha256(new Buffer('test')); |
|
||||
var keypair = KDF.buf2keypair(buf); |
|
||||
keypair.privkey.toString().should.equal('KxxVszVMFLGzmxpxR7sMSaWDmqMKLVhKebX5vZbGHyuR8spreQ7V'); |
|
||||
keypair.pubkey.toString().should.equal('03774f761ae89a0d2fda0d532bad62286ae8fcda9bc38c060036296085592a97c1'); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#sha256hmac2keypair', function() { |
|
||||
|
|
||||
it('should compute these known values', function() { |
|
||||
var buf = Hash.sha256(new Buffer('test')); |
|
||||
var keypair = KDF.sha256hmac2keypair(buf); |
|
||||
keypair.privkey.toString().should.equal('KxxVszVMFLGzmxpxR7sMSaWDmqMKLVhKebX5vZbGHyuR8spreQ7V'); |
|
||||
keypair.pubkey.toString().should.equal('03774f761ae89a0d2fda0d532bad62286ae8fcda9bc38c060036296085592a97c1'); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#sha256hmac2privkey', function() { |
|
||||
|
|
||||
it('should compute this known privkey', function() { |
|
||||
var buf = Hash.sha256(new Buffer('test')); |
|
||||
var privkey = KDF.sha256hmac2privkey(buf); |
|
||||
privkey.toString().should.equal('KxxVszVMFLGzmxpxR7sMSaWDmqMKLVhKebX5vZbGHyuR8spreQ7V'); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
@ -1,107 +0,0 @@ |
|||||
var Address = require('../lib/address'); |
|
||||
var Message = require('../lib/message'); |
|
||||
var Keypair = require('../lib/keypair'); |
|
||||
var should = require('chai').should(); |
|
||||
|
|
||||
describe('Message', function() { |
|
||||
|
|
||||
it('should make a new message', function() { |
|
||||
var message = new Message(); |
|
||||
should.exist(message); |
|
||||
}); |
|
||||
|
|
||||
it('should make a new message when called without "new"', function() { |
|
||||
var message = Message(); |
|
||||
should.exist(message); |
|
||||
}); |
|
||||
|
|
||||
describe('#set', function() { |
|
||||
|
|
||||
it('should set the messagebuf', function() { |
|
||||
var messagebuf = new Buffer('message'); |
|
||||
should.exist(Message().set({messagebuf: messagebuf}).messagebuf); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@sign', function() { |
|
||||
var messagebuf = new Buffer('this is my message'); |
|
||||
var keypair = Keypair().fromRandom(); |
|
||||
|
|
||||
it('should return a base64 string', function() { |
|
||||
var sigstr = Message.sign(messagebuf, keypair); |
|
||||
var sigbuf = new Buffer(sigstr, 'base64'); |
|
||||
sigbuf.length.should.equal(1 + 32 + 32); |
|
||||
}); |
|
||||
|
|
||||
it('should sign with a compressed pubkey', function() { |
|
||||
var keypair = Keypair().fromRandom(); |
|
||||
keypair.pubkey.compressed = true; |
|
||||
var sigstr = Message.sign(messagebuf, keypair); |
|
||||
var sigbuf = new Buffer(sigstr, 'base64'); |
|
||||
sigbuf[0].should.be.above(27 + 4 - 1); |
|
||||
sigbuf[0].should.be.below(27 + 4 + 4 - 1); |
|
||||
}); |
|
||||
|
|
||||
it('should sign with an uncompressed pubkey', function() { |
|
||||
var keypair = Keypair().fromRandom(); |
|
||||
keypair.pubkey.compressed = false; |
|
||||
var sigstr = Message.sign(messagebuf, keypair); |
|
||||
var sigbuf = new Buffer(sigstr, 'base64'); |
|
||||
sigbuf[0].should.be.above(27 - 1); |
|
||||
sigbuf[0].should.be.below(27 + 4 - 1); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@verify', function() { |
|
||||
var messagebuf = new Buffer('this is my message'); |
|
||||
var keypair = Keypair().fromRandom(); |
|
||||
|
|
||||
it('should verify a signed message', function() { |
|
||||
var sigstr = Message.sign(messagebuf, keypair); |
|
||||
var addr = Address().fromPubkey(keypair.pubkey); |
|
||||
Message.verify(messagebuf, sigstr, addr).should.equal(true); |
|
||||
}); |
|
||||
|
|
||||
it('should verify this known good signature', function() { |
|
||||
var addrstr = '1CKTmxj6DjGrGTfbZzVxnY4Besbv8oxSZb'; |
|
||||
var address = Address().fromString(addrstr); |
|
||||
var sigstr = 'IOrTlbNBI0QO990xOw4HAjnvRl/1zR+oBMS6HOjJgfJqXp/1EnFrcJly0UcNelqJNIAH4f0abxOZiSpYmenMH4M='; |
|
||||
Message.verify(messagebuf, sigstr, address); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#sign', function() { |
|
||||
var messagebuf = new Buffer('this is my message'); |
|
||||
var keypair = Keypair().fromRandom(); |
|
||||
|
|
||||
it('should sign a message', function() { |
|
||||
var message = new Message(); |
|
||||
message.messagebuf = messagebuf; |
|
||||
message.keypair = keypair; |
|
||||
message.sign(); |
|
||||
var sig = message.sig; |
|
||||
should.exist(sig); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#verify', function() { |
|
||||
var messagebuf = new Buffer('this is my message'); |
|
||||
var keypair = Keypair().fromRandom(); |
|
||||
|
|
||||
it('should verify a message that was just signed', function() { |
|
||||
var message = new Message(); |
|
||||
message.messagebuf = messagebuf; |
|
||||
message.keypair = keypair; |
|
||||
message.address = Address().fromPubkey(keypair.pubkey); |
|
||||
message.sign(); |
|
||||
message.verify(); |
|
||||
message.verified.should.equal(true); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
@ -1,10 +1,13 @@ |
|||||
|
'use strict'; |
||||
|
|
||||
var should = require('chai').should(); |
var should = require('chai').should(); |
||||
var Base58Check = require('../lib/base58check'); |
var bitcore = require('../..'); |
||||
var base58 = require('../lib/base58'); |
var Base58Check = bitcore.Base58Check; |
||||
|
var base58 = bitcore.Base58; |
||||
|
|
||||
describe('Base58Check', function() { |
describe('Base58Check', function() { |
||||
var buf = new Buffer([0, 1, 2, 3, 253, 254, 255]); |
var buf = new Buffer([0, 1, 2, 3, 253, 254, 255]); |
||||
var enc = "14HV44ipwoaqfg"; |
var enc = '14HV44ipwoaqfg'; |
||||
|
|
||||
it('should make an instance with "new"', function() { |
it('should make an instance with "new"', function() { |
||||
var b58 = new Base58Check(); |
var b58 = new Base58Check(); |
||||
@ -1,7 +1,10 @@ |
|||||
var BufferWriter = require('../lib/bufferwriter'); |
'use strict'; |
||||
var BufferReader = require('../lib/bufferreader'); |
|
||||
var should = require('chai').should(); |
var should = require('chai').should(); |
||||
var BN = require('../lib/bn'); |
var bitcore = require('../..'); |
||||
|
var BufferWriter = bitcore.BufferWriter; |
||||
|
var BufferReader = bitcore.BufferReader; |
||||
|
var BN = bitcore.BN; |
||||
|
|
||||
describe('BufferReader', function() { |
describe('BufferReader', function() { |
||||
|
|
||||
@ -0,0 +1,18 @@ |
|||||
|
'use strict'; |
||||
|
|
||||
|
var should = require('chai').should(); |
||||
|
var bitcore = require('../../'); |
||||
|
var constants = bitcore.Constants; |
||||
|
|
||||
|
describe('Constants', function() { |
||||
|
|
||||
|
it('should contain all constants for livenet and testnet', function() { |
||||
|
for (var key in constants.livenet) { |
||||
|
if (constants.livenet.hasOwnProperty(key)) { |
||||
|
constants.testnet.hasOwnProperty(key).should.equal(true); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
}); |
||||
|
|
||||
|
}); |
||||
@ -1,149 +0,0 @@ |
|||||
var StealthAddress = require('../lib/expmt/stealthaddress'); |
|
||||
var should = require('chai').should(); |
|
||||
var Stealthkey = require('../lib/expmt/stealthkey'); |
|
||||
var Keypair = require('../lib/keypair'); |
|
||||
var Privkey = require('../lib/privkey'); |
|
||||
var Pubkey = require('../lib/pubkey'); |
|
||||
var BN = require('../lib/bn'); |
|
||||
var Hash = require('../lib/hash'); |
|
||||
var Base58check = require('../lib/base58check'); |
|
||||
|
|
||||
describe('StealthAddress', function() { |
|
||||
|
|
||||
var stealthkey = Stealthkey(); |
|
||||
stealthkey.payloadKeypair = Keypair(); |
|
||||
stealthkey.payloadKeypair.privkey = Privkey(); |
|
||||
stealthkey.payloadKeypair.privkey.bn = BN().fromBuffer(Hash.sha256(new Buffer('test 1'))); |
|
||||
stealthkey.payloadKeypair.privkey2pubkey(); |
|
||||
stealthkey.scanKeypair = Keypair(); |
|
||||
stealthkey.scanKeypair.privkey = Privkey(); |
|
||||
stealthkey.scanKeypair.privkey.bn = BN().fromBuffer(Hash.sha256(new Buffer('test 2'))); |
|
||||
stealthkey.scanKeypair.privkey2pubkey(); |
|
||||
|
|
||||
var senderKeypair = Keypair(); |
|
||||
senderKeypair.privkey = Privkey(); |
|
||||
senderKeypair.privkey.bn = BN().fromBuffer(Hash.sha256(new Buffer('test 3'))); |
|
||||
senderKeypair.privkey2pubkey(); |
|
||||
|
|
||||
var addressString = 'vJmtuUb8ysKiM1HtHQF23FGfjGAKu5sM94UyyjknqhJHNdj5CZzwtpGzeyaATQ2HvuzomNVtiwsTJSWzzCBgCTtUZbRFpzKVq9MAUr'; |
|
||||
var dwhex = '2a0002697763d7e9becb0c180083738c32c05b0e2fee26d6278020c06bbb04d5f66b32010362408459041e0473298af3824dbabe4d2b7f846825ed4d1c2e2c670c07cb275d0100'; |
|
||||
var dwbuf = new Buffer(dwhex, 'hex'); |
|
||||
|
|
||||
it('should make a new stealth address', function() { |
|
||||
var sa = new StealthAddress(); |
|
||||
should.exist(sa); |
|
||||
sa = StealthAddress(); |
|
||||
should.exist(sa); |
|
||||
sa = StealthAddress(addressString); |
|
||||
should.exist(sa); |
|
||||
sa = StealthAddress(Base58check.decode(addressString)); |
|
||||
should.exist(sa); |
|
||||
}); |
|
||||
|
|
||||
describe('#fromJSON', function() { |
|
||||
|
|
||||
it('should give a stealthkey address with the right pubkeys', function() { |
|
||||
var sa = new StealthAddress(); |
|
||||
sa.fromJSON(addressString); |
|
||||
sa.payloadPubkey.toString().should.equal(stealthkey.payloadKeypair.pubkey.toString()); |
|
||||
sa.scanPubkey.toString().should.equal(stealthkey.scanKeypair.pubkey.toString()); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#toJSON', function() { |
|
||||
|
|
||||
it('should return this known address string', function() { |
|
||||
StealthAddress().fromJSON(addressString).toJSON().should.equal(addressString); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#fromBuffer', function() { |
|
||||
|
|
||||
it('should parse this DW buffer', function() { |
|
||||
StealthAddress().fromBuffer(new Buffer(dwhex, 'hex')).toBuffer().toString('hex').should.equal(dwhex); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#fromString', function() { |
|
||||
|
|
||||
it('should parse this DW buffer', function() { |
|
||||
StealthAddress().fromString(Base58check(new Buffer(dwhex, 'hex')).toString()).toBuffer().toString('hex').should.equal(dwhex); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#getSharedKeypair', function() { |
|
||||
|
|
||||
it('should return a key', function() { |
|
||||
var sa = new StealthAddress(); |
|
||||
sa.payloadPubkey = stealthkey.payloadKeypair.pubkey; |
|
||||
sa.scanPubkey = stealthkey.scanKeypair.pubkey; |
|
||||
var key = sa.getSharedKeypair(senderKeypair); |
|
||||
(key instanceof Keypair).should.equal(true); |
|
||||
}); |
|
||||
|
|
||||
it('should return the same key as Stealthkey.prototype.getSharedKeypair', function() { |
|
||||
var sa = new StealthAddress(); |
|
||||
sa.payloadPubkey = stealthkey.payloadKeypair.pubkey; |
|
||||
sa.scanPubkey = stealthkey.scanKeypair.pubkey; |
|
||||
var key = sa.getSharedKeypair(senderKeypair); |
|
||||
|
|
||||
var key2 = stealthkey.getSharedKeypair(senderKeypair.pubkey); |
|
||||
key.toString().should.equal(key2.toString()); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#getReceivePubkey', function() { |
|
||||
|
|
||||
it('should return a pubkey', function() { |
|
||||
var pubkey = StealthAddress().fromStealthkey(stealthkey).getReceivePubkey(senderKeypair); |
|
||||
(pubkey instanceof Pubkey).should.equal(true); |
|
||||
}); |
|
||||
|
|
||||
it('should return the same pubkey as getReceivePubkey', function() { |
|
||||
var pubkey = StealthAddress().fromStealthkey(stealthkey).getReceivePubkey(senderKeypair); |
|
||||
var pubkey2 = stealthkey.getReceivePubkey(senderKeypair.pubkey); |
|
||||
pubkey2.toString().should.equal(pubkey.toString()); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#toBuffer', function() { |
|
||||
|
|
||||
it('should return this known address buffer', function() { |
|
||||
var buf = Base58check.decode(addressString); |
|
||||
StealthAddress().fromBuffer(dwbuf).toBuffer().toString('hex').should.equal(dwhex); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#toString', function() { |
|
||||
|
|
||||
it('should return this known address buffer', function() { |
|
||||
var buf = Base58check.decode(addressString); |
|
||||
StealthAddress().fromBuffer(buf).toString().should.equal(Base58check(new Buffer(dwhex, 'hex')).toString()); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@parseDWBuffer', function() { |
|
||||
|
|
||||
it('should parse this known DW buffer', function() { |
|
||||
var buf = new Buffer(dwhex, 'hex'); |
|
||||
var parsed = StealthAddress.parseDWBuffer(buf); |
|
||||
parsed.version.should.equal(42); |
|
||||
parsed.options.should.equal(0); |
|
||||
parsed.scanPubkey.toString().should.equal('02697763d7e9becb0c180083738c32c05b0e2fee26d6278020c06bbb04d5f66b32'); |
|
||||
parsed.nPayloadPubkeys.should.equal(1); |
|
||||
parsed.payloadPubkeys[0].toString().should.equal('0362408459041e0473298af3824dbabe4d2b7f846825ed4d1c2e2c670c07cb275d'); |
|
||||
parsed.nSigs.should.equal(1); |
|
||||
parsed.prefix.toString().should.equal(''); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
@ -1,138 +0,0 @@ |
|||||
var should = require('chai').should(); |
|
||||
var Stealthkey = require('../lib/expmt/stealthkey'); |
|
||||
var Keypair = require('../lib/keypair'); |
|
||||
var Privkey = require('../lib/privkey'); |
|
||||
var Pubkey = require('../lib/pubkey'); |
|
||||
var BN = require('../lib/bn'); |
|
||||
var Hash = require('../lib/hash'); |
|
||||
|
|
||||
describe('Stealthkey', function() { |
|
||||
|
|
||||
var stealthkey = Stealthkey(); |
|
||||
stealthkey.payloadKeypair = Keypair(); |
|
||||
stealthkey.payloadKeypair.privkey = Privkey(); |
|
||||
stealthkey.payloadKeypair.privkey.bn = BN().fromBuffer(Hash.sha256(new Buffer('test 1'))); |
|
||||
stealthkey.payloadKeypair.privkey2pubkey(); |
|
||||
stealthkey.scanKeypair = Keypair(); |
|
||||
stealthkey.scanKeypair.privkey = Privkey(); |
|
||||
stealthkey.scanKeypair.privkey.bn = BN().fromBuffer(Hash.sha256(new Buffer('test 2'))); |
|
||||
stealthkey.scanKeypair.privkey2pubkey(); |
|
||||
|
|
||||
var senderKeypair = Keypair(); |
|
||||
senderKeypair.privkey = Privkey(); |
|
||||
senderKeypair.privkey.bn = BN().fromBuffer(Hash.sha256(new Buffer('test 3'))); |
|
||||
senderKeypair.privkey2pubkey(); |
|
||||
|
|
||||
it('should create a new stealthkey', function() { |
|
||||
var stealthkey = new Stealthkey(); |
|
||||
should.exist(stealthkey); |
|
||||
}); |
|
||||
|
|
||||
it('should create a new stealthkey without using "new"', function() { |
|
||||
var stealthkey = Stealthkey(); |
|
||||
should.exist(stealthkey); |
|
||||
}); |
|
||||
|
|
||||
it('should create a new stealthkey with both keypairs in the constructor', function() { |
|
||||
var keypair1 = Keypair(); |
|
||||
var keypair2 = Keypair(); |
|
||||
var stealthkey = Stealthkey(keypair1, keypair2); |
|
||||
should.exist(stealthkey.payloadKeypair); |
|
||||
should.exist(stealthkey.scanKeypair); |
|
||||
}); |
|
||||
|
|
||||
describe('#set', function() { |
|
||||
|
|
||||
it('should set payload key', function() { |
|
||||
should.exist(Stealthkey().set({payloadKeypair: stealthkey.payloadKeypair}).payloadKeypair); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#fromJSON', function() { |
|
||||
|
|
||||
it('should make a stealthkey from this JSON', function() { |
|
||||
var sk = Stealthkey().fromJSON({ |
|
||||
payloadKeypair: stealthkey.payloadKeypair.toJSON(), |
|
||||
scanKeypair: stealthkey.scanKeypair.toJSON() |
|
||||
}); |
|
||||
sk.payloadKeypair.toString().should.equal(stealthkey.payloadKeypair.toString()); |
|
||||
sk.scanKeypair.toString().should.equal(stealthkey.scanKeypair.toString()); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#toJSON', function() { |
|
||||
|
|
||||
it('should convert this stealthkey to json', function() { |
|
||||
var json = stealthkey.toJSON() |
|
||||
var json2 = Stealthkey().fromJSON(json).toJSON(); |
|
||||
json.payloadKeypair.privkey.should.equal(json2.payloadKeypair.privkey); |
|
||||
json.scanKeypair.privkey.should.equal(json2.scanKeypair.privkey); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#fromRandom', function() { |
|
||||
|
|
||||
it('should create a new stealthkey from random', function() { |
|
||||
var stealthkey = Stealthkey().fromRandom(); |
|
||||
should.exist(stealthkey.payloadKeypair.privkey.bn.gt(0)); |
|
||||
should.exist(stealthkey.scanKeypair.privkey.bn.gt(0)); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#getSharedKeypair', function() { |
|
||||
|
|
||||
it('should return a key', function() { |
|
||||
var key = stealthkey.getSharedKeypair(senderKeypair.pubkey); |
|
||||
(key instanceof Keypair).should.equal(true); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#getReceivePubkey', function() { |
|
||||
|
|
||||
it('should return a pubkey', function() { |
|
||||
var pubkey = stealthkey.getReceivePubkey(senderKeypair.pubkey); |
|
||||
(pubkey instanceof Pubkey).should.equal(true); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#getReceiveKeypair', function() { |
|
||||
|
|
||||
it('should return a key', function() { |
|
||||
var key = stealthkey.getReceiveKeypair(senderKeypair.pubkey); |
|
||||
(key instanceof Keypair).should.equal(true); |
|
||||
}); |
|
||||
|
|
||||
it('should return a key with the same pubkey as getReceivePubkey', function() { |
|
||||
var key = stealthkey.getReceiveKeypair(senderKeypair.pubkey); |
|
||||
var pubkey = stealthkey.getReceivePubkey(senderKeypair.pubkey); |
|
||||
key.pubkey.toString().should.equal(pubkey.toString()); |
|
||||
}); |
|
||||
|
|
||||
it('should return private key with length 32 or less', function() { |
|
||||
var key = stealthkey.getReceiveKeypair(senderKeypair.pubkey); |
|
||||
key.privkey.bn.toBuffer().length.should.be.below(33); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#isForMe', function() { |
|
||||
|
|
||||
it('should return true if it (the transaction or message) is for me', function() { |
|
||||
var pubkeyhash = new Buffer('3cb64fa6ee9b3e8754e3e2bd033bf61048604a99', 'hex'); |
|
||||
stealthkey.isForMe(senderKeypair.pubkey, pubkeyhash).should.equal(true); |
|
||||
}); |
|
||||
|
|
||||
it('should return false if it (the transaction or message) is not for me', function() { |
|
||||
var pubkeyhash = new Buffer('00b64fa6ee9b3e8754e3e2bd033bf61048604a99', 'hex'); |
|
||||
stealthkey.isForMe(senderKeypair.pubkey, pubkeyhash).should.equal(false); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
@ -1,139 +0,0 @@ |
|||||
var Keypair = require('../lib/keypair'); |
|
||||
var StealthMessage = require('../lib/expmt/stealthmessage'); |
|
||||
var Stealthkey = require('../lib/expmt/stealthkey'); |
|
||||
var StealthAddress = require('../lib/expmt/stealthaddress'); |
|
||||
var KDF = require('../lib/kdf'); |
|
||||
var Hash = require('../lib/hash'); |
|
||||
var should = require('chai').should(); |
|
||||
var Address = require('../lib/address'); |
|
||||
|
|
||||
describe('StealthMessage', function() { |
|
||||
|
|
||||
var payloadKeypair = KDF.buf2keypair(new Buffer('key1')); |
|
||||
var scanKeypair = KDF.buf2keypair(new Buffer('key2')); |
|
||||
var fromKeypair = KDF.buf2keypair(new Buffer('key3')); |
|
||||
var enchex = 'f557994f16d0d628fa4fdb4ab3d7e0bc5f2754f20381c7831a20c7c9ec88dcf092ea3683261798ccda991ed65a3a54a036d8125dec0381c7831a20c7c9ec88dcf092ea3683261798ccda991ed65a3a54a036d8125dec9f86d081884c7d659a2feaa0c55ad01560ba2904d3bc8395b6c4a6f87648edb33db6a22170e5e26f340c7ba943169210234cd6a753ad13919b0ab7d678b47b5e7d63e452382de2c2590fb57ef048f7b3'; |
|
||||
var encbuf = new Buffer(enchex, 'hex'); |
|
||||
var ivbuf = Hash.sha256(new Buffer('test')).slice(0, 128 / 8); |
|
||||
var sk = Stealthkey().set({payloadKeypair: payloadKeypair, scanKeypair: scanKeypair}); |
|
||||
var sa = StealthAddress().fromStealthkey(sk); |
|
||||
var messagebuf = new Buffer('this is my message'); |
|
||||
|
|
||||
it('should make a new stealthmessage', function() { |
|
||||
var sm = new StealthMessage(); |
|
||||
should.exist(sm); |
|
||||
sm = StealthMessage() |
|
||||
should.exist(sm); |
|
||||
}); |
|
||||
|
|
||||
it('should allow "set" style syntax', function() { |
|
||||
var encbuf = StealthMessage().set({ |
|
||||
messagebuf: messagebuf, |
|
||||
toStealthAddress: sa |
|
||||
}).encrypt().encbuf; |
|
||||
should.exist(encbuf); |
|
||||
encbuf.length.should.equal(113); |
|
||||
}); |
|
||||
|
|
||||
describe('#set', function() { |
|
||||
|
|
||||
it('should set the messagebuf', function() { |
|
||||
var sm = StealthMessage().set({messagebuf: messagebuf}); |
|
||||
should.exist(sm.messagebuf); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@encrypt', function() { |
|
||||
|
|
||||
it('should encrypt a message', function() { |
|
||||
var encbuf = StealthMessage.encrypt(messagebuf, sa); |
|
||||
encbuf.length.should.equal(166); |
|
||||
}); |
|
||||
|
|
||||
it('should encrypt a message with this fromKeypair and ivbuf the same each time', function() { |
|
||||
var encbuf = StealthMessage.encrypt(messagebuf, sa, fromKeypair, ivbuf); |
|
||||
encbuf.length.should.equal(166); |
|
||||
encbuf.toString('hex').should.equal(enchex); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@decrypt', function() { |
|
||||
|
|
||||
it('should decrypt this known message correctly', function() { |
|
||||
var messagebuf2 = StealthMessage.decrypt(encbuf, sk); |
|
||||
messagebuf2.toString('hex').should.equal(messagebuf.toString('hex')); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@isForMe', function() { |
|
||||
|
|
||||
it('should know that this message is for me', function() { |
|
||||
StealthMessage.isForMe(encbuf, sk).should.equal(true); |
|
||||
}); |
|
||||
|
|
||||
it('should know that this message is for me even if my payloadPrivkey is not present', function() { |
|
||||
var sk2 = new Stealthkey(); |
|
||||
sk2.scanKeypair = sk.scanKeypair; |
|
||||
sk2.payloadKeypair = Keypair().set({pubkey: sk.payloadKeypair.pubkey}); |
|
||||
should.not.exist(sk2.payloadKeypair.privkey); |
|
||||
StealthMessage.isForMe(encbuf, sk2).should.equal(true); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#encrypt', function() { |
|
||||
|
|
||||
it('should encrypt this message', function() { |
|
||||
var sm = StealthMessage().set({ |
|
||||
messagebuf: messagebuf, |
|
||||
toStealthAddress: sa, |
|
||||
fromKeypair: fromKeypair |
|
||||
}); |
|
||||
sm.encrypt().encbuf.length.should.equal(113); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#decrypt', function() { |
|
||||
|
|
||||
it('should decrypt that which was encrypted', function() { |
|
||||
var sm = StealthMessage().set({ |
|
||||
messagebuf: messagebuf, |
|
||||
toStealthAddress: sa |
|
||||
}).encrypt(); |
|
||||
var messagebuf2 = StealthMessage().set({ |
|
||||
encbuf: sm.encbuf, |
|
||||
fromKeypair: sm.fromKeypair, |
|
||||
toStealthkey: sk |
|
||||
}).decrypt().messagebuf; |
|
||||
messagebuf2.toString('hex').should.equal(messagebuf.toString('hex')); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#isForMe', function() { |
|
||||
|
|
||||
it('should know that this message is for me', function() { |
|
||||
StealthMessage().set({ |
|
||||
encbuf: encbuf, |
|
||||
toStealthkey: sk, |
|
||||
fromKeypair: fromKeypair, |
|
||||
receiveAddress: Address().set({hashbuf: encbuf.slice(0, 20)}) |
|
||||
}).isForMe().should.equal(true); |
|
||||
}); |
|
||||
|
|
||||
it('should know that this message is not for me', function() { |
|
||||
StealthMessage().set({ |
|
||||
encbuf: encbuf, |
|
||||
toStealthkey: sk, |
|
||||
fromKeypair: fromKeypair, |
|
||||
receiveAddress: Address().set({hashbuf: encbuf.slice(0, 20)}) |
|
||||
}).isForMe().should.equal(true); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
@ -1,68 +0,0 @@ |
|||||
var should = require('chai').should(); |
|
||||
var Txout = require('../lib/txout'); |
|
||||
var Stealthkey = require('../lib/expmt/stealthkey'); |
|
||||
var StealthTx = require('../lib/expmt/stealthtx'); |
|
||||
var Transaction = require('../lib/transaction'); |
|
||||
var Varint = require('../lib/varint'); |
|
||||
|
|
||||
describe('StealthTx', function() { |
|
||||
|
|
||||
var txhex = '0100000001c828ccce36eca04f96321ad488528af86c7598e67157c4f8e2f462a9e0e3af5f010000006a47304402204525eef6a56cc57fb184e53efdfdc1086d5265da21480d55c2184536440a64f70220349cdc6c66a8507dde0d172fe64aeb57ae56e014b50315f615086a6b85c5424e012102c0633ddb6bf2a8686e2ba4ce8026c94e1e27ef12e73f8fed6d6d2b97199f9b74ffffffff020000000000000000286a2606deadbeef0365b5a5b0ba059666e907b0b5e07b37fdb162d1399ed829315491fe1f30c87b3f905f0100000000001976a9142042d5e7ef9e82346419fbfe7df5ae52fe4bea3c88ac00000000'; |
|
||||
var txbuf = new Buffer(txhex, 'hex'); |
|
||||
var txidhex = '66da969fff214c329e27062beaf3baf20ed035801559b31f3e868c2de4cdfc5b'; |
|
||||
var tx = Transaction(txbuf); |
|
||||
|
|
||||
it('should make a new StealthTx', function() { |
|
||||
var stx = new StealthTx(); |
|
||||
should.exist(stx); |
|
||||
stx = StealthTx(); |
|
||||
should.exist(stx); |
|
||||
}); |
|
||||
|
|
||||
describe('#isForMe', function() { |
|
||||
|
|
||||
it('should return false for this known tx and random stealthkey', function() { |
|
||||
var sk = Stealthkey().fromRandom(); |
|
||||
var stx = StealthTx().set({sk: sk, tx: tx}); |
|
||||
stx.isForMe().should.equal(false); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#notMine', function() { |
|
||||
|
|
||||
it('should return true for this known tx and random stealthkey', function() { |
|
||||
var sk = Stealthkey().fromRandom(); |
|
||||
var stx = StealthTx().set({sk: sk, tx: tx}); |
|
||||
stx.notMine().should.equal("StealthTx not mine"); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('#notStealth', function() { |
|
||||
|
|
||||
it('should know this is a stealth tx', function() { |
|
||||
var stx = StealthTx().set({tx: tx}); |
|
||||
stx.notStealth().should.equal(false); |
|
||||
}); |
|
||||
|
|
||||
it('should know this is not a stealth tx', function() { |
|
||||
var tx2 = Transaction(tx); |
|
||||
tx2.txouts.pop(); |
|
||||
tx2.txoutsvi = Varint(1); |
|
||||
var stx = StealthTx().set({tx: tx2}); |
|
||||
stx.notStealth().should.equal("Not enough txouts"); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
|
|
||||
describe('@parseOpReturnData', function() { |
|
||||
var txout = tx.txouts[0]; |
|
||||
var buf = txout.script.chunks[1].buf; |
|
||||
var parsed = StealthTx.parseOpReturnData(buf); |
|
||||
(typeof parsed.version).should.equal('number'); |
|
||||
parsed.noncebuf.length.should.be.above(0); |
|
||||
parsed.pubkey.toBuffer().length.should.equal(33); |
|
||||
}); |
|
||||
|
|
||||
}); |
|
||||
Loading…
Reference in new issue