fix: support new and old, tests

Author: aulneau

packages/core/src/connect/message-signing/encoding.test.ts

@@ -2,19 +2,19 @@ import {
   encodeMessage as stacksEncodeMessage,
   hashMessage as stacksHashMessage,
 } from '@stacks/encryption';
-import { decodeMessage, encodeMessage, hashMessage } from './encoding';
+import { decodeMessage, encodeMessage, hashMessage, LEGACY_CHAIN_PREFIX_BYTES } from './encoding';
 import { bytesToHex, utf8ToBytes } from 'micro-stacks/common';
 import { concatBytes } from '@noble/hashes/utils';
 
 describe('encoding', function () {
   test('compat', () => {
     const message = stacksEncodeMessage('hi there');
-    const myMessage = encodeMessage('hi there');
+    const myMessage = encodeMessage('hi there', LEGACY_CHAIN_PREFIX_BYTES);
     expect(bytesToHex(message)).toEqual(bytesToHex(myMessage));
   });
   test('hashing', () => {
     const message = bytesToHex(stacksHashMessage('hi there'));
-    const myMessage = bytesToHex(hashMessage('hi there'));
+    const myMessage = bytesToHex(hashMessage('hi there', LEGACY_CHAIN_PREFIX_BYTES));
     expect(message).toEqual(myMessage);
   });
   // src: https://github.com/hirosystems/stacks.js/blob/a86f01e7a25a79ae9d3da0df5a654caf2bb7e9e9/packages/encryption/tests/messageSignature.test.ts

packages/core/src/connect/message-signing/encoding.ts

@@ -3,21 +3,29 @@ import { decode, encode, encodingLength } from './varuint';
 import { utf8ToBytes } from '@noble/hashes/utils';
 import { concatByteArrays } from 'micro-stacks/common';
 
-const chainPrefix = '\x17Stacks Signed Message:\n';
-const chainPrefixBytes = utf8ToBytes(chainPrefix);
+const CHAIN_PREFIX = '\x17Stacks Signed Message:\n';
+export const CHAIN_PREFIX_BYTES = utf8ToBytes(CHAIN_PREFIX);
+const LEGACY_CHAIN_PREFIX = '\x18Stacks Message Signing:\n';
+export const LEGACY_CHAIN_PREFIX_BYTES = utf8ToBytes(LEGACY_CHAIN_PREFIX);
 
-export function hashMessage(message: string | Uint8Array) {
-  return hashSha256(encodeMessage(message));
+export function hashMessage(message: string | Uint8Array, prefix: Uint8Array = CHAIN_PREFIX_BYTES) {
+  return hashSha256(encodeMessage(message, prefix));
 }
 
-export function encodeMessage(message: string | Uint8Array): Uint8Array {
+export function encodeMessage(
+  message: string | Uint8Array,
+  prefix: Uint8Array = CHAIN_PREFIX_BYTES
+): Uint8Array {
   const bytes = typeof message === 'string' ? utf8ToBytes(message) : message;
   const encoded = encode(bytes.length);
-  return concatByteArrays([chainPrefixBytes, encoded, bytes]);
+  return concatByteArrays([prefix, encoded, bytes]);
 }
 
-export function decodeMessage(encodedMessage: Uint8Array): Uint8Array {
-  const messageWithoutChainPrefix = encodedMessage.subarray(chainPrefixBytes.byteLength);
+export function decodeMessage(
+  encodedMessage: Uint8Array,
+  prefix: Uint8Array = CHAIN_PREFIX_BYTES
+): Uint8Array {
+  const messageWithoutChainPrefix = encodedMessage.subarray(prefix.byteLength);
   const decoded = decode(messageWithoutChainPrefix);
   const varIntLength = encodingLength(decoded);
   // Remove the varuint prefix

packages/core/src/connect/message-signing/verify.test.ts

@@ -23,7 +23,7 @@ import {
   verifyMessageSignature,
   verifyStructuredMessageSignature,
 } from './verify';
-import { hashMessage } from './encoding';
+import { hashMessage, LEGACY_CHAIN_PREFIX_BYTES } from './encoding';
 import { getStructuredDataHashes, makeStructuredDataHash } from './structured-message';
 import { publicKeyToStxAddress, StacksNetworkVersion } from 'micro-stacks/crypto';
 
@@ -91,7 +91,7 @@ describe('Verify messages (RSV mode)', () => {
   };
   const stxAddress = publicKeyToStxAddress(payload.publicKey);
 
-  const hash = hashMessage(message);
+  const hash = hashMessage(message, LEGACY_CHAIN_PREFIX_BYTES);
 
   // make sure we can get the public key
   test(getPublicKeyFromSignature.name, () => {

packages/core/src/connect/message-signing/verify.ts

@@ -1,6 +1,6 @@
 import { recoverPublicKey, Signature, verify } from '@noble/secp256k1';
 import { bytesToHex, hexToBigInt } from 'micro-stacks/common';
-import { hashMessage } from './encoding';
+import { hashMessage, LEGACY_CHAIN_PREFIX_BYTES } from './encoding';
 
 import { getStructuredDataHashes, makeStructuredDataHash } from './structured-message';
 import { StructuredSignatureRequestOptions } from './types';
@@ -55,13 +55,14 @@ export const recoverSignature = (options: { signature: string; mode?: 'vrs' | 'r
   };
 };
 
-export const verifyMessageSignature = (options: {
+export const _verifyMessageSignature = (options: {
   // string = message, bytes = hash
   message: string | Uint8Array;
   signature: string;
   publicKey?: string;
   stxAddress?: string;
   mode?: 'vrs' | 'rsv';
+  prefix?: Uint8Array;
 }) => {
   if (!options.publicKey && !options.stxAddress)
     throw Error(
@@ -72,7 +73,7 @@ export const verifyMessageSignature = (options: {
   let publicKey = options.publicKey;
 
   try {
-    const hash = typeof message === 'string' ? hashMessage(message) : message;
+    const hash = typeof message === 'string' ? hashMessage(message, options.prefix) : message;
     const { signature, recoveryBytes } = recoverSignature({
       signature: options.signature,
       mode,
@@ -109,13 +110,14 @@ export const verifyMessageSignature = (options: {
   }
 };
 
-export const verifyStructuredMessageSignature = (options: {
+const _verifyStructuredMessageSignature = (options: {
   message: StructuredSignatureRequestOptions['message'];
   domain: StructuredSignatureRequestOptions['domain'];
   signature: string;
   publicKey?: string;
   stxAddress?: string;
   mode?: 'vrs' | 'rsv';
+  prefix?: Uint8Array;
 }) => {
   if (!options.publicKey && !options.stxAddress)
     throw Error(
@@ -129,11 +131,47 @@ export const verifyStructuredMessageSignature = (options: {
 
   const hashBytes = makeStructuredDataHash(domain, message);
 
-  return verifyMessageSignature({
+  return _verifyMessageSignature({
     message: hashBytes,
     signature: options.signature,
     publicKey: options.publicKey,
     stxAddress: options.stxAddress,
     mode: options.mode,
+    prefix: options.prefix,
   });
 };
+
+export const verifyMessageSignature = (options: {
+  // string = message, bytes = hash
+  message: string | Uint8Array;
+  signature: string;
+  publicKey?: string;
+  stxAddress?: string;
+  mode?: 'vrs' | 'rsv';
+}) => {
+  const isValid = _verifyMessageSignature(options);
+  return isValid
+    ? true
+    : _verifyMessageSignature({
+        ...options,
+        prefix: LEGACY_CHAIN_PREFIX_BYTES,
+      });
+};
+
+export const verifyStructuredMessageSignature = (options: {
+  message: StructuredSignatureRequestOptions['message'];
+  domain: StructuredSignatureRequestOptions['domain'];
+  signature: string;
+  publicKey?: string;
+  stxAddress?: string;
+  mode?: 'vrs' | 'rsv';
+}) => {
+  const isValid = _verifyStructuredMessageSignature(options);
+  return (
+    isValid ??
+    _verifyStructuredMessageSignature({
+      ...options,
+      prefix: LEGACY_CHAIN_PREFIX_BYTES,
+    })
+  );
+};