#356: use keccak for merkle hash in aggregate transactions (may be reverted)

Author: Greg S

src/core/crypto/MerkleHashBuilder.ts

@@ -13,34 +13,46 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
+import { SHA3Hasher } from './SHA3Hasher';
 import { SignSchema } from './SignSchema';
 
 export class MerkleHashBuilder {
 
-    hashes: Uint8Array[] = new Array<Uint8Array>();
-    hasherFactory: any;
-    signSchema: SignSchema;
-    length: number;
+    /**
+     * The list of hashes used to calculate root hash.
+     *
+     * @var {Uint8Array}
+     */
+    protected hashes: Uint8Array[] = new Array<Uint8Array>();
 
     /**
      * Constructor
-     * @param hasherFactory Hasher (SHA3_256)
      * @param signSchema Sign schema
      * @param length Hash size
      */
-    constructor(hasherFactory: any, signSchema: SignSchema = SignSchema.SHA3, length: number = 32) {
-        this.hasherFactory = hasherFactory;
-        this.signSchema = signSchema;
-        this.length = length;
+    constructor(/**
+                 * Length of produced merkle hash in bytes.
+                 *
+                 * @var {number}
+                 */
+                public readonly length: 32 | 64,
+                /**
+                 * Signature schema used (hash algorithm diff)
+                 *
+                 * @var {SignSchema}
+                 */
+                public readonly signSchema: SignSchema) {
     }
 
-    /** @internal
+    /**
      * Hash inner transactions
+     *
+     * @internal
      * @param hashes Inner transaction hashes
+     * @return {Uint8Array}
      */
     protected hash(hashes: Uint8Array[]): Uint8Array {
-        const hasher = this.hasherFactory(this.length, this.signSchema);
+        const hasher = SHA3Hasher.createHasher(this.length, this.signSchema);
         hasher.reset();
 
         hashes.forEach((hashVal: Uint8Array) => {
@@ -52,9 +64,12 @@ export class MerkleHashBuilder {
         return hash;
     }
 
-    /** @internal
-     * Get root hash of Merkle Trees
-     * @param hashes Inner transaction hashes
+    /**
+     * Get root hash of Merkle Tree
+     *
+     * @internal
+     * @param {Uint8Array[]} hashes Inner transaction hashes
+     * @return {Uint8Array}
      */
     protected calculateRootHash(hashes: Uint8Array[]): Uint8Array {
 
@@ -80,18 +95,22 @@ export class MerkleHashBuilder {
     }
 
     /**
-     * Return root hash from Merkle tree
+     * Get root hash of Merkle tree
+     *
+     * @return {Uint8Array}
      */
     public getRootHash(): Uint8Array {
         return this.calculateRootHash(this.hashes);
     }
 
     /**
-     * Update hashes array
+     * Update hashes array (add hash)
+     *
      * @param hash Inner transaction hash buffer
+     * @return {MerkleHashBuilder}
      */
-    public update(hash: Uint8Array): void {
+    public update(hash: Uint8Array): MerkleHashBuilder {
         this.hashes.push(hash);
+        return this;
     }
-
 }

src/model/transaction/AggregateTransaction.ts

@@ -340,7 +340,7 @@ export class AggregateTransaction extends Transaction {
                 this.type.valueOf(),
                 new AmountDto(this.maxFee.toDTO()),
                 new TimestampDto(this.deadline.toDTO()),
-                new Hash256Dto(this.calculateInnerTransactionHash()),
+                new Hash256Dto(this.calculateInnerTransactionHash(this.networkType)),
                 transactions,
                 cosignatures,
             ) :
@@ -352,7 +352,7 @@ export class AggregateTransaction extends Transaction {
                 this.type.valueOf(),
                 new AmountDto(this.maxFee.toDTO()),
                 new TimestampDto(this.deadline.toDTO()),
-                new Hash256Dto(this.calculateInnerTransactionHash()),
+                new Hash256Dto(this.calculateInnerTransactionHash(this.networkType)),
                 transactions,
                 cosignatures,
             );
@@ -372,11 +372,23 @@ export class AggregateTransaction extends Transaction {
      * Generate inner transaction root hash (merkle tree)
      * @returns {Uint8Array}
      */
-    private calculateInnerTransactionHash(): Uint8Array {
-        const builder = new MerkleHashBuilder(SHA3Hasher.createHasher);
+    private calculateInnerTransactionHash(networkType: NetworkType): Uint8Array {
+        const signSchema = SHA3Hasher.resolveSignSchema(networkType);
+        const hasher  = SHA3Hasher.createHasher(32, signSchema);
+        const builder = new MerkleHashBuilder(32, signSchema);
         this.innerTransactions.forEach((transaction) => {
-            builder.update(RawArray.uint8View(sha3_256.arrayBuffer(transaction.toAggregateTransactionBytes())));
+            const entityHash: Uint8Array = new Uint8Array(32);
+
+            // for each embedded transaction hash their body
+            hasher.reset();
+            hasher.update(transaction.toAggregateTransactionBytes());
+            hasher.finalize(entityHash);
+
+            // update merkle tree (add transaction hash)
+            builder.update(entityHash);
         });
+
+        // calculate root hash with all transactions
         return builder.getRootHash();
     }
 

test/core/crypto/MerkleHashBuilder.spec.ts

@@ -15,23 +15,23 @@
  */
 
 import { expect } from 'chai';
-import { MerkleHashBuilder, SHA3Hasher } from '../../../src/core/crypto';
+import { MerkleHashBuilder, SHA3Hasher, SignSchema } from '../../../src/core/crypto';
 import { Convert } from '../../../src/core/format';
 
-describe('MerkleHashBuilder tests', () => {
-    it('Zero Value', () => {
+describe('MerkleHashBuilder should', () => {
+    it('fill 0s for empty merkle tree', () => {
         // Arrange:
-        const builder = new MerkleHashBuilder(SHA3Hasher.createHasher);
+        const builder = new MerkleHashBuilder(32, SignSchema.SHA3);
 
         const rootHash = builder.getRootHash();
 
         expect(Convert.uint8ToHex(rootHash)).equal('0000000000000000000000000000000000000000000000000000000000000000');
 
     });
 
-    it('One Value', () => {
+    it('return first hash given single child', () => {
         // Arrange:
-        const builder = new MerkleHashBuilder(SHA3Hasher.createHasher);
+        const builder = new MerkleHashBuilder(32, SignSchema.SHA3);
 
         builder.update(Convert.hexToUint8('215B158F0BD416B596271BCE527CD9DC8E4A639CC271D896F9156AF6F441EEB9'));
 
@@ -41,9 +41,9 @@ describe('MerkleHashBuilder tests', () => {
 
     });
 
-    it('Two Values', () => {
+    it('create correct merkle hash given two children', () => {
         // Arrange:
-        const builder = new MerkleHashBuilder(SHA3Hasher.createHasher);
+        const builder = new MerkleHashBuilder(32, SignSchema.SHA3);
 
         builder.update(Convert.hexToUint8('215b158f0bd416b596271bce527cd9dc8e4a639cc271d896f9156af6f441eeb9'));
         builder.update(Convert.hexToUint8('976c5ce6bf3f797113e5a3a094c7801c885daf783c50563ffd3ca6a5ef580e25'));
@@ -54,9 +54,9 @@ describe('MerkleHashBuilder tests', () => {
 
     });
 
-    it('Three Values', () => {
+    it('create correct merkle hash given three children', () => {
         // Arrange:
-        const builder = new MerkleHashBuilder(SHA3Hasher.createHasher);
+        const builder = new MerkleHashBuilder(32, SignSchema.SHA3);
 
         builder.update(Convert.hexToUint8('215b158f0bd416b596271bce527cd9dc8e4a639cc271d896f9156af6f441eeb9'));
         builder.update(Convert.hexToUint8('976c5ce6bf3f797113e5a3a094c7801c885daf783c50563ffd3ca6a5ef580e25'));