Cryptography Kotlin

https://github.com/whyoleg/cryptography-kotlin
Admin
A Kotlin Multiplatform cryptography library that wraps platform-native solutions with a type-safe...
Tokens:23,211
Snippets:267
Trust Score:8.5
License:Apache-2.0
Update:4 months ago
Show doc for...
Tokens:
Raw
### Setup Cryptography Provider and Imports

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/key-derivation.md

Required imports and provider initialization for all key derivation operations.

```kotlin
import dev.whyoleg.cryptography.*
import dev.whyoleg.cryptography.algorithms.*
import dev.whyoleg.cryptography.random.*
import dev.whyoleg.cryptography.BinarySize.Companion.bits

val provider = CryptographyProvider.Default
```

--------------------------------

### Build All Modules

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/CLAUDE.md

Execute this command to build all modules within the project. Ensure 'just' is installed and configured.

```bash
just build
```

--------------------------------

### Assumed Imports and Provider Setup

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/key-agreement.md

Required imports and default provider initialization for cryptographic operations.

```kotlin
import dev.whyoleg.cryptography.*
import dev.whyoleg.cryptography.algorithms.*

val provider = CryptographyProvider.Default
```

--------------------------------

### Generate HMAC Key and Sign/Verify Message

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/mac.md

This snippet demonstrates the basic usage of HMAC for generating a key, signing a message, and verifying the signature. Ensure you have the necessary imports and provider setup.

```kotlin
val hmac = provider.get(HMAC)
val key = hmac.keyGenerator(SHA256).generateKey()

// Generate a MAC tag (called "signature" in the API)
val signature = key.signatureGenerator().generateSignature(
    "Hello, World!".encodeToByteArray()
)

// Verify -- throws if the signature is invalid
key.signatureVerifier().verifySignature(
    "Hello, World!".encodeToByteArray(),
    signature
)
```

--------------------------------

### Build All Modules

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/CONTRIBUTING.md

Commands to build the entire project or link native binaries.

```bash
# Skip tests and native linking for faster builds
just build

# Link all native binaries
just link
```

--------------------------------

### List All Commands

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/CLAUDE.md

View a comprehensive list of all available 'just' commands for this project. Refer to CONTRIBUTING.md for full details.

```bash
just --list
```

--------------------------------

### Build Specific Module

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/CLAUDE.md

Use this command to build a particular module, such as 'core' or 'provider-jdk'. Replace 'module-name' with the desired module.

```bash
just build core
```

```bash
just build provider-jdk
```

--------------------------------

### Perform basic cryptographic operations

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/index.md

Demonstrates the standard workflow of obtaining an algorithm from a provider, generating a key, and performing an encryption operation.

```kotlin
// 1. Get the algorithm from a provider
val aesGcm = CryptographyProvider.Default.get(AES.GCM)
// 2. Generate a key
val key = aesGcm.keyGenerator().generateKey()
// 3. Use the key for operations
val ciphertext = key.cipher().encrypt(plaintext)
```

--------------------------------

### Configure Snapshot Repository

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/getting-started/dependency-management.md

Add Sonatype's snapshot repository to your `build.gradle.kts` to access development versions of the cryptography library.

```kotlin
repositories {
    maven("https://central.sonatype.com/repository/maven-snapshots/") {
        content {
            includeGroup("dev.whyoleg.cryptography")
        }
    }
}

// it's still possible to use BOM or version catalog if needed
kotlin {
    sourceSets {
        commonMain.dependencies {
            implementation("dev.whyoleg.cryptography:cryptography-core:0.7.0-SNAPSHOT")
            implementation("dev.whyoleg.cryptography:cryptography-provider-optimal:0.7.0-SNAPSHOT")
        }
    }
}
```

--------------------------------

### Run Compatibility Tests Workflow

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/CONTRIBUTING.md

Use these commands to clean previous test storage, generate test vectors for specified providers, and then validate them. Skip 'compat-clean' to add more providers to an existing generation run.

```bash
# 1. Clean previous server storage (start fresh)
just compat-clean

# 2. Generate test vectors for each provider you want to test
just test-provider-jdk --step generate
just test-provider-cryptokit --step generate

# 3. Validate test vectors for each provider
just test-provider-jdk --step validate
just test-provider-cryptokit --step validate
```

--------------------------------

### Perform Basic AES-CBC Encryption

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/symmetric-encryption.md

Generate a key, create a cipher, and perform encryption/decryption. AES-CBC includes PKCS#7 padding by default.

```kotlin
val aesCbc = provider.get(AES.CBC)
val key = aesCbc.keyGenerator().generateKey()
val cipher = key.cipher() // padding enabled by default

// Encrypt
val ciphertext = cipher.encrypt(plaintext = "secret message".encodeToByteArray())

// Decrypt
val plaintext = cipher.decrypt(ciphertext = ciphertext)
println(plaintext.decodeToString()) // secret message
```

--------------------------------

### Test Provider JDK

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/CLAUDE.md

Run all tests for the 'provider-jdk' module. This command is useful for verifying the functionality of the JDK provider.

```bash
just test-provider-jdk
```

--------------------------------

### Configure Apple platform dependencies

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/getting-started/providers/apple.md

Add these dependencies to your build file to enable CryptoKit or CommonCrypto providers.

```kotlin
dependencies {
    // for cryptokit
    implementation("dev.whyoleg.cryptography:cryptography-provider-cryptokit:0.6.0")
    // for commoncrypto
    implementation("dev.whyoleg.cryptography:cryptography-provider-apple:0.6.0")
}
```

--------------------------------

### Generate Documentation

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/CONTRIBUTING.md

Execute this command to auto-generate API documentation using Dokka. Ensure documentation is updated in the 'docs/' directory for user-facing features.

