redesigned signed box now Sealed box, refactored seals to incorporate expiration, introduced symmetric keys support

src/commonTest/kotlin/KeysTest.kt

@@ -1,15 +1,15 @@
-import com.ionspin.kotlin.crypto.secretbox.SecretBox
 import com.ionspin.kotlin.crypto.util.decodeFromUByteArray
 import com.ionspin.kotlin.crypto.util.encodeToUByteArray
 import kotlinx.coroutines.test.runTest
 import net.sergeych.crypto2.*
+import net.sergeych.utools.now
 import net.sergeych.utools.pack
 import net.sergeych.utools.unpack
 import kotlin.test.*
 
 class KeysTest {
     @Test
-    fun testCreationAndMap() = runTest {
+    fun testSigningCreationAndMap() = runTest {
         initCrypto()
         val (stk,pbk) = SigningKey.pair()
 
@@ -30,28 +30,56 @@ class KeysTest {
         val p2 = SigningKey.pair()
         val p3 = SigningKey.pair()
 
-        val ms = SignedBox(data, s1) + p2.secretKey
+        val ms = SealedBox.create(data, s1) + p2.secretKey
 
         // non tampered:
-        val ms1 = unpack<SignedBox>(pack(ms))
+        val ms1 = unpack<SealedBox>(pack(ms))
         assertContentEquals(data, ms1.message)
         assertTrue(pbk in ms1)
         assertTrue(p2.publicKey in ms1)
         assertTrue(p3.publicKey !in ms1)
 
         assertThrows<IllegalSignatureException> {
-            unpack<SignedBox>(pack(ms).also { it[3] = 1u })
+            unpack<SealedBox>(pack(ms).also { it[3] = 1u })
         }
     }
 
+    @Test
+    fun testNonDeterministicSeals() = runTest {
+        initCrypto()
+        val data = "Welcome to the Miami, bitch!".encodeToUByteArray()
+        val (sk,_) = SigningKey.pair()
+        val t = now()
+        val s1 = Seal.create(sk, data, createdAt = t)
+        val s2 = Seal.create(sk, data, createdAt = t)
+        val s2bad = Seal.create(sk, data + "!".encodeToUByteArray())
+        val s3 = Seal.create(sk, data, createdAt = t, nonDeterministic = true)
+        val s4 = Seal.create(sk, data, createdAt = t, nonDeterministic = true)
+
+        for( seal in listOf(s1,s2,s3,s4)) {
+            assertTrue { seal.isValid(data) }
+            assertTrue { Seal.unpack(seal.packed).isValid(data) }
+        }
+        assertFalse { s2bad.isValid(data)}
+        assertContentEquals(s1.packed, s2.packed)
+        assertFalse { s1.packed contentEquals s3.packed }
+        assertFalse { s4.packed contentEquals s3.packed }
+
+    }
+
     @Test
     fun secretEncryptTest() = runTest {
         initCrypto()
-        val key = SecretBox.keygen()
-        val key1 = SecretBox.keygen()
-        assertEquals("hello", decrypt(key, encrypt(key, "hello".encodeToUByteArray())).decodeFromUByteArray())
+        val key = SymmetricKey.random()
+        val key1 = SymmetricKey.random()
+        assertEquals("hello", key.decrypt(key.encrypt("hello".encodeToUByteArray())).decodeFromUByteArray())
+        assertEquals("hello", key.decryptString(key.encrypt("hello")))
+        assertEquals("hello", key.decryptObject(key.encryptObject("hello")))
+        assertEquals("hello", key.decrypt(key.encrypt("hello".encodeToUByteArray(), 18..334)).decodeFromUByteArray())
+        assertEquals("hello", key.decryptString(key.encrypt("hello", 18..334)))
+        assertEquals("hello", key.decryptObject(key.encryptObject("hello", 18..334)))
         assertThrows<DecryptionFailedException> {
-            decrypt(key, encrypt(key1, "hello".encodeToUByteArray())).decodeFromUByteArray()
+            key.decrypt(key1.encrypt("hello".encodeToUByteArray())).decodeFromUByteArray()
         }
     }