SECRET

Enterprise Secret Management Platform · v0.9

TLS 1.3Encryption

99.99%Uptime SLA

<5msAvg Latency

6Auth Modules

Core Capabilities

🔒

Military-Grade Encryption

TLS 1.3 transport with RSA key encryption. Secrets are encrypted before they ever touch disk.

⚡

Blazing Fast

Written in pure C/C++. Sub-millisecond secret retrieval with connection pooling and in-memory caching.

🛡️

Zero-Knowledge Architecture

Master keys never leave your infrastructure. Even RORBIT cannot access your secrets.

🔄

Automated Rotation

Schedule secret rotation with cron expressions. Parallel versioning ensures zero downtime.

👥

Modular Auth

LDAP, OAuth2, SSH keys, TOTP — mix and match authentication providers.

📋

Tamper-Evident Audit

Every operation is logged to a hash-chained audit trail. Detect and prove tampering instantly.

Use Cases

⚙️

Jenkins CI/CD

Pipeline jobs fetch deployment keys and database passwords at build time; rotate secrets automatically after each release.

🌐

Web Servers

Nginx, Apache, or custom servers retrieve TLS certificates, database credentials, and API keys from the vault on startup.

🖥️

GitHub / GitLab

Store personal access tokens, deploy keys, and webhook secrets in the vault — keep them out of your repositories.

🗄️

Database Credentials

Applications query Secret at connection time instead of hardcoding credentials in configuration files or env vars.

🔧

Microservices

Service-to-service authentication tokens managed centrally with automatic expiry and rotation policies.

📡

IoT / Edge Devices

Lightweight C SDK runs on constrained hardware, fetches device identity secrets over encrypted WebSocket.

Note: Some features (advanced rotation policies, full audit log querying) are planned but not yet implemented.

Architecture

Secret uses a monolithic core with pluggable modules. All network traffic is encrypted with TLS 1.3. The system supports MySQL for persistent storage and Redis for caching.

    # Core Component Stack

    Clients → TLS 1.3 → Core Server (main.c)

      ├── Router → API Endpoints

      ├── Auth → LDAP / OAuth2 / SSH / TOTP

      ├── Crypto → TLS 1.3 / RSA

      └── Storage → MySQL + Redis Cache

    # Default port: 6502

Technical Specifications

Parameter	Value
Encryption	TLS 1.3, RSA
Transport Security	TLS 1.3 (mandatory)
Key Derivation	Argon2id, HKDF
API Protocols	REST (HTTPS) + WebSocket (WSS)
Database	MySQL 8.0+, SQLite (embedded)
Platform	Linux (primary), Windows, macOS
Language	C11 / C++17
License	Closed Source

Explore SDK →

SECRET SDK

Integrate Secret into your applications with native SDK bindings.

SDK v1.0.0 — Stable

Supported Languages

Language	Status	WebSocket	Binding	Download
C / C++	Stable	Yes	Static `.a` / shared `.so` `.dll`	ZIP
Python	Stable	Yes	`.pyd` / `.so` via ctypes	ZIP
Node.js	Stable	Planned	`.node` addon (`.dll`/`.so`)	Contact RORBIT
Go	Stable	In Progress	CGo via `.so` / `.dll`	ZIP
Java	Stable	Yes	JNI `.dll`/`.so` + `.jar`	ZIP
Java (Android)	Beta	Planned	`.aar` wrapping `.so`	ZIP
Kotlin (Android)	Beta	Planned	`.aar` wrapping `.so`	ZIP
Swift	Beta	Yes	`.dylib` / `.xcframework`	ZIP
Objective-C	Beta	Yes	`.dylib` / `.framework`	ZIP
Ruby	Beta	Yes	Native ext `.so` / `.dll`	ZIP
Rust	Beta	In Progress	`.rlib` / `.so` / `.dll`	ZIP
Bash / CLI	Stable	Planned	`curl`-based, no library	ZIP

Native Library Distribution

All non-C language bindings sit atop the core C SDK (libsecret), compiled as a platform-specific shared library:

Platform	Shared Library	Architecture
Linux	`libsecret.so`	x86_64, aarch64
macOS	`libsecret.dylib`	x86_64, arm64
Windows	`secret.dll`	x86, x64

Download SDK Source

All SDK source code available as ZIP archives. Browse individual SDKs in the SDK directory.

BROWSE SDKs →

Quick Start Examples

