crypto2/src/commonTest/kotlin/KeysTest.kt

import com.ionspin.kotlin.crypto.util.decodeFromUByteArray
import com.ionspin.kotlin.crypto.util.encodeToUByteArray
import kotlinx.coroutines.test.runTest
import kotlinx.serialization.encodeToString
import kotlinx.serialization.json.Json
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 testSigningCreationAndMap() = runTest {
        initCrypto()
        val (stk,pbk) = SigningKey.pair()

        val x = mapOf( stk to "STK!", pbk to "PBK!")
        assertEquals("STK!", x[stk])
        val s1 = SigningKey.Secret(stk.packed)
        assertEquals(stk, s1)
        assertEquals("STK!", x[s1])
        assertEquals("PBK!", x[pbk])

        val data = "8 rays dev!".encodeToUByteArray()
        val data1 = "8 rays dev!".encodeToUByteArray()
        val s = stk.seal(data)
        s.verify(data)

        data1[0] = 0x01u
        assertFalse(s.isValid(data1))
        val p2 = SigningKey.pair()
        val p3 = SigningKey.pair()

        val ms = SealedBox.create(data, s1) + p2.secretKey

        // non tampered:
        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<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 = 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> {
            key.decrypt(key1.encrypt("hello".encodeToUByteArray())).decodeFromUByteArray()
        }
    }

    @Test
    fun keyExchangeTest() = runTest {
        initCrypto()
        val ske = SafeKeyExchange()
        val cke = SafeKeyExchange()

        val clientSessionKey = cke.clientSessionKey(ske.publicKey)
        val serverSessionKey = ske.serverSessionKey(cke.publicKey)

        val src = "Hello, Dolly!"
        assertEquals(src, serverSessionKey.decryptString(clientSessionKey.encrypt(src)))
        assertEquals(src, serverSessionKey.decryptString(clientSessionKey.encrypt(src)))
        assertEquals(src, serverSessionKey.decryptString(clientSessionKey.encrypt(src)))
        assertEquals(src, serverSessionKey.decryptString(clientSessionKey.encrypt(src)))

        assertEquals(src, clientSessionKey.decryptString(serverSessionKey.encrypt(src)))
        assertEquals(src, clientSessionKey.decryptString(serverSessionKey.encrypt(src)))
        assertEquals(src, clientSessionKey.decryptString(serverSessionKey.encrypt(src)))
        assertEquals(src, clientSessionKey.decryptString(serverSessionKey.encrypt(src)))

    }

    @Test
    fun asymmetricKeyTest() = runTest {
        initCrypto()
        val (sk0, pk0) = Asymmetric.generateKeys()
        assertEquals(pk0, sk0.publicKey)

        val (sk1, pk1) = Asymmetric.generateKeys()
        val (sk2, pk2) = Asymmetric.generateKeys()

        val plain = "The fake vaccine kills".encodeToUByteArray()

        var m = Asymmetric.createMessage(sk0, pk1, plain)
        assertContentEquals(plain, m.decrypt(sk1))
        assertThrows<DecryptionFailedException> {
            assertContentEquals(plain, m.decrypt(sk2))
        }

    }
    @Test
    fun asymmetricKeySerializationTest() = runTest {
        initCrypto()
        val (sk0, pk0) = Asymmetric.generateKeys()

//        println(sk0.publicKey)
        val j = Json { prettyPrint = true}

        val sk1 = j.decodeFromString<Asymmetric.SecretKey>(j.encodeToString(sk0))
        assertEquals(sk0, sk1)
        assertEquals(pk0, sk1.publicKey)
//        println(j.encodeToString(sk1))
    }

}