@brashkie/signalis-core 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,764 @@
+/**
+ * Shared TypeScript types for signalis-core.
+ *
+ * @packageDocumentation
+ */
+/**
+ * A Curve25519 keypair (private + public key).
+ *
+ * Both keys are 32-byte Buffers.
+ */
+interface KeyPair {
+    /**
+     * Private key (32 bytes).
+     *
+     * **⚠️ KEEP THIS SECRET.** Never log, transmit, or store in plaintext.
+     */
+    readonly privateKey: Buffer;
+    /**
+     * Public key (32 bytes).
+     *
+     * Safe to share publicly.
+     */
+    readonly publicKey: Buffer;
+}
+/**
+ * A Curve25519 public key — type-tag for stronger typing.
+ *
+ * Use {@link asPublicKey} to brand a Buffer.
+ */
+type PublicKey = Buffer & {
+    readonly __brand?: 'PublicKey';
+};
+/**
+ * A Curve25519 private key — type-tag for stronger typing.
+ *
+ * Use {@link asPrivateKey} to brand a Buffer.
+ */
+type PrivateKey = Buffer & {
+    readonly __brand?: 'PrivateKey';
+};
+/**
+ * An X25519 ECDH shared secret (32 bytes).
+ *
+ * **⚠️ DO NOT USE DIRECTLY AS A KEY.** Always derive through HKDF.
+ */
+type SharedSecret = Buffer & {
+    readonly __brand?: 'SharedSecret';
+};
+/**
+ * HKDF pseudorandom key (32 bytes), output of the Extract step.
+ */
+type PseudoRandomKey = Buffer & {
+    readonly __brand?: 'PRK';
+};
+/**
+ * HKDF parameters object — useful for organizing key derivation calls.
+ */
+interface HkdfParams {
+    /** Optional salt (use `Buffer.alloc(0)` if absent). */
+    salt: Buffer;
+    /** Input keying material (e.g., ECDH shared secret). */
+    ikm: Buffer;
+    /** Context-specific information (binds the output to a usage). */
+    info: Buffer;
+    /** Desired output length in bytes (1 to 8160). */
+    length: number;
+}
+/**
+ * AES-256-GCM parameters.
+ */
+interface AesGcmParams {
+    /** 32-byte symmetric key. */
+    key: Buffer;
+    /** 12-byte nonce (MUST be unique per message). */
+    nonce: Buffer;
+    /** Plaintext or ciphertext. */
+    data: Buffer;
+}
+/**
+ * AES-256-CBC parameters.
+ */
+interface AesCbcParams {
+    /** 32-byte symmetric key. */
+    key: Buffer;
+    /** 16-byte initialization vector. */
+    iv: Buffer;
+    /** Plaintext or ciphertext. */
+    data: Buffer;
+}
+/**
+ * Supported encodings for converting Buffers to/from strings.
+ */
+type Encoding = 'hex' | 'base64' | 'base64url' | 'utf8' | 'binary';
+/**
+ * Brand a Buffer as a {@link PublicKey}.
+ *
+ * Does NOT validate length — use validators separately.
+ */
+declare function asPublicKey(buf: Buffer): PublicKey;
+/**
+ * Brand a Buffer as a {@link PrivateKey}.
+ *
+ * Does NOT validate length — use validators separately.
+ */
+declare function asPrivateKey(buf: Buffer): PrivateKey;
+/**
+ * Brand a Buffer as a {@link SharedSecret}.
+ */
+declare function asSharedSecret(buf: Buffer): SharedSecret;
+
+/**
+ * Core cryptographic wrappers for signalis-core.
+ *
+ * Provides robust, validated, and well-documented APIs over the native Rust
+ * crypto primitives.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Curve25519 / X25519 elliptic curve operations.
+ *
+ * Provides:
+ * - Keypair generation
+ * - Public key derivation
+ * - ECDH key agreement
+ *
+ * @example
+ * ```ts
+ * import { Curve25519 } from '@brashkie/signalis-core';
+ *
+ * const alice = Curve25519.generateKeyPair();
+ * const bob = Curve25519.generateKeyPair();
+ *
+ * const shared = Curve25519.diffieHellman(alice.privateKey, bob.publicKey);
+ * // ⚠️ Always derive via HKDF before use as a key!
+ * ```
+ */
+declare const Curve25519: Readonly<{
+    /**
+     * Generate a new random Curve25519 keypair.
+     *
+     * Uses the OS's cryptographically secure RNG (via Rust's `OsRng`).
+     *
+     * @returns A {@link KeyPair} with private and public keys (32 bytes each)
+     */
+    generateKeyPair(): KeyPair;
+    /**
+     * Derive the public key corresponding to a given private key.
+     *
+     * @param privateKey - 32-byte private key
+     * @returns The corresponding 32-byte public key
+     * @throws {ValidationError} If `privateKey` is not a 32-byte Buffer.
+     */
+    publicFromPrivate(privateKey: Buffer): Buffer;
+    /**
+     * Perform X25519 Diffie-Hellman key agreement.
+     *
+     * Both parties run this with swapped (private, peer-public) arguments
+     * and obtain the same 32-byte shared secret.
+     *
+     * **⚠️ CRITICAL:** Do NOT use the returned secret directly as an
+     * encryption key. Always derive an actual key through HKDF:
+     *
+     * @example
+     * ```ts
+     * const shared = Curve25519.diffieHellman(myPriv, theirPub);
+     * const key = HKDF.derive(salt, shared, Buffer.from('aes-key'), 32);
+     * ```
+     *
+     * @param privateKey - Your 32-byte private key
+     * @param peerPublicKey - Peer's 32-byte public key
+     * @returns 32-byte shared secret
+     * @throws {ValidationError} If keys are not 32 bytes.
+     * @throws {CryptoError} If the operation fails.
+     */
+    diffieHellman(privateKey: Buffer, peerPublicKey: Buffer): Buffer;
+    /**
+     * The size of a Curve25519 private key in bytes (32).
+     */
+    PRIVATE_KEY_SIZE: 32;
+    /**
+     * The size of a Curve25519 public key in bytes (32).
+     */
+    PUBLIC_KEY_SIZE: 32;
+    /**
+     * The size of an X25519 shared secret in bytes (32).
+     */
+    SHARED_SECRET_SIZE: 32;
+}>;
+/**
+ * HKDF-SHA256 (RFC 5869) — HMAC-based Key Derivation Function.
+ *
+ * Provides cryptographic key derivation from high-entropy inputs (e.g., ECDH
+ * shared secrets) into arbitrary-length output keying material (OKM).
+ *
+ * @example
+ * ```ts
+ * // One-shot (recommended)
+ * const key = HKDF.derive(salt, sharedSecret, Buffer.from('aes-key'), 32);
+ *
+ * // Two-step (advanced)
+ * const prk = HKDF.extract(salt, ikm);
+ * const okm = HKDF.expand(prk, info, 64);
+ * ```
+ */
+declare const HKDF: Readonly<{
+    /**
+     * HKDF-Extract: produces a 32-byte pseudorandom key (PRK).
+     *
+     * @param salt - Optional salt (pass `Buffer.alloc(0)` if not available)
+     * @param ikm - Input keying material
+     * @returns 32-byte PRK
+     * @throws {ValidationError} If inputs are not Buffers.
+     */
+    extract(salt: Buffer, ikm: Buffer): Buffer;
+    /**
+     * HKDF-Expand: produces `length` bytes of output keying material.
+     *
+     * @param prk - 32-byte pseudorandom key from {@link extract}
+     * @param info - Context-specific information (binds output to a usage)
+     * @param length - Desired output length (1 to 8160 bytes)
+     * @returns OKM of requested length
+     * @throws {ValidationError} If PRK is not 32 bytes or length is out of bounds.
+     */
+    expand(prk: Buffer, info: Buffer, length: number): Buffer;
+    /**
+     * HKDF one-shot: extract + expand in a single call.
+     *
+     * Use this whenever possible — it's the standard HKDF API.
+     *
+     * @param salt - Optional salt
+     * @param ikm - Input keying material
+     * @param info - Context info
+     * @param length - Desired output length
+     * @returns OKM of requested length
+     */
+    derive(salt: Buffer, ikm: Buffer, info: Buffer, length: number): Buffer;
+    /**
+     * Derive multiple keys from the same shared secret in a single call.
+     *
+     * Useful for deriving e.g., a send key AND a receive key simultaneously.
+     *
+     * @example
+     * ```ts
+     * const [sendKey, recvKey] = HKDF.deriveMultiple(
+     *   salt,
+     *   sharedSecret,
+     *   Buffer.from('signalis-channel-v1'),
+     *   [32, 32],
+     * );
+     * ```
+     *
+     * @param salt - Optional salt
+     * @param ikm - Input keying material
+     * @param info - Context info
+     * @param lengths - Array of output lengths
+     * @returns Array of derived keys, one per requested length
+     */
+    deriveMultiple(salt: Buffer, ikm: Buffer, info: Buffer, lengths: number[]): Buffer[];
+    /**
+     * Derive a key using an {@link HkdfParams} object (alternative API).
+     */
+    deriveFromParams(params: HkdfParams): Buffer;
+    /**
+     * The size of an HKDF PRK in bytes (32).
+     */
+    PRK_SIZE: 32;
+}>;
+/**
+ * AES-256-GCM authenticated encryption (AEAD).
+ *
+ * Combines confidentiality + authenticity in a single primitive.
+ *
+ * **⚠️ CRITICAL SECURITY RULES:**
+ * 1. Never reuse a (key, nonce) pair. Catastrophic failure.
+ * 2. Generate nonces with `secureRandom(12)` for each message.
+ * 3. After 2^32 messages with random nonces, rotate the key.
+ *
+ * @example
+ * ```ts
+ * import { AES_GCM, secureRandom } from '@brashkie/signalis-core';
+ *
+ * const key = secureRandom(32);
+ * const nonce = secureRandom(12);
+ * const plaintext = Buffer.from('Hello!');
+ *
+ * const ciphertext = AES_GCM.encrypt(key, nonce, plaintext);
+ * const decrypted = AES_GCM.decrypt(key, nonce, ciphertext);
+ * ```
+ */
+declare const AES_GCM: Readonly<{
+    /**
+     * Encrypt plaintext.
+     *
+     * Returns: ciphertext || 16-byte authentication tag (concatenated).
+     *
+     * @param key - 32-byte symmetric key
+     * @param nonce - 12-byte unique nonce (NEVER reuse with same key)
+     * @param plaintext - Data to encrypt
+     * @returns Ciphertext + auth tag (output is `plaintext.length + 16` bytes)
+     * @throws {ValidationError} On invalid sizes.
+     * @throws {CryptoError} If the operation fails.
+     */
+    encrypt(key: Buffer, nonce: Buffer, plaintext: Buffer): Buffer;
+    /**
+     * Decrypt ciphertext and verify authentication tag.
+     *
+     * @param key - 32-byte symmetric key (same as encryption)
+     * @param nonce - 12-byte nonce (same as encryption)
+     * @param ciphertext - Ciphertext || auth tag
+     * @returns Original plaintext
+     * @throws {ValidationError} On invalid sizes.
+     * @throws {AuthenticationError} If the tag is invalid (tampered or wrong key).
+     */
+    decrypt(key: Buffer, nonce: Buffer, ciphertext: Buffer): Buffer;
+    /** Key size in bytes (32). */
+    KEY_SIZE: 32;
+    /** Nonce size in bytes (12). */
+    NONCE_SIZE: 12;
+    /** Tag size in bytes (16). */
+    TAG_SIZE: 16;
+}>;
+/**
+ * AES-256-CBC block cipher (NOT authenticated by itself).
+ *
+ * **⚠️ MUST be paired with HMAC** for integrity protection (encrypt-then-MAC).
+ *
+ * Prefer {@link AES_GCM} unless you need:
+ * - Legacy Signal Protocol media compatibility
+ * - Hardware that lacks GCM acceleration
+ */
+declare const AES_CBC: Readonly<{
+    /**
+     * Encrypt with PKCS#7 padding.
+     *
+     * @param key - 32-byte symmetric key
+     * @param iv - 16-byte initialization vector
+     * @param plaintext - Data to encrypt
+     * @returns Ciphertext (padded to nearest 16-byte block)
+     */
+    encrypt(key: Buffer, iv: Buffer, plaintext: Buffer): Buffer;
+    /**
+     * Decrypt with PKCS#7 padding (no authentication).
+     *
+     * @param key - 32-byte symmetric key
+     * @param iv - 16-byte IV (same as encryption)
+     * @param ciphertext - Ciphertext
+     * @returns Original plaintext
+     * @throws {CryptoError} On padding errors.
+     */
+    decrypt(key: Buffer, iv: Buffer, ciphertext: Buffer): Buffer;
+    /** Key size in bytes (32). */
+    KEY_SIZE: 32;
+    /** IV size in bytes (16). */
+    IV_SIZE: 16;
+}>;
+/**
+ * HMAC-SHA256 message authentication code.
+ *
+ * Provides cryptographic authentication of arbitrary data with a shared key.
+ *
+ * @example
+ * ```ts
+ * const tag = HMAC.sha256(key, message);
+ * const valid = HMAC.verifySha256(key, message, tag);  // constant-time
+ * ```
+ */
+declare const HMAC: Readonly<{
+    /**
+     * Compute HMAC-SHA256 of `data` using `key`.
+     *
+     * @param key - Authentication key (any length)
+     * @param data - Data to authenticate
+     * @returns 32-byte HMAC tag
+     */
+    sha256(key: Buffer, data: Buffer): Buffer;
+    /**
+     * Verify an HMAC-SHA256 tag in **constant time**.
+     *
+     * Always use this instead of `===` to prevent timing attacks.
+     *
+     * @param key - Authentication key
+     * @param data - Original data
+     * @param expectedTag - Tag to verify
+     * @returns `true` if tag matches, `false` otherwise
+     */
+    verifySha256(key: Buffer, data: Buffer, expectedTag: Buffer): boolean;
+    /** Tag size in bytes (32). */
+    TAG_SIZE: 32;
+}>;
+/**
+ * SHA-256 cryptographic hash function.
+ *
+ * @example
+ * ```ts
+ * const digest = SHA256.hash(Buffer.from('hello'));
+ * ```
+ */
+declare const SHA256: Readonly<{
+    /**
+     * Compute SHA-256 hash of `data`.
+     *
+     * @param data - Data to hash
+     * @returns 32-byte digest
+     */
+    hash(data: Buffer): Buffer;
+    /**
+     * Hash multiple Buffers concatenated together.
+     *
+     * Equivalent to `SHA256.hash(Buffer.concat([...]))` but slightly more
+     * efficient (avoids the intermediate concat).
+     */
+    hashAll(buffers: Buffer[]): Buffer;
+    /** Output size in bytes (32). */
+    OUTPUT_SIZE: 32;
+}>;
+/**
+ * The version of the underlying Rust crate (from `Cargo.toml`).
+ */
+declare const nativeVersion: string;
+
+/**
+ * Typed error classes for signalis-core.
+ *
+ * All errors extend the base `SignalisError` class for easy `instanceof` checks.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Base error class for all signalis-core errors.
+ *
+ * @example
+ * ```ts
+ * try {
+ *   Curve25519.diffieHellman(invalidKey, peer);
+ * } catch (e) {
+ *   if (e instanceof SignalisError) {
+ *     console.error('Crypto error:', e.code, e.message);
+ *   }
+ * }
+ * ```
+ */
+declare class SignalisError extends Error {
+    /** Error code for programmatic handling. */
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+/**
+ * Thrown when input validation fails (wrong size, wrong type, etc.).
+ */
+declare class ValidationError extends SignalisError {
+    /** Name of the parameter that failed validation. */
+    readonly parameter?: string;
+    /** Expected value description. */
+    readonly expected?: string;
+    /** Actual value received. */
+    readonly actual?: string | number;
+    constructor(message: string, options?: {
+        parameter?: string;
+        expected?: string;
+        actual?: string | number;
+    });
+}
+/**
+ * Thrown when a crypto operation fails (decryption, MAC verification, etc.).
+ */
+declare class CryptoError extends SignalisError {
+    /** The crypto operation that failed. */
+    readonly operation: string;
+    constructor(message: string, operation: string);
+}
+/**
+ * Thrown when AEAD authentication fails (e.g., AES-GCM tag mismatch).
+ *
+ * This is a security-critical error: the ciphertext was tampered with
+ * or the wrong key was used.
+ */
+declare class AuthenticationError extends CryptoError {
+    constructor(message?: string);
+}
+/**
+ * Thrown when a key derivation or key agreement operation fails.
+ */
+declare class KeyDerivationError extends CryptoError {
+    constructor(message: string);
+}
+/**
+ * Thrown when the requested output length is invalid (e.g., HKDF > 8160 bytes).
+ */
+declare class LengthError extends ValidationError {
+    constructor(message: string, options?: {
+        expected?: string;
+        actual?: number;
+    });
+}
+
+/**
+ * Utility functions for signalis-core.
+ *
+ * Encoding helpers, secure random generation, and constant-time comparisons.
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Generate cryptographically secure random bytes.
+ *
+ * Uses Node's `crypto.randomBytes` which delegates to the OS CSPRNG:
+ * - Linux/macOS: `getrandom()` / `/dev/urandom`
+ * - Windows: `BCryptGenRandom`
+ *
+ * @param length - Number of bytes to generate
+ * @returns A Buffer of `length` random bytes
+ *
+ * @example
+ * ```ts
+ * const nonce = secureRandom(12);  // 12-byte nonce for AES-GCM
+ * const key = secureRandom(32);    // 32-byte AES key
+ * ```
+ */
+declare function secureRandom(length: number): Buffer;
+/**
+ * Generate a cryptographically secure random 12-byte nonce (for AES-GCM).
+ */
+declare function randomNonce(): Buffer;
+/**
+ * Generate a cryptographically secure random 16-byte IV (for AES-CBC).
+ */
+declare function randomIv(): Buffer;
+/**
+ * Generate a cryptographically secure random 32-byte key.
+ */
+declare function randomKey(): Buffer;
+/**
+ * Convert a Buffer to its hexadecimal string representation.
+ *
+ * @example
+ * ```ts
+ * toHex(Buffer.from([0xff, 0x00])); // "ff00"
+ * ```
+ */
+declare function toHex(buf: Buffer): string;
+/**
+ * Parse a hexadecimal string into a Buffer.
+ *
+ * @throws {Error} If `hex` contains non-hex characters or has odd length.
+ */
+declare function fromHex(hex: string): Buffer;
+/**
+ * Convert a Buffer to a standard base64 string.
+ */
+declare function toBase64(buf: Buffer): string;
+/**
+ * Parse a base64 string into a Buffer.
+ */
+declare function fromBase64(b64: string): Buffer;
+/**
+ * Convert a Buffer to a URL-safe base64 string (no padding).
+ *
+ * Useful for URLs, query strings, JWT headers, etc.
+ */
+declare function toBase64Url(buf: Buffer): string;
+/**
+ * Parse a base64url string into a Buffer.
+ */
+declare function fromBase64Url(b64url: string): Buffer;
+/**
+ * Convert a Buffer to a string using the specified encoding.
+ */
+declare function bufferToString(buf: Buffer, encoding?: Encoding): string;
+/**
+ * Parse a string into a Buffer using the specified encoding.
+ */
+declare function stringToBuffer(str: string, encoding?: Encoding): Buffer;
+/**
+ * Compare two Buffers in constant time (resistant to timing attacks).
+ *
+ * **Always** use this instead of `===` or `Buffer.equals` when comparing
+ * MACs, signatures, or any other security-sensitive bytes.
+ *
+ * Returns `false` if lengths differ (without revealing the difference).
+ *
+ * @example
+ * ```ts
+ * const valid = constantTimeEqual(receivedTag, expectedTag);
+ * if (!valid) throw new Error('MAC verification failed');
+ * ```
+ */
+declare function constantTimeEqual(a: Buffer, b: Buffer): boolean;
+/**
+ * Concatenate multiple Buffers into one.
+ *
+ * Thin wrapper over `Buffer.concat` with cleaner naming.
+ */
+declare function concat(buffers: Buffer[]): Buffer;
+/**
+ * Zero out a Buffer in-place.
+ *
+ * Useful for clearing sensitive data after use.
+ *
+ * **Note:** JavaScript runtimes may keep copies in GC buffers, so this is
+ * NOT a guaranteed wipe. For real security, use Rust-side zeroization.
+ */
+declare function zeroize(buf: Buffer): void;
+/**
+ * XOR two equal-length Buffers and return the result.
+ *
+ * @throws {Error} If buffers have different lengths.
+ */
+declare function xor(a: Buffer, b: Buffer): Buffer;
+
+/**
+ * Input validators for signalis-core.
+ *
+ * All validators throw `ValidationError` with detailed information.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Assert that a value is a `Buffer`.
+ *
+ * @throws {ValidationError} If `value` is not a Buffer.
+ */
+declare function assertBuffer(value: unknown, parameter: string): asserts value is Buffer;
+/**
+ * Assert that a Buffer has exactly the expected length.
+ *
+ * @throws {ValidationError} If length mismatch.
+ */
+declare function assertBufferLength(value: Buffer, expectedLength: number, parameter: string): void;
+/**
+ * Combined check: must be a Buffer of exactly N bytes.
+ */
+declare function assertBufferOfSize(value: unknown, expectedLength: number, parameter: string): asserts value is Buffer;
+/**
+ * Assert that a number is a positive integer.
+ */
+declare function assertPositiveInteger(value: unknown, parameter: string): asserts value is number;
+/**
+ * Assert HKDF output length is within bounds.
+ */
+declare function assertHkdfLength(length: unknown): asserts length is number;
+/**
+ * Check if two Buffers have the same length (utility for tests).
+ */
+declare function buffersSameLength(a: Buffer, b: Buffer): boolean;
+
+/**
+ * Public constants used throughout signalis-core.
+ *
+ * @packageDocumentation
+ */
+/** Size of a Curve25519 private key in bytes. */
+declare const CURVE25519_PRIVATE_KEY_SIZE = 32;
+/** Size of a Curve25519 public key in bytes. */
+declare const CURVE25519_PUBLIC_KEY_SIZE = 32;
+/** Size of an X25519 ECDH shared secret in bytes. */
+declare const CURVE25519_SHARED_SECRET_SIZE = 32;
+/** Size of HKDF-SHA256 PRK (pseudorandom key) in bytes. */
+declare const HKDF_PRK_SIZE = 32;
+/** Maximum HKDF-SHA256 output length: 255 * HashLen = 255 * 32 = 8160 bytes. */
+declare const HKDF_MAX_OUTPUT_SIZE = 8160;
+/** Size of an AES-256 key in bytes. */
+declare const AES_256_KEY_SIZE = 32;
+/** Size of an AES-256-GCM nonce in bytes (recommended size per NIST SP 800-38D). */
+declare const AES_256_GCM_NONCE_SIZE = 12;
+/** Size of an AES-256-GCM authentication tag in bytes. */
+declare const AES_256_GCM_TAG_SIZE = 16;
+/** Size of an AES-256-CBC IV in bytes (one AES block). */
+declare const AES_256_CBC_IV_SIZE = 16;
+/** AES block size in bytes. */
+declare const AES_BLOCK_SIZE = 16;
+/** Size of a SHA-256 hash output in bytes. */
+declare const SHA256_OUTPUT_SIZE = 32;
+/** Size of an HMAC-SHA256 tag in bytes. */
+declare const HMAC_SHA256_TAG_SIZE = 32;
+/** SHA-256 block size (used internally by HMAC). */
+declare const SHA256_BLOCK_SIZE = 64;
+/**
+ * Maximum recommended plaintext size for AES-GCM (~64 GiB).
+ *
+ * AES-GCM has a hard limit of 2^39 - 256 bits ≈ 64 GiB per single encryption
+ * under the same key+nonce. We recommend much smaller messages and key rotation.
+ */
+declare const AES_GCM_MAX_PLAINTEXT_SIZE: number;
+/**
+ * Recommended maximum number of messages encrypted under the same AES-GCM key
+ * with random 96-bit nonces before key rotation: 2^32.
+ */
+declare const AES_GCM_RECOMMENDED_MESSAGES_PER_KEY = 4294967296;
+
+/**
+ * The version of `@brashkie/signalis-core` (matches `package.json`).
+ *
+ * Bumped on every release.
+ */
+declare const VERSION: "0.1.0";
+
+/**
+ * Default export — provides all primitives and helpers under one namespace.
+ *
+ * @example
+ * ```ts
+ * import sc from '@brashkie/signalis-core';
+ *
+ * const kp = sc.Curve25519.generateKeyPair();
+ * const nonce = sc.secureRandom(12);
+ * ```
+ */
+declare const SignalisCore: Readonly<{
+    Curve25519: Readonly<{
+        generateKeyPair(): KeyPair;
+        publicFromPrivate(privateKey: Buffer): Buffer;
+        diffieHellman(privateKey: Buffer, peerPublicKey: Buffer): Buffer;
+        PRIVATE_KEY_SIZE: 32;
+        PUBLIC_KEY_SIZE: 32;
+        SHARED_SECRET_SIZE: 32;
+    }>;
+    HKDF: Readonly<{
+        extract(salt: Buffer, ikm: Buffer): Buffer;
+        expand(prk: Buffer, info: Buffer, length: number): Buffer;
+        derive(salt: Buffer, ikm: Buffer, info: Buffer, length: number): Buffer;
+        deriveMultiple(salt: Buffer, ikm: Buffer, info: Buffer, lengths: number[]): Buffer[];
+        deriveFromParams(params: HkdfParams): Buffer;
+        PRK_SIZE: 32;
+    }>;
+    AES_GCM: Readonly<{
+        encrypt(key: Buffer, nonce: Buffer, plaintext: Buffer): Buffer;
+        decrypt(key: Buffer, nonce: Buffer, ciphertext: Buffer): Buffer;
+        KEY_SIZE: 32;
+        NONCE_SIZE: 12;
+        TAG_SIZE: 16;
+    }>;
+    AES_CBC: Readonly<{
+        encrypt(key: Buffer, iv: Buffer, plaintext: Buffer): Buffer;
+        decrypt(key: Buffer, iv: Buffer, ciphertext: Buffer): Buffer;
+        KEY_SIZE: 32;
+        IV_SIZE: 16;
+    }>;
+    HMAC: Readonly<{
+        sha256(key: Buffer, data: Buffer): Buffer;
+        verifySha256(key: Buffer, data: Buffer, expectedTag: Buffer): boolean;
+        TAG_SIZE: 32;
+    }>;
+    SHA256: Readonly<{
+        hash(data: Buffer): Buffer;
+        hashAll(buffers: Buffer[]): Buffer;
+        OUTPUT_SIZE: 32;
+    }>;
+    secureRandom: typeof secureRandom;
+    randomNonce: typeof randomNonce;
+    randomIv: typeof randomIv;
+    randomKey: typeof randomKey;
+    toHex: typeof toHex;
+    fromHex: typeof fromHex;
+    toBase64: typeof toBase64;
+    fromBase64: typeof fromBase64;
+    constantTimeEqual: typeof constantTimeEqual;
+    VERSION: "0.1.0";
+    nativeVersion: string;
+}>;
+
+export { AES_256_CBC_IV_SIZE, AES_256_GCM_NONCE_SIZE, AES_256_GCM_TAG_SIZE, AES_256_KEY_SIZE, AES_BLOCK_SIZE, AES_CBC, AES_GCM, AES_GCM_MAX_PLAINTEXT_SIZE, AES_GCM_RECOMMENDED_MESSAGES_PER_KEY, type AesCbcParams, type AesGcmParams, AuthenticationError, CURVE25519_PRIVATE_KEY_SIZE, CURVE25519_PUBLIC_KEY_SIZE, CURVE25519_SHARED_SECRET_SIZE, CryptoError, Curve25519, type Encoding, HKDF, HKDF_MAX_OUTPUT_SIZE, HKDF_PRK_SIZE, HMAC, HMAC_SHA256_TAG_SIZE, type HkdfParams, KeyDerivationError, type KeyPair, LengthError, type PrivateKey, type PseudoRandomKey, type PublicKey, SHA256, SHA256_BLOCK_SIZE, SHA256_OUTPUT_SIZE, type SharedSecret, SignalisError, VERSION, ValidationError, asPrivateKey, asPublicKey, asSharedSecret, assertBuffer, assertBufferLength, assertBufferOfSize, assertHkdfLength, assertPositiveInteger, bufferToString, buffersSameLength, concat, constantTimeEqual, SignalisCore as default, fromBase64, fromBase64Url, fromHex, nativeVersion, randomIv, randomKey, randomNonce, secureRandom, stringToBuffer, toBase64, toBase64Url, toHex, xor, zeroize };