crypto2/src/commonTest/kotlin/RingTest.kt

import com.ionspin.kotlin.crypto.util.encodeToUByteArray
import kotlinx.coroutines.test.runTest
import net.sergeych.bintools.toDump
import net.sergeych.bipack.BipackDecoder
import net.sergeych.bipack.BipackEncoder
import net.sergeych.crypto2.*
import kotlin.test.*

class RingTest {

    @Test
    fun testCreationAndSerialization() = runTest {
        initCrypto()

        val y1 = SymmetricKey("1234567890Hello,dolly.here-we-go".encodeToUByteArray())
        val y2 = SymmetricKey("1234567890Hello,dolly.here-we-go".encodeToUByteArray())
        assertEquals(y1, y2)

        val e1 = Asymmetric.newSecretKey()
        val e2: Asymmetric.SecretKey = BipackDecoder.decode(BipackEncoder.encode(e1))
        assertEquals(e1, e2)

        val k1 = UniversalKey.from(SymmetricKey("1234567890Hello,dolly.here-we-go".encodeToUByteArray()))
        val k11 = UniversalKey.from(SymmetricKey("1234567890Hello,dolly.here-we-go".encodeToUByteArray()))

        assertEquals(k1, k11)


        val k2 = UniversalKey.from(Asymmetric.newSecretKey())
        val k3 = UniversalKey.from(Asymmetric.newSecretKey())
//
        val r = UniversalRing(k1, k2)
//        val r = UniversalRing(k1)
        assertTrue(k2 in r)
        assertTrue(k1 in r)
        assertFalse { k3 in r }

        println(Asymmetric.newSecretKey().keyBytes.size)
        println(BipackEncoder.encode(Asymmetric.newSecretKey()).size)
        val encoded = BipackEncoder.encode(r)
        println(encoded.toDump())
        println(encoded.size)
        assertTrue { encoded.size < 80 }
        val r2: UniversalRing = BipackDecoder.decode(encoded)
        assertTrue { k2 in r2 }
        assertTrue { k1 in r2 }
        assertFalse { k3 in r2 }

        println("\r\n")
        println(r)
        println(r2)

//        Kr[U.Sym:XYjneNaPFbg-PZJIYjgIz7F-DsH1dEY8Mg6LCirko2QBFA,U.Sec:FzuzDbrS0xR5nTkdd-mYvrqsfQn9HbQgtFnIw9CEirIAlw]
//        Kr[U.Sym:XYjneNaPFbg-PZJIYjgIz7F-DsH1dEY8Mg6LCirko2QBFA,U.Sec:FzuzDbrS0xR5nTkdd-mYvrqsfQn9HbQgtFnIw9CEirIAlw]

        assertEquals(r, r2)
    }

    @Test
    fun testAsymmetricPublic() = runTest {
        initCrypto()
        val sk = Asymmetric.newSecretKey()
        assertEquals(sk.id, sk.publicKey.id)
        val r = UniversalRing.from(sk.publicKey to "foo")
        println(sk.publicKey.id)
        println(sk.id)
        println(r.findKey<EncryptingKey>(sk.id))
        println(BipackEncoder.encode(r).toDump())
        val r1 = deepCopy(r)
        println(r1.findKey<EncryptingKey>(sk.id))
        println(sk)
        assertTrue { sk.publicKey.toUniversalKey() == r1.findKey<EncryptingKey>(sk.id) }
        assertTrue { sk.publicKey.toUniversalKey() == r1.keyByTag<EncryptingKey>("foo") }
    }

    @Test
    fun testTags() = runTest {
        initCrypto()

        val k1 = UniversalKey.from(SymmetricKey("1234567890Hello,dolly.here-we-go".encodeToUByteArray()))
        val k2 = UniversalKey.from(Asymmetric.newSecretKey())

        val r1 = UniversalRing(k1, k2)
        var r2 = UniversalRing(deepCopy(k1), deepCopy(k2))
        assertEquals(r2, r1)
        val r3 = UniversalRing(k1 to "foo", k2 to "bar")
        assertNotEquals(r3, r2)
        assertTrue { r3 equalKeys r2 }

        r2 += (k1 to "foo")
        r2 = r2.addTags(k2, "bar")
        assertEquals(r2, r3)
        assertEquals(deepCopy(r2), r3)

        r2 += k1 to "buzz"
        r2 = deepCopy(r2)
        assertEquals(setOf("foo", "buzz"), r2.getTags(k1))
        assertNotEquals(r2, r3)
        r2 = deepCopy(r2.removeTags(k1, "buzz"))
        assertEquals(r2, r3)
    }

    @Test
    fun testAsymmetricEncryption() = runTest {
        initCrypto()

        val sk1 = UniversalKey.newSecretKey()
        val sk2 = UniversalKey.newSecretKey()
        val sk3 = UniversalKey.newSecretKey()
//        val sk4 = UniversalKey.newSecretKey()
        val sik1 = UniversalKey.newSigningKey()
//        val sik2 = UniversalKey.newSigningKey()
        val sik3 = UniversalKey.newSigningKey()

        val data = "Mendeleev' table".encodeToUByteArray()

        var r = UniversalRing(sk2, sk3, sk1.publicKey, sk3.publicKey, sik3.publicKey, sik1.publicKey)

        r = r.addTags(sik1, "SECRET_SIGN")

        val box = deepCopy(Container.create(data) { key(sk3.publicKey) })
        assertContentEquals(data, box.decryptWith(r))

        assertEquals(sk3.publicKey, r.findKey<EncryptingKey>(sk3.id))
        assertTrue { sik3.publicKey in r }
        assertTrue { sik1 in r }
        assertEquals(sik1, r.keyByTag<UniversalKey>("SECRET_SIGN"))

        assertEquals(sik1, r.findKey<SigningKey>(sik1.publicKey.id))
    }

    @Test
    fun testSize() = runTest {
        initCrypto()
        val r = UniversalRing(UniversalKey.newSymmetricKey())
        val rd = BipackEncoder.encode(r)
        println(rd.size)
        println(rd.toDump())
        assertTrue { rd.size <= 46 }
    }

    @Test
    fun testJoin() = runTest {
        initCrypto()
        val a = UniversalKey.newSecretKey()
        val b = UniversalKey.newSigningKey()
        val c = UniversalKey.newSymmetricKey()
        val d = UniversalKey.newSigningKey()

        val ra = UniversalRing(a)
        val rb = UniversalRing(b)
        val rc = UniversalRing(c)
        val rd = UniversalRing(d) + (a to "foo_a")

        var r1 = ra + rb + rc + rd

        assertEquals(a, r1.findKey<UniversalKey.Secret>(a.id))
        assertEquals(a, r1.keyByTag<UniversalKey>("foo_a"))
        assertEquals(b, r1.findKey<SigningKey>(b.id))
        assertEquals(c, r1.keysById(c.key.id).first())

        r1 = UniversalRing.join(listOf(ra, rb, rc, rd))

        assertEquals(a, r1.findKey<UniversalKey.Secret>(a.id))
        assertEquals(a, r1.keyByTag<UniversalKey>("foo_a"))
        assertEquals(b, r1.findKey<SigningKey>(b.id))
        assertEquals(c, r1.keysById(c.key.id).first())

    }
}