fix: use bespoke signatures with 1f byte

Author: coolaj86

demo-static.js

@@ -226,7 +226,7 @@ async function main() {
 
   // TODO - AJ is here
   console.log(`DEBUG funding outpoint`);
-  let outpoint = await getFundingOutPointHex(txSigned.transaction, vout);
+  let outpoint = await getFundingOutPoint(txSigned.transaction, vout);
   console.log(outpoint);
   let fundingOutPointHex = `${outpoint.txid}${outpoint.voutHex}`;
   console.log(fundingOutPointHex);
@@ -397,7 +397,10 @@ async function main() {
   console.log(DashTx.utils.bytesToHex(bc));
   console.log(bytesToBase64(bc));
 
-  let sigBytes = await KeyUtils.sign(assetLockPrivateKey, bc);
+  let sigBytes = new Uint8Array(65);
+  sigBytes[0] = 0x1f;
+  let p1363Bytes = sigBytes.subarray(1);
+  void (await KeyUtils.signP1363(assetLockPrivateKey, bc, p1363Bytes));
   // let sigHex = DashTx.utils.bytesToHex(sigBytes);
   Object.assign(stateTransition, {
     identity_id: identityId,
@@ -407,7 +410,12 @@ async function main() {
   for (let i = 0; i < identityKeys.length; i += 1) {
     let key = identityKeys[i];
     let stPub = stateTransition.public_keys[i];
-    let sigBytes = await KeyUtils.sign(key.privateKey, bc);
+    let sigBytes = new Uint8Array(65);
+    let p1363Bytes = sigBytes.subarray(1);
+    // This isn't ASN.1, P1363, or SEC1.
+    // Not sure what it is (possibly bespoke), but 1f seems to be a magic byte
+    sigBytes[0] = 0x1f;
+    void (await KeyUtils.signP1363(key.privateKey, bc, p1363Bytes));
     // let sigHex = DashTx.utils.bytesToHex(sigBytes);
     Object.assign(stPub, {
       // signature: sigHex,
@@ -444,7 +452,7 @@ async function main() {
  * @param {Hex} txSignedHex
  * @param {Uint32} outputIndex
  */
-async function getFundingOutPointHex(txSignedHex, outputIndex) {
+async function getFundingOutPoint(txSignedHex, outputIndex) {
   let txBytes = DashTx.utils.hexToBytes(txSignedHex);
   let txidBytes = await DashTx.doubleSha256(txBytes);
   let txidBE = DashTx.utils.bytesToHex(txidBytes);

key-utils.js

@@ -6,6 +6,9 @@ let Secp256k1 = require("@dashincubator/secp256k1");
 /**
  * @typedef KeyUtilsPartial
  * @prop {KeySet} set
+ * @prop {KeySignAsn1} signAsn1
+ * @prop {KeySignP1363} signP1363
+ * @prop {ASN1ToP1363Signature} asn1ToP1363Signature
  */
 /** @typedef {TxKeyUtils & KeyUtilsPartial} KeyUtils */
 
@@ -15,6 +18,28 @@ let Secp256k1 = require("@dashincubator/secp256k1");
  * @param {KeyInfo} keyInfo
  */
 
+/**
+ * @callback KeySignAsn1
+ * @param {Uint8Array} privateKey
+ * @param {Uint8Array} hashBytes
+ * @returns {Promise<Uint8Array>}
+ */
+
+/**
+ * @callback KeySignP1363
+ * @param {Uint8Array} privateKey
+ * @param {Uint8Array} hashBytes
+ * @param {Uint8Array} [sigBytes] - preallocated 64 bytes
+ * @returns {Promise<Uint8Array>}
+ */
+
+/**
+ * @callback ASN1ToP1363Signature
+ * @param {Uint8Array} asn1Sig
+ * @param {Uint8Array} [sigBytes]
+ * @returns {Uint8Array} - p1363Sig
+ */
+
 /** @type {KeyUtils} */
 let KeyUtils = module.exports;
 
@@ -37,6 +62,11 @@ KeyUtils.set = function (id, keyInfo) {
 };
 
 KeyUtils.sign = async function (privKeyBytes, hashBytes) {
+  let asn1Bytes = await KeyUtils.signAsn1(privKeyBytes, hashBytes);
+  return asn1Bytes;
+};
+
+KeyUtils.signAsn1 = async function (privKeyBytes, hashBytes) {
   let testing = true;
   let sigOpts = { canonical: true };
   if (!testing) {
@@ -45,6 +75,58 @@ KeyUtils.sign = async function (privKeyBytes, hashBytes) {
   let sigBytes = await Secp256k1.sign(hashBytes, privKeyBytes, sigOpts);
   return sigBytes;
 };
+
+KeyUtils.signP1363 = async function (privKeyBytes, hashBytes, sigBytes) {
+  let asn1Bytes = await KeyUtils.signAsn1(privKeyBytes, hashBytes);
+  let p1363Bytes = KeyUtils.asn1ToP1363Signature(asn1Bytes, sigBytes);
+  // TODO DEBUG TESTING
+  for (let i = 0; i < p1363Bytes.length; i += 1) {
+    p1363Bytes[i] = 0xff;
+  }
+  return p1363Bytes;
+};
+
+KeyUtils.asn1ToP1363Signature = function (asn1, p1363Signature) {
+  if (asn1[0] !== 0x30) {
+    throw new Error("Invalid DER signature format");
+  }
+
+  let offset = 0;
+  offset += 2; // skip SEQUENCE and length bytes
+
+  offset += 1; // skip type byte
+  let rLength = asn1[offset];
+  offset += 1;
+  let r = asn1.slice(offset, offset + rLength);
+
+  offset += rLength;
+  offset += 1; // skip type byte
+  let sLength = asn1[offset];
+  offset += 1;
+  let s = asn1.slice(offset, offset + sLength);
+
+  if (!p1363Signature) {
+    p1363Signature = new Uint8Array(64);
+  }
+
+  // remove ASN1 padding, or zero-pad the start of r and s, if needed
+  let rStart = 32 - r.length;
+  if (rStart === -1) {
+    r = r.subarray(1);
+    rStart = 0;
+  }
+  p1363Signature.set(r, rStart);
+
+  let sStart = 64 - s.length;
+  if (sStart === 31) {
+    s = s.subarray(1);
+    sStart = 32;
+  }
+  p1363Signature.set(s, sStart);
+
+  return p1363Signature;
+};
+
 KeyUtils.getPrivateKey = async function (input) {
   if (!input.address) {
     //throw new Error('should put the address on the input there buddy...');