From 94da1a30dcd1c0592740001bb9339b7e6bbbc37b Mon Sep 17 00:00:00 2001
From: CalDescent <caldescent@protonmail.com>
Date: Sun, 15 Aug 2021 20:27:16 +0100
Subject: [PATCH] When merging two states, validate that the transaction
 signature we are using for the "before" layer matches the "previous
 transaction signature" that is baked into the "after" layer.

This defends against a missing or out-of-order transaction. If this ever fails validation, we may need to rethink the way we are requesting transactions. But in theory this shouldn't happen, given that the "last reference" field of a transaction ensures that out-of-order transactions are invalid already.
---
 .../arbitrary/ArbitraryDataBuilder.java       |  3 ++-
 .../arbitrary/ArbitraryDataCombiner.java      | 24 ++++++++++++++++++-
 2 files changed, 25 insertions(+), 2 deletions(-)

diff --git a/src/main/java/org/qortal/arbitrary/ArbitraryDataBuilder.java b/src/main/java/org/qortal/arbitrary/ArbitraryDataBuilder.java
index 7ef29d03..f8c95596 100644
--- a/src/main/java/org/qortal/arbitrary/ArbitraryDataBuilder.java
+++ b/src/main/java/org/qortal/arbitrary/ArbitraryDataBuilder.java
@@ -154,7 +154,8 @@ public class ArbitraryDataBuilder {
         for (int i=1; i<paths.size(); i++) {
             LOGGER.info(String.format("[%s][%s] Applying layer %d...", this.service, this.name, i));
             Path pathAfter = this.paths.get(i);
-            ArbitraryDataCombiner combiner = new ArbitraryDataCombiner(pathBefore, pathAfter);
+            byte[] signatureBefore = this.transactions.get(i-1).getSignature();
+            ArbitraryDataCombiner combiner = new ArbitraryDataCombiner(pathBefore, pathAfter, signatureBefore);
             combiner.combine();
             combiner.cleanup();
             pathBefore = combiner.getFinalPath();
diff --git a/src/main/java/org/qortal/arbitrary/ArbitraryDataCombiner.java b/src/main/java/org/qortal/arbitrary/ArbitraryDataCombiner.java
index 08409784..3d3fbe9f 100644
--- a/src/main/java/org/qortal/arbitrary/ArbitraryDataCombiner.java
+++ b/src/main/java/org/qortal/arbitrary/ArbitraryDataCombiner.java
@@ -10,6 +10,7 @@ import java.io.IOException;
 import java.nio.file.DirectoryNotEmptyException;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.Arrays;
 
 public class ArbitraryDataCombiner {
 
@@ -17,16 +18,19 @@ public class ArbitraryDataCombiner {
 
     private Path pathBefore;
     private Path pathAfter;
+    private byte[] signatureBefore;
     private Path finalPath;
 
-    public ArbitraryDataCombiner(Path pathBefore, Path pathAfter) {
+    public ArbitraryDataCombiner(Path pathBefore, Path pathAfter, byte[] signatureBefore) {
         this.pathBefore = pathBefore;
         this.pathAfter = pathAfter;
+        this.signatureBefore = signatureBefore;
     }
 
     public void combine() throws IOException {
         try {
             this.preExecute();
+            this.validatePreviousSignature();
             this.process();
 
         } finally {
@@ -78,6 +82,24 @@ public class ArbitraryDataCombiner {
 
     }
 
+    private void validatePreviousSignature() throws IOException {
+        if (this.signatureBefore == null) {
+            throw new IllegalStateException("No previous signature passed to the combiner");
+        }
+
+        ArbitraryDataMetadata metadata = new ArbitraryDataMetadata(this.pathAfter);
+        metadata.read();
+        byte[] previousSignature = metadata.getPreviousSignature();
+        if (previousSignature == null) {
+            throw new IllegalStateException("Unable to extract previous signature from patch metadata");
+        }
+
+        // Compare the signatures
+        if (!Arrays.equals(previousSignature, this.signatureBefore)) {
+            throw new IllegalStateException("Previous signatures do not match - transactions out of order?");
+        }
+    }
+
     private void process() throws IOException {
         ArbitraryDataMerge merge = new ArbitraryDataMerge(this.pathBefore, this.pathAfter);
         merge.compute();