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 = function BN_extended(n) { |
|||
@ -1,9 +1,11 @@ |
|||
'use strict'; |
|||
|
|||
var BN = require('./bn'); |
|||
var Point = require('./point'); |
|||
var Signature = require('./signature'); |
|||
var Keypair = require('./keypair'); |
|||
var Pubkey = require('./pubkey'); |
|||
var Random = require('./random'); |
|||
var Pubkey = require('../pubkey'); |
|||
var Keypair = require('../keypair'); |
|||
var Signature = require('../signature'); |
|||
|
|||
var ECDSA = function ECDSA(obj) { |
|||
if (!(this instanceof ECDSA)) |
|||
@ -1,3 +1,5 @@ |
|||
'use strict'; |
|||
|
|||
var hashjs = require('hash.js'); |
|||
var sha512 = require('sha512'); |
|||
|
|||
@ -1,3 +1,5 @@ |
|||
'use strict'; |
|||
|
|||
var BN = require('./bn'); |
|||
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 Base58 = function Base58(obj) { |
|||
@ -1,5 +1,7 @@ |
|||
'use strict'; |
|||
|
|||
var base58 = require('./base58'); |
|||
var sha256sha256 = require('./hash').sha256sha256; |
|||
var sha256sha256 = require('../crypto/hash').sha256sha256; |
|||
|
|||
var Base58Check = function Base58Check(obj) { |
|||
if (!(this instanceof Base58Check)) |
|||
@ -1,4 +1,6 @@ |
|||
var BN = require('./bn'); |
|||
'use strict'; |
|||
|
|||
var BN = require('../crypto/bn'); |
|||
|
|||
var BufferReader = function BufferReader(buf) { |
|||
if (!(this instanceof BufferReader)) |
|||
@ -1,4 +1,4 @@ |
|||
var BN = require('./bn'); |
|||
'use strict'; |
|||
|
|||
var BufferWriter = function BufferWriter(obj) { |
|||
if (!(this instanceof BufferWriter)) |
|||
@ -1,6 +1,8 @@ |
|||
'use strict'; |
|||
|
|||
var BufferWriter = require('./bufferwriter'); |
|||
var BufferReader = require('./bufferreader'); |
|||
var BN = require('./bn'); |
|||
var BN = require('../crypto/bn'); |
|||
|
|||
var Varint = function Varint(buf) { |
|||
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'); |
|||
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(); |
|||
'use strict'; |
|||
|
|||
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() { |
|||
var ecdsa = new ECDSA(); |
|||
should.exist(ecdsa); |
|||
}); |
|||
|
|||
var ecdsa = new ECDSA(); |
|||
@ -1,9 +1,12 @@ |
|||
var should = require('chai').should(); |
|||
var Hash = require('../lib/hash'); |
|||
'use strict'; |
|||
|
|||
require('chai').should(); |
|||
var bitcore = require('../..'); |
|||
var Hash = bitcore.Hash; |
|||
|
|||
describe('Hash', function() { |
|||
var buf = new Buffer([0, 1, 2, 3, 253, 254, 255]); |
|||
var str = "test string"; |
|||
var str = 'test string'; |
|||
|
|||
describe('#sha256', function() { |
|||
|
|||
@ -1,6 +1,9 @@ |
|||
'use strict'; |
|||
|
|||
var should = require('chai').should(); |
|||
var point = require('../lib/point'); |
|||
var BN = require('../lib/bn'); |
|||
var bitcore = require('../..'); |
|||
var point = bitcore.Point; |
|||
var BN = bitcore.BN; |
|||
|
|||
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 Base58Check = require('../lib/base58check'); |
|||
var base58 = require('../lib/base58'); |
|||
var bitcore = require('../..'); |
|||
var Base58Check = bitcore.Base58Check; |
|||
var base58 = bitcore.Base58; |
|||
|
|||
describe('Base58Check', function() { |
|||
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() { |
|||
var b58 = new Base58Check(); |
|||
@ -1,7 +1,10 @@ |
|||
var BufferWriter = require('../lib/bufferwriter'); |
|||
var BufferReader = require('../lib/bufferreader'); |
|||
'use strict'; |
|||
|
|||
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() { |
|||
|
|||
@ -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