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 11+ (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

**Time:** ~5 minutes

[Jump to REST API Quickstart](#rest-api-quickstart)

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: - Explore 28 Integration Flows - Learn about Algorithm Selection - See Performance Optimization Guide

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: - See All CLI Commands - Automate with Scripts - Integrate with CI/CD

REST API Quickstart

1. Authenticate

Obtain a JWT token (if using user authentication):

curl -X POST https://api.ankasecure.com/api/v1/auth/login \
  -H "Content-Type: application/json" \
  -d '{
    "username": "your-username",
    "password": "your-password",
    "tenantId": "your-tenant-id"
  }'

# Response:
# {
#   "token": "eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...",
#   "expiresIn": 3600
# }

Or use API Key authentication (recommended for services):

export API_KEY="your-api-key"
export TENANT_ID="your-tenant-id"

2. Generate a Key

curl -X POST https://api.ankasecure.com/api/v1/key-management/keys \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $TOKEN" \
  -H "X-Tenant-ID: $TENANT_ID" \
  -d '{
    "algorithm": "ML-KEM-768",
    "keyId": "my-api-key"
  }'

# Response:
# {
#   "keyId": "my-api-key",
#   "algorithm": "ML-KEM-768",
#   "status": "ACTIVE",
#   "createdAt": "2025-12-26T10:00:00Z"
# }

3. Encrypt Data

curl -X POST https://api.ankasecure.com/api/v1/crypto/encrypt \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $TOKEN" \
  -H "X-Tenant-ID: $TENANT_ID" \
  -d '{
    "keyId": "my-api-key",
    "plaintext": "U2Vuc2l0aXZlIGRhdGE="
  }'

# Response:
# {
#   "ciphertext": "eyJhbGciOiJNTC1LRU0tNzY4IiwiZW5jIjoiQTI1NkdDTSJ9...",
#   "keyUsed": "my-api-key",
#   "algorithm": "ML-KEM-768"
# }

Note: plaintext must be Base64-encoded.

4. Decrypt Data

curl -X POST https://api.ankasecure.com/api/v1/crypto/decrypt \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $TOKEN" \
  -H "X-Tenant-ID: $TENANT_ID" \
  -d '{
    "ciphertext": "eyJhbGciOiJNTC1LRU0tNzY4IiwiZW5jIjoiQTI1NkdDTSJ9..."
  }'

# Response:
# {
#   "plaintext": "U2Vuc2l0aXZlIGRhdGE=",
#   "keyUsed": "my-api-key",
#   "algorithm": "ML-KEM-768"
# }

Decode the Base64 plaintext:

echo "U2Vuc2l0aXZlIGRhdGE=" | base64 -d
# Sensitive data

✅ Success! You've completed a full encrypt/decrypt cycle via REST API.

Next Steps: - Explore All API Endpoints - Learn About Error Handling - See Monitoring & Rate Limiting

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 one of three integration methods (SDK, CLI, or REST API)

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