indispensable/at.asitplus.signum.indispensable.symmetric/SymmetricEncryptionAlgorithm

SymmetricEncryptionAlgorithm

sealed interface SymmetricEncryptionAlgorithm<out A : AuthCapability<out K>, out I : NonceTrait, out K : KeyType> : Identifiable(source)

Base interface for every symmetric encryption algorithm. A Symmetric encryption algorithm is characterised by:

Inheritors

Unauthenticated

Types

sealed class AES<I : NonceTrait, K : KeyType, A : AuthCapability<K>> : BlockCipher<A, I, K> , SymmetricEncryptionAlgorithm<A, I, K>

Advanced Encryption Standard

sealed interface Authenticated<out A : AuthCapability.Authenticated<out K>, out I : NonceTrait, out K : KeyType> : SymmetricEncryptionAlgorithm<A, I, K>

ChaCha20Poly1305

object ChaCha20Poly1305 : StreamCipher<AuthCapability.Authenticated.Integrated, NonceTrait.Required, KeyType.Integrated> , SymmetricEncryptionAlgorithm.Authenticated.Integrated<NonceTrait.Required> , SymmetricEncryptionAlgorithm.RequiringNonce<AuthCapability.Authenticated.Integrated, KeyType.Integrated>

ChaCha20 with Poly-1305 AEAD stream cipher

object Companion

sealed interface RequiringNonce<out A : AuthCapability<out K>, K : KeyType> : SymmetricEncryptionAlgorithm<A, NonceTrait.Required, K>

Unauthenticated

sealed interface Unauthenticated<out I : NonceTrait> : SymmetricEncryptionAlgorithm<AuthCapability.Unauthenticated, I, KeyType.Integrated>

sealed interface WithoutNonce<out A : AuthCapability<out K>, K : KeyType> : SymmetricEncryptionAlgorithm<A, NonceTrait.Without, K>

Properties

abstract val authCapability: A

val SymmetricEncryptionAlgorithm<AuthCapability.Authenticated<*>, *, *>.authTagSize: BitLength

val SymmetricEncryptionAlgorithm<*, *, *>.jcaKeySpec: String

val SymmetricEncryptionAlgorithm<*, *, *>.jcaName: String

abstract val keySize: BitLength

Key length

abstract val name: String

Human-readable name

val SymmetricEncryptionAlgorithm<*, NonceTrait.Required, *>.nonceSize: BitLength

abstract val nonceTrait: I

Indicates if this algorithm requires a nonce.

abstract val oid: ObjectIdentifier

preferredMacKeyLength

val SymmetricEncryptionAlgorithm<AuthCapability.Authenticated.WithDedicatedMac, *, KeyType.WithDedicatedMacKey>.preferredMacKeyLength: BitLength

@get:JvmName(name = "boxWithNonceAuthenticated")

val <K : KeyType, A : AuthCapability.Authenticated<out K>> SymmetricEncryptionAlgorithm<A, NonceTrait.Required, K>.sealedBox: SealedBoxBuilder.WithNonce.Awaiting<A, K>

@get:JvmName(name = "boxWithoutNonceAuthenticatedGeneric")

val SymmetricEncryptionAlgorithm<AuthCapability.Authenticated<*>, NonceTrait.Without, *>.sealedBox: SealedBoxBuilder.Without.Authenticated<AuthCapability.Authenticated<*>, *>

@get:JvmName(name = "boxWithoutNonceAuthenticatedIntegrated")

val SymmetricEncryptionAlgorithm<AuthCapability.Authenticated<KeyType.Integrated>, NonceTrait.Without, KeyType.Integrated>.sealedBox: SealedBoxBuilder.Without.Authenticated<AuthCapability.Authenticated<KeyType.Integrated>, KeyType.Integrated>

@get:JvmName(name = "boxWithoutNonceAuthenticatedDedicated")

val SymmetricEncryptionAlgorithm<AuthCapability.Authenticated<KeyType.WithDedicatedMacKey>, NonceTrait.Without, KeyType.WithDedicatedMacKey>.sealedBox: SealedBoxBuilder.Without.Authenticated<AuthCapability.Authenticated<KeyType.WithDedicatedMacKey>, KeyType.WithDedicatedMacKey>

@get:JvmName(name = "boxWithNonceUnauthenticated")

val SymmetricEncryptionAlgorithm<AuthCapability.Unauthenticated, NonceTrait.Required, KeyType.Integrated>.sealedBox: SealedBoxBuilder.WithNonce.Awaiting<AuthCapability.Unauthenticated, KeyType.Integrated>

