Container started

src/commonTest/kotlin/ContainerTest.kt

@@ -0,0 +1,86 @@
+import com.ionspin.kotlin.crypto.util.encodeToUByteArray
+import kotlinx.coroutines.test.runTest
+import net.sergeych.crypto2.Asymmetric
+import net.sergeych.crypto2.Container
+import net.sergeych.crypto2.SymmetricKey
+import net.sergeych.crypto2.initCrypto
+import kotlin.test.*
+
+class ContainerTest {
+    @Test
+    fun testSingle() = runTest {
+        initCrypto()
+        val syk1 = SymmetricKey.random()
+        val syk2 = SymmetricKey.random()
+        val data = "sergeych, ohm many.".encodeToUByteArray()
+
+        val c = Container.create(data, syk1)
+        assertFalse { c.isDecrypted }
+        val c1 = Container.decode(c.encoded)
+        assertFalse { c.isDecrypted }
+        assertIs<Container.Single>(c)
+
+        assertNull(c1.decryptWith(syk2))
+        val d = c1.decryptWith(syk2, syk1)
+        assertNotNull(d)
+        assertContentEquals(data, d)
+        assertTrue { c1.isDecrypted }
+    }
+
+    @Test
+    fun testSinglePair() = runTest {
+        initCrypto()
+        val p1 = Asymmetric.generateKeys()
+        val p2 = Asymmetric.generateKeys()
+        val p3 = Asymmetric.generateKeys()
+        val data = "sergeych, ohm many.".encodeToUByteArray()
+
+        val c = Container.create(data, p1.secretKey to p2.publicKey)
+        assertFalse { c.isDecrypted }
+        val c1 = Container.decode(c.encoded)
+        assertFalse { c.isDecrypted }
+        assertIs<Container.Single>(c)
+
+        assertNull(c1.decryptWith(p3.secretKey))
+        val d = c1.decryptWith(p3.secretKey, p2.secretKey)
+        assertNotNull(d)
+        assertContentEquals(data, d)
+        assertTrue { c1.isDecrypted }
+    }
+
+    @Test
+    fun testSingleAsymmetric() = runTest {
+        initCrypto()
+//        val p1 = Asymmetric.generateKeys()
+        val p2 = Asymmetric.generateKeys()
+        val p3 = Asymmetric.generateKeys()
+        val data = "sergeych, ohm many.".encodeToUByteArray()
+
+        val c = Container.create(data) { key(p2.publicKey) }
+        assertFalse { c.isDecrypted }
+        val c1 = Container.decode(c.encoded)
+        assertFalse { c.isDecrypted }
+        assertIs<Container.Single>(c)
+
+        assertNull(c1.decryptWith(p3.secretKey))
+        val d = c1.decryptWith(p3.secretKey, p2.secretKey)
+        assertNotNull(d)
+        assertContentEquals(data, d)
+        assertTrue { c1.isDecrypted }
+    }
+
+    @Test
+    fun testMultipleSymmetric() = runTest {
+        initCrypto()
+        val syk1 = SymmetricKey.random()
+        val syk2 = SymmetricKey.random()
+//        val syk3 = SymmetricKey.random()
+        val data = "Translating the name 'Sergey Chernov' from Russian to archaic Sanskrit would be 'Ramo Krishna'"
+            .encodeToUByteArray()
+
+        val c = Container.create(data, syk1, syk2)
+        assertFalse { c.isDecrypted }
+        val c1 = Container.decode(c.encoded)
+        assertFalse { c1.isDecrypted }
+    }
+}

src/commonTest/kotlin/KeysTest.kt

@@ -3,7 +3,6 @@ import com.ionspin.kotlin.crypto.util.encodeToUByteArray
 import kotlinx.coroutines.test.runTest
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
-import net.sergeych.bipack.BipackEncoder
 import net.sergeych.crypto2.*
 import net.sergeych.utools.now
 import net.sergeych.utools.pack
@@ -140,25 +139,24 @@ class KeysTest {
 
         val plain = "The fake vaccine kills".encodeToUByteArray()
 
-        var m = Asymmetric.createMessage(sk0, pk1, plain)
+        var m = pk1.encryptMessage(plain, sk1)
         assertContentEquals(plain, m.decrypt(sk1))
         assertThrows<DecryptionFailedException> {
             assertContentEquals(plain, m.decrypt(sk2))
         }
 
-        m = pk2.encryptAnonymously(plain)
+        m = pk2.encryptAnonymousMessage(plain)
         assertContentEquals(plain, m.decrypt(sk2))
         assertContentEquals(plain, sk2.decrypt(m))
-        assertContentEquals(plain, sk2.decrypt(sk1.encrypt(plain, pk2)))
+//        assertContentEquals(plain, sk2.decrypt(sk1.encrypt(plain, pk2)))
         assertThrows<DecryptionFailedException> {
             assertContentEquals(plain, m.decrypt(sk1))
         }
 
-        val x1 = BipackEncoder.encode(Asymmetric.createMessage(sk0, pk1, plain))
-        val x2 = BipackEncoder.encode(Asymmetric.createMessage(sk0, pk1, plain))
+        val x1 = pk1.encryptMessage(plain, sk1).encoded
+        val x2 = pk1.encryptMessage(plain, sk1).encoded
 
         assertFalse { x1 contentEquals x2 }
-
     }
     @Test
     fun asymmetricKeySerializationTest() = runTest {

src/commonTest/kotlin/RingTest.kt

@@ -52,4 +52,9 @@ class RingTest {
         assertEquals(r, r2)
     }
 
+    @Test
+    @Ignore
+    fun testKeysWithSameTags() {
+        // it should be able to keep keys with same tags
+    }
 }