lukechilds
/
bitcoincashjs
mirror of https://github.com/lukechilds/bitcoincashjs.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

bring formatting in line with bitcore standards

patch-2
Ryan X. Charles 11 years ago
parent
fa47ee9984
commit
31a024a20b
1 changed files with 281 additions and 275 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 556
      BIP32.js

556
BIP32.js
View File

@ -1,3 +1,6 @@
var EncodedData = require('./util/EncodedData');
var base58 = imports.base58 || require('base58-native').base58Check;
var BITCOIN_MAINNET_PUBLIC = 0x0488b21e; var BITCOIN_MAINNET_PUBLIC = 0x0488b21e;
var BITCOIN_MAINNET_PRIVATE = 0x0488ade4; var BITCOIN_MAINNET_PRIVATE = 0x0488ade4;
var BITCOIN_TESTNET_PUBLIC = 0x043587cf; var BITCOIN_TESTNET_PUBLIC = 0x043587cf;
@ -12,338 +15,341 @@ var LITECOIN_TESTNET_PUBLIC = 0x0436f6e1;
var LITECOIN_TESTNET_PRIVATE = 0x0436ef7d; var LITECOIN_TESTNET_PRIVATE = 0x0436ef7d;
var BIP32 = function(bytes) { var BIP32 = function(bytes) {
// decode base58 // decode base58
if( typeof bytes === "string" ) { if (typeof bytes === "string") {
var decoded = Bitcoin.Base58.decode(bytes); var decoded = base58.decode(bytes);
if( decoded.length != 82 ) throw new Error("Not enough data"); if (decoded.length != 82)
var checksum = decoded.slice(78, 82); throw new Error("Not enough data");
bytes = decoded.slice(0, 78); var checksum = decoded.slice(78, 82);
bytes = decoded.slice(0, 78);
var hash = Crypto.SHA256( Crypto.SHA256( bytes, { asBytes: true } ), { asBytes: true } );
var hash = Crypto.SHA256(Crypto.SHA256(bytes, {asBytes: true}), {asBytes: true});
if( hash[0] != checksum[0] || hash[1] != checksum[1] || hash[2] != checksum[2] || hash[3] != checksum[3] ) {
throw new Error("Invalid checksum"); if (hash[0] != checksum[0] || hash[1] != checksum[1] || hash[2] != checksum[2] || hash[3] != checksum[3]) {
} throw new Error("Invalid checksum");
} }
}
if( bytes !== undefined ) if (bytes !== undefined)
this.init_from_bytes(bytes); this.init_from_bytes(bytes);
} }
BIP32.prototype.init_from_bytes = function(bytes) { BIP32.prototype.init_from_bytes = function(bytes) {
// Both pub and private extended keys are 78 bytes // Both pub and private extended keys are 78 bytes
if( bytes.length != 78 ) throw new Error("not enough data"); if(bytes.length != 78) throw new Error("not enough data");
this.version = u32(bytes.slice(0, 4)); this.version = u32(bytes.slice(0, 4));
this.depth = u8 (bytes.slice(4, 5)); this.depth = u8(bytes.slice(4, 5));
this.parent_fingerprint = bytes.slice(5, 9); this.parent_fingerprint = bytes.slice(5, 9);
this.child_index = u32(bytes.slice(9, 13)); this.child_index = u32(bytes.slice(9, 13));
this.chain_code = bytes.slice(13, 45); this.chain_code = bytes.slice(13, 45);
var key_bytes = bytes.slice(45, 78); var key_bytes = bytes.slice(45, 78);
var is_private = var is_private =
(this.version == BITCOIN_MAINNET_PRIVATE || (this.version == BITCOIN_MAINNET_PRIVATE ||
this.version == BITCOIN_TESTNET_PRIVATE || this.version == BITCOIN_TESTNET_PRIVATE ||
this.version == DOGECOIN_MAINNET_PRIVATE || this.version == DOGECOIN_MAINNET_PRIVATE ||
this.version == DOGECOIN_TESTNET_PRIVATE || this.version == DOGECOIN_TESTNET_PRIVATE ||
this.version == LITECOIN_MAINNET_PRIVATE || this.version == LITECOIN_MAINNET_PRIVATE ||
this.version == LITECOIN_TESTNET_PRIVATE ); this.version == LITECOIN_TESTNET_PRIVATE );
var is_public = var is_public =
(this.version == BITCOIN_MAINNET_PUBLIC || (this.version == BITCOIN_MAINNET_PUBLIC ||
this.version == BITCOIN_TESTNET_PUBLIC || this.version == BITCOIN_TESTNET_PUBLIC ||
this.version == DOGECOIN_MAINNET_PUBLIC || this.version == DOGECOIN_MAINNET_PUBLIC ||
this.version == DOGECOIN_TESTNET_PUBLIC || this.version == DOGECOIN_TESTNET_PUBLIC ||
this.version == LITECOIN_MAINNET_PUBLIC || this.version == LITECOIN_MAINNET_PUBLIC ||
this.version == LITECOIN_TESTNET_PUBLIC ); this.version == LITECOIN_TESTNET_PUBLIC );
if( is_private && key_bytes[0] == 0 ) { if (is_private && key_bytes[0] == 0) {
this.eckey = new Bitcoin.ECKey(key_bytes.slice(1, 33)); this.eckey = new Bitcoin.ECKey(key_bytes.slice(1, 33));
this.eckey.setCompressed(true); this.eckey.setCompressed(true);
var ecparams = getSECCurveByName("secp256k1");
var pt = ecparams.getG().multiply(this.eckey.priv);
this.eckey.pub = pt;
this.eckey.pubKeyHash = Bitcoin.Util.sha256ripe160(this.eckey.pub.getEncoded(true));
this.has_private_key = true;
} else if( is_public && (key_bytes[0] == 0x02 || key_bytes[0] == 0x03) ) {
this.eckey = new Bitcoin.ECKey();
this.eckey.pub = decompress_pubkey(key_bytes);
this.eckey.pubKeyHash = Bitcoin.Util.sha256ripe160(this.eckey.pub.getEncoded(true));
this.eckey.setCompressed(true);
this.has_private_key = false;
} else {
throw new Error("Invalid key");
}
this.build_extended_public_key(); var ecparams = getSECCurveByName("secp256k1");
this.build_extended_private_key(); var pt = ecparams.getG().multiply(this.eckey.priv);
this.eckey.pub = pt;
this.eckey.pubKeyHash = Bitcoin.Util.sha256ripe160(this.eckey.pub.getEncoded(true));
this.has_private_key = true;
} else if (is_public && (key_bytes[0] == 0x02 || key_bytes[0] == 0x03)) {
this.eckey = new Bitcoin.ECKey();
this.eckey.pub = decompress_pubkey(key_bytes);
this.eckey.pubKeyHash = Bitcoin.Util.sha256ripe160(this.eckey.pub.getEncoded(true));
this.eckey.setCompressed(true);
this.has_private_key = false;
} else {
throw new Error("Invalid key");
}
this.build_extended_public_key();
this.build_extended_private_key();
} }
BIP32.prototype.build_extended_public_key = function() { BIP32.prototype.build_extended_public_key = function() {
this.extended_public_key = []; this.extended_public_key = [];
var v = null; var v = null;
switch(this.version) { switch(this.version) {
case BITCOIN_MAINNET_PUBLIC: case BITCOIN_MAINNET_PUBLIC:
case BITCOIN_MAINNET_PRIVATE: case BITCOIN_MAINNET_PRIVATE:
v = BITCOIN_MAINNET_PUBLIC; v = BITCOIN_MAINNET_PUBLIC;
break; break;
case BITCOIN_TESTNET_PUBLIC: case BITCOIN_TESTNET_PUBLIC:
case BITCOIN_TESTNET_PRIVATE: case BITCOIN_TESTNET_PRIVATE:
v = BITCOIN_TESTNET_PUBLIC; v = BITCOIN_TESTNET_PUBLIC;
break; break;
case DOGECOIN_MAINNET_PUBLIC: case DOGECOIN_MAINNET_PUBLIC:
case DOGECOIN_MAINNET_PRIVATE: case DOGECOIN_MAINNET_PRIVATE:
v = DOGECOIN_MAINNET_PUBLIC; v = DOGECOIN_MAINNET_PUBLIC;
break; break;
case DOGECOIN_TESTNET_PUBLIC: case DOGECOIN_TESTNET_PUBLIC:
case DOGECOIN_TESTNET_PRIVATE: case DOGECOIN_TESTNET_PRIVATE:
v = DOGECOIN_TESTNET_PUBLIC; v = DOGECOIN_TESTNET_PUBLIC;
break; break;
case LITECOIN_MAINNET_PUBLIC: case LITECOIN_MAINNET_PUBLIC:
case LITECOIN_MAINNET_PRIVATE: case LITECOIN_MAINNET_PRIVATE:
v = LITECOIN_MAINNET_PUBLIC; v = LITECOIN_MAINNET_PUBLIC;
break; break;
case LITECOIN_TESTNET_PUBLIC: case LITECOIN_TESTNET_PUBLIC:
case LITECOIN_TESTNET_PRIVATE: case LITECOIN_TESTNET_PRIVATE:
v = LITECOIN_TESTNET_PUBLIC; v = LITECOIN_TESTNET_PUBLIC;
break; break;
default: default:
throw new Error("Unknown version"); throw new Error("Unknown version");
} }
// Version // Version
this.extended_public_key.push(v >> 24); this.extended_public_key.push(v >> 24);
this.extended_public_key.push((v >> 16) & 0xff); this.extended_public_key.push((v >> 16) & 0xff);
this.extended_public_key.push((v >> 8) & 0xff); this.extended_public_key.push((v >> 8) & 0xff);
this.extended_public_key.push(v & 0xff); this.extended_public_key.push(v & 0xff);
// Depth // Depth
this.extended_public_key.push(this.depth); this.extended_public_key.push(this.depth);
// Parent fingerprint // Parent fingerprint
this.extended_public_key = this.extended_public_key.concat(this.parent_fingerprint); this.extended_public_key = this.extended_public_key.concat(this.parent_fingerprint);
// Child index // Child index
this.extended_public_key.push(this.child_index >>> 24); this.extended_public_key.push(this.child_index >>> 24);
this.extended_public_key.push((this.child_index >>> 16) & 0xff); this.extended_public_key.push((this.child_index >>> 16) & 0xff);
this.extended_public_key.push((this.child_index >>> 8) & 0xff); this.extended_public_key.push((this.child_index >>> 8) & 0xff);
this.extended_public_key.push(this.child_index & 0xff); this.extended_public_key.push(this.child_index & 0xff);
// Chain code // Chain code
this.extended_public_key = this.extended_public_key.concat(this.chain_code); this.extended_public_key = this.extended_public_key.concat(this.chain_code);
// Public key // Public key
this.extended_public_key = this.extended_public_key.concat(this.eckey.pub.getEncoded(true)); this.extended_public_key = this.extended_public_key.concat(this.eckey.pub.getEncoded(true));
} }
BIP32.prototype.extended_public_key_string = function(format) { BIP32.prototype.extended_public_key_string = function(format) {
if( format === undefined || format === "base58" ) { if (format === undefined || format === "base58") {
var hash = Crypto.SHA256( Crypto.SHA256( this.extended_public_key, { asBytes: true } ), { asBytes: true } ); var hash = Crypto.SHA256(Crypto.SHA256(this.extended_public_key, {asBytes: true} ), {asBytes: true});
var checksum = hash.slice(0, 4); var checksum = hash.slice(0, 4);
var data = this.extended_public_key.concat(checksum); var data = this.extended_public_key.concat(checksum);
return Bitcoin.Base58.encode(data); return Bitcoin.Base58.encode(data);
} else if( format === "hex" ) { } else if (format === "hex") {
return Crypto.util.bytesToHex(this.extended_public_key); return Crypto.util.bytesToHex(this.extended_public_key);
} else { } else {
throw new Error("bad format"); throw new Error("bad format");
} }
} }
BIP32.prototype.build_extended_private_key = function() { BIP32.prototype.build_extended_private_key = function() {
if( !this.has_private_key ) return; if (!this.has_private_key) return;
this.extended_private_key = []; this.extended_private_key = [];
var v = this.version; var v = this.version;
// Version // Version
this.extended_private_key.push(v >> 24); this.extended_private_key.push(v >> 24);
this.extended_private_key.push((v >> 16) & 0xff); this.extended_private_key.push((v >> 16) & 0xff);
this.extended_private_key.push((v >> 8) & 0xff); this.extended_private_key.push((v >> 8) & 0xff);
this.extended_private_key.push(v & 0xff); this.extended_private_key.push(v & 0xff);
// Depth // Depth
this.extended_private_key.push(this.depth); this.extended_private_key.push(this.depth);
// Parent fingerprint // Parent fingerprint
this.extended_private_key = this.extended_private_key.concat(this.parent_fingerprint); this.extended_private_key = this.extended_private_key.concat(this.parent_fingerprint);
// Child index // Child index
this.extended_private_key.push(this.child_index >>> 24); this.extended_private_key.push(this.child_index >>> 24);
this.extended_private_key.push((this.child_index >>> 16) & 0xff); this.extended_private_key.push((this.child_index >>> 16) & 0xff);
this.extended_private_key.push((this.child_index >>> 8) & 0xff); this.extended_private_key.push((this.child_index >>> 8) & 0xff);
this.extended_private_key.push(this.child_index & 0xff); this.extended_private_key.push(this.child_index & 0xff);
// Chain code // Chain code
this.extended_private_key = this.extended_private_key.concat(this.chain_code); this.extended_private_key = this.extended_private_key.concat(this.chain_code);
// Private key // Private key
this.extended_private_key.push(0); this.extended_private_key.push(0);
this.extended_private_key = this.extended_private_key.concat(this.eckey.priv.toByteArrayUnsigned()); this.extended_private_key = this.extended_private_key.concat(this.eckey.priv.toByteArrayUnsigned());
} }
BIP32.prototype.extended_private_key_string = function(format) { BIP32.prototype.extended_private_key_string = function(format) {
if( format === undefined || format === "base58" ) { if (format === undefined || format === "base58") {
var hash = Crypto.SHA256( Crypto.SHA256( this.extended_private_key, { asBytes: true } ), { asBytes: true } ); var hash = Crypto.SHA256(Crypto.SHA256(this.extended_private_key, {asBytes: true}), {asBytes: true});
var checksum = hash.slice(0, 4); var checksum = hash.slice(0, 4);
var data = this.extended_private_key.concat(checksum); var data = this.extended_private_key.concat(checksum);
return Bitcoin.Base58.encode(data); return Bitcoin.Base58.encode(data);
} else if( format === "hex" ) { } else if( format === "hex" ) {
return Crypto.util.bytesToHex(this.extended_private_key); return Crypto.util.bytesToHex(this.extended_private_key);
} else { } else {
throw new Error("bad format"); throw new Error("bad format");
} }
} }
BIP32.prototype.derive = function(path) { BIP32.prototype.derive = function(path) {
var e = path.split('/'); var e = path.split('/');
// Special cases: // Special cases:
if( path == 'm' || path == 'M' || path == 'm\'' || path == 'M\'' ) return this; if (path == 'm' || path == 'M' || path == 'm\'' || path == 'M\'')
return this;
var bip32 = this; var bip32 = this;
for( var i in e ) { for (var i in e) {
var c = e[i]; var c = e[i];
if( i == 0 ) { if (i == 0 ) {
if( c != 'm' ) throw new Error("invalid path"); if (c != 'm') throw new Error("invalid path");
continue; continue;
} }
var use_private = (c.length > 1) && (c[c.length-1] == '\''); var use_private = (c.length > 1) && (c[c.length-1] == '\'');
var child_index = parseInt(use_private ? c.slice(0, c.length - 1) : c) & 0x7fffffff; var child_index = parseInt(use_private ? c.slice(0, c.length - 1) : c) & 0x7fffffff;
if( use_private ) if( use_private )
child_index += 0x80000000; child_index += 0x80000000;
bip32 = bip32.derive_child(child_index); bip32 = bip32.derive_child(child_index);
} }
return bip32; return bip32;
} }
BIP32.prototype.derive_child = function(i) { BIP32.prototype.derive_child = function(i) {
var ib = []; var ib = [];
ib.push( (i >> 24) & 0xff ); ib.push((i >> 24) & 0xff);
ib.push( (i >> 16) & 0xff ); ib.push((i >> 16) & 0xff);
ib.push( (i >> 8) & 0xff ); ib.push((i >> 8) & 0xff);
ib.push( i & 0xff ); ib.push(i & 0xff );
var use_private = (i & 0x80000000) != 0; var use_private = (i & 0x80000000) != 0;
var ecparams = getSECCurveByName("secp256k1"); var ecparams = getSECCurveByName("secp256k1");
var is_private = var is_private =
(this.version == BITCOIN_MAINNET_PRIVATE || (this.version == BITCOIN_MAINNET_PRIVATE ||
this.version == BITCOIN_TESTNET_PRIVATE || this.version == BITCOIN_TESTNET_PRIVATE ||
this.version == DOGECOIN_MAINNET_PRIVATE || this.version == DOGECOIN_MAINNET_PRIVATE ||
this.version == DOGECOIN_TESTNET_PRIVATE || this.version == DOGECOIN_TESTNET_PRIVATE ||
this.version == LITECOIN_MAINNET_PRIVATE || this.version == LITECOIN_MAINNET_PRIVATE ||
this.version == LITECOIN_TESTNET_PRIVATE); this.version == LITECOIN_TESTNET_PRIVATE);
if( use_private && (!this.has_private_key || !is_private) ) throw new Error("Cannot do private key derivation without private key"); if (use_private && (!this.has_private_key || !is_private))
throw new Error("Cannot do private key derivation without private key");
var ret = null;
if( this.has_private_key ) { var ret = null;
var data = null; if (this.has_private_key) {
var data = null;
if( use_private ) {
data = [0].concat(this.eckey.priv.toByteArrayUnsigned()).concat(ib); if (use_private) {
} else { data = [0].concat(this.eckey.priv.toByteArrayUnsigned()).concat(ib);
data = this.eckey.pub.getEncoded(true).concat(ib); } else {
} data = this.eckey.pub.getEncoded(true).concat(ib);
}
var j = new jsSHA(Crypto.util.bytesToHex(data), 'HEX'); var j = new jsSHA(Crypto.util.bytesToHex(data), 'HEX');
var hash = j.getHMAC(Crypto.util.bytesToHex(this.chain_code), "HEX", "SHA-512", "HEX"); var hash = j.getHMAC(Crypto.util.bytesToHex(this.chain_code), "HEX", "SHA-512", "HEX");
var il = new BigInteger(hash.slice(0, 64), 16); var il = new BigInteger(hash.slice(0, 64), 16);
var ir = Crypto.util.hexToBytes(hash.slice(64, 128)); var ir = Crypto.util.hexToBytes(hash.slice(64, 128));
// ki = IL + kpar (mod n). // ki = IL + kpar (mod n).
var curve = ecparams.getCurve(); var curve = ecparams.getCurve();
var k = il.add(this.eckey.priv).mod(ecparams.getN()); var k = il.add(this.eckey.priv).mod(ecparams.getN());
ret = new BIP32(); ret = new BIP32();
ret.chain_code = ir; ret.chain_code = ir;
ret.eckey = new Bitcoin.ECKey(k.toByteArrayUnsigned()); ret.eckey = new Bitcoin.ECKey(k.toByteArrayUnsigned());
ret.eckey.pub = ret.eckey.getPubPoint(); ret.eckey.pub = ret.eckey.getPubPoint();
ret.has_private_key = true; ret.has_private_key = true;
} else { } else {
var data = this.eckey.pub.getEncoded(true).concat(ib); var data = this.eckey.pub.getEncoded(true).concat(ib);
var j = new jsSHA(Crypto.util.bytesToHex(data), 'HEX'); var j = new jsSHA(Crypto.util.bytesToHex(data), 'HEX');
var hash = j.getHMAC(Crypto.util.bytesToHex(this.chain_code), "HEX", "SHA-512", "HEX"); var hash = j.getHMAC(Crypto.util.bytesToHex(this.chain_code), "HEX", "SHA-512", "HEX");
var il = new BigInteger(hash.slice(0, 64), 16); var il = new BigInteger(hash.slice(0, 64), 16);
var ir = Crypto.util.hexToBytes(hash.slice(64, 128)); var ir = Crypto.util.hexToBytes(hash.slice(64, 128));
// Ki = (IL + kpar)*G = IL*G + Kpar // Ki = (IL + kpar)*G = IL*G + Kpar
var k = ecparams.getG().multiply(il).add(this.eckey.pub); var k = ecparams.getG().multiply(il).add(this.eckey.pub);
ret = new BIP32(); ret = new BIP32();
ret.chain_code = ir; ret.chain_code = ir;
ret.eckey = new Bitcoin.ECKey(); ret.eckey = new Bitcoin.ECKey();
ret.eckey.pub = k; ret.eckey.pub = k;
ret.has_private_key = false; ret.has_private_key = false;
} }
ret.child_index = i; ret.child_index = i;
ret.parent_fingerprint = this.eckey.pubKeyHash.slice(0,4); ret.parent_fingerprint = this.eckey.pubKeyHash.slice(0,4);
ret.version = this.version; ret.version = this.version;
ret.depth = this.depth + 1; ret.depth = this.depth + 1;
ret.eckey.setCompressed(true); ret.eckey.setCompressed(true);
ret.eckey.pubKeyHash = Bitcoin.Util.sha256ripe160(ret.eckey.pub.getEncoded(true)); ret.eckey.pubKeyHash = Bitcoin.Util.sha256ripe160(ret.eckey.pub.getEncoded(true));
ret.build_extended_public_key(); ret.build_extended_public_key();
ret.build_extended_private_key(); ret.build_extended_private_key();
return ret; return ret;
} }
function uint(f, size) { function uint(f, size) {
if (f.length < size) if (f.length < size)
throw new Error("not enough data"); throw new Error("not enough data");
var n = 0; var n = 0;
for (var i = 0; i < size; i++) { for (var i = 0; i < size; i++) {
n *= 256; n *= 256;
n += f[i]; n += f[i];
} }
return n; return n;
} }
function u8(f) { return uint(f,1); } function u8(f) {return uint(f,1);}
function u16(f) { return uint(f,2); } function u16(f) {return uint(f,2);}
function u32(f) { return uint(f,4); } function u32(f) {return uint(f,4);}
function u64(f) { return uint(f,8); } function u64(f) {return uint(f,8);}
function decompress_pubkey(key_bytes) { function decompress_pubkey(key_bytes) {
var y_bit = u8(key_bytes.slice(0, 1)) & 0x01; var y_bit = u8(key_bytes.slice(0, 1)) & 0x01;
var ecparams = getSECCurveByName("secp256k1"); var ecparams = getSECCurveByName("secp256k1");
// build X // build X
var x = BigInteger.ZERO.clone(); var x = BigInteger.ZERO.clone();
x.fromString(Crypto.util.bytesToHex(key_bytes.slice(1, 33)), 16); x.fromString(Crypto.util.bytesToHex(key_bytes.slice(1, 33)), 16);
// get curve // get curve
var curve = ecparams.getCurve(); var curve = ecparams.getCurve();
var a = curve.getA().toBigInteger(); var a = curve.getA().toBigInteger();
var b = curve.getB().toBigInteger(); var b = curve.getB().toBigInteger();
var p = curve.getQ(); var p = curve.getQ();
// compute y^2 = x^3 + a*x + b // compute y^2 = x^3 + a*x + b
var tmp = x.multiply(x).multiply(x).add(a.multiply(x)).add(b).mod(p); var tmp = x.multiply(x).multiply(x).add(a.multiply(x)).add(b).mod(p);
// compute modular square root of y (mod p) // compute modular square root of y (mod p)
var y = tmp.modSqrt(p); var y = tmp.modSqrt(p);
// flip sign if we need to // flip sign if we need to
if( (y[0] & 0x01) != y_bit ) { if ((y[0] & 0x01) != y_bit) {
y = y.multiply(new BigInteger("-1")).mod(p); y = y.multiply(new BigInteger("-1")).mod(p);
} }
return new ECPointFp(curve, curve.fromBigInteger(x), curve.fromBigInteger(y)); return new ECPointFp(curve, curve.fromBigInteger(x), curve.fromBigInteger(y));
} }

Write Preview
Loading…
Cancel
Save