```bash
just docs
```

--------------------------------

### Choosing the Optimal Cryptography Provider

Source: https://context7.com/whyoleg/cryptography-kotlin/llms.txt

Select the best cryptography backend for the current platform using CryptographyProvider.Default. You can also check algorithm availability or access specific providers.

```kotlin
import dev.whyoleg.cryptography.*

// Use the default (optimal) provider - recommended for most users
val provider = CryptographyProvider.Default

// Access provider name
println(provider.name) // "JDK", "OpenSSL3", "CryptoKit", etc.

// Check algorithm availability
val aesGcm = provider.getOrNull(AES.GCM) // Returns null if not supported
val aesGcmRequired = provider.get(AES.GCM) // Throws if not supported

```

--------------------------------

### Manual Linker Options Configuration

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/getting-started/troubleshooting/xcode-compatibility.md

Manually configure linker options in build.gradle.kts by defining the Swift libraries path and adding '-L' flags for each Apple target binary.

```kotlin
val swiftLibsPath =
    "/Applications/Xcode_16.4.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/lib/swift"

kotlin {
    listOf(
        iosArm64(),
        iosSimulatorArm64(),
        iosX64(),
        macosArm64(),
        macosX64(),
        // add other Apple targets as needed
    ).forEach { appleTarget ->
        val platformDir = when (appleTarget.konanTarget) {
            KonanTarget.IOS_ARM64  -> "iphoneos"
            KonanTarget.IOS_SIMULATOR_ARM64,
            KonanTarget.IOS_X64
                                   -> "iphonesimulator"
            KonanTarget.MACOS_ARM64,
            KonanTarget.MACOS_X64
                                   -> "macosx"
            KonanTarget.TVOS_ARM64 -> "appletvos"
            KonanTarget.TVOS_SIMULATOR_ARM64,
            KonanTarget.TVOS_X64
                                   -> "appletvsimulator"
            KonanTarget.WATCHOS_ARM32,
            KonanTarget.WATCHOS_ARM64,
            KonanTarget.WATCHOS_DEVICE_ARM64
                                   -> "watchos"
            KonanTarget.WATCHOS_SIMULATOR_ARM64,
            KonanTarget.WATCHOS_X64
                                   -> "watchsimulator"
            else                   -> error("Unsupported Apple target: ${appleTarget.konanTarget}")
        }
        appleTarget.binaries.configureEach {
            linkerOpts("-L$swiftLibsPath/$platformDir")
        }
    }
}
```

--------------------------------

### Configure Gradle Version Catalog

Source: https://context7.com/whyoleg/cryptography-kotlin/llms.txt

Set up a version catalog in Gradle for type-safe dependency declarations, referencing the cryptography library versions.

```kotlin
// settings.gradle.kts
dependencyResolutionManagement {
    versionCatalogs {
        create("cryptographyLibs") {
            from("dev.whyoleg.cryptography:cryptography-version-catalog:0.6.0")
        }
    }
}

// build.gradle.kts
dependencies {
    implementation(cryptographyLibs.core)
    implementation(cryptographyLibs.provider.optimal)
}
```

--------------------------------

### Project Directory Structure

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/CONTRIBUTING.md

Overview of the repository layout, separating core APIs, serialization, and various platform-specific providers.

```text
cryptography-kotlin/
├── cryptography-core/           # Public API (algorithms, materials, operations)
├── cryptography-random/         # Secure random number generation
├── cryptography-bigint/         # Big integer support
├── cryptography-serialization/
│   ├── pem/                     # PEM encoding/decoding
│   └── asn1/                    # ASN.1/DER encoding/decoding
│       └── modules/             # Standard ASN.1 structures (PKCS#8, X.509, etc.)
├── cryptography-providers/
│   ├── base/                    # Shared provider utilities
│   ├── tests/                   # Shared test infrastructure
│   ├── jdk/                     # JVM provider (JCA)
│   ├── webcrypto/               # JS/WasmJS provider
│   ├── apple/                   # Apple CommonCrypto/Security provider
│   ├── cryptokit/               # Apple CryptoKit provider
│   ├── openssl3/
│   │   ├── api/                 # OpenSSL provider API
│   │   ├── shared/              # Shared OpenSSL (link at runtime)
│   │   ├── prebuilt/            # Prebuilt OpenSSL (bundled)
│   │   └── test/                # OpenSSL-specific tests
│   └── optimal/                 # Auto-selecting composite provider
├── cryptography-bom/            # Bill of Materials
├── cryptography-version-catalog/# Gradle version catalog
├── build-logic/                 # Custom Gradle plugins
└── docs/                        # MkDocs documentation
```

--------------------------------

### Add to libs.versions.toml

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/getting-started/dependency-management.md

Paste this TOML content into your `libs.versions.toml` file to define cryptography library versions and libraries.

```toml
[versions]
cryptography = "0.6.0"

[libraries]
cryptography-core = { group = "dev.whyoleg.cryptography", name = "cryptography-core", version.ref = "cryptography" }
cryptography-provider-optimal = { group = "dev.whyoleg.cryptography", name = "cryptography-provider-optimal", version.ref = "cryptography" }
```

--------------------------------

### ECDH Key Agreement Workflow

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/key-agreement.md

Demonstrates the full process of generating key pairs, exchanging public keys, and deriving a shared secret using the ECDH algorithm.

