9351915506

Committed 03 Jun 2024 02:21PM UTC coverage: 92.846% (+0.04%) from 92.811%

Build # 9351915506

Build Type

push

github

Committed by

web-flow

Commit Message

Improve imitation detection to cover incoming (and multiple) transfers (#1564)

This improves address poisoning detection in the following manner:

- Comparison now occurs relative to a "lookup distance". This means that multiple imitation transafers within that distance, relative to the legitimate transaction are detected.
- Incoming transfers are also now detected.
- Imitation tokens that leverage varying decimals are also now detected.

Run Details

2007 of 2452 branches covered (81.85%)

Branch coverage included in aggregate %.

30 of 36 new or added lines in 2 files covered. (83.33%)

2 existing lines in 1 file now uncovered.

7117 of 7375 relevant lines covered (96.5%)

328.08 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.91

/src/routes/transactions/mappers/transfers/transfer-imitation.mapper.ts

import { IConfigurationService } from '@/config/configuration.service.interface';
import { TransactionItem } from '@/routes/transactions/entities/transaction-item.entity';
import {
  isTransferTransactionInfo,
  TransferDirection,
  TransferTransactionInfo,
} from '@/routes/transactions/entities/transfer-transaction-info.entity';
import { isErc20Transfer } from '@/routes/transactions/entities/transfers/erc20-transfer.entity';
import { Inject } from '@nestjs/common';
import { formatUnits } from 'viem';

export class TransferImitationMapper {
  private static ETH_DECIMALS = 18;

  private readonly lookupDistance: number;
  private readonly prefixLength: number;
  private readonly suffixLength: number;

  constructor(
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
  ) {
    this.lookupDistance = configurationService.getOrThrow(
      'mappings.imitation.lookupDistance',
    );
    this.prefixLength = configurationService.getOrThrow(
      'mappings.imitation.prefixLength',
    );
    this.suffixLength = configurationService.getOrThrow(
      'mappings.imitation.suffixLength',
    );
  }

  /**
   * Flags or filters (according to {@link args.showImitations}) transactions
   * that are likely imitations, based on the value and vanity of the address of
   * the sender or recipient.
   *
   * Note: does not support batched transactions as we have no transaction data
   * to decode the individual transactions from.
   *
   * @param args.transactions - transactions to map
   * @param args.previousTransaction - first transaction of the next page
   * @param args.showImitations - whether to filter out imitations
   *
   * @returns - mapped transactions
   */
  mapImitations(args: {
    transactions: Array<TransactionItem>;
    previousTransaction: TransactionItem | undefined;
    showImitations: boolean;
  }): Array<TransactionItem> {
    const mappedTransactions: Array<TransactionItem> = [];

    // Iterate in reverse order as transactions are date descending
    for (let i = args.transactions.length - 1; i >= 0; i--) {
      const item = args.transactions[i];

      // Executed by Safe - cannot be imitation
      if (item.transaction.executionInfo) {
        mappedTransactions.unshift(item);
        continue;
      }

      const txInfo = item.transaction.txInfo;
      // Only transfers can be imitated, of which we are only interested in ERC20s
      if (
        !isTransferTransactionInfo(txInfo) ||
        !isErc20Transfer(txInfo.transferInfo)
      ) {
        mappedTransactions.unshift(item);
        continue;
      }

      /**
       * Transactions to compare for imitation against, limited by a lookup distance.
       *
       * Concatenation takes preference of already mapped transactions over their
       * original in order to prevent comparison against duplicates.
       * Its length is {@link transactions} + 1 as {@link previousTransaction}
       * is appended to compare {@link transactions.at(-1)} against.
       */
      const prevItems = mappedTransactions
        .concat(args.transactions.slice(i - 1), args.previousTransaction ?? [])
        // Only compare so far back
        .slice(0, this.lookupDistance);

      if (prevItems.length === 0) {
        txInfo.transferInfo.imitation = false;
        mappedTransactions.unshift(item);
        continue;
      }

      // Imitation transfers often employ differing decimals to prevent direct
      // comparison of values. Here we normalize the value
      const formattedValue = this.formatValue(
        txInfo.transferInfo.value,
        txInfo.transferInfo.decimals,
      );
      // Either sender or recipient according to "direction" of transaction
      const refAddress = this.getReferenceAddress(txInfo);

      const isImitation = prevItems.some((prevItem) => {
        const prevTxInfo = prevItem.transaction.txInfo;
        if (
          !isTransferTransactionInfo(prevTxInfo) ||
          !isErc20Transfer(prevTxInfo.transferInfo) ||
          // Do not compare against previously identified imitations
          prevTxInfo.transferInfo.imitation
        ) {
          return false;
        }

        const prevFormattedValue = this.formatValue(
          prevTxInfo.transferInfo.value,
          prevTxInfo.transferInfo.decimals,
        );

        // Imitation transfers match in value
        if (formattedValue !== prevFormattedValue) {
          return false;
        }

        // Imitation transfers match in vanity of address
        const prevRefAddress = this.getReferenceAddress(prevTxInfo);
        return this.isImitatorAddress(refAddress, prevRefAddress);
      });

      txInfo.transferInfo.imitation = isImitation;

      if (!isImitation || args.showImitations) {
        mappedTransactions.unshift(item);
      }
    }

    return mappedTransactions;
  }

  /**
   * Returns a string value of the value multiplied by the given decimals
   * @param value - value to format
   * @param decimals - decimals to multiply value by
   * @returns - formatted value
   */
  private formatValue(value: string, decimals: number | null): string {
    // Default to "standard" Ethereum decimals
    const _decimals = decimals ?? TransferImitationMapper.ETH_DECIMALS;
    return formatUnits(BigInt(value), _decimals);
  }

  /**
   * Returns the address of the sender or recipient according to the direction
   * @param txInfo - transaction info
   * @returns - address of sender or recipient
   */
  private getReferenceAddress(txInfo: TransferTransactionInfo): string {
    return txInfo.direction === TransferDirection.Outgoing
      ? txInfo.recipient.value
      : txInfo.sender.value;
  }

  /**
   * Returns whether the two addresses match in vanity
   * @param address1 - address to compare against
   * @param address2  - second address to compare
   * @returns - whether the two addresses are imitators
   */
  private isImitatorAddress(address1: string, address2: string): boolean {
    const a1 = address1.toLowerCase();
    const a2 = address2.toLowerCase();

    // Same address is not an imitation
    if (a1 === a2) {
      return false;
    }

    const isSamePrefix =
      // Ignore `0x` prefix
      a1.slice(2, 2 + this.prefixLength) === a2.slice(2, 2 + this.prefixLength);
    const isSameSuffix =
      a1.slice(-this.suffixLength) === a2.slice(-this.suffixLength);
    return isSamePrefix && isSameSuffix;
  }
}

1	import { IConfigurationService } from '@/config/configuration.service.interface';	102✔
2	import { TransactionItem } from '@/routes/transactions/entities/transaction-item.entity';
3	import {	102✔
4	isTransferTransactionInfo,
5	TransferDirection,
6	TransferTransactionInfo,
7	} from '@/routes/transactions/entities/transfer-transaction-info.entity';
8	import { isErc20Transfer } from '@/routes/transactions/entities/transfers/erc20-transfer.entity';	102✔
9	import { Inject } from '@nestjs/common';	102✔
10	import { formatUnits } from 'viem';	102✔
11
12	export class TransferImitationMapper {	102✔
13	private static ETH_DECIMALS = 18;	102✔
14
15	private readonly lookupDistance: number;
16	private readonly prefixLength: number;
17	private readonly suffixLength: number;
18
19	constructor(
20	@Inject(IConfigurationService)
21	private readonly configurationService: IConfigurationService,	1,374✔
22	) {
23	this.lookupDistance = configurationService.getOrThrow(	1,374✔
24	'mappings.imitation.lookupDistance',
25	);
26	this.prefixLength = configurationService.getOrThrow(	1,374✔
27	'mappings.imitation.prefixLength',
28	);
29	this.suffixLength = configurationService.getOrThrow(	1,374✔
30	'mappings.imitation.suffixLength',
31	);
32	}
33
34	/**
35	* Flags or filters (according to {@link args.showImitations}) transactions
36	* that are likely imitations, based on the value and vanity of the address of
37	* the sender or recipient.
38	*
39	* Note: does not support batched transactions as we have no transaction data
40	* to decode the individual transactions from.
41	*
42	* @param args.transactions - transactions to map
43	* @param args.previousTransaction - first transaction of the next page
44	* @param args.showImitations - whether to filter out imitations
45	*
46	* @returns - mapped transactions
47	*/
48	mapImitations(args: {
49	transactions: Array<TransactionItem>;
50	previousTransaction: TransactionItem \| undefined;
51	showImitations: boolean;
52	}): Array<TransactionItem> {
53	const mappedTransactions: Array<TransactionItem> = [];	10✔
54
55	// Iterate in reverse order as transactions are date descending
56	for (let i = args.transactions.length - 1; i >= 0; i--) {	10✔
57	const item = args.transactions[i];	44✔
58
59	// Executed by Safe - cannot be imitation
60	if (item.transaction.executionInfo) {	44✔
61	mappedTransactions.unshift(item);	26✔
62	continue;	26✔
63	}
64
65	const txInfo = item.transaction.txInfo;	18✔
66	// Only transfers can be imitated, of which we are only interested in ERC20s
67	if (	18!
68	!isTransferTransactionInfo(txInfo) \|\|	18✔
69	!isErc20Transfer(txInfo.transferInfo)
70	) {
NEW 71	mappedTransactions.unshift(item);	×
NEW 72	continue;	×
73	}
74
75	/**
76	* Transactions to compare for imitation against, limited by a lookup distance.
77	*
78	* Concatenation takes preference of already mapped transactions over their
79	* original in order to prevent comparison against duplicates.
80	* Its length is {@link transactions} + 1 as {@link previousTransaction}
81	* is appended to compare {@link transactions.at(-1)} against.
82	*/
83	const prevItems = mappedTransactions	18✔
84	.concat(args.transactions.slice(i - 1), args.previousTransaction ?? [])	27!
85	// Only compare so far back
86	.slice(0, this.lookupDistance);
87
88	if (prevItems.length === 0) {	18!
NEW 89	txInfo.transferInfo.imitation = false;	×
NEW 90	mappedTransactions.unshift(item);	×
NEW 91	continue;	×
92	}
93
94	// Imitation transfers often employ differing decimals to prevent direct
95	// comparison of values. Here we normalize the value
96	const formattedValue = this.formatValue(	18✔
97	txInfo.transferInfo.value,
98	txInfo.transferInfo.decimals,
99	);
100	// Either sender or recipient according to "direction" of transaction
101	const refAddress = this.getReferenceAddress(txInfo);	18✔
102
103	const isImitation = prevItems.some((prevItem) => {	18✔
104	const prevTxInfo = prevItem.transaction.txInfo;	30✔
105	if (	30!
106	!isTransferTransactionInfo(prevTxInfo) \|\|	45✔
107	!isErc20Transfer(prevTxInfo.transferInfo) \|\|
108	// Do not compare against previously identified imitations
109	prevTxInfo.transferInfo.imitation
110	) {
NEW 111	return false;	×
112	}
113
114	const prevFormattedValue = this.formatValue(	30✔
115	prevTxInfo.transferInfo.value,
116	prevTxInfo.transferInfo.decimals,
117	);
118
119	// Imitation transfers match in value
120	if (formattedValue !== prevFormattedValue) {	30✔
121	return false;	16✔
122	}
123
124	// Imitation transfers match in vanity of address
125	const prevRefAddress = this.getReferenceAddress(prevTxInfo);	14✔
126	return this.isImitatorAddress(refAddress, prevRefAddress);	14✔
127	});
128
129	txInfo.transferInfo.imitation = isImitation;	18✔
130
131	if (!isImitation \|\| args.showImitations) {	18✔
132	mappedTransactions.unshift(item);	14✔
133	}
134	}
135
136	return mappedTransactions;	10✔
137	}
138
139	/**
140	* Returns a string value of the value multiplied by the given decimals
141	* @param value - value to format
142	* @param decimals - decimals to multiply value by
143	* @returns - formatted value
144	*/
145	private formatValue(value: string, decimals: number \| null): string {
146	// Default to "standard" Ethereum decimals
147	const _decimals = decimals ?? TransferImitationMapper.ETH_DECIMALS;	48!
148	return formatUnits(BigInt(value), _decimals);	48✔
149	}
150
151	/**
152	* Returns the address of the sender or recipient according to the direction
153	* @param txInfo - transaction info
154	* @returns - address of sender or recipient
155	*/
156	private getReferenceAddress(txInfo: TransferTransactionInfo): string {
157	return txInfo.direction === TransferDirection.Outgoing	32✔
158	? txInfo.recipient.value
159	: txInfo.sender.value;
160	}
161
162	/**
163	* Returns whether the two addresses match in vanity
164	* @param address1 - address to compare against
165	* @param address2 - second address to compare
166	* @returns - whether the two addresses are imitators
167	*/
168	private isImitatorAddress(address1: string, address2: string): boolean {
169	const a1 = address1.toLowerCase();	14✔
170	const a2 = address2.toLowerCase();	14✔
171
172	// Same address is not an imitation
173	if (a1 === a2) {	14✔
174	return false;	4✔
175	}
176
177	const isSamePrefix =
178	// Ignore `0x` prefix
179	a1.slice(2, 2 + this.prefixLength) === a2.slice(2, 2 + this.prefixLength);	10✔
180	const isSameSuffix =
181	a1.slice(-this.suffixLength) === a2.slice(-this.suffixLength);	10✔
182	return isSamePrefix && isSameSuffix;	10✔
183	}
184	}

safe-global / safe-client-gateway / 9351915506

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous