bitcoin.ECPair.prototype.sign = function (hash) {
if (!this.d) {
throw new Error('Missing private key');
}
var sig = secp256k1.sign(hash, this.d.toBuffer(32)).signature;
return bitcoin.ECSignature.fromDER(secp256k1.signatureExport(sig));
};
}).then(function (res) {
var sig = res.message.signature;
sig = sig.toHex ? sig.toHex() : sig;
var signature = bitcoin.ECSignature.parseCompact(new Buffer(sig, 'hex'));
return {
r: signature.signature.r,
s: signature.signature.s,
i: signature.i
};
});
.then((config) => {
t.ok(config, 'Config returned by connectToGaiaHub()')
t.equal(hubInfo.read_url_prefix, config.url_prefix)
t.equal(address, config.address)
t.equal(hubServer, config.server)
const verificationKey = bitcoin.ECPair.fromPublicKeyBuffer(Buffer.from(publicKey, 'hex'))
const decoded = JSON.parse(Buffer.from(config.token, 'base64').toString())
const signature = bitcoin.ECSignature.fromDER(Buffer.from(
decoded.signature, 'hex'))
t.ok(verificationKey.verify(
bitcoin.crypto.sha256(hubInfo.challenge_text), signature), 'Verified token')
})
}).then(function (result) {
var signature = bitcoin.ECSignature.fromDER(
new Buffer('30' + result.bytes(1).toString(HEX), 'hex')
);
var i;
if (dev.features.signMessageRecoveryParam) {
i = result.byteAt(0) & 0x01;
} else {
i = bitcoin.ecdsa.calcPubKeyRecoveryParam(
BigInteger.fromBuffer(bitcoin.message.magicHash(msg_plain)),
{ r: signature.r, s: signature.s },
pk.keyPair.Q
);
}
return {
r: signature.r,
s: signature.s,
i: i
};
});
/**
* Verify a signature on the given data
*
* ** For now assumes ec_secp256k1 **
*
* @param {String} public_key Hex-encoded public key
* @param {String} data Hex-encoded data
* @param {String} signature Hex-encoded signature
*/
function verify(public_key, data, signature) {
var pubkey = bitcoinjs.ECPubKey.fromHex(public_key);
var hash = bitcoinjs.crypto.hash256(new Buffer(data, 'hex'));
var ecsignature = bitcoinjs.ECSignature.fromDER(new Buffer(signature, 'hex'));
return pubkey.verify(hash, ecsignature);
}
return new Promise(function (resolve, reject) {
var key = _this.hdnode.keyPair;
var sig, siglenPointer;
if (schnorr) {
sig = secp256k1._malloc(64);
} else {
sig = secp256k1._malloc(128);
siglenPointer = secp256k1._malloc(4);
}
var msg = secp256k1._malloc(32);
var seckey = secp256k1._malloc(32);
var start = key.d.toByteArray().length - 32;
var slice;
if (start >= 0) { // remove excess zeroes
slice = key.d.toByteArray().slice(start);
} else { // add missing zeroes
slice = key.d.toByteArray();
while (slice.length < 32) slice.unshift(0);
}
secp256k1.writeArrayToMemory(slice, seckey);
if (!schnorr) {
secp256k1.setValue(siglenPointer, 128, 'i32');
}
var i;
for (i = 0; i < 32; ++i) {
secp256k1.setValue(msg + i, msgIn[i], 'i8');
}
var len = -1;
if (schnorr) {
if (secp256k1._secp256k1_schnorr_sign(
secp256k1ctx, sig, msg, seckey, 0, 0
) !== 1) {
reject('secp256k1 Schnorr sign failed');
} else {
len = 64;
}
} else {
len = -1;
var sigOpaque = secp256k1._malloc(64);
if (secp256k1._secp256k1_ecdsa_sign(
secp256k1ctx, sigOpaque, msg, seckey, 0, 0
) !== 1) {
reject('secp256k1 ECDSA sign failed');
} else if (secp256k1._secp256k1_ecdsa_signature_serialize_der(
secp256k1ctx, sig, siglenPointer, sigOpaque
) !== 1) {
reject('secp256k1 ECDSA signature serialize failed');
} else {
len = secp256k1.getValue(siglenPointer, 'i32');
}
secp256k1._free(sigOpaque);
}
if (len !== -1) {
var ret = new Buffer(len);
for (i = 0; i < len; ++i) {
ret.writeUInt8(secp256k1.getValue(sig + i, 'i8') & 0xff, i);
}
if (schnorr) {
resolve(ret);
} else {
resolve(bitcoin.ECSignature.fromDER(ret));
}
}
secp256k1._free(sig);
if (!schnorr) {
secp256k1._free(siglenPointer);
}
secp256k1._free(msg);
secp256k1._free(seckey);
});