MegaCrypt SDK

Enterprise Cross-Platform End-to-End Encryption Engine

MegaCrypt is a high-performance cryptographic SDK written in Rust and designed for secure application infrastructure.

It provides a unified encryption layer across:

• Native Rust applications
• Backend services
• Node.js environments
• Browser applications through WebAssembly
• Cross-platform secure communication systems

MegaCrypt focuses on:

• authenticated encryption
• secure key derivation
• encrypted packet transport
• portable cryptographic workflows
• memory-safe implementation

The project is designed for applications requiring strong confidentiality guarantees, including:

• secure messaging platforms
• encrypted APIs
• file protection systems
• WebRTC signaling layers
• confidential application data pipelines

---

Security Model

MegaCrypt follows a zero-trust encryption architecture.

The library does not implement custom cryptographic algorithms. Instead, it combines established cryptographic primitives through controlled APIs.

Cryptographic Components

Component	Algorithm	Purpose
Authenticated Encryption	ChaCha20-Poly1305	Encrypt and authenticate application data
Password Key Derivation	Argon2id	Derive encryption keys from user secrets
Hash Derivation	BLAKE3	Fast cryptographic hashing and key derivation
Random Generation	OS CSPRNG	Secure nonce and salt generation

---

Architecture Overview

            Application Layer

┌─────────────────────────────────┐
│ Chat • API • Storage • Media    │
└───────────────┬─────────────────┘
                │

┌───────────────┴─────────────────┐
│          MegaCrypt API           │
│                                  │
│  Rust API      WASM API          │
└───────────────┬─────────────────┘
                │

┌───────────────┴─────────────────┐
│        Crypto Engine             │
│                                  │
│ Key Management                   │
│ Encryption Contexts              │
│ Packet Processing                │
└───────────────┬─────────────────┘
                │

┌───────────────┴─────────────────┐
│     ChaCha20-Poly1305 AEAD       │
└─────────────────────────────────┘

---

Features

Core Cryptography

• Authenticated encryption
• Secure key derivation
• Random nonce generation
• Tamper detection
• Portable encrypted packets

Rust Native Support

• Zero-cost abstractions
• Memory safety guarantees
• Async-compatible integration
• Server-side deployment support

JavaScript Support

• WebAssembly bindings
• Node.js compatibility
• TypeScript definitions
• Browser-ready encryption APIs

---

Installation

Rust

Add MegaCrypt to your Cargo.toml:

[dependencies]
megacrypt = "1.0.0"

Then:

cargo build

---

Node.js / TypeScript

Install using npm:

npm install megacrypt

or:

pnpm add megacrypt

---

Quick Start

Rust Example

use megacrypt::{ CryptoEngine, derive_password_key };
use megacrypt::api::ApiCrypto;
use megacrypt::types::Salt;
use megacrypt::kdf::KdfParams;

fn main() {
    // 1. Create a valid 16-byte salt type
    let salt = Salt::new(*b"megacryptsalt16b");

    // 2. Supply the missing KdfParams argument (using default parameters)
    let key = derive_password_key(b"password", &salt, KdfParams::default()).expect(
        "Failed to derive password key"
    );

    let engine = CryptoEngine::new(key);

    let message = b"confidential message";

    // 3. Encrypt and wrap using the API layer
    let packet = ApiCrypto::encrypt_request(&engine, message);

    // This is what you send to frontend / API
    println!("WEB RESPONSE: {}", packet.data);

    // 4. Decrypt back
    let decrypted = ApiCrypto::decrypt_request(&engine, packet);

    println!("DECRYPTED: {}", String::from_utf8_lossy(&decrypted));
}

---

JavaScript / TypeScript Example

import { WasmApiCrypto } from "megacrypt";

const crypto = new WasmApiCrypto("application-secret");

const encoder = new TextEncoder();

const payload = encoder.encode("confidential message");

const encrypted = crypto.encrypt_request(payload);

console.log(encrypted);

const decrypted = crypto.decrypt_request(encrypted);

console.log(new TextDecoder().decode(decrypted));