```kotlin
val ecdh = provider.get(ECDH)

// Step 1: Both parties generate key pairs on the same curve
val aliceKeyPair = ecdh.keyPairGenerator(EC.Curve.P256).generateKey()
val bobKeyPair = ecdh.keyPairGenerator(EC.Curve.P256).generateKey()

// Step 2: They exchange public keys (over the network, via a server, etc.)
val alicePublicKey = aliceKeyPair.publicKey
val bobPublicKey = bobKeyPair.publicKey

// Step 3: Each party derives the shared secret independently
val aliceSharedSecret = aliceKeyPair.privateKey
    .sharedSecretGenerator()
    .generateSharedSecretToByteArray(bobPublicKey)

val bobSharedSecret = bobKeyPair.privateKey
    .sharedSecretGenerator()
    .generateSharedSecretToByteArray(alicePublicKey)

// Step 4: Both shared secrets are identical
println(aliceSharedSecret.contentEquals(bobSharedSecret)) // true
```

--------------------------------

### Use Existing Version Catalog in build.gradle.kts

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/getting-started/dependency-management.md

Reference cryptography library dependencies in your `build.gradle.kts` when using an existing `libs.versions.toml`.

```kotlin
dependencies {
    implementation(libs.cryptography.core)
    implementation(libs.cryptography.provider.optimal)
}
```

--------------------------------

### Build Specific Modules

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/CONTRIBUTING.md

Commands to build individual modules or the core API using the just command runner.

```bash
# Build a provider module (short form, auto-prefixed with :cryptography-)
just build provider-jdk

# Build core API
just build core

# Or use the full Gradle module path
just build :cryptography-provider-openssl3-api
```

--------------------------------

### Configure Gradle Version Catalog

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/getting-started/dependency-management.md

Add this to your `settings.gradle.kts` to enable type-safe dependency management for the cryptography library.

```kotlin
dependencyResolutionManagement {
    versionCatalogs {
        create("cryptographyLibs") {
            from("dev.whyoleg.cryptography:cryptography-version-catalog:0.6.0")
        }
    }
}
```

--------------------------------

### Apply ProGuard Configuration in Compose Desktop

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/getting-started/troubleshooting/proguard-r8.md

Configure your `build.gradle.kts` file to include the custom ProGuard configuration file for release builds of your Compose Desktop application. This ensures that the `keep` rules are applied during the build process.

```kotlin
// build.gradle.kts
compose.desktop {
    application {
        buildTypes.release.proguard {
            obfuscate = true
            configurationFiles.from(project.file("compose-desktop.pro"))
        }
    }
}
```

--------------------------------

### Use Version Catalog in build.gradle.kts

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/getting-started/dependency-management.md

Declare cryptography library dependencies in your `build.gradle.kts` using the configured version catalog.

```kotlin
dependencies {
    implementation(cryptographyLibs.core)
    implementation(cryptographyLibs.provider.optimal)
}
```

--------------------------------

### Alice Encrypts Message using ECDH, HKDF, and AES-GCM

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/recipes/secure-messaging.md

Alice generates ECDH key pairs, computes a shared secret with Bob's public key, derives an AES-256 key using HKDF, and encrypts a message. Ensure a proper salt is used in practice.

```kotlin
// --- Both parties generate ECDH key pairs and exchange public keys ---
val ecdh = provider.get(ECDH)
val aliceKeyPair = ecdh.keyPairGenerator(EC.Curve.P256).generateKey()
val bobKeyPair = ecdh.keyPairGenerator(EC.Curve.P256).generateKey()

// --- Alice: compute shared secret using her private key and Bob's public key ---
val aliceSharedSecret = aliceKeyPair.privateKey
    .sharedSecretGenerator()
    .generateSharedSecretToByteArray(bobKeyPair.publicKey)

// --- Alice: derive an AES-256 key from the shared secret via HKDF ---
val hkdf = provider.get(HKDF)
val salt = ByteArray(32) // in practice, use a random or agreed-upon salt
val derivedKeyBytes = hkdf.secretDerivation(
    digest = SHA256,
    outputSize = 256.bits,
    salt = salt,
    info = "messaging-key".encodeToByteArray()
).deriveSecretToByteArray(aliceSharedSecret)

// --- Alice: import the derived bytes as an AES-GCM key and encrypt ---
val aesGcm = provider.get(AES.GCM)
val encryptionKey = aesGcm.keyDecoder().decodeFromByteArray(AES.Key.Format.RAW, derivedKeyBytes)
val ciphertext = encryptionKey.cipher().encrypt(plaintext = "Hello, Bob!".encodeToByteArray())
```

--------------------------------

### MAC with Large Data using RawSource

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/mac.md

For handling larger data efficiently, use the overload that accepts a `RawSource` from `kotlinx-io`. This is suitable for file or network stream data.

```kotlin
val source: RawSource = ... // file, network stream, etc.
val signature = key.signatureGenerator().generateSignature(source)
key.signatureVerifier().verifySignature(source, signature)
```

--------------------------------

### Basic AEAD Encryption and Decryption

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/aead.md

Demonstrates the fundamental process of encrypting and decrypting data using AES-GCM. Assumes necessary imports and a CryptographyProvider instance.

```kotlin
val aesGcm = provider.get(AES.GCM)
val key = aesGcm.keyGenerator().generateKey()
val cipher = key.cipher()

// Encrypt
val ciphertext = cipher.encrypt(plaintext = "secret message".encodeToByteArray())

// Decrypt
val plaintext = cipher.decrypt(ciphertext = ciphertext)
println(plaintext.decodeToString()) // secret message
```

--------------------------------

### Use Maven BOM for Dependency Management

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/getting-started/dependency-management.md

Include the Maven BOM in your `build.gradle.kts` to simplify dependency version management and enable automatic dependency alignment.

```kotlin
dependencies {
    implementation(platform("dev.whyoleg.cryptography:cryptography-bom:0.6.0"))

    // now you can declare other dependencies without a version
    implementation("dev.whyoleg.cryptography:cryptography-core")
    implementation("dev.whyoleg.cryptography:cryptography-provider-optimal")
}
```

