Merge pull request #3 from vault12/integration-test

add integration test to ShamirCore tests on native platforms

Author: lord-max

android/src/test/java/com/vault12/plugins/shamir/ShamirCoreUnitTest.java

@@ -3,19 +3,71 @@
 
 import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotEquals;
 import static org.junit.Assert.fail;
 
 import org.junit.Test;
 
 import java.nio.charset.StandardCharsets;
 import java.security.SecureRandom;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 
 public class ShamirCoreUnitTest {
 
+    @Test
+    public void integration() throws SimpleException {
+        final SecureRandom random = new SecureRandom();
+        for (int i = 0; i < 100; i++) {
+            // generate a random secret
+            int length = random.nextInt(9001) + 1000; // 1000..10000
+            byte[] secretBytes = new byte[length];
+            random.nextBytes(secretBytes);
+            // choose totalShards ∈ [2..10] and threshold ∈ [2..totalShards]
+            short totalShards = (short) (random.nextInt(9) + 2);
+            short threshold   = (short) (random.nextInt(totalShards - 1) + 2);
+            // split into shards
+            Map<Short, byte[]> shards = ShamirCore.split(secretBytes, totalShards, threshold, null);
+
+            for (int j = 0; j < 10; j++) {
+                // incorrect restore check
+                if (threshold > 2) {
+                    // pick a random subset of shards not enough to restore (size < threshold)
+                    int notEnoughToRestoreCount = random.nextInt(threshold - 2) + 2;
+                    List<Short> keys = new ArrayList<>(shards.keySet());
+                    Collections.shuffle(keys);
+                    List<Short> notEnoughKeys = keys.subList(0, notEnoughToRestoreCount);
+                    Map<Short, byte[]> shardsNotEnough = new HashMap<>();
+                    for (Short k : notEnoughKeys) {
+                        shardsNotEnough.put(k, shards.get(k));
+                    }
+                    // restore and verify
+                    byte[] badRestored = ShamirCore.restore(shardsNotEnough, null);
+                    assertFalse("Incorrectly restored data matched original", Arrays.equals(secretBytes, badRestored));
+                }
+
+                // correct restore check
+                // pick a random subset of shards to restore (size ∈ [threshold..totalShards])
+                int enoughToRestoreCount = random.nextInt(totalShards - threshold + 1) + threshold;
+                List<Short> keysForCorrect = new ArrayList<>(shards.keySet());
+                Collections.shuffle(keysForCorrect);
+                List<Short> enoughKeys = keysForCorrect.subList(0, enoughToRestoreCount);
+                Map<Short, byte[]> shardsEnough = new HashMap<>();
+                for (Short k : enoughKeys) {
+                    shardsEnough.put(k, shards.get(k));
+                }
+                // restore and verify
+                byte[] goodRestored = ShamirCore.restore(shardsEnough, null);
+                assertArrayEquals("Correctly restored data does not match original", secretBytes, goodRestored);
+            }
+        }
+    }
+
     @Test
     public void wrongShards() {
 

ios/Tests/ShamirPluginTests/ShamirCoreTests.swift

@@ -3,7 +3,44 @@ import XCTest
 @testable import ShamirPlugin
 
 class ShamirCoreTests: XCTestCase {
-
+    
+    func testIntegration() throws {
+        for _ in 1...100 {
+            // generate a random secret
+            let length = Int.random(in: 1000...10000)
+            var secureBytes = [UInt8](repeating: 0, count: length)
+            let status = SecRandomCopyBytes(kSecRandomDefault, length, &secureBytes)
+            if status != errSecSuccess { throw SimpleError("ShamirCoreTests: RNG failed") }
+            let secretData = Data(secureBytes)
+            // choose totalShards ∈ [2..10] and threshold ∈ [2..totalShards]
+            let totalShards = UInt8.random(in: 2...10)
+            let threshold = UInt8.random(in: 2...totalShards)
+            // split into shards
+            let shards = try ShamirCore.split(totalShards: UInt8(totalShards), threshold: UInt8(threshold), secret: secretData)
+            
+            for _ in 1...10 {
+                // incorrect resore check (only if threshold > 2)
+                if (threshold > 2) {
+                    // pick a random subset of shards not enough to restore (size < threshold)
+                    let shardsNotEnoughToRestoreCount = Int.random(in: Int(2)..<Int(threshold))
+                    let shardsNotEnoughToRestoreIndexes = Array(0..<totalShards).shuffled().prefix(shardsNotEnoughToRestoreCount)
+                    let shardsNotEnoughToRestore = shardsNotEnoughToRestoreIndexes.map { shards[Int($0)] }
+                    // restore and verify
+                    let incorrectRestoredData = try ShamirCore.restore(shards: shardsNotEnoughToRestore)
+                    XCTAssertNotEqual(incorrectRestoredData, secretData, "Incorrectly restored data does match original")
+                }
+                // correct restore check
+                // pick a random subset of shards to restore (size ∈ [threshold..totalShards])
+                let shardsEnoughToRestoreCount = Int.random(in: Int(threshold)...Int(totalShards))
+                let shardsEnoughToRestoreIndexes = Array(0..<totalShards).shuffled().prefix(shardsEnoughToRestoreCount)
+                let shardsEnoughToRestore = shardsEnoughToRestoreIndexes.map { shards[Int($0)] }
+                // restore and verify
+                let correctRestoredData = try ShamirCore.restore(shards: shardsEnoughToRestore)
+                XCTAssertEqual(correctRestoredData, secretData, "Correctly restored data does not match original")
+            }
+        }
+    }
+    
     // Testing restricted parameter ranges when creating ShamirSecretSharing
     func testWrongShards() {
         XCTAssertThrowsError( try { // T too low