quarkdash 1.0.0

package/dist/types/cipher.d.ts

@@ -0,0 +1,153 @@
+/**
+ * QuarkDash Ciphers Implementation
+ *
+ * @git             https://github.com/devsdaddy/quarkdash
+ * @version         1.0.0
+ * @author          Elijah Rastorguev
+ * @build           1000
+ * @website         https://dev.to/devsdaddy
+ */
+import { ICipher } from "./types";
+/**
+ * Cipher Type
+ */
+export declare enum CipherType {
+    ChaCha20 = 0,
+    Gimli = 1
+}
+/**
+ * Cipher Factory
+ */
+export declare class CipherFactory {
+    /**
+     * Create Cipher
+     * @param algorithm {CipherType} Current cipher type
+     * @param key {Uint8Array} Key buffer
+     * @param nonce {Uint8Array} Nonce buffer
+     * @returns {ICipher} Cipher class instance
+     */
+    static create(algorithm: CipherType, key: Uint8Array, nonce: Uint8Array): ICipher;
+}
+/**
+ * ChaCha20 Based Cipher Implementation
+ */
+export declare class QuarkDashChaCha implements ICipher {
+    private readonly key;
+    private readonly nonce;
+    /**
+     * Create ChaCha20 Cipher
+     * @param key {Uint8Array} Key buffer
+     * @param nonce {Uint8Array} Nonce buffer
+     */
+    constructor(key: Uint8Array, nonce: Uint8Array);
+    /**
+     * Encrypt data async using ChaCha20
+     * @param data {Uint8Array} Raw data buffer
+     * @returns {Promise<Uint8Array>} Result buffer
+     * TODO: GPU Calculations
+     */
+    encrypt(data: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Decrypt data async using ChaCha20
+     * @param data {Uint8Array} Encrypted raw data buffer
+     * @returns {Promise<Uint8Array>} Result buffer
+     * TODO: GPU Calculations
+     */
+    decrypt(data: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Encrypt data sync using ChaCha20
+     * @param data {Uint8Array} Raw data buffer
+     * @returns {Uint8Array} Result buffer
+     */
+    encryptSync(data: Uint8Array): Uint8Array;
+    /**
+     * Decrypt data sync using ChaCha20
+     * @param data {Uint8Array} Encrypted raw data buffer
+     * @returns {Uint8Array} Result buffer
+     */
+    decryptSync(data: Uint8Array): Uint8Array;
+    /**
+     * Process ChaCha20 Cipher
+     * @param data {Uint8Array} Data for processing
+     * @returns {Uint8Array} Processing result
+     * @private
+     */
+    private process;
+    /**
+     * Get keystream block
+     * @param counter {number} counter
+     * @returns {Uint8Array} result buffer
+     * @private
+     */
+    private keystreamBlock;
+    /**
+     * Quarter Round
+     * @param s {Uint8Array} Buffer
+     * @param a {number}
+     * @param b {number}
+     * @param c {number}
+     * @param d {number}
+     * @private
+     */
+    private quarterRound;
+}
+/**
+ * Gimli Cipher
+ */
+export declare class QuarkDashGimli implements ICipher {
+    private readonly key;
+    private readonly nonce;
+    /**
+     * Create Gimli Cipher
+     * @param key {Uint8Array} Key buffer
+     * @param nonce {Uint8Array} Nonce buffer
+     */
+    constructor(key: Uint8Array, nonce: Uint8Array);
+    /**
+     * Encrypt data async using Gimli
+     * @param data {Uint8Array} Raw data buffer
+     * @returns {Promise<Uint8Array>} Result buffer
+     * TODO: GPU Calculations
+     */
+    encrypt(data: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Decrypt data async using Gimli
+     * @param data {Uint8Array} Encrypted raw data buffer
+     * @returns {Promise<Uint8Array>} Result buffer
+     * TODO: GPU Calculations
+     */
+    decrypt(data: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Encrypt data sync using Gimli
+     * @param data {Uint8Array} Raw data buffer
+     * @returns {Uint8Array} Result buffer
+     */
+    encryptSync(data: Uint8Array): Uint8Array;
+    /**
+     * Decrypt data sync using Gimli
+     * @param data {Uint8Array} Encrypted raw data buffer
+     * @returns {Uint8Array} Result buffer
+     */
+    decryptSync(data: Uint8Array): Uint8Array;
+    /**
+     * Process Gimli Cipher
+     * @param data {Uint8Array} Input buffer
+     * @returns {Uint8Array} Output buffer
+     * @private
+     */
+    private process;
+    /**
+     * Get keystream block
+     * @param counter {number} Counter
+     * @returns {Uint8Array} Result buffer
+     * @private
+     */
+    private keystreamBlock;
+    /**
+     * Gimli Round
+     * @param state {Uint32Array} State buffer
+     * @param round {number} Round number
+     * @private
+     */
+    private gimliRound;
+}

package/dist/types/crypto.d.ts

@@ -0,0 +1,155 @@
+/**
+ * QuarkDash Crypto Algorithm Implementation
+ *
+ * @git             https://github.com/devsdaddy/quarkdash
+ * @version         1.0.0
+ * @author          Elijah Rastorguev
+ * @build           1000
+ * @website         https://dev.to/devsdaddy
+ */
+import { CipherType } from "./cipher";
+import { ICryptoMethodAsync, ICryptoMethodSync, IKDF, IKeyExchange, IMAC } from "./types";
+/**
+ * Quark Dash parsed encrypted packet
+ */
+export interface QDEncryptedPacket {
+    metadata: Uint8Array;
+    encrypted: Uint8Array;
+    mac: Uint8Array;
+}
+/**
+ * QuarkDash options
+ */
+export interface QuarkDashOptions {
+    cipher: CipherType;
+    kdf: IKDF;
+    mac: IMAC;
+    keyExchange: IKeyExchange;
+    maxPacketWindow: number;
+    timestampToleranceMs: number;
+}
+/**
+ * QuarkDash Crypto Algorithm Implementation
+ */
+export declare class QuarkDash implements ICryptoMethodAsync, ICryptoMethodSync {
+    private config;
+    private sessionKey;
+    private cipher;
+    private macKey;
+    private sendSeq;
+    private recvSeq;
+    private receivedPackets;
+    private myKeyPair?;
+    private peerPublicKey?;
+    /**
+     * Create QuarkDash Crypto
+     * @param config {QuarkDashOptions} Crypto Options
+     */
+    constructor(config?: Partial<QuarkDashOptions>);
+    /**
+     * Generate key pair async
+     * @returns {Promise<Uint8Array>} Key pair buffer
+     * TODO: GPU Computing
+     */
+    generateKeyPair(): Promise<Uint8Array>;
+    /**
+     * Generate key pair sync
+     * @returns {Uint8Array} Key pair buffer
+     */
+    generateKeyPairSync(): Uint8Array;
+    /**
+     * Initialize session async
+     * @param peerPublicKey {Uint8Array} Peer public key buffer
+     * @param isInitiator {boolean} Is session initiator
+     * @returns {Promise<Uint8Array|number>} Returns derived session key or null
+     * TODO: GPU Computing
+     */
+    initializeSession(peerPublicKey: Uint8Array, isInitiator: boolean): Promise<Uint8Array | null>;
+    /**
+     * Initialize session sync
+     * @param peerPublicKey {Uint8Array} Peer public key buffer
+     * @param isInitiator {boolean} Is session initiator
+     * @returns {Uint8Array|number} Returns derived session key or null
+     */
+    initializeSessionSync(peerPublicKey: Uint8Array, isInitiator: boolean): Uint8Array | null;
+    /**
+     * Finalize session async
+     * @param ciphertext {Uint8Array} Cipher text buffer
+     * TODO: GPU Computing
+     */
+    finalizeSession(ciphertext: Uint8Array): Promise<void>;
+    /**
+     * Finalize session sync
+     * @param ciphertext {Uint8Array} Cipher text buffer
+     */
+    finalizeSessionSync(ciphertext: Uint8Array): void;
+    /**
+     * Derive session keys async
+     * @param sharedSecret {Uint8Array} Shared secret buffer
+     * @private
+     * TODO: GPU Computing
+     */
+    private deriveSessionKeys;
+    /**
+     * Derive session keys sync
+     * @param sharedSecret {Uint8Array} Shared secret buffer
+     * @private
+     */
+    private deriveSessionKeysSync;
+    /**
+     * Process derive session keys
+     * @param keyMaterial {Uint8Array} Key material buffer
+     * @param sharedSecret {Uint8Array} Shared secret buffer
+     * @private
+     */
+    private processDeriveSessionKeys;
+    /**
+     * Encrypt sync
+     * @param decryptedData {Uint8Array} Decrypted buffer
+     * @returns {Promise<Uint8Array>} Encrypted buffer
+     * TODO: GPU Computing
+     */
+    encrypt(decryptedData: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Encrypt sync
+     * @param decryptedData {Uint8Array} Decrypted buffer
+     * @returns {Uint8Array} Encrypted buffer
+     */
+    encryptSync(decryptedData: Uint8Array): Uint8Array;
+    /**
+     * Decrypt async
+     * @param encryptedData {Uint8Array} Encrypted buffer
+     * @returns {Promise<Uint8Array>} Decrypted buffer
+     * TODO: GPU Computing
+     */
+    decrypt(encryptedData: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Decrypt sync
+     * @param encryptedData {Uint8Array} Encrypted buffer
+     * @returns {Uint8Array} Decrypted buffer
+     */
+    decryptSync(encryptedData: Uint8Array): Uint8Array;
+    /**
+     * Process decrypt
+     * @param encryptedData {Uint8Array} encrypted buffer
+     * @returns {QDEncryptedPacket} Parsed encrypted packet
+     * @private
+     */
+    private processDecrypt;
+    /**
+     * Build meta-data
+     * @returns {Uint8Array} Meta-data buffer
+     * @private
+     */
+    private buildMetadata;
+    /**
+     * Check Meta-Data
+     * @param metadata {Uint8Array} Meta-data buffer
+     * @private
+     */
+    private checkMetadata;
+    /**
+     * Dispose QuarkDash Crypto
+     */
+    dispose(): void;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * QuarkDash Crypto Library
+ *
+ * @git             https://github.com/devsdaddy/quarkdash
+ * @version         1.0.0
+ * @author          Elijah Rastorguev
+ * @build           1000
+ * @website         https://dev.to/devsdaddy
+ */
+export * from "./types";
+export * from "./utils";
+export * from "./kdf";
+export * from "./mac";
+export * from "./cipher";
+export * from "./ringlwe";
+export * from "./crypto";

package/dist/types/kdf.d.ts

@@ -0,0 +1,34 @@
+/**
+ * QuarkDash Shake256 Based KDF
+ *
+ * @git             https://github.com/devsdaddy/quarkdash
+ * @version         1.0.0
+ * @author          Elijah Rastorguev
+ * @build           1000
+ * @website         https://dev.to/devsdaddy
+ */
+import type { IKDF } from "./types";
+/**
+ * KDF implementation using Shake-256
+ */
+export declare class QuarkDashKDF implements IKDF {
+    /**
+     * Derive KDF async
+     * @param ikm {Uint8Array} IKM buffer
+     * @param salt {Uint8Array} Salt buffer
+     * @param info {Uint8Array} Meta buffer
+     * @param length {number} Buffer length
+     * @returns {Promise<Uint8Array>} Result
+     * TODO: GPU Calculations
+     */
+    derive(ikm: Uint8Array, salt: Uint8Array, info: Uint8Array, length: number): Promise<Uint8Array>;
+    /**
+     * Derive KDF sync
+     * @param ikm {Uint8Array} IKM buffer
+     * @param salt {Uint8Array} Salt buffer
+     * @param info {Uint8Array} Meta buffer
+     * @param length {number} Buffer length
+     * @returns {Uint8Array} Result
+     */
+    deriveSync(ikm: Uint8Array, salt: Uint8Array, info: Uint8Array, length: number): Uint8Array;
+}

package/dist/types/mac.d.ts

@@ -0,0 +1,47 @@
+/**
+ * QuarkDash Shake256 Based MAC
+ *
+ * @git             https://github.com/devsdaddy/quarkdash
+ * @version         1.0.0
+ * @author          Elijah Rastorguev
+ * @build           1000
+ * @website         https://dev.to/devsdaddy
+ */
+import { IMAC } from "./types";
+/**
+ * MAC implementation using Shake-256
+ */
+export declare class QuarkDashMAC implements IMAC {
+    /**
+     * Sign data async
+     * @param data {Uint8Array} Data buffer
+     * @param key {Uint8Array} Key buffer
+     * @returns {Promise<Uint8Array>} Signed result buffer
+     * TODO: GPU Calculations
+     */
+    sign(data: Uint8Array, key: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Verify async
+     * @param data {Uint8Array} data buffer
+     * @param key {Uint8Array} key buffer
+     * @param tag {Uint8Array} tag buffer
+     * @returns {Promise<boolean>} Is verified?
+     * TODO: GPU Calculations
+     */
+    verify(data: Uint8Array, key: Uint8Array, tag: Uint8Array): Promise<boolean>;
+    /**
+     * Sign data sync
+     * @param data {Uint8Array} Data buffer
+     * @param key {Uint8Array} Key buffer
+     * @returns {Uint8Array} Signed result buffer
+     */
+    signSync(data: Uint8Array, key: Uint8Array): Uint8Array;
+    /**
+     * Verify sync
+     * @param data {Uint8Array} data buffer
+     * @param key {Uint8Array} key buffer
+     * @param tag {Uint8Array} tag buffer
+     * @returns {Promise<boolean>} Is verified?
+     */
+    verifySync(data: Uint8Array, key: Uint8Array, tag: Uint8Array): boolean;
+}

package/dist/types/ringlwe.d.ts

@@ -0,0 +1,127 @@
+/**
+ * QuarkDash Ring-LWE Implementation
+ *
+ * @git             https://github.com/devsdaddy/quarkdash
+ * @version         1.0.0
+ * @author          Elijah Rastorguev
+ * @build           1000
+ * @website         https://dev.to/devsdaddy
+ */
+import { ICryptoEncapsulated, ICryptoKeyPair, IKeyExchange } from "./types";
+/**
+ * Ring-LWE based key exchange implementation
+ */
+export declare class QuarkDashKeyExchange implements IKeyExchange {
+    private static readonly N;
+    private static readonly Q;
+    private static readonly ROOT;
+    private static readonly INV_N;
+    /**
+     * Get small polygon
+     * @returns {bigint[]} Small polygon
+     * @private
+     */
+    private static smallPoly;
+    /**
+     * Uniform polygon
+     * @returns {bigint[]}
+     * @private
+     */
+    private static uniformPoly;
+    /**
+     * NTT Operation
+     * @param poly {bigint[]} Polygon
+     * @private
+     */
+    private static ntt;
+    /**
+     * Inverse NTT
+     * @param poly {bigint[]} Polygon
+     * @private
+     */
+    private static invNTT;
+    /**
+     * Multiply
+     * @param a {bigint[]} Polygon
+     * @param b {bigint[]} Polygon
+     * @returns {bigint[]} Multiplied polygons
+     */
+    static multiply(a: bigint[], b: bigint[]): bigint[];
+    /**
+     * Serialize polygon
+     * @param poly {bigint[]} Polygon
+     * @returns {Uint8Array} Polygon buffer
+     * @private
+     */
+    private static serializePoly;
+    /**
+     * Deserialize Polygon
+     * @param bytes {Uint8Array} Polygon buffer
+     * @returns {bigint[]} Polygon
+     * @private
+     */
+    private static deserializePoly;
+    /**
+     * Round to bits
+     * @param poly {bigint[]} Polygon
+     * @returns {Uint8Array} rounded buffer
+     * @private
+     */
+    private static roundToBits;
+    /**
+     * Modular exponentiation
+     * @param base {bigint} Base
+     * @param exp {bigint} exponential
+     * @param mod {bigint} module
+     * @returns {bigint} Result of modular exponentiation
+     * @private
+     */
+    private static powMod;
+    /**
+     * Modular inverse
+     * @param a {bigint}
+     * @param m {bigint}
+     * @returns {bigint} Inversion result
+     * @private
+     */
+    private static modInverse;
+    /**
+     * Generate crypto key pair async
+     * @returns {ICryptoKeyPair} Crypto key pair
+     * TODO: GPU Calculations
+     */
+    generateKeyPair(): Promise<ICryptoKeyPair>;
+    /**
+     * Generate crypto key pair sync
+     * @returns {ICryptoKeyPair} Crypto key pair
+     */
+    generateKeyPairSync(): ICryptoKeyPair;
+    /**
+     * Encapsulate async
+     * @param publicKey {Uint8Array} Public key buffer
+     * @returns {Promise<ICryptoEncapsulated>} Encapsulated data
+     * TODO: GPU Calculations
+     */
+    encapsulate(publicKey: Uint8Array): Promise<ICryptoEncapsulated>;
+    /**
+     * Encapsulate sync
+     * @param publicKey {Uint8Array} Public key buffer
+     * @returns {ICryptoEncapsulated} Encapsulated data
+     */
+    encapsulateSync(publicKey: Uint8Array): ICryptoEncapsulated;
+    /**
+     * Decapsulate async
+     * @param privateKey {Uint8Array} Private key buffer
+     * @param ciphertext {Uint8Array} Cipher text buffer
+     * @returns {Promise<Uint8Array>} Buffer data
+     * TODO: GPU Calculations
+     */
+    decapsulate(privateKey: Uint8Array, ciphertext: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Decapsulate sync
+     * @param privateKey {Uint8Array} Private key buffer
+     * @param ciphertext {Uint8Array} Cipher text buffer
+     * @returns {Uint8Array} Buffer data
+     */
+    decapsulateSync(privateKey: Uint8Array, ciphertext: Uint8Array): Uint8Array;
+}

package/dist/types/types.d.ts

@@ -0,0 +1,69 @@
+/**
+ * QuarkDash Crypto Types
+ *
+ * @git             https://github.com/devsdaddy/quarkdash
+ * @version         1.0.0
+ * @author          Elijah Rastorguev
+ * @build           1000
+ * @website         https://dev.to/devsdaddy
+ */
+/**
+ * Crypto methods async interface
+ */
+export interface ICryptoMethodAsync {
+    encrypt(decryptedData: Uint8Array): Promise<Uint8Array>;
+    decrypt(encryptedData: Uint8Array): Promise<Uint8Array>;
+}
+/**
+ * Crypto methods sync interface
+ */
+export interface ICryptoMethodSync {
+    encryptSync(decryptedData: Uint8Array): Uint8Array;
+    decryptSync(encryptedData: Uint8Array): Uint8Array;
+}
+/**
+ * Cipher interface
+ */
+export interface ICipher extends ICryptoMethodAsync, ICryptoMethodSync {
+}
+/**
+ * KDF interface
+ */
+export interface IKDF {
+    derive(ikm: Uint8Array, salt: Uint8Array, info: Uint8Array, length: number): Promise<Uint8Array>;
+    deriveSync(ikm: Uint8Array, salt: Uint8Array, info: Uint8Array, length: number): Uint8Array;
+}
+/**
+ * MAC interface
+ */
+export interface IMAC {
+    sign(data: Uint8Array, key: Uint8Array): Promise<Uint8Array>;
+    verify(data: Uint8Array, key: Uint8Array, tag: Uint8Array): Promise<boolean>;
+    signSync(data: Uint8Array, key: Uint8Array): Uint8Array;
+    verifySync(data: Uint8Array, key: Uint8Array, tag: Uint8Array): boolean;
+}
+/**
+ * Key exchange interface
+ */
+export interface IKeyExchange {
+    generateKeyPair(): Promise<ICryptoKeyPair>;
+    generateKeyPairSync(): ICryptoKeyPair;
+    encapsulate(publicKey: Uint8Array): Promise<ICryptoEncapsulated>;
+    encapsulateSync(publicKey: Uint8Array): ICryptoEncapsulated;
+    decapsulate(privateKey: Uint8Array, ciphertext: Uint8Array): Promise<Uint8Array>;
+    decapsulateSync(privateKey: Uint8Array, ciphertext: Uint8Array): Uint8Array;
+}
+/**
+ * Crypto key pair
+ */
+export interface ICryptoKeyPair {
+    publicKey: Uint8Array;
+    privateKey: Uint8Array;
+}
+/**
+ * Crypto encapsulated
+ */
+export interface ICryptoEncapsulated {
+    ciphertext: Uint8Array;
+    sharedSecret: Uint8Array;
+}