Support for encryption

[yuvaraj119]

Storing the file as encrypted.

[percy-g2]

@xxfast , I have a proposal for an enhancement where we encrypt JSON data using secp256k1. The decryption key can either be cached or provided by the user. I have a working sample that supports encryption and decryption across all platforms. You can read more about secp256k1 here: https://en.bitcoin.it/wiki/Secp256k1. Let me know if you'd like me to provide pseudocode or a working example!

[laguiar]

This feature will be very helpful.

[xxfast]

PRs welcome 😁

[dxwil]

+1

[dxwil]

I wrote a simple implementation using this cryptography library:

import dev.whyoleg.cryptography.CryptographyProvider
import dev.whyoleg.cryptography.algorithms.AES
import dev.whyoleg.cryptography.algorithms.AES.Key
import io.github.xxfast.kstore.Codec
import io.github.xxfast.kstore.DefaultJson
import io.github.xxfast.kstore.KStore
import kotlinx.io.buffered
import kotlinx.io.files.FileNotFoundException
import kotlinx.io.files.Path
import kotlinx.io.files.SystemFileSystem
import kotlinx.io.readByteArray
import kotlinx.serialization.KSerializer
import kotlinx.serialization.Serializable
import kotlinx.serialization.json.Json
import kotlinx.serialization.serializer

inline fun <reified T : @Serializable Any> storeOf(
  file: Path,
  key: ByteArray,
  default: T? = null,
  enableCache: Boolean = true,
  json: Json = DefaultJson,
): KStore<T> = io.github.xxfast.kstore.storeOf(
  codec = EncryptedCodec(
    file = file,
    json = json,
    key = key,
    tempFile = Path("$file.temp"),
    serializer = json.serializersModule.serializer()
  ),
  default = default,
  enableCache = enableCache,
)

class EncryptedCodec<T : @Serializable Any>(
  private val file: Path,
  private val key: ByteArray,
  private val tempFile: Path,
  private val json: Json,
  private val serializer: KSerializer<T>,
) : Codec<T> {
  override suspend fun decode(): T? =
    try {
      val encryptedBytes = SystemFileSystem.source(file).buffered().readByteArray()
      val decryptedJson = decryptData(encryptedBytes)
      json.decodeFromString(serializer, decryptedJson)
    } catch (e: FileNotFoundException) {
      null
    }

  override suspend fun encode(value: T?) {
    if (value == null) {
      SystemFileSystem.delete(file, mustExist = false)
      return
    }

    try {
      val jsonString = json.encodeToString(serializer, value)
      val encryptedData = encryptData(jsonString)

      SystemFileSystem.sink(tempFile).buffered().use {
        it.write(encryptedData)
      }
    } catch (e: Throwable) {
      SystemFileSystem.delete(tempFile, mustExist = false)
      throw e
    }

    SystemFileSystem.atomicMove(source = tempFile, destination = file)
  }

  private suspend fun encryptData(text: String): ByteArray =
    getAESCipher().encrypt(text.encodeToByteArray())


  private suspend fun decryptData(encryptedData: ByteArray): String =
    getAESCipher().decrypt(encryptedData).decodeToString()


  private suspend fun getAESCipher(): AES.IvCipher =
    CryptographyProvider.Default
      .get(AES.CBC)
      .keyDecoder()
      .decodeFromByteArray(Key.Format.RAW, key)
      .cipher()
}