Compare commits
7
Commits
0.9.0
...
2d55af4e3b
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
2d55af4e3b | ||
|
|
a77fdd79c1 | ||
|
|
d6b171229f | ||
|
|
cd57627cdb | ||
|
|
5c3ff72123 | ||
|
|
d0f1fffe6d | ||
|
|
8015a4310b |
No files matched your search
Generated
-1
@@ -1,4 +1,3 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<project version="4">
|
||||
<component name="ExternalStorageConfigurationManager" enabled="true" />
|
||||
<component name="FrameworkDetectionExcludesConfiguration">
|
||||
|
||||
+1
-1
@@ -20,7 +20,7 @@ plugins {
|
||||
}
|
||||
|
||||
group = "net.sergeych"
|
||||
version = "0.9.0"
|
||||
version = "0.9.2-SNAPSHOT"
|
||||
|
||||
repositories {
|
||||
mavenCentral()
|
||||
|
||||
@@ -0,0 +1,65 @@
|
||||
/*
|
||||
* Copyright (c) 2025. Sergey S. Chernov - All Rights Reserved
|
||||
*
|
||||
* You may use, distribute and modify this code under the
|
||||
* terms of the private license, which you must obtain from the author
|
||||
*
|
||||
* To obtain the license, contact the author: https://t.me/real_sergeych or email to
|
||||
* real dot sergeych at gmail.
|
||||
*/
|
||||
|
||||
package net.sergeych.crypto2
|
||||
|
||||
import com.ionspin.kotlin.crypto.generichash.GenericHash
|
||||
import com.ionspin.kotlin.crypto.util.encodeToUByteArray
|
||||
|
||||
/**
|
||||
* Deterministic seed derivation helper.
|
||||
*
|
||||
* It compresses arbitrary byte material to an exact seed size using domain-separated BLAKE2b.
|
||||
* This is intended for already strong random byte material. Do not use it as a password KDF;
|
||||
* use [KDF] and [PBKD] for passwords and other low-entropy secrets.
|
||||
*/
|
||||
object KeySeed {
|
||||
private const val maxBlake2bOutput = 64
|
||||
private const val minBlake2bOutput = 16
|
||||
private val apiKey = "net.sergeych.crypto2.KeySeed.v1".encodeToUByteArray()
|
||||
|
||||
/**
|
||||
* Derive exactly [size] bytes suitable for APIs expecting fixed-size cryptographic seeds.
|
||||
*
|
||||
* [purpose] domain-separates seeds for different key types. Use a stable, key-specific value
|
||||
* when deriving more than one seed from the same [source].
|
||||
*/
|
||||
fun fromBytes(source: UByteArray, size: Int, purpose: String = "default"): UByteArray {
|
||||
require(size > 0) { "seed size should be positive" }
|
||||
require(source.isNotEmpty()) { "source bytes should not be empty" }
|
||||
val key = GenericHash.genericHash(apiKey + purpose.encodeToUByteArray(), 32)
|
||||
if (size <= maxBlake2bOutput) {
|
||||
val hashSize = size.coerceAtLeast(minBlake2bOutput)
|
||||
return GenericHash.genericHash(source, hashSize, key).copyOf(size)
|
||||
}
|
||||
|
||||
val result = mutableListOf<UByte>()
|
||||
var round = 0
|
||||
while (result.size < size) {
|
||||
val block = GenericHash.genericHash(
|
||||
round.toLittleEndianBytes() + size.toLittleEndianBytes() + source,
|
||||
maxBlake2bOutput,
|
||||
key
|
||||
)
|
||||
val count = minOf(block.size, size - result.size)
|
||||
result += block.take(count)
|
||||
round += 1
|
||||
}
|
||||
return result.toUByteArray()
|
||||
}
|
||||
|
||||
private fun Int.toLittleEndianBytes(): UByteArray =
|
||||
ubyteArrayOf(
|
||||
(this and 0xff).toUByte(),
|
||||
((this ushr 8) and 0xff).toUByte(),
|
||||
((this ushr 16) and 0xff).toUByte(),
|
||||
((this ushr 24) and 0xff).toUByte(),
|
||||
)
|
||||
}
|
||||
@@ -11,7 +11,14 @@
|
||||
package net.sergeych.crypto2
|
||||
|
||||
import com.ionspin.kotlin.crypto.keyexchange.KeyExchange
|
||||
import com.ionspin.kotlin.crypto.keyexchange.KeyExchangeKeyPair
|
||||
import com.ionspin.kotlin.crypto.keyexchange.crypto_kx_PUBLICKEYBYTES
|
||||
import com.ionspin.kotlin.crypto.keyexchange.crypto_kx_SECRETKEYBYTES
|
||||
import kotlinx.serialization.KSerializer
|
||||
import kotlinx.serialization.Serializable
|
||||
import kotlinx.serialization.descriptors.SerialDescriptor
|
||||
import kotlinx.serialization.encoding.Decoder
|
||||
import kotlinx.serialization.encoding.Encoder
|
||||
import net.sergeych.crypto2.SafeKeyExchange.SessionKey
|
||||
|
||||
/**
|
||||
@@ -20,7 +27,7 @@ import net.sergeych.crypto2.SafeKeyExchange.SessionKey
|
||||
* Usage:
|
||||
*
|
||||
* 1. Create [SafeKeyExchange] on both server and client sides
|
||||
* 2. Exchange [EncryptingPublicKey] instances
|
||||
* 2. Exchange [PublicKey] instances
|
||||
* 3. Create [serverSessionKey] and [clientSessionKey] respectively
|
||||
* 4. Use [SessionKey.sendingKey] and [SessionKey.receivingKey] to send and receive encrypted data.
|
||||
*
|
||||
@@ -31,9 +38,44 @@ import net.sergeych.crypto2.SafeKeyExchange.SessionKey
|
||||
* - while it is possible to generate several keys "ahead", the care should be taken when storing them,
|
||||
* encrypt it with some other key to maintain safety.
|
||||
* - do not use [EncryptingPublicKey] for anything but creating session keys.
|
||||
* - the serialized form includes the secret exchange key, so it should be encrypted when stored.
|
||||
*/
|
||||
class SafeKeyExchange {
|
||||
private val pair = KeyExchange.keypair()
|
||||
@Serializable(with = SafeKeyExchange.SafeKeyExchangeSerializer::class)
|
||||
class SafeKeyExchange private constructor(
|
||||
private val pair: KeyExchangeKeyPair,
|
||||
) {
|
||||
|
||||
constructor() : this(KeyExchange.keypair())
|
||||
|
||||
@Serializable
|
||||
private class Packed(
|
||||
val publicKey: UByteArray,
|
||||
val secretKey: UByteArray,
|
||||
)
|
||||
|
||||
object SafeKeyExchangeSerializer : KSerializer<SafeKeyExchange> {
|
||||
private val packedSerializer = Packed.serializer()
|
||||
|
||||
override val descriptor: SerialDescriptor = packedSerializer.descriptor
|
||||
|
||||
override fun serialize(encoder: Encoder, value: SafeKeyExchange) {
|
||||
encoder.encodeSerializableValue(
|
||||
packedSerializer,
|
||||
Packed(value.pair.publicKey, value.pair.secretKey)
|
||||
)
|
||||
}
|
||||
|
||||
override fun deserialize(decoder: Decoder): SafeKeyExchange {
|
||||
val packed = decoder.decodeSerializableValue(packedSerializer)
|
||||
require(packed.publicKey.size == crypto_kx_PUBLICKEYBYTES) {
|
||||
"SafeKeyExchange public key must be $crypto_kx_PUBLICKEYBYTES bytes"
|
||||
}
|
||||
require(packed.secretKey.size == crypto_kx_SECRETKEYBYTES) {
|
||||
"SafeKeyExchange secret key must be $crypto_kx_SECRETKEYBYTES bytes"
|
||||
}
|
||||
return SafeKeyExchange(KeyExchangeKeyPair(packed.publicKey, packed.secretKey))
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The session key. It uses a pair of keys to encrypt and decrypt messages to maintain high
|
||||
@@ -90,9 +132,24 @@ class SafeKeyExchange {
|
||||
* The public key; it should be transmitted to the other party, this is serializable.
|
||||
* Do not use it except to get [SessionKey] with [clientSessionKey] or [serverSessionKey]. Storing and reusing
|
||||
* it is a great danger.
|
||||
*
|
||||
* Instances can be compared and used as hashtable keys.
|
||||
*/
|
||||
@Serializable
|
||||
class PublicKey(val keyBytes: UByteArray)
|
||||
class PublicKey(val keyBytes: UByteArray) {
|
||||
override fun equals(other: Any?): Boolean {
|
||||
if (this === other) return true
|
||||
if (other == null || this::class != other::class) return false
|
||||
|
||||
other as PublicKey
|
||||
|
||||
return keyBytes.contentEquals(other.keyBytes)
|
||||
}
|
||||
|
||||
override fun hashCode(): Int {
|
||||
return keyBytes.contentHashCode()
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The public key to be sent to the other party. When received, get the session keys with [clientSessionKey]
|
||||
@@ -120,4 +177,4 @@ class SafeKeyExchange {
|
||||
.let { SessionKey(SymmetricKey(it.sendKey), SymmetricKey(it.receiveKey), isClient = false) }
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
@@ -11,6 +11,7 @@
|
||||
package net.sergeych.crypto2
|
||||
|
||||
import com.ionspin.kotlin.crypto.box.Box
|
||||
import com.ionspin.kotlin.crypto.box.crypto_box_SEEDBYTES
|
||||
import com.ionspin.kotlin.crypto.scalarmult.ScalarMultiplication
|
||||
import kotlinx.serialization.SerialName
|
||||
import kotlinx.serialization.Serializable
|
||||
@@ -87,6 +88,11 @@ class DecryptingSecretKey(
|
||||
companion object {
|
||||
data class KeyPair(val secretKey: DecryptingSecretKey, val publicKey: EncryptingPublicKey)
|
||||
|
||||
/**
|
||||
* Required seed size for deterministic decrypting key generation.
|
||||
*/
|
||||
val seedLength = crypto_box_SEEDBYTES
|
||||
|
||||
/**
|
||||
* Generate a new random pair of public and secret keys.
|
||||
*/
|
||||
@@ -96,7 +102,30 @@ class DecryptingSecretKey(
|
||||
return KeyPair(DecryptingSecretKey(p.secretKey, pk), pk)
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the key pair deterministically from an exact [seedLength]-byte seed.
|
||||
*/
|
||||
fun generateKeys(seed: UByteArray): KeyPair {
|
||||
require(seed.size == seedLength) { "seed should be $seedLength bytes" }
|
||||
val p = Box.seedKeypair(seed)
|
||||
val pk = EncryptingPublicKey(p.publicKey)
|
||||
return KeyPair(DecryptingSecretKey(p.secretKey, pk), pk)
|
||||
}
|
||||
|
||||
fun new(): DecryptingSecretKey = generateKeys().secretKey
|
||||
|
||||
/**
|
||||
* Create a deterministic secret key from an exact [seedLength]-byte seed.
|
||||
*/
|
||||
fun fromSeed(seed: UByteArray): DecryptingSecretKey = generateKeys(seed).secretKey
|
||||
|
||||
/**
|
||||
* Derive an exact [seedLength]-byte seed from arbitrary byte material.
|
||||
*
|
||||
* Use this only with high-entropy source bytes. It is not a password KDF.
|
||||
*/
|
||||
fun seedFromBytes(source: UByteArray): UByteArray =
|
||||
KeySeed.fromBytes(source, seedLength, "DecryptingSecretKey")
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -11,6 +11,7 @@
|
||||
package net.sergeych.crypto2
|
||||
|
||||
import com.ionspin.kotlin.crypto.signature.Signature
|
||||
import com.ionspin.kotlin.crypto.signature.crypto_sign_SEEDBYTES
|
||||
import kotlin.time.Instant
|
||||
import kotlinx.serialization.SerialName
|
||||
import kotlinx.serialization.Serializable
|
||||
@@ -76,13 +77,41 @@ class SigningSecretKey(
|
||||
|
||||
data class SigningKeyPair(val secretKey: SigningSecretKey, val publicKey: VerifyingPublicKey)
|
||||
|
||||
/**
|
||||
* Required seed size for deterministic signing key generation.
|
||||
*/
|
||||
const val seedLength = crypto_sign_SEEDBYTES
|
||||
|
||||
fun generatePair(): SigningKeyPair {
|
||||
val p = Signature.keypair()
|
||||
val publicKey = VerifyingPublicKey(p.publicKey)
|
||||
return SigningKeyPair(SigningSecretKey(p.secretKey, publicKey), publicKey)
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate the key pair deterministically from an exact [seedLength]-byte seed.
|
||||
*/
|
||||
fun generatePair(seed: UByteArray): SigningKeyPair {
|
||||
require(seed.size == seedLength) { "seed should be $seedLength bytes" }
|
||||
val p = Signature.seedKeypair(seed)
|
||||
val publicKey = VerifyingPublicKey(p.publicKey)
|
||||
return SigningKeyPair(SigningSecretKey(p.secretKey, publicKey), publicKey)
|
||||
}
|
||||
|
||||
fun new(): SigningSecretKey = generatePair().secretKey
|
||||
|
||||
/**
|
||||
* Create a deterministic signing key from an exact [seedLength]-byte seed.
|
||||
*/
|
||||
fun fromSeed(seed: UByteArray): SigningSecretKey = generatePair(seed).secretKey
|
||||
|
||||
/**
|
||||
* Derive an exact [seedLength]-byte seed from arbitrary byte material.
|
||||
*
|
||||
* Use this only with high-entropy source bytes. It is not a password KDF.
|
||||
*/
|
||||
fun seedFromBytes(source: UByteArray): UByteArray =
|
||||
KeySeed.fromBytes(source, seedLength, "SigningSecretKey")
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -46,13 +46,54 @@ class SymmetricKey(
|
||||
data class WithNonce(
|
||||
val cipherData: UByteArray,
|
||||
val nonce: UByteArray,
|
||||
)
|
||||
) {
|
||||
override fun equals(other: Any?): Boolean {
|
||||
if (this === other) return true
|
||||
if (other == null || this::class != other::class) return false
|
||||
|
||||
other as WithNonce
|
||||
|
||||
if (!cipherData.contentEquals(other.cipherData)) return false
|
||||
if (!nonce.contentEquals(other.nonce)) return false
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
override fun hashCode(): Int {
|
||||
var result = cipherData.contentHashCode()
|
||||
result = 31 * result + nonce.contentHashCode()
|
||||
return result
|
||||
}
|
||||
}
|
||||
|
||||
override fun encryptWithNonce(plainData: UByteArray, nonce: UByteArray, randomFill: IntRange?): UByteArray {
|
||||
require(nonce.size == nonceLength)
|
||||
return SecretBox.easy(WithFill.encode(plainData, randomFill), nonce, keyBytes)
|
||||
}
|
||||
|
||||
/**
|
||||
* Compact authenticated encryption with a caller-provided nonce.
|
||||
*
|
||||
* This method is meant for storage formats where the nonce is derived or stored elsewhere
|
||||
* and every byte of encoded output matters, for example short encrypted file names.
|
||||
* The output is the raw SecretBox ciphertext only: [plainData] size plus 16 authentication
|
||||
* bytes. The nonce is not stored in the output and must be reproduced exactly for
|
||||
* [decryptCompactWithNonce].
|
||||
*
|
||||
* Unlike [encryptWithNonce], this method does not wrap [plainData] with [WithFill]. For
|
||||
* short payloads this usually saves only 1 byte over [encryptWithNonce], because both
|
||||
* methods already require the caller to manage the nonce separately. Use it only when this
|
||||
* small size gain is important or when the surrounding format explicitly requires raw
|
||||
* SecretBox output.
|
||||
*
|
||||
* Never reuse the same nonce with the same key for different plaintext. Reusing a
|
||||
* `(key, nonce)` pair with SecretBox breaks the security of the stream cipher.
|
||||
*/
|
||||
fun encryptCompactWithNonce(plainData: UByteArray, nonce: UByteArray): UByteArray {
|
||||
require(nonce.size == nonceLength)
|
||||
return SecretBox.easy(plainData, nonce, keyBytes)
|
||||
}
|
||||
|
||||
override val nonceBytesLength: Int = nonceLength
|
||||
|
||||
override val id by lazy {
|
||||
@@ -64,6 +105,22 @@ class SymmetricKey(
|
||||
WithFill.decode(SecretBox.openEasy(cipherData, nonce, keyBytes))
|
||||
}
|
||||
|
||||
/**
|
||||
* Compact authenticated decryption with a caller-provided nonce.
|
||||
*
|
||||
* Decrypts data produced by [encryptCompactWithNonce]. The nonce is not read from
|
||||
* [cipherData] and must be the exact same nonce that was used for encryption. Use this
|
||||
* method only for compact formats that intentionally omit both the nonce and the [WithFill]
|
||||
* wrapper.
|
||||
*
|
||||
* @throws DecryptionFailedException if the key, nonce, or cipher data is invalid.
|
||||
*/
|
||||
fun decryptCompactWithNonce(cipherData: UByteArray, nonce: UByteArray): UByteArray =
|
||||
protectDecryption {
|
||||
require(nonce.size == nonceLength)
|
||||
SecretBox.openEasy(cipherData, nonce, keyBytes)
|
||||
}
|
||||
|
||||
override fun equals(other: Any?): Boolean {
|
||||
if (this === other) return true
|
||||
if (other !is SymmetricKey) return false
|
||||
@@ -85,4 +142,4 @@ class SymmetricKey(
|
||||
val keyLength = crypto_secretbox_KEYBYTES
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
@@ -48,10 +48,38 @@ class UniversalPrivateKey(
|
||||
}
|
||||
|
||||
companion object {
|
||||
/**
|
||||
* Required seed size for deterministic universal private key generation.
|
||||
*
|
||||
* It contains independent signing and decrypting seeds.
|
||||
*/
|
||||
val seedLength = SigningSecretKey.seedLength + DecryptingSecretKey.seedLength
|
||||
|
||||
/**
|
||||
* Generate 2 new random keys (4 key pairs under the hood) to securely signd and
|
||||
* decrypt data.
|
||||
*/
|
||||
fun new() = UniversalPrivateKey(SigningSecretKey.new(), DecryptingSecretKey.new())
|
||||
|
||||
/**
|
||||
* Create a deterministic private key from an exact [seedLength]-byte seed.
|
||||
*/
|
||||
fun fromSeed(seed: UByteArray): UniversalPrivateKey {
|
||||
require(seed.size == seedLength) { "seed should be $seedLength bytes" }
|
||||
val signingSeed = seed.sliceArray(0..<SigningSecretKey.seedLength)
|
||||
val decryptingSeed = seed.sliceArray(SigningSecretKey.seedLength..<seedLength)
|
||||
return UniversalPrivateKey(
|
||||
SigningSecretKey.fromSeed(signingSeed),
|
||||
DecryptingSecretKey.fromSeed(decryptingSeed)
|
||||
)
|
||||
}
|
||||
|
||||
/**
|
||||
* Derive an exact [seedLength]-byte seed from arbitrary byte material.
|
||||
*
|
||||
* Use this only with high-entropy source bytes. It is not a password KDF.
|
||||
*/
|
||||
fun seedFromBytes(source: UByteArray): UByteArray =
|
||||
KeySeed.fromBytes(source, seedLength, "UniversalPrivateKey")
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -229,6 +229,8 @@ class UniversalRing(
|
||||
companion object {
|
||||
val EMPTY = UniversalRing(keyWithTags = emptyMap())
|
||||
|
||||
fun new(): UniversalRing = UniversalRing(keyWithTags = emptyMap())
|
||||
|
||||
/**
|
||||
* Join a collection of keyrings together (same as reducing with `+`). Correctly
|
||||
* works if there is no keyring (returns [EMPTY]), or only one keyring (returns
|
||||
|
||||
@@ -47,6 +47,12 @@ sealed class KDF {
|
||||
fun kdfForSize(numberOfKeys: Int,salt: UByteArray = Argon.randomSalt()): KDF =
|
||||
creteDefault(SymmetricKey.keyLength * numberOfKeys, this, salt)
|
||||
|
||||
fun kdfForSizeInBytes(sizeInBytes: Int, domain: String): KDF {
|
||||
val salt = Hash.Blake2b.deriveSalt(domain, Argon.saltSize)
|
||||
return creteDefault(sizeInBytes, this, salt)
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Derive multiple keys from the password. Derivation params will be included in the key ids, see
|
||||
* [SymmetricKey.id] as [KeyId.kdp].
|
||||
@@ -66,6 +72,12 @@ sealed class KDF {
|
||||
* Derive single key from password, same as [deriveMultiple] with count=1.
|
||||
*/
|
||||
fun derive(password: String, salt: UByteArray): SymmetricKey = deriveMultiple(password, 1, salt).first()
|
||||
|
||||
/**
|
||||
* Derive bytes from bytes using the default [Argon] KDF with this complexity.
|
||||
*/
|
||||
fun derive(source: UByteArray, salt: UByteArray, derivedSize: Int): UByteArray =
|
||||
creteDefault(derivedSize, this, salt).deriveFromBytes(source, derivedSize)
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -73,6 +85,11 @@ sealed class KDF {
|
||||
*/
|
||||
abstract fun deriveKey(password: String): UByteArray
|
||||
|
||||
/**
|
||||
* Derive bytes from bytes using this KDF parameters.
|
||||
*/
|
||||
abstract fun deriveFromBytes(source: UByteArray, derivedSize: Int): UByteArray
|
||||
|
||||
/**
|
||||
* Derive keys from lower part of bytes derived from the password. E.g., if generated size is longer than
|
||||
* required to create [count] keys, the first bytes will be used. It let use rest bytes for other purposes.
|
||||
@@ -131,6 +148,18 @@ sealed class KDF {
|
||||
override fun deriveKey(password: String): UByteArray =
|
||||
PasswordHash.pwhash(keySize, password, salt, instructionsComplexity, memComplexity, algorithm.code)
|
||||
|
||||
override fun deriveFromBytes(source: UByteArray, derivedSize: Int): UByteArray {
|
||||
require(derivedSize >= minKeySize) { "The derived size should be at least $minKeySize bytes" }
|
||||
return PasswordHash.pwhash(
|
||||
derivedSize,
|
||||
source.encodeToBase64Url(),
|
||||
salt,
|
||||
instructionsComplexity,
|
||||
memComplexity,
|
||||
algorithm.code
|
||||
)
|
||||
}
|
||||
|
||||
override fun equals(other: Any?): Boolean {
|
||||
if (this === other) return true
|
||||
if (other !is Argon) return false
|
||||
@@ -171,7 +200,7 @@ sealed class KDF {
|
||||
|
||||
fun create(complexity: Complexity, salt: UByteArray, keySize: Int): Argon {
|
||||
require(salt.size == saltSize) { "The salt size should be $saltSize" }
|
||||
require(keySize > minKeySize) { "The key size should be at least $keySize bytes" }
|
||||
require(keySize >= minKeySize) { "The key size should be at least $minKeySize bytes" }
|
||||
return when (complexity) {
|
||||
FixedLow -> Argon(
|
||||
V2id_13,
|
||||
@@ -221,6 +250,7 @@ sealed class KDF {
|
||||
}
|
||||
|
||||
companion object {
|
||||
|
||||
fun creteDefault(keySize: Int, complexity: Complexity, salt: UByteArray = Argon.randomSalt()): KDF {
|
||||
return Argon.create(complexity, salt, keySize)
|
||||
}
|
||||
@@ -230,4 +260,3 @@ sealed class KDF {
|
||||
data class Instance(val kdf: KDF, val password: String)
|
||||
|
||||
}
|
||||
|
||||
@@ -9,11 +9,15 @@
|
||||
*/
|
||||
|
||||
import kotlinx.coroutines.test.runTest
|
||||
import net.sergeych.crypto2.Hash
|
||||
import net.sergeych.crypto2.KDF
|
||||
import net.sergeych.crypto2.initCrypto
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertContentEquals
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertFalse
|
||||
import kotlin.test.assertFailsWith
|
||||
import kotlin.test.assertIs
|
||||
|
||||
class KDFTest {
|
||||
@Test
|
||||
@@ -55,4 +59,62 @@ class KDFTest {
|
||||
assertEquals(3, kk.size)
|
||||
}
|
||||
|
||||
}
|
||||
@Test
|
||||
fun complexityKdfForSizeInBytesTest() = runTest {
|
||||
initCrypto()
|
||||
val size = KDF.Argon.minKeySize + 17
|
||||
val domain = "kdf-size-in-bytes-test"
|
||||
val expectedSalt = Hash.Blake2b.deriveSalt(domain, KDF.Argon.saltSize)
|
||||
|
||||
val kdf = KDF.Complexity.FixedLow.kdfForSizeInBytes(size, domain)
|
||||
assertIs<KDF.Argon>(kdf)
|
||||
|
||||
assertEquals(KDF.Argon.create(KDF.Complexity.FixedLow, expectedSalt, size), kdf)
|
||||
assertEquals(size, kdf.keySize)
|
||||
assertContentEquals(expectedSalt, kdf.salt)
|
||||
assertFalse {
|
||||
kdf.salt contentEquals Hash.Blake2b.deriveSalt("$domain-other", KDF.Argon.saltSize)
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun deriveFromBytesTest() = runTest {
|
||||
initCrypto()
|
||||
val salt = UByteArray(KDF.Argon.saltSize) { it.toUByte() }
|
||||
val kdf = KDF.Argon.create(KDF.Complexity.Interactive, salt, 80)
|
||||
val source = UByteArray(47) { (it * 3).toUByte() }
|
||||
|
||||
val b1 = kdf.deriveFromBytes(source, 80)
|
||||
val b2 = kdf.deriveFromBytes(source, 80)
|
||||
val b3 = kdf.deriveFromBytes(source + 1u, 80)
|
||||
|
||||
assertEquals(80, b1.size)
|
||||
assertContentEquals(b1, b2)
|
||||
assertFalse { b1 contentEquals b3 }
|
||||
}
|
||||
|
||||
@Test
|
||||
fun complexityDeriveFromBytesTest() = runTest {
|
||||
initCrypto()
|
||||
val salt = UByteArray(KDF.Argon.saltSize) { (it + 1).toUByte() }
|
||||
val source = UByteArray(23) { (it + 7).toUByte() }
|
||||
|
||||
val b1 = KDF.Complexity.Interactive.derive(source, salt, 64)
|
||||
val b2 = KDF.Argon.create(KDF.Complexity.Interactive, salt, 64).deriveFromBytes(source, 64)
|
||||
|
||||
assertContentEquals(b1, b2)
|
||||
assertEquals(64, b1.size)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun deriveFromBytesValidationTest() = runTest {
|
||||
initCrypto()
|
||||
val salt = UByteArray(KDF.Argon.saltSize) { it.toUByte() }
|
||||
val kdf = KDF.Argon.create(KDF.Complexity.Interactive, salt, KDF.Argon.minKeySize)
|
||||
|
||||
assertFailsWith<IllegalArgumentException> {
|
||||
kdf.deriveFromBytes(ubyteArrayOf(1u, 2u, 3u), KDF.Argon.minKeySize - 1)
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -11,7 +11,6 @@
|
||||
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.bipack.BipackDecoder
|
||||
import net.sergeych.bipack.BipackEncoder
|
||||
@@ -83,6 +82,48 @@ class KeysTest {
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
fun seededPrivateKeysTest() = runTest {
|
||||
initCrypto()
|
||||
val source = "stable high entropy key material placeholder".encodeToUByteArray() + randomUBytes(128)
|
||||
val data = "seeded generation works".encodeToUByteArray()
|
||||
|
||||
val signingSeed = SigningSecretKey.seedFromBytes(source)
|
||||
val decryptingSeed = DecryptingSecretKey.seedFromBytes(source)
|
||||
assertEquals(SigningSecretKey.seedLength, signingSeed.size)
|
||||
assertEquals(DecryptingSecretKey.seedLength, decryptingSeed.size)
|
||||
assertFalse(signingSeed contentEquals decryptingSeed)
|
||||
|
||||
val signingKey1 = SigningSecretKey.fromSeed(signingSeed)
|
||||
val signingKey2 = SigningSecretKey.fromSeed(signingSeed)
|
||||
assertEquals(signingKey1, signingKey2)
|
||||
val signature = signingKey1.sign(data)
|
||||
assertTrue(signingKey2.verifyingKey.verify(signature, data))
|
||||
|
||||
val decryptingKey1 = DecryptingSecretKey.fromSeed(decryptingSeed)
|
||||
val decryptingKey2 = DecryptingSecretKey.fromSeed(decryptingSeed)
|
||||
assertEquals(decryptingKey1.publicKey, decryptingKey2.publicKey)
|
||||
assertContentEquals(data, decryptingKey2.decrypt(decryptingKey1.publicKey.encrypt(data)))
|
||||
|
||||
val universalSeed = UniversalPrivateKey.seedFromBytes(source)
|
||||
assertEquals(UniversalPrivateKey.seedLength, universalSeed.size)
|
||||
val universalKey1 = UniversalPrivateKey.fromSeed(universalSeed)
|
||||
val universalKey2 = UniversalPrivateKey.fromSeed(universalSeed)
|
||||
assertEquals(universalKey1.publicKey, universalKey2.publicKey)
|
||||
assertTrue(universalKey2.publicKey.verify(universalKey1.sign(data), data))
|
||||
assertContentEquals(data, universalKey2.decrypt(universalKey1.publicKey.encrypt(data)))
|
||||
|
||||
assertFailsWith<IllegalArgumentException> {
|
||||
SigningSecretKey.fromSeed(signingSeed.dropLast(1).toUByteArray())
|
||||
}
|
||||
assertFailsWith<IllegalArgumentException> {
|
||||
DecryptingSecretKey.fromSeed(decryptingSeed.dropLast(1).toUByteArray())
|
||||
}
|
||||
assertFailsWith<IllegalArgumentException> {
|
||||
UniversalPrivateKey.fromSeed(universalSeed.dropLast(1).toUByteArray())
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun secretEncryptTest() = runTest {
|
||||
initCrypto()
|
||||
@@ -118,6 +159,44 @@ class KeysTest {
|
||||
assertContentEquals(src, k1.decrypt(k1.encrypt(src, 7..117)))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun symmetricKeyCompactTest() = runTest {
|
||||
initCrypto()
|
||||
val key = SymmetricKey.new()
|
||||
val otherKey = SymmetricKey.new()
|
||||
val src = "readme.md".encodeToUByteArray()
|
||||
val nonce = key.randomNonce()
|
||||
val cipher = key.encryptCompactWithNonce(src, nonce)
|
||||
|
||||
assertEquals(src.size + 16, cipher.size)
|
||||
assertTrue(cipher.size < key.encryptWithNonce(src, nonce).size)
|
||||
assertTrue(cipher.size < key.encrypt(src).size)
|
||||
assertContentEquals(src, key.decryptCompactWithNonce(cipher, nonce))
|
||||
|
||||
assertThrows<DecryptionFailedException> {
|
||||
otherKey.decryptCompactWithNonce(cipher, nonce)
|
||||
}
|
||||
|
||||
assertThrows<DecryptionFailedException> {
|
||||
val n2 = nonce.copyOf()
|
||||
n2[4] = n2[4].inv()
|
||||
key.decryptCompactWithNonce(cipher, n2)
|
||||
}
|
||||
|
||||
assertThrows<DecryptionFailedException> {
|
||||
val c2 = cipher.copyOf()
|
||||
c2[3] = c2[3].inv()
|
||||
key.decryptCompactWithNonce(c2, nonce)
|
||||
}
|
||||
|
||||
assertThrows<IllegalArgumentException> {
|
||||
key.encryptCompactWithNonce(src, nonce.dropLast(1).toUByteArray())
|
||||
}
|
||||
assertThrows<DecryptionFailedException> {
|
||||
key.decryptCompactWithNonce(cipher, nonce.dropLast(1).toUByteArray())
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
fun keyExchangeTest() = runTest {
|
||||
initCrypto()
|
||||
@@ -142,6 +221,26 @@ class KeysTest {
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
fun keyExchangeSerializationTest() = runTest {
|
||||
initCrypto()
|
||||
val ske = SafeKeyExchange()
|
||||
val packedExchange = pack(ske)
|
||||
|
||||
val cke = SafeKeyExchange()
|
||||
val clientSessionKey = cke.clientSessionKey(ske.publicKey)
|
||||
|
||||
val restoredExchange = unpack<SafeKeyExchange>(packedExchange)
|
||||
assertEquals(ske.publicKey, restoredExchange.publicKey)
|
||||
|
||||
val serverSessionKey = restoredExchange.serverSessionKey(cke.publicKey)
|
||||
|
||||
val src = "Hello after restore!"
|
||||
assertEquals(src, serverSessionKey.decryptString(clientSessionKey.encrypt(src)))
|
||||
assertEquals(src, clientSessionKey.decryptString(serverSessionKey.encrypt(src)))
|
||||
assertContentEquals(clientSessionKey.sessionTag, serverSessionKey.sessionTag)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun asymmetricKeyTest() = runTest {
|
||||
initCrypto()
|
||||
|
||||
Reference in new issue
Block a user