@bitpay-labs/bitcore-wallet-service 11.10.6 → 11.10.8

package/src/lib/model/copayer.ts

@@ -54,6 +54,7 @@ export class Copayer {
   isMarketingStaff?: boolean;
 
   static xPubToCopayerId(coin, xpub) {
+    $.checkArgument(xpub, 'Missing xPubKey for copayer id derivation');
     const str = coin == Defaults.COIN ? xpub : coin + xpub;
     const hash = sjcl.hash.sha256.hash(str);
     return sjcl.codec.hex.fromBits(hash);

package/src/lib/model/tsskeygen.ts

@@ -103,14 +103,36 @@ export class TssKeyGenModel implements ITssKeyGenModel {
   __v: number;
 
 
-  static create(params: { id: string; message: ITssKeyMessageObject; n: number; copayerId: string; passwordHash?: string }): TssKeyGenModel {
-    const { id, message, n, copayerId, passwordHash } = params;
+  /**
+   * Create a new TssKeyGenModel instance. This is used to create a new TSS keygen session.
+   */
+  static create(params: {
+    /** Session ID */
+    id: string;
+    /** Initial broadcast message from party 0 */
+    message: ITssKeyMessageObject;
+    /** Number of key participants */
+    n: number;
+    /** Copayer ID of party 0 */
+    copayerId: string;
+    /** Password hash for joining the session */
+    passwordHash?: string;
+    /** TSS keygen version */
+    version: number;
+    /** Time limit for the session in minutes, after which the session expires */
+    timeLimit?: number;
+  }): TssKeyGenModel {
+    const { id, message, n, copayerId, passwordHash, version } = params;
     const { partyId } = message;
+    const timeLimit = parseFloat(params.timeLimit?.toString());
     $.checkArgument(partyId === 0, 'Key generation session must be started by partyId 0');
+    $.checkArgument(!timeLimit || (Number.isFinite(timeLimit) && timeLimit > 0), 'Time limit must be a positive number');
+
+    const ONE_MINUTE = 60 * 1000;
 
     const x = new TssKeyGenModel();
     x.id = id;
-    x.schemeVersion = Defaults.TSS_KEYGEN_SCHEME_VERSION;
+    x.schemeVersion = version || Defaults.TSS_KEYGEN_SCHEME_VERSION;
     x.n = n;
     x.participants = new Array(n);
     x.participants[partyId] = copayerId;
@@ -121,7 +143,7 @@ export class TssKeyGenModel implements ITssKeyGenModel {
     x.joinPassword = passwordHash;
     x.keyShares = new Array(n);
     x.createdOn = Date.now();
-    x.timeLimit = null; // TODO - add a session time limit
+    x.timeLimit = Math.min(timeLimit || Defaults.TSS_KEYGEN_TIME_LIMIT, 60) * ONE_MINUTE; // capped at 60 minutes
     x.__v = 0;
     return x;
   }
@@ -151,4 +173,11 @@ export class TssKeyGenModel implements ITssKeyGenModel {
     }
     return mostRecentRound;
   }
+
+  isExpired(): boolean {
+    if (!this.timeLimit) {
+      return false;
+    }
+    return Date.now() > this.createdOn + this.timeLimit;
+  }
 }

package/src/lib/model/tsssign.ts

@@ -1,5 +1,8 @@
+import { singleton } from 'preconditions';
 import { Common } from '../common';
 
+const $ = singleton();
+
 const { Defaults } = Common;
 
 
@@ -60,6 +63,14 @@ export interface ITssSigGenModel {
     fromPartyId: number;
     messages: ITssSigMessageObject;
   }>>;
+  /**
+   * Timestamp the session was created
+   */
+  createdOn: number;
+  /**
+   * Session expires after this many milliseconds.
+   */
+  timeLimit?: number;
   /**
    * The signature generated as the result of the TSS signature generation process.
    * The signature can be generated along a derivation path, which produces a pubKey that's
@@ -90,16 +101,27 @@ export class TssSigGenModel implements ITssSigGenModel {
   }>>;
   signature?: ITssSigMessageObject['signature'];
   schemeVersion: number;
+  createdOn: number;
+  timeLimit?: number;
   __v: number;
 
 
-  static create(params: { id: string; message: ITssSigMessageObject; m: number; copayerId: string }): TssSigGenModel {
-    const { id, message, m, copayerId } = params;
+  static create(params: { id: string; message: ITssSigMessageObject; m: number; copayerId: string; version: number; timeLimit?: number }): TssSigGenModel {
+    const { id, message, m, copayerId, version } = params;
     const { partyId } = message;
+    const timeLimit = parseFloat(params.timeLimit?.toString());
+    $.checkArgument(!timeLimit || (Number.isFinite(timeLimit) && timeLimit > 0), 'Time limit must be a positive number');
+
+    const MAX_TIME_LIMIT = 7 * 24 * 60; // 7 days in minutes
+    const ONE_MINUTE = 60 * 1000;
 
     const x = new TssSigGenModel();
     x.id = id;
-    x.schemeVersion = Defaults.TSS_SIGGEN_SCHEME_VERSION;
+    x.schemeVersion = version || Defaults.TSS_SIGGEN_SCHEME_VERSION;
+    x.createdOn = Date.now();
+    x.timeLimit = (timeLimit === 0
+      ? MAX_TIME_LIMIT
+      : Math.min(timeLimit || Defaults.TSS_SIGGEN_TIME_LIMIT, MAX_TIME_LIMIT)) * ONE_MINUTE;
     x.m = m;
     x.participants = [{
       partyId,
@@ -117,6 +139,8 @@ export class TssSigGenModel implements ITssSigGenModel {
     const x = new TssSigGenModel();
     x.id = obj.id;
     x.schemeVersion = obj.schemeVersion;
+    x.createdOn = obj.createdOn;
+    x.timeLimit = obj.timeLimit;
     x.m = obj.m;
     x.participants = obj.participants;
     x.rounds = obj.rounds;
@@ -133,4 +157,11 @@ export class TssSigGenModel implements ITssSigGenModel {
     }
     return mostRecentRound;
   }
+
+  isExpired(): boolean {
+    if (!this.timeLimit) {
+      return false;
+    }
+    return Date.now() > this.createdOn + this.timeLimit;
+  }
 }

package/src/lib/pushnotificationsservice.ts

@@ -224,6 +224,7 @@ export class PushNotificationsService {
                 const chain = notification?.data?.chain || notification?.data?.coin;
                 const coin = chain; // backwards compatibility
                 const network = notification?.data?.network ? Utils.getNetworkName(chain, notification.data.network) : null;
+                const txid = typeof notification?.data?.txid === 'string' ? notification.data.txid : null;
 
                 if (sub.token) {
                   notificationData = {
@@ -267,10 +268,11 @@ export class PushNotificationsService {
                     network,
                     tokenAddress,
                     multisigContractAddress,
+                    txid,
                     title,
                     body
                   };
-                  const custom_uri = `bitpay://wallet?walletId=${walletId}&tokenAddress=${tokenAddress}&multisigContractAddress=${multisigContractAddress}&copayerId=${copayerId}&coin=${coin}&chain=${chain}&network=${network}&notification_type=${notification_type}&title=${title}&body=${body}`;
+                  const custom_uri = `bitpay://wallet?walletId=${walletId}&tokenAddress=${tokenAddress}&multisigContractAddress=${multisigContractAddress}&copayerId=${copayerId}&coin=${coin}&chain=${chain}&network=${network}&notification_type=${notification_type}&txid=${txid}&title=${title}&body=${body}`;
                   notificationData = {
                     external_user_ids: [sub.externalUserId],
                     messages: {

package/src/lib/routes/middleware/authTssRequest.ts

@@ -5,7 +5,8 @@ import { Errors } from '../../errors/errordefinitions';
 import { WalletService, checkRequired } from '../../server';
 import { error } from '../helpers';
 import { getCredentials, getMessage } from './authRequest';
-
+import type { TssKeyGenModel } from '../../model/tsskeygen';
+import type { TssSigGenModel } from '../../model/tsssign';
 
 /**
  * Middleware to authenticate TSS requests and attach the TSS session to the request.
@@ -13,7 +14,6 @@ import { getCredentials, getMessage } from './authRequest';
  * and retrieves the TSS session based on the request path.
  */
 export function authTssRequest(): express.RequestHandler {
-
   return async function(req, res, next) {
     try {
       const storage = WalletService.getStorage();
@@ -28,7 +28,8 @@ export function authTssRequest(): express.RequestHandler {
       } = credentials;
       
       const { id } = req.params as { [key: string]: string };
-      let session;
+
+      let session: TssKeyGenModel | TssSigGenModel | null = null;
       let partyId = null;
       let pubKey = null;
       if (req.path.includes('/tss/keygen/')) {
@@ -38,7 +39,9 @@ export function authTssRequest(): express.RequestHandler {
       } else if (req.path.includes('/tss/sign/')) {
         session = await storage.fetchTssSigSession({ id });
         partyId = session?.participants.find(p => p.copayerId === copayerId)?.partyId;
-        pubKey = partyId == null ? null : session.rounds[0].find(r => r.fromPartyId === partyId).messages.publicKey;
+        pubKey = partyId == null ? null : session?.rounds[0]?.find(r => r.fromPartyId === partyId)?.messages.publicKey;
+      } else {
+        throw new Error('Unknown TSS request path: ' + req.path);
       }
 
       if (!session) {
@@ -47,6 +50,9 @@ export function authTssRequest(): express.RequestHandler {
       if (!pubKey) {
         throw Errors.NOT_AUTHORIZED.withMessage('Copayer not found in session');
       }
+      if (session.isExpired()) {
+        throw Errors.TSS_SESSION_EXPIRED;
+      }
 
       const message = getMessage(req);
       const isValid = !!Utils.verifyMessage(message, signature, pubKey);

package/src/lib/routes/middleware/verifyTssMessage.ts

@@ -1,7 +1,9 @@
 import { utils as tssUtils } from '@bitpay-labs/bitcore-tss';
+import { ClientError } from '../../errors/clienterror';
 import { Errors } from '../../errors/errordefinitions';
-import { ITssKeyMessageObject } from '../../model/tsskeygen';
-import { ITssSigMessageObject } from '../../model/tsssign';
+import { error } from '../helpers';
+import type { ITssKeyMessageObject } from '../../model/tsskeygen';
+import type { ITssSigMessageObject } from '../../model/tsssign';
 
 
 export async function verifyTssMessage(req, res, next) {
@@ -9,16 +11,16 @@ export async function verifyTssMessage(req, res, next) {
     const { message }: { message: ITssKeyMessageObject | ITssSigMessageObject } = req.body;
     const { publicKey } = message || {};
     if (!publicKey) {
-      return res.status(400).send(Errors.TSS_PUBKEY_MISSING);
+      throw Errors.TSS_PUBKEY_MISSING;
     }
 
     if (!message.broadcastMessages?.length && !message.p2pMessages?.length) {
-      return res.status(400).send(Errors.TSS_INVALID_MESSAGE);
+      throw Errors.TSS_INVALID_MESSAGE;
     }
 
     for (const m of message.broadcastMessages) {
       if (!tssUtils.verifySignedData(m.payload, publicKey)) {
-        return res.status(400).send(Errors.TSS_INVALID_MESSAGE_SIG);
+        throw Errors.TSS_INVALID_MESSAGE_SIG;
       };
     }
     for (const m of message.p2pMessages) {
@@ -26,12 +28,15 @@ export async function verifyTssMessage(req, res, next) {
       //  `m.payload.signature` is for the unencrypted message.
       //  Only the recipients can verify on the client side.
       if (!m.payload || !m.payload.encryptedMessage || !m.payload.signature) {
-        return res.status(400).send(Errors.TSS_INVALID_MESSAGE_SIG);
+        throw Errors.TSS_INVALID_MESSAGE_SIG;
       }
     }
     return next();
-  } catch {
-    return res.status(400).send(Errors.TSS_INVALID_MESSAGE);
+  } catch (err) {
+    if (err instanceof ClientError) {
+      return error.returnError(err, res, req);
+    }
+    return error.returnError(Errors.TSS_INVALID_MESSAGE, res, req);
   }
 };
 

package/src/lib/routes/tss.ts

@@ -21,12 +21,15 @@ export class TssRouter {
     const { returnError, opts } = params;
     const router = express.Router();
     
+    /** Key generation methods */
+
     router.post('/v1/tss/keygen/:id', createWalletLimiter(opts), verifyTssMessage, async function(req, res) {
       try {
         const id = req.params.id;
-        const { message, n, password } = req.body;
+        // version was not given by client until 1.1, so fallback to 1.0
+        const { message, n, password, version = 1.0, timeLimit } = req.body;
         const copayerId = req.headers['x-identity'];
-        await TssKeyGen.processMessage({ id, message, n, password, copayerId });
+        await TssKeyGen.processMessage({ id, message, n, password, copayerId, version, timeLimit });
         return res.send();
       } catch (err) {
         return returnError(err ?? 'unknown', res, req);
@@ -84,12 +87,16 @@ export class TssRouter {
       }
     });
 
+
+    /** Signature Methods */
+
     router.post('/v1/tss/sign/:id', authRequest(), verifyTssMessage, async function(req, res) {
       try {
         const id = req.params.id;
-        const { message, m } = req.body;
+        // version was not given by client until 1.1, so fallback to 1.0
+        const { message, m, version = 1.0, timeLimit } = req.body;
         const copayerId = req.headers['x-identity'];
-        await TssSign.processMessage({ id, message, m, copayerId });
+        await TssSign.processMessage({ id, message, m, copayerId, version, timeLimit });
         return res.send();
       } catch (err) {
         return returnError(err ?? 'unknown', res, req);

package/src/lib/server.ts

@@ -668,15 +668,17 @@ export class WalletService implements IWalletService {
     }
 
     if (opts.tssKeyId) {
-      opts.tssVersion = opts.tssVersion || Defaults.TSS_KEYGEN_SCHEME_VERSION;
-      if (!(opts.tssVersion > 0 && opts.tssVersion <= Constants.TSS_KEYGEN_SCHEME_VERSION_MAX)) {
-        return cb(new ClientError('Invalid TSS version'));
-      }
-
       const keySession = await storage.fetchTssKeyGenSession({ id: opts.tssKeyId });
       if (!keySession || !keySession.sharedPublicKey) {
+        // TODO: support importing a TSS key that was generated outside of this BWS instance.
         return cb(new ClientError('Invalid TSS key session id'));
       }
+
+      opts.tssVersion = opts.tssVersion || keySession.schemeVersion || Defaults.TSS_KEYGEN_SCHEME_VERSION;
+      if (!(opts.tssVersion >= Constants.TSS_KEYGEN_SCHEME_VERSION_MIN && opts.tssVersion <= Constants.TSS_KEYGEN_SCHEME_VERSION_MAX)) {
+        return cb(new ClientError('Invalid TSS version'));
+      }
+
       // TSS wallets behave like a single-sig
       opts.m = 1;
       opts.n = 1;
@@ -1144,9 +1146,13 @@ export class WalletService implements IWalletService {
         if (err) return cb(err);
         if (!wallet) return cb(Errors.NOT_AUTHORIZED);
 
-        const xPubKey = wallet.copayers.find(c => c.id === opts.copayerId).xPubKey;
+        const target = wallet.copayers.find(c => c.id === opts.copayerId);
+        if (!target?.xPubKey) return cb(Errors.NOT_AUTHORIZED);
 
-        if (!this._verifyRequestPubKey(opts.requestPubKey, opts.signature, xPubKey)) {
+        try {
+          const isValid = this._verifyRequestPubKey(opts.requestPubKey, opts.signature, target.xPubKey);
+          if (!isValid) return cb(Errors.NOT_AUTHORIZED);
+        } catch (e) {
           return cb(Errors.NOT_AUTHORIZED);
         }
 
@@ -1207,7 +1213,17 @@ export class WalletService implements IWalletService {
    * @param {boolean} [opts.dryRun] Simulate the action but do not change server state.
    */
   joinWallet(opts, cb) {
-    if (!checkRequired(opts, ['walletId', 'name', 'requestPubKey', 'copayerSignature'], cb)) return;
+    // xPubKey is the canonical copayer identity in the current protocol. Alternate public-key
+    // fields are ancillary metadata; supporting an xPubKey-less copayer requires a versioned
+    // end-to-end identity protocol rather than a local identity fallback.
+    // SECURITY: xPubKey is required for every join, including hardwareSourcePublicKey/
+    // clientDerivedPublicKey ones. Copayer.xPubToCopayerId() (called below both for the TSS
+    // participant check and inside Copayer.create()) now throws on a missing xpub for every
+    // coin (see its own guard), so an xPubKey-less join can no longer derive a copayer id at
+    // all. bitcore-wallet-client's only join path (_doJoinWallet) always sends a real
+    // xPubKey regardless of these two fields, so this doesn't restrict any flow this repo's
+    // own client exercises - see the TSS-participant comment below for how that was confirmed.
+    if (!checkRequired(opts, ['walletId', 'name', 'requestPubKey', 'copayerSignature', 'xPubKey'], cb)) return;
     if (!opts.name) return cb(new ClientError('Invalid copayer name'));
 
     opts.coin = opts.coin || Defaults.COIN;
@@ -1216,17 +1232,17 @@ export class WalletService implements IWalletService {
     }
     if (!Utils.checkValueInCollection(opts.chain, Constants.CHAINS)) return cb(new ClientError('Invalid coin'));
 
+    // xPubKey is parsed and validated for every join; ancillary fields never suppress it.
+    // A future update will re-add conditional logic which allows opts.hardwareSourcePublicKey
+    // or opts.clientDerivedPublicKey to circumvent this requirement
     let xPubKey;
-    if (!opts.hardwareSourcePublicKey && !opts.clientDerivedPublicKey) {
-      if (!checkRequired(opts, ['xPubKey'], cb)) return;
-      try {
-        xPubKey = Bitcore_[opts.chain].HDPublicKey(opts.xPubKey);
-      } catch {
-        return cb(new ClientError('Invalid extended public key'));
-      }
-      if (xPubKey.network == null) {
-        return cb(new ClientError('Invalid extended public key'));
-      }
+    try {
+      xPubKey = Bitcore_[opts.chain].HDPublicKey(opts.xPubKey);
+    } catch {
+      return cb(new ClientError('Invalid extended public key'));
+    }
+    if (xPubKey.network == null) {
+      return cb(new ClientError('Invalid extended public key'));
     }
 
     this.walletId = opts.walletId;
@@ -1235,10 +1251,9 @@ export class WalletService implements IWalletService {
         if (err) return cb(err);
         if (!wallet) return cb(Errors.WALLET_NOT_FOUND);
 
-        if ((opts.hardwareSourcePublicKey || opts.clientDerivedPublicKey) && !opts.tssKeyId) {
-          this._addCopayerToWallet(wallet, opts, cb);
-          return;
-        }
+        // SECURITY: opts.hardwareSourcePublicKey or opts.clientDerivedPublicKey may not
+        // circumvent the required checks below. A future update may enable either to replace xPubKey
+        // That is currently not supported
 
         if (this._upgradeNeeded(UPGRADES.BCH_bwc_$lt_8_3_multisig, { chain: opts.chain, n: wallet.n })) {
           return cb(Errors.UPGRADE_NEEDED.withMessage('BWC clients < 8.3 are no longer supported for multisig BCH wallets.'));
@@ -2398,6 +2413,7 @@ export class WalletService implements IWalletService {
 
           this.getSendMaxInfo(
             {
+              feeLevel: opts.feeLevel,
               feePerKb: opts.feePerKb,
               excludeUnconfirmedUtxos: !!opts.excludeUnconfirmedUtxos,
               returnInputs: true,
@@ -3138,7 +3154,14 @@ export class WalletService implements IWalletService {
    * @returns {Object} txProposal
    */
   getTxByHash(opts, cb) {
-    this.storage.fetchTxByHash(opts.txid, (err, txp) => {
+    if (!checkRequired(opts, 'txid', cb)) return;
+
+    // Scoped to this.walletId: the global storage.fetchTxByHash
+    // would return any wallet's TxProposal for a known txid, disclosing a
+    // foreign wallet's proposal data to any authenticated copayer. The
+    // internal global consumers (BlockchainMonitor, getWalletFromIdentifier)
+    // are unaffected; they keep calling storage.fetchTxByHash directly.
+    this.storage.fetchTxByHashForWallet(this.walletId, opts.txid, (err, txp) => {
       if (err) return cb(err);
       if (!txp) return cb(Errors.TX_NOT_FOUND);
 
@@ -3249,7 +3272,7 @@ export class WalletService implements IWalletService {
         {
           txProposalId: opts.txProposalId
         },
-        (err, txp) => {
+        (err, txp: TxProposal) => {
           if (err) return cb(err);
 
           if (!txp.isPending()) return cb(Errors.TX_NOT_PENDING);
@@ -3257,7 +3280,13 @@ export class WalletService implements IWalletService {
           const deleteLockTime = this.getRemainingDeleteLockTime(txp);
           if (deleteLockTime > 0) return cb(Errors.TX_CANNOT_REMOVE);
 
-          this.storage.removeTx(this.walletId, txp.id, () => {
+          this.storage.removeTx(this.walletId, txp.id, async () => {
+            try { 
+              const inputPaths = Array.isArray(txp.inputPaths) && txp.inputPaths?.length ? txp.inputPaths : [txp.inputPaths || 'm/0/0']; // doesn't actually matter what's in the array
+              await Promise.all(inputPaths.map((_, i) => this.storage.removeTssSigSession({ id: `${txp.id}:input${i}` })));
+            } catch (err) {
+              logger.warn('Error removing tss sig session for wallet %s txp %s: %o', this.walletId, txp.id, err);
+            }
             this._notifyTxProposalAction('TxProposalRemoved', txp, cb);
           });
         }

package/src/lib/storage.ts

@@ -360,6 +360,25 @@ export class Storage {
     );
   }
 
+  // Wallet-scoped counterpart to fetchTxByHash, used by the authenticated
+  // by-hash API read.
+  fetchTxByHashForWallet(walletId: string, hash, cb: (err?: any, tx?: TxProposal) => void) {
+    if (!this.db) return cb();
+
+    this.db.collection(collections.TXS).findOne(
+      {
+        walletId,
+        txid: hash
+      },
+      (err, result) => {
+        if (err) return cb(err);
+        if (!result) return cb();
+
+        return this._completeTxData(walletId, TxProposal.fromObj(result), cb);
+      }
+    );
+  }
+
   fetchLastTxs(walletId, creatorId, limit, cb) {
     this.db
       .collection(collections.TXS)
@@ -1910,7 +1929,7 @@ export class Storage {
 
   async storeTssSignature({ id, signature }: { id: string; signature: ITssSigMessageObject['signature'] }) {
     return this.db.collection(collections.TSS_SIGN).updateOne(
-      { id },
+      { id, $or: [{ signature: null }, { signature: { $exists: false } }] },
       {
         $set: {
           signature
@@ -1920,4 +1939,8 @@ export class Storage {
     );
   }
 
+  async removeTssSigSession({ id }: { id: string }) {
+    return this.db.collection(collections.TSS_SIGN).deleteOne({ id }, { w: 1 });
+  }
+
 }