@get:JvmName(name = "boxWithoutNonceUnauthenticated")

val SymmetricEncryptionAlgorithm<AuthCapability.Unauthenticated, NonceTrait.Without, KeyType.Integrated>.sealedBox: SealedBoxBuilder.Without<AuthCapability.Unauthenticated, KeyType.Integrated>

Creates a SealedBoxBuilder matching this algorithm's characteristics:

Functions

hasDedicatedMac

@JvmName(name = "hasDedicatedMacAlias")

fun <I : NonceTrait> SymmetricEncryptionAlgorithm<*, I, *>.hasDedicatedMac(): Boolean

Use to smart-cast this algorithm

isAuthenticated

@JvmName(name = "isAuthenticatedAlias")

fun <I : NonceTrait, K : KeyType> SymmetricEncryptionAlgorithm<*, I, K>.isAuthenticated(): Boolean

Use to smart-cast this algorithm

@JvmName(name = "isBlockCipherAlias")

fun <A : AuthCapability<out K>, I : NonceTrait, K : KeyType> SymmetricEncryptionAlgorithm<A, I, K>.isBlockCipher(): Boolean

Use to smart-cast this algorithm

@JvmName(name = "isIntegrated")

fun <I : NonceTrait> SymmetricEncryptionAlgorithm<AuthCapability.Authenticated<*>, I, *>.isIntegrated(): Boolean

Use to smart-cast this algorithm

@JvmName(name = "isStreamCipherAlias")

fun <A : AuthCapability<out K>, I : NonceTrait, K : KeyType> SymmetricEncryptionAlgorithm<A, I, K>.isStreamCipher(): Boolean

Use to smart-cast this algorithm

@JvmName(name = "fixedKeyAuthenticatedIntegrated")

fun <I : NonceTrait> SymmetricEncryptionAlgorithm<AuthCapability.Authenticated<KeyType.Integrated>, I, KeyType.Integrated>.keyFrom( secretKey: ByteArray): KmmResult<SymmetricKey<AuthCapability.Authenticated.Integrated, I, KeyType.Integrated>>

@JvmName(name = "fixedKeyIntegrated")

fun <I : NonceTrait> SymmetricEncryptionAlgorithm<AuthCapability<KeyType.Integrated>, I, KeyType.Integrated>.keyFrom( secretKey: ByteArray): KmmResult<SymmetricKey<AuthCapability<KeyType.Integrated>, I, KeyType.Integrated>>

Creates a SymmetricKey from the specified secretKey. Returns KmmResult.failure in case the provided bytes don't match SymmetricEncryptionAlgorithm.keySize

@JvmName(name = "fixedKeyDedicatedMacKey")

fun <A : AuthCapability<KeyType.WithDedicatedMacKey>, I : NonceTrait> SymmetricEncryptionAlgorithm<A, I, KeyType.WithDedicatedMacKey>.keyFrom( encryptionKey: ByteArray, macKey: ByteArray): KmmResult<SymmetricKey<A, I, KeyType.WithDedicatedMacKey>>

Creates a SymmetricKey from the specified encryptionKey and macKey. Returns KmmResult.failure in case the provided bytes don't match SymmetricEncryptionAlgorithm.keySize or the specified macKey is empty.

suspend fun <A : AuthCapability<out K>, I : NonceTrait, K : KeyType> SymmetricEncryptionAlgorithm<A, I, K>.randomKey(): SymmetricKey<A, I, out K>

Generates a fresh random key for this algorithm.

@JvmName(name = "randomKeyAndMacKey")

suspend fun <I : NonceTrait> SymmetricEncryptionAlgorithm<AuthCapability.Authenticated.WithDedicatedMac, I, KeyType.WithDedicatedMacKey>.randomKey( macKeyLength: BitLength): SymmetricKey.WithDedicatedMac<I>

Generates a fresh random key for this algorithm. macKeyLength can be specified to override preferredMacKeyLength.

fun SymmetricEncryptionAlgorithm<*, NonceTrait.Required, *>.randomNonce(): ByteArray

Generates a new random nonce matching the Nonce size of this algorithm. You typically don't want to use this, but have your nonces auto-generated during the encryption process

@JvmName(name = "requiresNonceAlias")

fun <A : AuthCapability<out K>, K : KeyType> SymmetricEncryptionAlgorithm<A, *, K>.requiresNonce(): Boolean

Use to smart-cast this algorithm

abstract override fun toString(): String