Merge pull request #6210 from BitGo/BTC-2150.extractAddressFromPaygoAttestationProof

Author: davidkaplanbitgo

modules/utxo-core/src/index.ts

@@ -1,6 +1,7 @@
 export * as bip65 from './bip65';
 export * as descriptor from './descriptor';
 export * as testutil from './testutil';
+export * as paygo from './paygo';
 export * from './dustThreshold';
 export * from './Output';
 export * from './xOnlyPubkey';

modules/utxo-core/src/paygo/ExtractAddressPayGoAttestation.ts

@@ -0,0 +1,45 @@
+import assert from 'assert';
+
+import { bufferutils } from '@bitgo/utxo-lib';
+
+// The signed address will always have the following structure:
+// 0x18Bitcoin Signed Message:\n<varint_length><ENTROPY><ADDRESS><UUID>
+
+const PrefixLength = Buffer.from([0x18]).length + Buffer.from('Bitcoin Signed Message:\n').length;
+// UUID has the structure 00000000-0000-0000-0000-000000000000, and after
+// we Buffer.from and get it's length its 36.
+const UuidBufferLength = 36;
+// The entropy will always be 64 bytes
+const EntropyLen = 64;
+
+/**
+ * This function takes in the attestation proof of a PayGo address of the from
+ * 0x18Bitcoin Signed Message:\n<varint_length><ENTROPY><ADDRESS><UUID> and returns
+ * the address given its length. It is assumed that the ENTROPY is 64 bytes in the Buffer
+ * so if not given an address proof length we can still extract the address from the proof.
+ *
+ * @param message
+ * @param adressProofLength
+ */
+export function extractAddressBufferFromPayGoAttestationProof(message: Buffer): Buffer {
+  if (message.length <= PrefixLength + EntropyLen + UuidBufferLength) {
+    throw new Error('PayGo attestation proof is too short to contain a valid address');
+  }
+
+  // This generates the first part before the varint length so that we can
+  // determine how many bytes this is and iterate through the Buffer.
+  let offset = PrefixLength;
+
+  // we decode the varint of the message which is uint32
+  // https://en.bitcoin.it/wiki/Protocol_documentation
+  const varInt = bufferutils.varuint.decode(message, offset);
+  assert(varInt);
+  offset += 1;
+
+  const addressLength = varInt - EntropyLen - UuidBufferLength;
+  offset += EntropyLen;
+
+  // we return what the Buffer subarray from the offset (beginning of address)
+  // to the end of the address index in the buffer.
+  return message.subarray(offset, offset + addressLength);
+}

modules/utxo-core/src/paygo/index.ts

@@ -0,0 +1 @@
+export * from './ExtractAddressPayGoAttestation';

modules/utxo-core/src/testutil/generatePayGoAttestationProof.utils.ts

@@ -0,0 +1,43 @@
+import crypto from 'crypto';
+
+import { bufferutils } from '@bitgo/utxo-lib';
+/** We have a mirrored function similar to our hsm that generates our Bitcoin signed
+ * message so that we can use for testing. This creates a random entropy as well using
+ * the nilUUID structure to construct our uuid buffer and given our address we can
+ * directly encode it into our message.
+ *
+ * @param attestationPrvKey
+ * @param uuid
+ * @param address
+ * @returns
+ */
+export function generatePayGoAttestationProof(uuid: string, address: Buffer): Buffer {
+  // <0x18Bitcoin Signed Message:\n
+  const prefixByte = Buffer.from([0x18]);
+  const prefixMessage = Buffer.from('Bitcoin Signed Message:\n');
+  const prefixBuffer = Buffer.concat([prefixByte, prefixMessage]);
+
+  // <ENTROPY>
+  const entropyLength = 64;
+  const entropy = crypto.randomBytes(entropyLength);
+
+  // <UUID>
+  const uuidBuffer = Buffer.from(uuid);
+  const uuidBufferLength = uuidBuffer.length;
+
+  // <ADDRESS>
+  const addressBufferLength = address.length;
+
+  // <VARINT_LENGTH>
+  const msgLength = entropyLength + addressBufferLength + uuidBufferLength;
+  const msgLengthBuffer = bufferutils.varuint.encode(msgLength);
+
+  // <0x18Bitcoin Signed Message:\n<LENGTH><ENTROPY><ADDRESS><UUID>
+  const proofMessage = Buffer.concat([prefixBuffer, msgLengthBuffer, entropy, address, uuidBuffer]);
+
+  // we sign this with the priv key
+  // don't know what sign function to call. Since this is just a mirrored function don't know if we need
+  // to include this part.
+  // const signedMsg = sign(attestationPrvKey, proofMessage);
+  return proofMessage;
+}

modules/utxo-core/src/testutil/index.ts

@@ -1,3 +1,4 @@
 export * from './fixtures.utils';
 export * from './key.utils';
 export * from './toPlainObject.utils';
+export * from './generatePayGoAttestationProof.utils';

modules/utxo-core/test/paygo/ExtractAddressPayGoAttestation.ts

@@ -0,0 +1,43 @@
+import * as assert from 'assert';
+
+import { extractAddressBufferFromPayGoAttestationProof } from '../../src/paygo';
+import { generatePayGoAttestationProof } from '../../src/testutil';
+
+const addressFromPubKeyBase58 = 'bitgoAddressToExtract';
+const bufferAddressPubKeyB58 = Buffer.from(addressFromPubKeyBase58);
+
+describe('extractAddressBufferFromPayGoAttestationProof', () => {
+  it('should extractAddressBufferFromPayGoAttestationProof properly', () => {
+    const paygoAttestationProof = generatePayGoAttestationProof(
+      '00000000-0000-0000-0000-000000000000',
+      bufferAddressPubKeyB58
+    );
+    const addressFromProof = extractAddressBufferFromPayGoAttestationProof(paygoAttestationProof);
+    assert.deepStrictEqual(Buffer.compare(addressFromProof, bufferAddressPubKeyB58), 0);
+  });
+
+  it('should extract the paygo address paygo attestation proof given a non nilUUID', () => {
+    const paygoAttestationProof = generatePayGoAttestationProof(
+      '12345678-1234-4567-6890-231928472123',
+      bufferAddressPubKeyB58
+    );
+    const addressFromProof = extractAddressBufferFromPayGoAttestationProof(paygoAttestationProof);
+    assert.deepStrictEqual(Buffer.compare(addressFromProof, bufferAddressPubKeyB58), 0);
+  });
+
+  it('should not extract the correct address given a uuid of wrong format', () => {
+    const paygoAttestationProof = generatePayGoAttestationProof(
+      '000000000000000-000000-0000000-000000-0000000000000000',
+      bufferAddressPubKeyB58
+    );
+    const addressFromProof = extractAddressBufferFromPayGoAttestationProof(paygoAttestationProof);
+    assert.notDeepStrictEqual(Buffer.compare(addressFromProof, bufferAddressPubKeyB58), 0);
+  });
+
+  it('should throw an error if the paygo attestation proof is too short', () => {
+    assert.throws(
+      () => extractAddressBufferFromPayGoAttestationProof(Buffer.from('shortproof-shrug')),
+      'PayGo attestation proof is too short to contain a valid address.'
+    );
+  });
+});

modules/utxo-lib/src/index.ts

@@ -1,5 +1,7 @@
 export * from 'bitcoinjs-lib';
 
+export * as bufferutils from 'bitcoinjs-lib/src/bufferutils';
+
 export * as bitgo from './bitgo';
 
 export * as address from './address';