Skip to content

Quick Start Guide

Get started with AnkaSecure in less than 10 minutes. This guide shows you how to perform your first post-quantum cryptographic operation using the SDK, CLI, or REST API.

Prerequisites

Before you begin, ensure you have:

  • API Credentials: Access to AnkaSecure platform (SaaS or provided endpoint)
  • API Key: Obtain from your tenant administrator or platform console
  • Development Environment: Java 17+ (for SDK) or curl/HTTP client (for REST API)

New to AnkaSecure? See Environment Setup for detailed prerequisites.

Choose Your Path

Select the integration method that best fits your workflow:

=== "Java SDK" Best for: Java/JVM applications, enterprise integrations

**Time:** ~5 minutes

[Jump to SDK Quickstart](#sdk-quickstart)

=== "CLI" Best for: Scripting, automation, CI/CD pipelines

**Time:** ~3 minutes

[Jump to CLI Quickstart](#cli-quickstart)

=== "REST API" Best for: Any language, microservices, direct HTTP integration

Full reference, authentication, and runnable examples are hosted in our interactive API portal.

[Open the API Portal →](https://apidocs.ankatech.co/docs/getting-started)

SDK Quickstart

1. Add SDK Dependency

Add the AnkaSecure SDK to your Maven project:

<dependency>
    <groupId>co.ankatech.secureclient</groupId>
    <artifactId>AnkaSecureSDK</artifactId>
    <version>3.0.0</version>
</dependency>

Or Gradle:

implementation 'co.ankatech.secureclient:AnkaSecureSDK:3.0.0'

2. Authenticate

AnkaSecureSdk is the unauthenticated factory; authenticating returns an AuthenticatedSdk, which is the object every data-plane call is made on. The client secret is held in a SecretChars so it can be wiped rather than lingering in a String:

import co.ankatech.ankasecure.sdk.AnkaSecureSdk;
import co.ankatech.ankasecure.sdk.AuthenticatedSdk;
import co.ankatech.ankasecure.sdk.security.SecretChars;

Properties props = new Properties();
props.setProperty("openapi.scheme", "https");
props.setProperty("openapi.host", "api.ankatech.co");
props.setProperty("openapi.port", "443");

AnkaSecureSdk factory = new AnkaSecureSdk(props);
try (SecretChars secret = new SecretChars(clientSecret.toCharArray())) {
    AuthenticatedSdk sdk = factory.authenticateApplication(clientId, secret);
    // every call below is made on `sdk`
}

3. Use a Quantum-Resistant Key

Keys are provisioned in the control plane — the Admin Console or ankasecure-cli-admin — not from the SDK. The data plane names an existing key by its kid; everything below assumes one has been provisioned for your tenant.

4. Encrypt Data

encrypt takes the kid and the plaintext bytes and returns an EncryptResult carrying the JWE:

import co.ankatech.ankasecure.sdk.model.EncryptResult;

EncryptResult result = sdk.encrypt("my-ml-kem-768-key",
        "sensitive payload".getBytes(StandardCharsets.UTF_8));
String jwe = result.getJweToken();

5. Decrypt Data

decrypt takes the JWE alone — the key is named inside the token's header, so there is no kid argument:

import co.ankatech.ankasecure.sdk.model.DecryptResult;

DecryptResult decrypted = sdk.decrypt(jwe);
byte[] plaintext = decrypted.getDecryptedData();

✅ Success! You've encrypted and decrypted data using post-quantum cryptography.

Next Steps:

CLI Quickstart

1. Install the CLI

Download the CLI for your platform:

Or install via package manager:

# macOS (Homebrew)
brew install ankatech/tap/ankasecure-cli

# Linux (apt)
sudo apt install ankasecure-cli

# Linux (yum)
sudo yum install ankasecure-cli

2. Initialize Configuration

ankasecure-cli config init

# Follow prompts to enter:
# - API Endpoint: https://api.ankasecure.com
# - API Key: YOUR_API_KEY
# - Tenant ID: your-tenant-id

Configuration is saved to ~/.ankasecure/config.properties.

3. Generate a Key

ankasecure-cli key generate \
  --algorithm ML-KEM-768 \
  --key-id my-cli-key

# Output:
# ✓ Key generated successfully
# Key ID: my-cli-key
# Algorithm: ML-KEM-768
# Status: ACTIVE

4. Encrypt a File

echo "Sensitive data" > secret.txt

ankasecure-cli encrypt \
  --key-id my-cli-key \
  --input secret.txt \
  --output secret.enc

# Output:
# ✓ File encrypted successfully
# Input: secret.txt (15 bytes)
# Output: secret.enc (encrypted)

5. Decrypt the File

ankasecure-cli decrypt \
  --input secret.enc \
  --output decrypted.txt

# Output:
# ✓ File decrypted successfully
# Output: decrypted.txt (15 bytes)

cat decrypted.txt
# Sensitive data

✅ Success! You've encrypted and decrypted a file using the CLI.

Next Steps:

What You've Learned

In this quickstart, you:

  • ✅ Generated a quantum-resistant encryption key (ML-KEM-768)
  • ✅ Encrypted sensitive data using post-quantum cryptography
  • ✅ Decrypted the data back to plaintext
  • ✅ Used the SDK or CLI to complete a full encrypt/decrypt cycle

For REST API integration, continue at the API Portal.

Next Steps

Explore More Algorithms

AnkaSecure supports 78+ cryptographic algorithms:

  • Encryption: ML-KEM-512/768/1024, RSA-2048/4096, AES-256
  • Signatures: ML-DSA-44/65/87, Falcon-512/1024, RSA-PSS, ECDSA
  • Hybrid: Combine classical + quantum-resistant algorithms

See: Algorithm Catalog

Learn Migration Strategies

Migrating from classical cryptography to PQC:

Explore Industry Use Cases

Dive Deeper

Need Help?

Documentation Version: 3.0.0
Last Updated: 2025-12-26