--------------------------------

### Create Custom JDK Provider with BouncyCastle

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/getting-started/providers/jdk.md

Instantiate a custom JDK provider using BouncyCastle for algorithms not supported by the default JDK version or platform.

```kotlin
// any other JCA provider could be used
val provider = CryptographyProvider.JDK(BouncyCastleProvider())

// get some algorithm which not supported on a JDK version or platform (in case of Android)
provider.get(SHA512)
```

--------------------------------

### Add dependencies in Gradle

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/getting-started/index.md

Configure the project dependencies by adding the core library and the optimal provider to the common source set.

```kotlin
kotlin {
    sourceSets {
        commonMain.dependencies {
            implementation("dev.whyoleg.cryptography:cryptography-core:0.6.0")
            implementation("dev.whyoleg.cryptography:cryptography-provider-optimal:0.6.0")
        }
    }
}
```

--------------------------------

### Verify Signature with Boolean Result

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/digital-signatures.md

Demonstrates the difference between throwing an exception and returning a boolean result during verification.

```kotlin
val verifier = keyPair.publicKey
    .signatureVerifier(digest = SHA256, format = ECDSA.SignatureFormat.DER)

// Option 1: throws on failure
verifier.verifySignature(message, signature)

// Option 2: Boolean result
val isValid = verifier.tryVerifySignature(message, signature)
```

--------------------------------

### Add OpenSSL3 Provider Dependencies

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/getting-started/providers/openssl3.md

Include the OpenSSL3 API module and choose one of the libcrypto linking options (shared, prebuilt, or prebuilt-nativebuilds). The prebuilt-nativebuilds option allows specifying a specific OpenSSL version.

```kotlin
dependencies {
    implementation("dev.whyoleg.cryptography:cryptography-provider-openssl3-api:0.6.0")

    // Additionally, you must choose exactly one of these options:

    // Option 1: shared
    implementation("dev.whyoleg.cryptography:cryptography-provider-openssl3-shared:0.6.0")

    // Option 2: prebuilt
    implementation("dev.whyoleg.cryptography:cryptography-provider-openssl3-prebuilt:0.6.0")

    // Option 3: prebuilt-nativebuilds
    implementation("dev.whyoleg.cryptography:cryptography-provider-openssl3-prebuilt-nativebuilds:0.6.0")
    implementation("com.ensody.nativebuilds:openssl-libcrypto:3.6.0") // optional but recommended to get automatic (e.g. Dependabot) updates
}
```

--------------------------------

### Apply CryptoKit Gradle Plugin

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/getting-started/troubleshooting/xcode-compatibility.md

Apply the dev.whyoleg.cryptography Gradle plugin in your build.gradle.kts file and enable automatic linker option configuration for seamless Xcode integration.

```kotlin
plugins {
    id("dev.whyoleg.cryptography") version "0.6.0"
}

cryptography {
    configureSwiftLinkerOpts = true
}
```

--------------------------------

### Generate RSA Key Pair, Encrypt, and Decrypt

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/public-key-encryption.md

Use this snippet to generate an RSA key pair, encrypt a secret message using the public key, and then decrypt it with the private key. Ensure the CryptographyProvider is initialized.

```kotlin
val algorithm = provider.get(RSA.OAEP)

// Generate a 3072-bit RSA key pair
val keyPair = algorithm.keyPairGenerator(3072.bits).generateKey()

// Encrypt with the public key
val ciphertext = keyPair.publicKey.encryptor()
    .encrypt("secret".encodeToByteArray())

// Decrypt with the private key
val plaintext = keyPair.privateKey.decryptor()
    .decrypt(ciphertext)

println(plaintext.decodeToString()) // secret
```

--------------------------------

### Manage Dependencies with Maven BOM

Source: https://context7.com/whyoleg/cryptography-kotlin/llms.txt

Use the Bill of Materials (BOM) to simplify dependency management, allowing version omission and ensuring module alignment.

```kotlin
dependencies {
    implementation(platform("dev.whyoleg.cryptography:cryptography-bom:0.6.0"))

    // Now declare dependencies without versions
    implementation("dev.whyoleg.cryptography:cryptography-core")
    implementation("dev.whyoleg.cryptography:cryptography-provider-optimal")
}
```

--------------------------------

### Perform Basic Hashing

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/hashing.md

Obtain a hasher and compute a digest from a byte array. The hasher is reusable for independent hash operations.

```kotlin
val hasher = provider.get(SHA256).hasher()

val digest = hasher.hash("Hello, World!".encodeToByteArray())

// Same input always produces the same digest
val digest2 = hasher.hash("Hello, World!".encodeToByteArray())
println(digest.contentEquals(digest2)) // true
```

--------------------------------

### Typical Error Message

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/getting-started/troubleshooting/xcode-compatibility.md

This error occurs when Xcode is not found at the default path, preventing the linking of Swift compatibility packs.

```text
Could not find or use auto-linked library 'swiftCompatibilityPacks'
```

--------------------------------

### Sign and Verify Large Data Streams

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/digital-signatures.md

Use RawSource to handle large data streams from files or network sources.

```kotlin
val source: RawSource = ... // file, network stream, etc.
val signature = keyPair.privateKey
    .signatureGenerator(digest = SHA256, format = ECDSA.SignatureFormat.DER)
    .generateSignature(source)
keyPair.publicKey
    .signatureVerifier(digest = SHA256, format = ECDSA.SignatureFormat.DER)
    .verifySignature(source, signature)
```

--------------------------------

### Run Provider Tests

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/CONTRIBUTING.md

Commands to execute tests for specific providers or filter by test class.