Authenticate and retrieve a secret in seconds, across all supported languages:

    // C / C++ — native, direct libsecret binding

    #include <secret/sdk.h>

    int main() {

      SecretClient *c = secret_client_new("https://localhost:6502");

      c->authenticate("fadmin", "securefassword");

      SecretValue *v = c->get_secret("API_KEY_PROD");

      printf("Secret: %s\n", v->data);

      v->free(); c->free(); return 0;

    }

    # Python — via ctypes (libsecret.so / secret.dll)

    import secret_sdk

    client = secret_sdk.Client("https://localhost:6502")

    client.authenticate("fadmin", "securefassword")

    val = client.get_secret("API_KEY_PROD")

    print(f"Secret: {val}")

    // Node.js — .node addon binding

    const { SecretClient } = require('secret-sdk');

    const client = new SecretClient('https://localhost:6502');

    await client.authenticate('fadmin', 'securefassword');

    const val = await client.getSecret('API_KEY_PROD');

    console.log('Secret:', val);

    // Go — CGo wrapper around libsecret

    package main

    import "github.com/rorbit/secret-sdk"

    func main() {

      client := secretsdk.NewClient("https://localhost:6502")

      client.Authenticate("fadmin", "securefassword")

      val, _ := client.GetSecret("API_KEY_PROD")

      println("Secret:", val)

    }

    // Java — JNI via secret.dll / libsecret.so

    import com.rorbit.secret.SecretClient;

    SecretClient client = new SecretClient("https://localhost:6502");

    client.authenticate("fadmin", "securefassword");

    SecretValue val = client.getSecret("API_KEY_PROD");

    System.out.println("Secret: " + val);

    // Java (Android) — .aar with embedded .so

    // build.gradle: implementation 'com.rorbit:secret-sdk:1.0.0'

    SecretClient client = new SecretClient.Builder(context)

        .setEndpoint("https://localhost:6502").build();

    client.authenticate("fadmin", "securefassword");

    SecretValue val = client.getSecret("API_KEY_PROD");

    // Kotlin (Android) — .aar with embedded .so

    // build.gradle: implementation 'com.rorbit:secret-sdk:1.0.0'

    val client = SecretClient.Builder(context)

        .setEndpoint("https://localhost:6502").build()

    client.authenticate("fadmin", "securefassword")

    val secret = client.getSecret("API_KEY_PROD")

    // Swift — .dylib / .xcframework

    import SecretSDK

    let client = SecretClient(endpoint: "https://localhost:6502")

    try client.authenticate(user: "fadmin", password: "securefassword")

    let val = try client.getSecret(id: "API_KEY_PROD")

    print("Secret:", val)

    // Objective-C — .dylib / .framework

    #import <SecretSDK/SecretSDK.h>

    SecretClient *client = [[SecretClient alloc] initWithEndpoint:@"https://localhost:6502"];

    [client authenticateWithUser:@"fadmin" password:@"securefassword" error:nil];

    NSString *val = [client getSecretWithId:@"API_KEY_PROD" error:nil];

    NSLog(@"Secret: %@", val);

    # Ruby — native extension via gem

    require 'secret_sdk'

    client = SecretSDK::Client.new('https://localhost:6502')

    client.authenticate('fadmin', 'securefassword')

    val = client.get_secret('API_KEY_PROD')

    puts "Secret: #{val}"

    // Rust — .rlib / .so binding

    use secret_sdk::Client;

    let mut client = Client::new("https://localhost:6502")?;

    client.authenticate("fadmin", "securefassword")?;

    let val = client.get_secret("API_KEY_PROD")?;

    println!("Secret: {}", val);

    # Bash / CLI — curl-based, no library required

    SESSIONID=$(curl -s -X POST https://localhost:6502/system.library/login/ \

      -d "username=fadmin&password=securefassword&deviceid=secret-cli" | jq -r '.sessionid')

    curl -s -X POST https://localhost:6502/system.library/secret/secretget \

      -d "sessionid=$SESSIONID&name=API_KEY_PROD&encode=true"

API Methods

Method	Description
`authenticate(user, pass)`	Authenticate with username/password
`get_secret(id)`	Retrieve a secret by ID
`create_secret(name, value, opts)`	Store a new secret
`update_secret(id, value)`	Update an existing secret
`delete_secret(id)`	Delete a secret permanently
`list_secrets(filter)`	List secrets with optional filters
`rotate_secret(id)`	Force-rotate a secret immediately
`get_audit_log(from, to)`	Query the tamper-evident audit log

WebSocket API

For real-time applications, connect via WSS and subscribe to secret change events:

    # Connect to WebSocket endpoint

    wss://host:6502/ws?token=<your-jwt>

    # Subscribe to secret updates

    { "type": "subscribe", "events": ["secret.updated", "secret.rotated"] }

    # Server pushes events in real-time

    { "type": "event", "event": "secret.updated", "id": "sec-abc123" }

Contact for SDK Access →

ABOUT RORBIT

The company behind Secret.

Founder & Lead Developer

Pawel Stefanski

Security engineer, systems architect, and creator of the Secret platform. Two decades of experience in low-level systems programming, cryptography, and infrastructure security.

C/C++ Cryptography Systems Architecture Infrastructure Security

Company

Name: RORBIT
Founder: Pawel Stefanski
Location: Warszawa, Poland
Email: rorbitcompany@gmail.com
Product: Secret v0.9 — Enterprise Secret Management Platform

Mission

RORBIT builds security infrastructure for organizations that demand uncompromising protection for their sensitive data. We believe that secret management should be fast, reliable, and mathematically verifiable — not a black box. Every component of Secret is designed with a single principle: trust nothing, verify everything.

Contact & Support

✉️

Email

rorbitcompany@gmail.com

For licensing, SDK access, and support inquiries.

🏠

Office

Warszawa, Poland
Available for remote collaboration worldwide.

📄

Documentation

Comprehensive docs included with every deployment. API reference available for SDK licensees.