crypto2/src/commonTest/kotlin/ContainerTest.kt

import com.ionspin.kotlin.crypto.util.encodeToUByteArray
import kotlinx.coroutines.test.runTest
import net.sergeych.crypto2.*
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.createWith(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.createWith(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 p1 = Asymmetric.generateKeys()
        val p2 = Asymmetric.generateKeys()
        val p3 = Asymmetric.generateKeys()
        val p4 = Asymmetric.generateKeys()
        val data = "Translating the name 'Sergey Chernov' from Russian to archaic Sanskrit would be 'Ramo Krishna'"
            .encodeToUByteArray()

        val c = Container.createWith(data, syk1, syk2) {
            key(p1.secretKey to p3.publicKey)
            key(p4.publicKey)
        }
        assertFalse { c.isDecrypted }
        var c1 = Container.decode(c.encoded)
        assertFalse { c1.isDecrypted }

        assertNull(c1.decryptWith(syk3))
        assertFalse { c1.isDecrypted }

        assertContentEquals(data, c1.decryptWith(syk3, syk1))
        assertTrue { c1.isDecrypted }

        c1 = Container.decode(c.encoded)
        assertFalse { c1.isDecrypted }
        assertNull(c1.decryptWith(p2.secretKey, p1.secretKey))
        assertContentEquals(data, c1.decryptWith(syk3, p3.secretKey))

        c1 = Container.decode(c.encoded)
        assertFalse { c1.isDecrypted }
        assertContentEquals(data, c1.decryptWith(syk3, p4.secretKey))
    }

    @Test
    fun testSingleGrowSymmetric() = runTest {
        initCrypto()
        val syk1 = SymmetricKey.random()
        val syk2 = SymmetricKey.random()
        val syk3 = SymmetricKey.random()
        val p1 = Asymmetric.generateKeys()
        val p3 = Asymmetric.generateKeys()
        val p4 = Asymmetric.generateKeys()
        val data = "Translating the name 'Sergey Chernov' from Russian to archaic Sanskrit would be 'Ramo Krishna'"
            .encodeToUByteArray()

        var c = Container.createWith(data, syk1)

        fun expectOpen(k: DecryptingKey) {
            val c1 = Container.decode(c.encoded)
            assertContentEquals(data, c1.decryptWith(k))
        }

        fun expectNotOpen(k: DecryptingKey) {
            val c1 = Container.decode(c.encoded)
            assertNull(c1.decryptWith(k))
        }

        expectOpen(syk1)
        expectNotOpen(syk2)
        expectNotOpen(p3.secretKey)

        c.decryptWith(syk1)
        assertTrue { c.isDecrypted }
        assertNotNull(c.decryptedData)
        c += syk2
        expectOpen(syk1)
        expectOpen(syk2)
        expectNotOpen(syk3)
        expectNotOpen(p3.secretKey)

        c.decryptWith(syk1)
        c += p3.publicKey
        expectOpen(syk1)
        expectOpen(syk2)
        expectOpen(p3.secretKey)
        expectNotOpen(syk3)
        expectNotOpen(p4.secretKey)

        c.decryptWith(syk1)
        c += p1.secretKey to p4.publicKey
        expectOpen(syk1)
        expectOpen(syk2)
        expectOpen(p3.secretKey)
        expectNotOpen(syk3)
        expectOpen(p4.secretKey)
    }

    @Test
    fun testSingleGrowAsymmetric() = runTest {
        initCrypto()
        val syk1 = SymmetricKey.random()
        val syk2 = SymmetricKey.random()
        val syk3 = SymmetricKey.random()
        val p1 = Asymmetric.generateKeys()
        val p2 = Asymmetric.generateKeys()
        val p3 = Asymmetric.generateKeys()
        val p4 = Asymmetric.generateKeys()
        val data = "Translating the name 'Sergey Chernov' from Russian to archaic Sanskrit would be 'Ramo Krishna'"
            .encodeToUByteArray()

        var c = Container.createWith(data, p1.secretKey to p3.publicKey)

        fun expectOpen(k: DecryptingKey) {
            val c1 = Container.decode(c.encoded)
            assertContentEquals(data, c1.decryptWith(k))
        }

        fun expectNotOpen(k: DecryptingKey) {
            val c1 = Container.decode(c.encoded)
            assertNull(c1.decryptWith(k))
        }

        expectNotOpen(syk1)
        expectOpen(p3.secretKey)

        c.decryptWith(p3.secretKey)

        c += syk1
        expectOpen(syk1)
        expectNotOpen(syk2)
        expectOpen(p3.secretKey)
    }
}