quarkdash 1.0.0

package/dist/types/utils.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Crypto Utils Class
+ */
+export declare class QuarkDashUtils {
+    private static HEXChars;
+    /**
+     * Run SHA256 async
+     * @param data {Uint8Array} Bytes buffer
+     * @return {Promise<Uint8Array>} Result
+     */
+    static sha256(data: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Run SHA256 sync
+     * @param data {Uint8Array} Bytes buffer
+     * @return {Uint8Array} Result
+     */
+    static sha256Sync(data: Uint8Array): Uint8Array;
+    /**
+     * Get Shake-256 result async
+     * @param data {Uint8Array} Bytes buffer
+     * @param len {number} Buffer length
+     * @return {Promise<Uint8Array>} Result buffer
+     */
+    static shake256(data: Uint8Array, len: number): Promise<Uint8Array>;
+    /**
+     * Get Shake-256 result sync
+     * @param data {Uint8Array} Bytes buffer
+     * @param len {number} Buffer length
+     * @return {Uint8Array} Result buffer
+     */
+    static shake256Sync(data: Uint8Array, len: number): Uint8Array;
+    /**
+     * Concat bytes
+     * @param arrays {Uint8Array|null|undefined} Input arrays for concat
+     * @returns {Uint8Array} Result buffer
+     */
+    static concatBytes(...arrays: (Uint8Array | null | undefined)[]): Uint8Array;
+    /**
+     * Coerce Array
+     * @param arg {any} Argument
+     * @param copy {any} Copy
+     * @protected
+     */
+    static coerceArray(arg: any, copy?: any): any;
+    /**
+     * Check if value is int
+     * @param value {any} Value
+     * @returns {boolean}
+     * @protected
+     */
+    static checkInt(value: any): boolean;
+    /**
+     * Check Ints inside array
+     * @param arrayish {any} Array
+     * @returns {boolean} Any value is integer and between 0 and 255
+     * @protected
+     */
+    static checkInts(arrayish: any): boolean;
+    /**
+     * Get random bytes
+     * @param len {number} buffer length
+     * @returns {Uint8Array} Random bytes buffer
+     */
+    static randomBytes(len: number): Uint8Array;
+    /**
+     * Convert raw text to bytes array
+     * @param text {string} raw string
+     * @returns {any} bytes array
+     */
+    static textToBytes(text: string): any;
+    /**
+     * Convert bytes array to raw string
+     * @param bytes {number[]|Uint8Array} Bytes array
+     * @returns {string} raw string
+     */
+    static bytesToText(bytes: number[] | Uint8Array): string;
+    /**
+     * Convert HEX string to bytes array
+     * @param text {string} HEX string
+     * @returns {number[]} bytes array
+     * @constructor
+     */
+    static HEXToBytes(text: string): number[];
+    /**
+     * Convert bytes array to HEX string
+     * @param bytes {number[]|Uint8Array} Bytes array
+     * @returns {string} HEX String
+     */
+    static bytesToHEX(bytes: number[] | Uint8Array): string;
+    /**
+     * Constant time equal
+     * @param a {Uint8Array} first buffer
+     * @param b {Uint8Array} second buffer
+     * @returns {boolean} Equal or not
+     */
+    static constantTimeEqual(a: Uint8Array, b: Uint8Array): boolean;
+    /**
+     * Secure zero
+     * @param bytes {Uint8Array} bytes buffer
+     */
+    static secureZero(bytes: Uint8Array): void;
+    /**
+     * Read U32 from buffer
+     * @param arr {Uint8Array} buffer
+     * @param off {number} Offset
+     * @returns {number} U32
+     * @private
+     */
+    static readU32(arr: Uint8Array, off: number): number;
+    /**
+     * Write U32 to buffer
+     * @param v {number} U32
+     * @param arr {Uint8Array} Target buffer
+     * @param off {number} Offset
+     * @private
+     */
+    static writeU32(v: number, arr: Uint8Array, off: number): void;
+    /**
+     * Read Uint32 Value
+     * @param arr {Uint8Array} Bytes buffer
+     * @param off {number} Offset
+     * @returns {number} Uint32 Value
+     */
+    static readUint32(arr: Uint8Array, off: number): number;
+    /**
+     * Read Uint64 Value
+     * @param arr {Uint8Array} Bytes buffer
+     * @param off {number} offset
+     * @returns {bigint} Bigint
+     */
+    static readUint64(arr: Uint8Array, off: number): bigint;
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "quarkdash",
+  "version": "1.0.0",
+  "description": "QuarkDash - pure typescript hybrid cryptographic protocol that provides post-quantum security, high performance, and attack resistance.",
+  "keywords": [
+    "quark",
+    "dash",
+    "qd-256",
+    "quarkdash",
+    "encryption",
+    "crypto",
+    "protocol",
+    "binary",
+    "hybrid",
+    "fast",
+    "secure",
+    "quantum"
+  ],
+  "homepage": "https://github.com/DevsDaddy/quarkdash#readme",
+  "bugs": {
+    "url": "https://github.com/DevsDaddy/quarkdash/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DevsDaddy/quarkdash.git"
+  },
+  "license": "MIT",
+  "author": "Elijah Rastroguev",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "types": "./dist/types/index.d.ts"
+    }
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "npm run clean && npm run build:esm && npm run build:cjs && npm run build:types",
+    "build:esm": "tsc -p tsconfig.json",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:types": "tsc -p tsconfig.json --emitDeclarationOnly --declaration --outDir dist/types",
+    "test": "jest --coverage",
+    "test:watch": "jest --watch",
+    "bench": "ts-node --compiler-options '{\"module\":\"CommonJS\"}' benchmarks/bench.ts",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "jest": "^29.5.0",
+    "ts-jest": "^29.1.0",
+    "ts-node": "^10.9.0",
+    "typescript": "^5.0.0",
+    "ws": "^8.14.0"
+  },
+  "dependencies": {},
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}

