indispensable/at.asitplus.signum.indispensable.symmetric/SymmetricEncryptionAlgorithm/AES/CBC/HMAC

HMAC

class HMAC : SymmetricEncryptionAlgorithm.AES.CBC<KeyType.WithDedicatedMacKey, AuthCapability.Authenticated.WithDedicatedMac> , SymmetricEncryptionAlgorithm.Authenticated.EncryptThenMAC<HMAC, NonceTrait.Required> , SymmetricEncryptionAlgorithm.RequiringNonce<AuthCapability.Authenticated.WithDedicatedMac, KeyType.WithDedicatedMacKey> (source)

AEAD-capabilities bolted onto AES-CBC

Constructors

constructor(innerCipher: SymmetricEncryptionAlgorithm.AES.CBC.Unauthenticated, mac: HMAC)

Properties

open override val authCapability: AuthCapability.Authenticated.WithDedicatedMac

open override val authTagSize: BitLength

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

val blockSize: BitLength

open override val innerCipher: SymmetricEncryptionAlgorithm.AES.CBC.Unauthenticated

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

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

abstract val keySize: BitLength

Key length

open override val mac: HMAC

The mac function used to provide authenticated encryption

macAuthTagTransform

open override val macAuthTagTransform: MacAuthTagTransformation

Specifies how the inputs to the MAC are to be encoded/processed

macInputCalculation

open override val macInputCalculation: MacInputCalculation

Specifies how the inputs to the MAC are to be encoded/processed

val mode: BlockCipher.ModeOfOperation

open override val name: String

Human-readable name

abstract val nonceSize: BitLength

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

abstract val nonceTrait: NonceTrait.Required

Indicates if this algorithm requires a nonce.

abstract val oid: ObjectIdentifier

preferredMacKeyLength

open override val preferredMacKeyLength: BitLength

The preferred length pf the MAC key. Can be overridden during key generation and is unconstrained.

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

fun Custom(tagLength: BitLength, dedicatedMacInputCalculation: MacInputCalculation): SymmetricEncryptionAlgorithm.AES.CBC.HMAC

fun Custom( tagLength: BitLength, dedicatedMacAuthTagTransformation: MacAuthTagTransformation, dedicatedMacInputCalculation: MacInputCalculation): SymmetricEncryptionAlgorithm.AES.CBC.HMAC

Instantiates a new CBC.HMAC instance with

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