dependencies {
    implementation("io.github.kotlinmania:crypto-box-kotlin:0.2.1")
}

import io.github.kotlinmania.cryptobox.ChaChaBox
import io.github.kotlinmania.cryptobox.PublicKey
import io.github.kotlinmania.cryptobox.SalsaBox
import io.github.kotlinmania.cryptobox.SecretKey

// Alice and Bob each generate a keypair
val aliceSecretKey = SecretKey.generate()
val alicePublicKey = aliceSecretKey.publicKey()

val bobSecretKey = SecretKey.generate()
val bobPublicKey = bobSecretKey.publicKey()

// Alice derives a box with Bob's public key and her secret key
val aliceBox = SalsaBox.new(bobPublicKey, aliceSecretKey)
val nonce = SalsaBox.generateNonce()
val plaintext = "Top secret message we're encrypting".encodeToByteArray()

// Encrypt (returns 16-byte Poly1305 tag + ciphertext)
val ciphertext = aliceBox.encrypt(nonce, plaintext)

// Bob derives the same box using Alice's public key and his secret key
val bobBox = SalsaBox.new(alicePublicKey, bobSecretKey)
val decrypted = bobBox.decrypt(nonce, ciphertext)
check(plaintext.contentEquals(decrypted))

// ChaChaBox provides the same API using XChaCha20Poly1305:
val chachaBox = ChaChaBox.new(bobPublicKey, aliceSecretKey)
val chachaNonce = ChaChaBox.generateNonce()
val chachaCiphertext = chachaBox.encrypt(chachaNonce, plaintext)
val chachaDecrypted = ChaChaBox.new(alicePublicKey, bobSecretKey).decrypt(chachaNonce, chachaCiphertext)
check(plaintext.contentEquals(chachaDecrypted))

import io.github.kotlinmania.cryptobox.SecretKey

val recipientSecretKey = SecretKey.generate()
val recipientPublicKey = recipientSecretKey.publicKey()

val message = "Anonymous sealed box payload".encodeToByteArray()

// Sender only needs the recipient's PublicKey
val sealedCiphertext = recipientPublicKey.seal(message)

// Recipient opens the sealed box using their SecretKey
val unsealedPlaintext = recipientSecretKey.unseal(sealedCiphertext)
check(message.contentEquals(unsealedPlaintext))

import io.github.kotlinmania.cryptobox.ChaChaBox
import io.github.kotlinmania.cryptobox.SecretKey

val aliceSk = SecretKey.generate()
val bobSk = SecretKey.generate()
val box = ChaChaBox.new(bobSk.publicKey(), aliceSk)
val nonce = ChaChaBox.generateNonce()

val buffer = "Detached in-place encryption".encodeToByteArray()

// Encrypts `buffer` in place and returns the 16-byte authentication tag
val tag = box.encryptInPlaceDetached(nonce, ByteArray(0), buffer)

// Verifies `tag` in constant time and decrypts `buffer` in place
ChaChaBox.new(aliceSk.publicKey(), bobSk).decryptInPlaceDetached(nonce, ByteArray(0), buffer, tag)

import io.github.kotlinmania.cryptobox.PublicKey
import io.github.kotlinmania.cryptobox.SecretKey

SecretKey.generate().use { secretKey ->
    val publicKey = PublicKey.from(secretKey)

    // ByteArray and hexadecimal serialization round-trips
    val pubHex = publicKey.serializeHex()
    val restoredPub = PublicKey.deserializeHex(pubHex)
    check(restoredPub == publicKey)
} // secretKey.close() automatically zeroizes raw key bytes and scalar material