package/src/cipher.ts

@@ -0,0 +1,260 @@
+/**
+ * QuarkDash Ciphers Implementation
+ *
+ * @git             https://github.com/devsdaddy/quarkdash
+ * @version         1.0.0
+ * @author          Elijah Rastorguev
+ * @build           1000
+ * @website         https://dev.to/devsdaddy
+ */
+/* Import Required Modules */
+import {ICipher} from "./types";
+import {QuarkDashUtils} from "./utils";
+
+/**
+ * Cipher Type
+ */
+export enum CipherType {
+    ChaCha20 = 0,
+    Gimli = 1
+}
+
+/**
+ * Cipher Factory
+ */
+export 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 {
+        switch(algorithm) {
+            case CipherType.ChaCha20: return new QuarkDashChaCha(key, nonce);
+            case CipherType.Gimli: return new QuarkDashGimli(key, nonce);
+            default: throw new Error('Unsupported cipher type');
+        }
+    }
+}
+
+/**
+ * ChaCha20 Based Cipher Implementation
+ */
+export class QuarkDashChaCha implements ICipher {
+    // Key and Nonce
+    private readonly key: Uint8Array;
+    private readonly nonce: Uint8Array;
+
+    /**
+     * Create ChaCha20 Cipher
+     * @param key {Uint8Array} Key buffer
+     * @param nonce {Uint8Array} Nonce buffer
+     */
+    constructor(key: Uint8Array, nonce: Uint8Array) {
+        if (key.length !== 32) throw new Error('Key must be 32 bytes');
+        if (nonce.length !== 12) throw new Error('Nonce must be 12 bytes');
+        this.key = key;
+        this.nonce = nonce;
+    }
+
+    /**
+     * Encrypt data async using ChaCha20
+     * @param data {Uint8Array} Raw data buffer
+     * @returns {Promise<Uint8Array>} Result buffer
+     * TODO: GPU Calculations
+     */
+    public async encrypt(data: Uint8Array): Promise<Uint8Array> { return this.process(data); }
+
+    /**
+     * Decrypt data async using ChaCha20
+     * @param data {Uint8Array} Encrypted raw data buffer
+     * @returns {Promise<Uint8Array>} Result buffer
+     * TODO: GPU Calculations
+     */
+    public async decrypt(data: Uint8Array): Promise<Uint8Array> { return this.process(data); }
+
+    /**
+     * Encrypt data sync using ChaCha20
+     * @param data {Uint8Array} Raw data buffer
+     * @returns {Uint8Array} Result buffer
+     */
+    public encryptSync(data: Uint8Array): Uint8Array { return this.process(data); }
+
+    /**
+     * Decrypt data sync using ChaCha20
+     * @param data {Uint8Array} Encrypted raw data buffer
+     * @returns {Uint8Array} Result buffer
+     */
+    public decryptSync(data: Uint8Array): Uint8Array { return this.process(data); }
+
+    /**
+     * Process ChaCha20 Cipher
+     * @param data {Uint8Array} Data for processing
+     * @returns {Uint8Array} Processing result
+     * @private
+     */
+    private process(data: Uint8Array): Uint8Array {
+        const out = new Uint8Array(data.length);
+        let block = 0;
+        let pos = 0;
+        while (pos < data.length) {
+            const ks = this.keystreamBlock(block);
+            const len = Math.min(64, data.length - pos);
+            for (let i = 0; i < len; i++) out[pos+i] = data[pos+i] ^ ks[i];
+            pos += len;
+            block++;
+        }
+        return out;
+    }
+
+    /**
+     * Get keystream block
+     * @param counter {number} counter
+     * @returns {Uint8Array} result buffer
+     * @private
+     */
+    private keystreamBlock(counter: number): Uint8Array {
+        const state = new Uint32Array(16);
+        state[0]=0x61707865; state[1]=0x3320646e; state[2]=0x79622d32; state[3]=0x6b206574;
+        for (let i=0;i<8;i++) state[4+i] = QuarkDashUtils.readU32(this.key, i*4);
+        state[12] = counter;
+        for (let i=0;i<3;i++) state[13+i] = QuarkDashUtils.readU32(this.nonce, i*4);
+        const working = new Uint32Array(state);
+        for (let r=0;r<10;r++) {
+            this.quarterRound(working,0,4,8,12); this.quarterRound(working,1,5,9,13);
+            this.quarterRound(working,2,6,10,14); this.quarterRound(working,3,7,11,15);
+            this.quarterRound(working,0,5,10,15); this.quarterRound(working,1,6,11,12);
+            this.quarterRound(working,2,7,8,13); this.quarterRound(working,3,4,9,14);
+        }
+        for(let i=0;i<16;i++) working[i] += state[i];
+        const out = new Uint8Array(64);
+        for(let i=0;i<16;i++) QuarkDashUtils.writeU32(working[i], out, i*4);
+        return out;
+    }
+
+    /**
+     * Quarter Round
+     * @param s {Uint8Array} Buffer
+     * @param a {number}
+     * @param b {number}
+     * @param c {number}
+     * @param d {number}
+     * @private
+     */
+    private quarterRound(s:Uint32Array, a:number,b:number,c:number,d:number){
+        s[a] += s[b]; s[d] ^= s[a]; s[d] = (s[d]<<16)|(s[d]>>>16);
+        s[c] += s[d]; s[b] ^= s[c]; s[b] = (s[b]<<12)|(s[b]>>>20);
+        s[a] += s[b]; s[d] ^= s[a]; s[d] = (s[d]<<8)|(s[d]>>>24);
+        s[c] += s[d]; s[b] ^= s[c]; s[b] = (s[b]<<7)|(s[b]>>>25);
+    }
+}
+
+/**
+ * Gimli Cipher
+ */
+export class QuarkDashGimli implements ICipher {
+    // Key and Nonce
+    private readonly key: Uint8Array;
+    private readonly nonce: Uint8Array;
+
+    /**
+     * Create Gimli Cipher
+     * @param key {Uint8Array} Key buffer
+     * @param nonce {Uint8Array} Nonce buffer
+     */
+    constructor(key: Uint8Array, nonce: Uint8Array) {
+        if (key.length !== 32) throw new Error('Key must be 32 bytes');
+        if (nonce.length !== 12) throw new Error('Nonce must be 12 bytes');
+        this.key = key;
+        this.nonce = nonce;
+    }
+
+    /**
+     * Encrypt data async using Gimli
+     * @param data {Uint8Array} Raw data buffer
+     * @returns {Promise<Uint8Array>} Result buffer
+     * TODO: GPU Calculations
+     */
+    public async encrypt(data: Uint8Array): Promise<Uint8Array> { return this.process(data); }
+
+    /**
+     * Decrypt data async using Gimli
+     * @param data {Uint8Array} Encrypted raw data buffer
+     * @returns {Promise<Uint8Array>} Result buffer
+     * TODO: GPU Calculations
+     */
+    public async decrypt(data: Uint8Array): Promise<Uint8Array> { return this.process(data); }
+
+    /**
+     * Encrypt data sync using Gimli
+     * @param data {Uint8Array} Raw data buffer
+     * @returns {Uint8Array} Result buffer
+     */
+    public encryptSync(data: Uint8Array): Uint8Array { return this.process(data); }
+
+    /**
+     * Decrypt data sync using Gimli
+     * @param data {Uint8Array} Encrypted raw data buffer
+     * @returns {Uint8Array} Result buffer
+     */
+    public decryptSync(data: Uint8Array): Uint8Array { return this.process(data); }
+
+    /**
+     * Process Gimli Cipher
+     * @param data {Uint8Array} Input buffer
+     * @returns {Uint8Array} Output buffer
+     * @private
+     */
+    private process(data: Uint8Array): Uint8Array {
+        const out = new Uint8Array(data.length);
+        let block = 0;
+        let pos = 0;
+        while (pos < data.length) {
+            const ks = this.keystreamBlock(block);
+            const len = Math.min(48, data.length - pos);
+            for (let i = 0; i < len; i++) out[pos+i] = data[pos+i] ^ ks[i];
+            pos += len;
+            block++;
+        }
+        return out;
+    }
+
+    /**
+     * Get keystream block
+     * @param counter {number} Counter
+     * @returns {Uint8Array} Result buffer
+     * @private
+     */
+    private keystreamBlock(counter: number): Uint8Array {
+        const state = new Uint32Array(12);
+        for (let i=0;i<8;i++) state[i] = QuarkDashUtils.readU32(this.key, i*4);
+        state[8] = QuarkDashUtils.readU32(this.nonce,0);
+        state[9] = QuarkDashUtils.readU32(this.nonce,4);
+        state[10] = QuarkDashUtils.readU32(this.nonce,8);
+        state[11] = counter;
+        for (let r=0;r<24;r++) this.gimliRound(state, r);
+        const out = new Uint8Array(48);
+        for(let i=0;i<12;i++) QuarkDashUtils.writeU32(state[i], out, i*4);
+        return out;
+    }
+
+    /**
+     * Gimli Round
+     * @param state {Uint32Array} State buffer
+     * @param round {number} Round number
+     * @private
+     */
+    private gimliRound(state:Uint32Array, round:number){
+        for(let i=0;i<4;i++){
+            const x=state[i], y=state[i+4], z=state[i+8];
+            const newX = x ^ (z<<1) ^ ((y&z)<<2);
+            const newY = y ^ x ^ ((x|z)<<1);
+            const newZ = z ^ y ^ ((x&y)<<3);
+            state[i]=newX; state[i+4]=newY; state[i+8]=newZ;
+        }
+        const t=state[1]; state[1]=state[2]; state[2]=state[3]; state[3]=t;
+        if((round&3)===0) state[0] ^= (0x9e377900 | round);
+    }
+}