```bash
# JVM tests
just test-provider-jdk

# WebCrypto tests (WasmJS on Node.js)
just test-provider-webcrypto

# Native tests (macOS ARM)
just test-provider-openssl3
just test-provider-cryptokit
just test-provider-apple

# Filter by test class (wildcard supported)
just test-provider-jdk "*AesGcmTest*"
```

--------------------------------

### Pass-Through MAC Computation with UpdatingSource

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/mac.md

Compute a MAC as data flows through a `kotlinx-io` pipeline using `updatingSource`. Data is simultaneously fed into the MAC and read by the consumer.

```kotlin
val signFunction = key.signatureGenerator().createSignFunction()

// Wrap a source -- data passes through AND is fed into the MAC
val macSource: RawSource = signFunction.updatingSource(dataSource)

// Read all data (it goes to both the consumer and the MAC)
val data = macSource.readByteArray()

// After reading, the signature is ready
val signature = signFunction.signToByteArray()
```

--------------------------------

### Incremental MAC Generation with Update

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/mac.md

For maximum control, use the `update` method directly to feed data in arbitrary chunks to the MAC generator.

```kotlin
val signFunction = key.signatureGenerator().createSignFunction()

signFunction.update("chunk1".encodeToByteArray())
signFunction.update("chunk2".encodeToByteArray())

val signature = signFunction.signToByteArray()
```

--------------------------------

### Retrieve Public Key from Private Key

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/keys.md

Use this when you have only the private key and need the corresponding public key for verification or sharing. Note that on the JDK provider, this may fail unless specific conditions are met.

```kotlin
val privateKey: ECDSA.PrivateKey = keyPair.privateKey
val publicKey: ECDSA.PublicKey = privateKey.publicKey
```

--------------------------------

### Add Optimal Provider Dependency

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/getting-started/providers/index.md

Include the optimal provider to automatically bundle the best-fit cryptographic implementation for each target platform.

```kotlin
dependencies {
    implementation("dev.whyoleg.cryptography:cryptography-provider-optimal:0.6.0")
}
```

--------------------------------

### Test Provider JDK with Filter

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/CLAUDE.md

Execute tests for the 'provider-jdk' module, filtering by a specific pattern. This allows for targeted testing of related test cases.

```bash
just test-provider-jdk "*AesGcm*"
```

--------------------------------

### Add WebCrypto dependency

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/getting-started/providers/webcrypto.md

Include the WebCrypto provider dependency in your Gradle build file.

```kotlin
dependencies {
    implementation("dev.whyoleg.cryptography:cryptography-provider-webcrypto:0.6.0")
}
```

--------------------------------

### Update ABI

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/CONTRIBUTING.md

Run this command to update the Application Binary Interface (ABI) after making changes to algorithms or APIs.

```bash
just update-abi
```

--------------------------------

### Filter Compatibility Tests by Algorithm

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/CONTRIBUTING.md

To filter compatibility tests for a specific algorithm, pass its test class name as the first argument to the 'just' command. This allows focused testing on particular algorithms like AesGcm.

```bash
just test-provider-jdk "*AesGcmCompatibilityTest*" --step generate
just test-provider-cryptokit "*AesGcmCompatibilityTest*" --step generate
just test-provider-jdk "*AesGcmCompatibilityTest*" --step validate
just test-provider-cryptokit "*AesGcmCompatibilityTest*" --step validate
```

--------------------------------

### Generate and Verify ECDSA Signatures

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/digital-signatures.md

Basic workflow for generating a key pair, signing a message, and verifying the signature.

```kotlin
val ecdsa = provider.get(ECDSA)
val keyPair = ecdsa.keyPairGenerator(EC.Curve.P256).generateKey()

// Sign a message with the private key
val message = "Transfer 100 EUR to Alice".encodeToByteArray()
val signature = keyPair.privateKey
    .signatureGenerator(digest = SHA256, format = ECDSA.SignatureFormat.DER)
    .generateSignature(message)

// Verify -- throws if the signature is invalid
keyPair.publicKey
    .signatureVerifier(digest = SHA256, format = ECDSA.SignatureFormat.DER)
    .verifySignature(message, signature)
```

--------------------------------

### Sign and verify a message

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/getting-started/index.md

Generate an ECDSA key pair to sign a message with the private key and verify the resulting signature with the public key.

```kotlin
// get an algorithm
val ecdsa = CryptographyProvider.Default.get(ECDSA)
// generate a key pair
val keyPair = ecdsa.keyPairGenerator(EC.Curve.P256).generateKey()
// sign a message via private key
val signature = keyPair.privateKey
    .signatureGenerator(digest = SHA256)
    .generateSignature("message".encodeToByteArray())
// verify a signature via public key
val isValid = keyPair.publicKey
    .signatureVerifier(digest = SHA256)
    .tryVerifySignature("message".encodeToByteArray(), signature)
```

--------------------------------

### Secure Messaging with ECDH, HKDF, and AES-GCM

Source: https://context7.com/whyoleg/cryptography-kotlin/llms.txt

Demonstrates secure communication between two parties using Elliptic Curve Diffie-Hellman for key agreement, HKDF for key derivation, and AES-GCM for authenticated encryption. Ensure consistent HKDF parameters (digest, salt, info) for both parties.

