#356: added hashing of merkle transactions hash for aggregates ; added more unit tests for createTransactionHash

Author: Greg S

src/model/transaction/Transaction.ts

@@ -36,9 +36,32 @@ export abstract class Transaction {
     /**
      * Transaction header size
      *
+     * Included fields are `size`, `verifiableEntityHeader_Reserved1`,
+     * `signature`, `signerPublicKey` and `entityBody_Reserved1`.
+     *
+     * @var {number}
+     */
+    public static readonly Header_Size: number = 8 + 64 + 32 + 4;
+
+    /**
+     * Index of the transaction *type*
+     *
+     * Included fields are the transaction header, `version`
+     * and `network`
+     *
+     * @var {number}
+     */
+    public static readonly Type_Index: number = Transaction.Header_Size + 2;
+
+    /**
+     * Index of the transaction *body*
+     *
+     * Included fields are the transaction header, `version`,
+     * `network`, `type`, `maxFee` and `deadline`
+     *
      * @var {number}
      */
-    public static readonly Header_Size = 8 + 64 + 32 + 4;
+    public static readonly Body_Index: number = Transaction.Header_Size + 1 + 1 + 2 + 8 + 8;
 
     /**
      * @constructor
@@ -101,9 +124,17 @@ export abstract class Transaction {
 
         // prepare
         const entityHash: Uint8Array = new Uint8Array(32);
-        const signSchema: SignSchema = SHA3Hasher.resolveSignSchema(networkType);
         const transactionBytes: Uint8Array = Convert.hexToUint8(transactionPayload);
 
+        // read transaction type
+        const typeIdx: number = Transaction.Type_Index;
+        const typeBytes: Uint8Array = transactionBytes.slice(typeIdx, typeIdx + 2).reverse(); // REVERSED
+        const entityType: TransactionType = parseInt(Convert.uint8ToHex(typeBytes), 16);
+        const isAggregateTransaction = [
+            TransactionType.AGGREGATE_BONDED,
+            TransactionType.AGGREGATE_COMPLETE,
+        ].find((type: TransactionType) => entityType === type) !== undefined;
+
         // 1) take "R" part of a signature (first 32 bytes)
         const signatureR: Uint8Array = transactionBytes.slice(8, 8 + 32);
 
@@ -118,7 +149,12 @@ export abstract class Transaction {
         // 4) add transaction data without header (EntityDataBuffer)
         // @link https://github.com/nemtech/catapult-server/blob/master/src/catapult/model/EntityHasher.cpp#L30
         const transactionBodyIdx: number = generationHashIdx + generationHash.length;
-        const transactionBody: Uint8Array = transactionBytes.slice(Transaction.Header_Size);
+        let transactionBody: Uint8Array = transactionBytes.slice(Transaction.Header_Size);
+
+        // in case of aggregate transactions, we hash only the merkle transaction hash.
+        if (isAggregateTransaction) {
+            transactionBody = transactionBytes.slice(Transaction.Header_Size, Transaction.Body_Index + 32);
+        }
 
         // 5) concatenate binary hash parts
         // layout: `signature_R || signerPublicKey || generationHash || EntityDataBuffer`
@@ -134,6 +170,7 @@ export abstract class Transaction {
         entityHashBytes.set(transactionBody, transactionBodyIdx);
 
         // 6) create SHA3 or Keccak hash depending on `signSchema`
+        const signSchema: SignSchema = SHA3Hasher.resolveSignSchema(networkType);
         SHA3Hasher.func(entityHash, entityHashBytes, 32, signSchema);
         return Convert.uint8ToHex(entityHash);
     }

test/model/transaction/Transaction.spec.ts

@@ -240,10 +240,125 @@ describe('Transaction', () => {
           + 'A0860100000000002AD8FC018D9A49E100056576696173'
         );
 
+        const knownAggregatePayload = (
+            '0801000000000000AC1F3E0EE2C16F465CDC2E091DC44D6EB55F7FE3988A5F21'
+          + '309DF479BE6D3F0033E155695FB1133EA0EA64A67C1EDC2B430CFAF9722AF36B'
+          + 'AE84DBDB1C8F1509C2F93346E27CE6AD1A9F8F5E3066F8326593A406BDF357AC'
+          + 'B041E2F9AB402EFE000000000190414200000000000000006BA50FB91A000000'
+          + 'EA8F8301E7EDFD701F62E1DC1601ABDE22E5FCD11C9C7E7A01B87F8DFB6B62B0'
+          + '60000000000000005D00000000000000C2F93346E27CE6AD1A9F8F5E3066F832'
+          + '6593A406BDF357ACB041E2F9AB402EFE00000000019054419050B9837EFAB4BB'
+          + 'E8A4B9BB32D812F9885C00D8FC1650E142000D000000000000746573742D6D65'
+          + '7373616765000000'
+        );
+
         // expected values
         const knownHash_sha3 = '709373248659274C5933BEA2920942D6C7B48B9C2DA4BAEE233510E71495931F';
         const knownHash_keccak = '787423372BEC0CB2BE3EEA58E773074E121989AF29E5E5BD9EE660C1E3A0AF93';
         const generationHashBytes = Array.from(Convert.hexToUint8('988C4CDCE4D188013C13DE7914C7FD4D626169EF256722F61C52EFBE06BD5A2C'));
+        const generationHashBytes_mt = Array.from(Convert.hexToUint8('17FA4747F5014B50413CCF968749604D728D7065DC504291EEE556899A534CBB'));
+
+        it ('create different hash given different signatures', () => {
+            const hash1 = Transaction.createTransactionHash(
+                knownPayload,
+                generationHashBytes,
+                NetworkType.MIJIN_TEST,
+            );
+
+            // modify signature part of the payload ; this must affect produced hash
+            const tamperedSig = knownPayload.substr(0, 16) + '12' + knownPayload.substr(18);
+            const hash2 = Transaction.createTransactionHash(
+                tamperedSig, // replaced two first bytes of signature
+                generationHashBytes,
+                NetworkType.MIJIN_TEST,
+            );
+
+            expect(hash1).to.not.equal(hash2);
+        });
+
+        it ('create different hash given different signer public key', () => {
+            const hash1 = Transaction.createTransactionHash(
+                knownPayload,
+                generationHashBytes,
+                NetworkType.MIJIN_TEST,
+            );
+
+            // modify signer public key part of the payload ; this must affect produced hash
+            const tamperedSigner = knownPayload.substr(0, 16 + 128) + '12' + knownPayload.substr(16 + 128 + 2);
+            const hash2 = Transaction.createTransactionHash(
+                tamperedSigner, // replaced two first bytes of signer public key
+                generationHashBytes,
+                NetworkType.MIJIN_TEST,
+            );
+
+            expect(hash1).to.not.equal(hash2);
+        });
+
+        it ('create different hash given different generation hash', () => {
+            const hash1 = Transaction.createTransactionHash(
+                knownPayload,
+                generationHashBytes,
+                NetworkType.MIJIN_TEST,
+            );
+
+            const hash2 = Transaction.createTransactionHash(
+                knownPayload,
+                generationHashBytes_mt, // uses different generation hash
+                NetworkType.MIJIN_TEST,
+            );
+
+            expect(hash1).to.not.equal(hash2);
+        });
+
+        it ('create different hash given different transaction body', () => {
+            const hash1 = Transaction.createTransactionHash(
+                knownPayload,
+                generationHashBytes,
+                NetworkType.MIJIN_TEST,
+            );
+
+            // modify "transaction body" part of payload ; this must affect produced transaction hash
+            const tamperedBody = knownAggregatePayload.substr(0, Transaction.Body_Index * 2)
+                                  + '12' + knownAggregatePayload.substr(Transaction.Body_Index * 2 + 2);
+            const hash2 = Transaction.createTransactionHash(
+                tamperedBody,
+                generationHashBytes, // uses different generation hash
+                NetworkType.MIJIN_TEST,
+            );
+
+            expect(hash1).to.not.equal(hash2);
+        });
+
+        it ('create same hash given same payloads', () => {
+            const hash1 = Transaction.createTransactionHash(
+                knownPayload,
+                generationHashBytes,
+                NetworkType.MIJIN_TEST,
+            );
+            const hash2 = Transaction.createTransactionHash(
+                knownPayload,
+                generationHashBytes,
+                NetworkType.MIJIN_TEST,
+            );
+
+            expect(hash1).to.equal(hash2);
+        });
+
+        it ('create different hash given different signature schemas', () => {
+            const hash1 = Transaction.createTransactionHash(
+                knownPayload,
+                generationHashBytes,
+                NetworkType.MIJIN_TEST, // SHA3
+            );
+
+            const hash2 = Transaction.createTransactionHash(
+                knownPayload,
+                generationHashBytes,
+                NetworkType.TEST_NET, // KECCAK
+            );
+
+            expect(hash1).to.not.equal(hash2);
+        });
 
         it('create correct SHA3 transaction hash given network type MIJIN or MIJIN_TEST', () => {
             const hash1 = Transaction.createTransactionHash(
@@ -276,6 +391,35 @@ describe('Transaction', () => {
             expect(hash1).to.equal(knownHash_keccak);
             expect(hash2).to.equal(knownHash_keccak);
         });
+
+        it('hash only merkle transaction hash for aggregate transactions', () => {
+            const hash1 = Transaction.createTransactionHash(
+                knownAggregatePayload,
+                generationHashBytes,
+                NetworkType.MIJIN_TEST,
+            );
+
+            // modify end of payload ; this must not affect produced transaction hash
+            // this test is valid only for Aggregate Transactions
+            const tamperedSize = '12' + knownAggregatePayload.substr(2);
+            const hashTamperedBody = Transaction.createTransactionHash(
+                tamperedSize, // replace in size (header change should not affect hash)
+                generationHashBytes,
+                NetworkType.MIJIN_TEST,
+            );
+
+            // modify "merkle hash" part of payload ; this must affect produced transaction hash
+            const tamperedPayload = knownAggregatePayload.substr(0, Transaction.Body_Index * 2)
+                                  + '12' + knownAggregatePayload.substr(Transaction.Body_Index * 2 + 2);
+            const hashTamperedMerkle = Transaction.createTransactionHash(
+                tamperedPayload, // replace in merkle hash (will affect hash)
+                generationHashBytes,
+                NetworkType.MIJIN_TEST,
+            );
+
+            expect(hash1).to.equal(hashTamperedBody);
+            expect(hash1).to.not.equal(hashTamperedMerkle);
+        });
     });
 });