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</groupId>
    <artifactId>ankasecure-sdk</artifactId>
    <version>3.0.0</version>
</dependency>

Or Gradle:

implementation 'co.ankatech:ankasecure-sdk:3.0.0'

2. Configure Client

import co.ankatech.ankasecure.sdk.AnkaSecureClient;
import co.ankatech.ankasecure.sdk.config.ClientConfig;

// Configure the client
ClientConfig config = ClientConfig.builder()
    .baseUrl("https://api.ankasecure.com")  // Or your on-premise endpoint
    .apiKey("YOUR_API_KEY")
    .tenant("your-tenant-id")
    .build();

AnkaSecureClient client = new AnkaSecureClient(config);

3. Generate a Quantum-Resistant Key

import co.ankatech.ankasecure.sdk.model.KeyGenerationRequest;
import co.ankatech.ankasecure.sdk.model.KeyResponse;

// Generate ML-KEM-768 key (quantum-resistant encryption)
KeyGenerationRequest keyRequest = KeyGenerationRequest.builder()
    .algorithm("ML-KEM-768")
    .keyId("my-first-pqc-key")
    .build();

KeyResponse key = client.generateKey(keyRequest);
System.out.println("Key generated: " + key.getKeyId());

4. Encrypt Data

import co.ankatech.ankasecure.sdk.model.EncryptRequest;
import co.ankatech.ankasecure.sdk.model.EncryptResponse;

// Encrypt sensitive data
EncryptRequest encryptRequest = EncryptRequest.builder()
    .keyId("my-first-pqc-key")
    .plaintext("Sensitive data to protect")
    .build();

EncryptResponse encrypted = client.encrypt(encryptRequest);
String ciphertext = encrypted.getCiphertext();
System.out.println("Encrypted: " + ciphertext);

5. Decrypt Data

import co.ankatech.ankasecure.sdk.model.DecryptRequest;
import co.ankatech.ankasecure.sdk.model.DecryptResponse;

// Decrypt data
DecryptRequest decryptRequest = DecryptRequest.builder()
    .ciphertext(ciphertext)
    .build();

DecryptResponse decrypted = client.decrypt(decryptRequest);
String plaintext = decrypted.getPlaintext();
System.out.println("Decrypted: " + plaintext);

✅ 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