```kotlin
import dev.whyoleg.cryptography.*
import dev.whyoleg.cryptography.algorithms.*
import dev.whyoleg.cryptography.BinarySize.Companion.bits

val provider = CryptographyProvider.Default

// --- Setup: Both parties generate ECDH key pairs ---
val ecdh = provider.get(ECDH)
val aliceKeyPair = ecdh.keyPairGenerator(EC.Curve.P256).generateKey()
val bobKeyPair = ecdh.keyPairGenerator(EC.Curve.P256).generateKey()

// --- Alice sends encrypted message to Bob ---

// Alice: compute shared secret
val aliceSharedSecret = aliceKeyPair.privateKey
    .sharedSecretGenerator()
    .generateSharedSecretToByteArray(bobKeyPair.publicKey)

// Alice: derive AES key via HKDF
val hkdf = provider.get(HKDF)
val salt = ByteArray(32) // In practice, use random or agreed-upon salt
val derivedKeyBytes = hkdf.secretDerivation(
    digest = SHA256,
    outputSize = 256.bits,
    salt = salt,
    info = "messaging-key".encodeToByteArray()
).deriveSecretToByteArray(aliceSharedSecret)

// Alice: import derived bytes as AES-GCM key and encrypt
val aesGcm = provider.get(AES.GCM)
val encryptionKey = aesGcm.keyDecoder().decodeFromByteArray(AES.Key.Format.RAW, derivedKeyBytes)
val ciphertext = encryptionKey.cipher().encrypt(plaintext = "Hello, Bob!".encodeToByteArray())

// --- Bob receives and decrypts ---

// Bob: same shared secret via his private key + Alice's public key
val bobSharedSecret = bobKeyPair.privateKey
    .sharedSecretGenerator()
    .generateSharedSecretToByteArray(aliceKeyPair.publicKey)

// Bob: same HKDF parameters produce the same key
val bobDerivedKeyBytes = provider.get(HKDF).secretDerivation(
    digest = SHA256,
    outputSize = 256.bits,
    salt = salt,
    info = "messaging-key".encodeToByteArray()
).deriveSecretToByteArray(bobSharedSecret)

// Bob: decrypt
val decryptionKey = provider.get(AES.GCM)
    .keyDecoder()
    .decodeFromByteArray(AES.Key.Format.RAW, bobDerivedKeyBytes)
val plaintext = decryptionKey.cipher().decrypt(ciphertext = ciphertext)
println(plaintext.decodeToString()) // "Hello, Bob!"

```

--------------------------------

### Find Swift Libraries Path

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/getting-started/troubleshooting/xcode-compatibility.md

Use 'xcrun --find swift' to locate the Swift executable and derive the path to Swift libraries. This is necessary for manual linker option configuration.

```bash
xcrun --find swift
# example output:
# /Applications/Xcode_16.4.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/swift
# → use: .../XcodeDefault.xctoolchain/usr/lib/swift
```

--------------------------------

### Derive Keys with PBKDF2

Source: https://context7.com/whyoleg/cryptography-kotlin/llms.txt

Uses PBKDF2 to derive keys from passwords. The salt must be stored alongside the ciphertext to allow for future decryption.

```kotlin
import dev.whyoleg.cryptography.*
import dev.whyoleg.cryptography.algorithms.*
import dev.whyoleg.cryptography.random.*
import dev.whyoleg.cryptography.BinarySize.Companion.bits

val provider = CryptographyProvider.Default

val pbkdf2 = provider.get(PBKDF2)

val password = "user-password".encodeToByteArray()
val salt = CryptographyRandom.nextBytes(16) // Store alongside ciphertext

// Derive a 256-bit key (OWASP recommends 600,000 iterations for SHA-256)
val derivation = pbkdf2.secretDerivation(
    digest = SHA256,
    iterations = 600_000,
    outputSize = 256.bits,
    salt = salt
)
val derivedKey: ByteArray = derivation.deriveSecretToByteArray(password)

// Salt must be stored - same salt required for decryption
```

--------------------------------

### Generate Asymmetric Key Pair (RSA)

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/keys.md

Generate a Rivest–Shamir–Adleman (RSA) key pair for OAEP padding with a specified key size, e.g., 4096 bits.

```kotlin
val rsa = provider.get(RSA.OAEP)
val rsaKeyPair = rsa.keyPairGenerator(4096.bits).generateKey()
```

--------------------------------

### Verify Signature Options

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/mac.md

Two methods are available for signature verification: `verifySignature` which throws an exception on failure, and `tryVerifySignature` which returns a boolean. Choose the method that best suits your error handling strategy.

```kotlin
// Option 1: throws on failure
key.signatureVerifier().verifySignature(data, signature)
```

```kotlin
// Option 2: Boolean result
val isValid = key.signatureVerifier().tryVerifySignature(data, signature)
```

--------------------------------

### Incremental Verification

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/digital-signatures.md

Verify data incrementally by feeding chunks and calling verify.

```kotlin
val verifyFunction = keyPair.publicKey
    .signatureVerifier(SHA256, ECDSA.SignatureFormat.DER)
    .createVerifyFunction()

verifyFunction.update("first chunk ".encodeToByteArray())
verifyFunction.update("second chunk".encodeToByteArray())

verifyFunction.verify(signature) // throws on failure
```

--------------------------------

### Derive Keys with HKDF

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/key-derivation.md

Derives a cryptographic key from high-entropy input material using the HKDF algorithm.

```kotlin
val hkdf = provider.get(HKDF)

// Input key material -- e.g., a shared secret from ECDH
val inputKeyMaterial = ByteArray(32) // placeholder for actual key material

val salt = CryptographyRandom.nextBytes(32)

val derivation = hkdf.secretDerivation(
    digest = SHA256,
    outputSize = 256.bits,
    salt = salt,
    info = "encryption-key".encodeToByteArray()
)

val derivedKey: ByteArray = derivation.deriveSecretToByteArray(inputKeyMaterial)
```

--------------------------------

### Hash Large Data Sources

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/hashing.md

Use a RawSource for memory-efficient hashing of large data streams.

```kotlin
val source: RawSource = ... // file, network stream, etc.
val digest = hasher.hash(source)
```

--------------------------------

### Encode and Decode Keys

Source: https://context7.com/whyoleg/cryptography-kotlin/llms.txt

Supports encoding and decoding keys using formats such as RAW, DER, PEM, and JWK.

```kotlin
import dev.whyoleg.cryptography.*
import dev.whyoleg.cryptography.algorithms.*

val provider = CryptographyProvider.Default

// --- Symmetric Key Encoding ---
val aesKey = provider.get(AES.GCM).keyGenerator().generateKey()
val rawBytes = aesKey.encodeToByteArray(AES.Key.Format.RAW)
val jwkBytes = aesKey.encodeToByteArray(AES.Key.Format.JWK)

// --- Symmetric Key Decoding ---
val decodedKey = provider.get(AES.GCM)
    .keyDecoder()
    .decodeFromByteArray(AES.Key.Format.RAW, rawBytes)

// --- Asymmetric Key Encoding ---
val ecdsa = provider.get(ECDSA)
val keyPair = ecdsa.keyPairGenerator(EC.Curve.P256).generateKey()

val publicDer = keyPair.publicKey.encodeToByteArray(EC.PublicKey.Format.DER)
val privateDer = keyPair.privateKey.encodeToByteArray(EC.PrivateKey.Format.DER)
val publicPem = keyPair.publicKey.encodeToByteArray(EC.PublicKey.Format.PEM)

// --- Asymmetric Key Decoding ---
val decodedPublicKey = ecdsa.publicKeyDecoder(EC.Curve.P256)
    .decodeFromByteArray(EC.PublicKey.Format.DER, publicDer)

val decodedPrivateKey = ecdsa.privateKeyDecoder(EC.Curve.P256)
    .decodeFromByteArray(EC.PrivateKey.Format.DER, privateDer)
```

--------------------------------

### Incremental Signing

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/digital-signatures.md

Feed data in arbitrary chunks using the update method.

```kotlin
val signFunction = keyPair.privateKey
    .signatureGenerator(SHA256, ECDSA.SignatureFormat.DER)
    .createSignFunction()

signFunction.update("first chunk ".encodeToByteArray())
signFunction.update("second chunk".encodeToByteArray())

val signature = signFunction.signToByteArray()
```

--------------------------------

### Derive Keys with PBKDF2

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/key-derivation.md

Derives a key from a password using PBKDF2, which is designed to be computationally expensive to resist brute-force attacks.

```kotlin
val pbkdf2 = provider.get(PBKDF2)

val password = "user-password".encodeToByteArray()
val salt = CryptographyRandom.nextBytes(16) // store alongside ciphertext

val derivation = pbkdf2.secretDerivation(
    digest = SHA256,
    iterations = 600_000,
    outputSize = 256.bits,
    salt = salt
)

val derivedKey: ByteArray = derivation.deriveSecretToByteArray(password)
```

--------------------------------

### Compute Signatures via Pass-Through

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/digital-signatures.md

Use updatingSource to compute a signature while data flows through a pipeline.

```kotlin
val signFunction = keyPair.privateKey
    .signatureGenerator(SHA256, ECDSA.SignatureFormat.DER)
    .createSignFunction()

// Wrap a source -- data passes through AND is fed into the signature
val signingSource: RawSource = signFunction.updatingSource(messageSource)

// Read all data (it goes to both the consumer and the signature function)
val data = signingSource.readByteArray()

// After reading, the signature is ready
val signature = signFunction.signToByteArray()
```

--------------------------------

### Add JDK Provider Dependency

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/getting-started/providers/jdk.md

Include this dependency in your project to use the default JDK cryptography provider.

```kotlin
dependencies {
    implementation("dev.whyoleg.cryptography:cryptography-provider-jdk:0.6.0")
}
```

--------------------------------

### Perform a SHA-512 hash

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/getting-started/index.md

Retrieve a hasher from the default provider and compute a digest for a byte array message.

```kotlin
// get a hasher
val hasher = CryptographyProvider.Default.get(SHA512).hasher()
// hash a message
val digest = hasher.hash("Kotlin is Awesome".encodeToByteArray())
```

--------------------------------

### Incremental MAC Verification

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/mac.md

Incremental verification works similarly to generation. Use the `update` method to feed data chunks to the verifier, followed by the `verify` method with the signature.

```kotlin
val verifyFunction = key.signatureVerifier().createVerifyFunction()

verifyFunction.update("chunk1".encodeToByteArray())
verifyFunction.update("chunk2".encodeToByteArray())

verifyFunction.verify(signature) // throws on failure
```

--------------------------------

### Bob Decrypts Message using ECDH, HKDF, and AES-GCM

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/recipes/secure-messaging.md

Bob computes the same shared secret using his private key and Alice's public key, derives the identical AES-256 key via HKDF with the same parameters, and decrypts the message. The raw ECDH shared secret should not be used directly as an encryption key.

```kotlin
// --- Bob: same shared secret via his private key + Alice's public key ---
val bobSharedSecret = bobKeyPair.privateKey
    .sharedSecretGenerator()
    .generateSharedSecretToByteArray(aliceKeyPair.publicKey)

// --- Bob: same HKDF parameters produce the same key ---
val bobDerivedKeyBytes = provider.get(HKDF).secretDerivation(
    digest = SHA256,
    outputSize = 256.bits,
    salt = salt,
    info = "messaging-key".encodeToByteArray()
).deriveSecretToByteArray(bobSharedSecret)

// --- Bob: decrypt ---
val decryptionKey = provider.get(AES.GCM)
    .keyDecoder()
    .decodeFromByteArray(AES.Key.Format.RAW, bobDerivedKeyBytes)
val plaintext = decryptionKey.cipher().decrypt(ciphertext = ciphertext)
println(plaintext.decodeToString()) // "Hello, Bob!"
```

--------------------------------

### Hash Data via Pass-Through

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/hashing.md

Use updatingSource to compute a hash while simultaneously reading data from a stream.

```kotlin
val hashFunction = hasher.createHashFunction()

// Wrap a source -- data passes through AND is fed into the hash
val source: RawSource = ...
val hashingSource: RawSource = hashFunction.updatingSource(source)

// Read all data from hashingSource (it goes to both the consumer and the hash)
val data = hashingSource.readByteArray()

// After reading, the hash is ready
val digest = hashFunction.hashToByteArray()
```

--------------------------------

### Hash a message using SHA-512

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/index.md

Retrieves a SHA-512 hasher from the default provider and hashes a byte array.

```kotlin
// get a hasher
val sha = CryptographyProvider.Default.get(SHA512).hasher()
// hash a message
sha.hash("Kotlin is Awesome".encodeToByteArray())
```

--------------------------------

### Generate Asymmetric Key Pairs

Source: https://context7.com/whyoleg/cryptography-kotlin/llms.txt

Generates EC and RSA key pairs. Public keys can be accessed directly from the private key object.

```kotlin
import dev.whyoleg.cryptography.*
import dev.whyoleg.cryptography.algorithms.*
import dev.whyoleg.cryptography.BinarySize.Companion.bits

val provider = CryptographyProvider.Default

// Generate EC key pair with P-256 curve
val ecdsa = provider.get(ECDSA)
val ecKeyPair = ecdsa.keyPairGenerator(EC.Curve.P256).generateKey()

// Generate RSA key pair with 4096-bit key size
val rsa = provider.get(RSA.OAEP)
val rsaKeyPair = rsa.keyPairGenerator(4096.bits).generateKey()

// Access public key from private key
val publicKey = ecKeyPair.privateKey.publicKey
```

--------------------------------

### Generate Symmetric Key

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/keys.md

Use this to generate a symmetric key for algorithms like AES-GCM. The key generator can be reused.

```kotlin
val aesGcm = provider.get(AES.GCM)
val key = aesGcm.keyGenerator().generateKey()
```

--------------------------------

### Derive Cryptographic Keys with HKDF

Source: https://context7.com/whyoleg/cryptography-kotlin/llms.txt

Derives cryptographic keys from input key material using HKDF with SHA256 digest. Supports deriving multiple independent keys using different 'info' strings. Requires a salt and output size.

```kotlin
import dev.whyoleg.cryptography.*
import dev.whyoleg.cryptography.algorithms.*
import dev.whyoleg.cryptography.random.*
import dev.whyoleg.cryptography.BinarySize.Companion.bits

val provider = CryptographyProvider.Default

val hkdf = provider.get(HKDF)

// Input key material (e.g., from ECDH key agreement)
val inputKeyMaterial = ByteArray(32) // placeholder

val salt = CryptographyRandom.nextBytes(32)

// Derive a 256-bit key
val derivation = hkdf.secretDerivation(
    digest = SHA256,
    outputSize = 256.bits,
    salt = salt,
    info = "encryption-key".encodeToByteArray()
)
val derivedKey: ByteArray = derivation.deriveSecretToByteArray(inputKeyMaterial)

// Derive multiple independent keys using different info strings
val encryptionKey = hkdf.secretDerivation(
    digest = SHA256, outputSize = 256.bits, salt = salt,
    info = "encryption".encodeToByteArray()
).deriveSecretToByteArray(inputKeyMaterial)

val macKey = hkdf.secretDerivation(
    digest = SHA256, outputSize = 256.bits, salt = salt,
    info = "authentication".encodeToByteArray()
).deriveSecretToByteArray(inputKeyMaterial)
```

--------------------------------

### Encode Asymmetric Public and Private Keys

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/keys.md

Encode asymmetric public and private keys separately into DER format. Public keys are encoded using EC.PublicKey.Format.DER and private keys using EC.PrivateKey.Format.DER.

```kotlin
val ecdsa = provider.get(ECDSA)
val keyPair = ecdsa.keyPairGenerator(EC.Curve.P256).generateKey()

val publicDer = keyPair.publicKey.encodeToByteArray(EC.PublicKey.Format.DER)
val privateDer = keyPair.privateKey.encodeToByteArray(EC.PrivateKey.Format.DER)
```

--------------------------------

### Generate Symmetric Keys

Source: https://context7.com/whyoleg/cryptography-kotlin/llms.txt

Generates symmetric keys with optional size specifications. Key generators are reusable for creating multiple independent keys.

```kotlin
import dev.whyoleg.cryptography.*
import dev.whyoleg.cryptography.algorithms.*

val provider = CryptographyProvider.Default

// Generate AES key with default size
val aesGcm = provider.get(AES.GCM)
val key = aesGcm.keyGenerator().generateKey()

// Generate AES-256 key explicitly
val key256 = aesGcm.keyGenerator(AES.Key.Size.B256).generateKey()

// Generators are reusable
val generator = aesGcm.keyGenerator(AES.Key.Size.B256)
val key1 = generator.generateKey()
val key2 = generator.generateKey() // independent key
```

--------------------------------

### Encrypt and Decrypt with Custom IV

Source: https://github.com/whyoleg/cryptography-kotlin/blob/main/docs/primitives/operations/symmetric-encryption.md

Use specific IVs for encryption and decryption. Note that the output does not contain the IV when using these methods.

```kotlin
val cipher = key.cipher()
val iv = ByteArray(16) // 16 bytes for AES-CBC

val ciphertext = cipher.encryptWithIv(
    iv = iv,
    plaintext = "secret".encodeToByteArray()
)

// With custom IV, the output does NOT contain the IV -- only the ciphertext
val plaintext = cipher.decryptWithIv(
    iv = iv,
    ciphertext = ciphertext
)
```
Tokens:
Raw