quarkdash 1.0.7 → 1.1.0

package/src/shake.ts

@@ -1,163 +0,0 @@
-/**
- * QuarkDash Crypto SHAKE-256 Implementation
- *
- * @git             https://github.com/devsdaddy/quarkdash
- * @version         1.0.0
- * @author          Elijah Rastorguev
- * @build           1000
- * @website         https://dev.to/devsdaddy
- */
-/**
- * Shake-256 Hash
- */
-export class Shake256 {
-    /* Shake 256 Constants */
-    private static KECCAK_ROUNDS = 24;
-    private static RATE_BYTES = 136;
-    private static ROTATIONS: number[] = [
-        1,  3,  6,  10, 15, 21, 28, 36, 45, 55, 2,  14,
-        27, 41, 56, 8,  25, 43, 62, 18, 39, 61, 20, 44
-    ];
-    private static RC: bigint[] = [
-        0x0000000000000001n, 0x0000000000008082n, 0x800000000000808an, 0x8000000080008000n,
-        0x000000000000808bn, 0x0000000080000001n, 0x8000000080008081n, 0x8000000000008009n,
-        0x000000000000008an, 0x0000000000000088n, 0x0000000080008009n, 0x000000008000000an,
-        0x000000008000808bn, 0x800000000000008bn, 0x8000000000008089n, 0x8000000000008003n,
-        0x8000000000008002n, 0x8000000000000080n, 0x000000000000800an, 0x800000008000000an,
-        0x8000000080008081n, 0x8000000000008080n, 0x0000000080000001n, 0x8000000080008008n
-    ];
-
-    /**
-     * Shake-256 async
-     * @param input {Uint8Array} Input buffer
-     * @param outputLength {number} Output buffer length
-     * @returns {Uint8Array} Output buffer
-     */
-    public static async hash(input: Uint8Array, outputLength: number): Promise<Uint8Array> {
-        return this.process(input, outputLength);
-    }
-
-    /**
-     * Shake-256 sync
-     * @param input {Uint8Array} Input buffer
-     * @param outputLength {number} Output buffer length
-     * @returns {Uint8Array} Output buffer
-     */
-    public static hashSync(input: Uint8Array, outputLength: number): Uint8Array {
-        return this.process(input, outputLength);
-    }
-
-    /**
-     * Process SHAKE-256
-     * @param input {Uint8Array} Input buffer
-     * @param outputLength {number} Output length
-     * @returns {Uint8Array} Output buffer
-     * @private
-     */
-    private static process(input: Uint8Array, outputLength: number): Uint8Array {
-        const state = new Array(25).fill(0n);
-        // Absorb phase
-        let offset = 0;
-        let blockSize = this.RATE_BYTES;
-        while (offset < input.length) {
-            const block = input.subarray(offset, Math.min(offset + blockSize, input.length));
-            for (let i = 0; i < block.length; i++) {
-                const lane = i % 8;
-                const bytePos = i - lane;
-                const laneIdx = bytePos / 8;
-                const shift = BigInt(lane * 8);
-                const val = BigInt(block[i]) << shift;
-                state[laneIdx] ^= val;
-            }
-            offset += block.length;
-            if (block.length === blockSize || offset >= input.length) {
-                // padding
-                if (offset >= input.length) {
-                    const lastByteIdx = block.length;
-                    const padByte = 0x1F; // domain for SHAKE256
-                    const laneIdx = Math.floor(lastByteIdx / 8);
-                    const shift = BigInt((lastByteIdx % 8) * 8);
-                    state[laneIdx] ^= (BigInt(padByte) << shift);
-                    // final padding bit
-                    const finalBytePos = lastByteIdx + 1;
-                    const finalLane = Math.floor(finalBytePos / 8);
-                    const finalShift = BigInt((finalBytePos % 8) * 8);
-                    state[finalLane] ^= (0x80n << finalShift);
-                }
-                this.keccakF(state);
-            }
-        }
-
-        // Squeeze phase
-        const result = new Uint8Array(outputLength);
-        let outOffset = 0;
-        while (outOffset < outputLength) {
-            for (let lane = 0; lane < 25 && outOffset < outputLength; lane++) {
-                let val = state[lane];
-                for (let byte = 0; byte < 8 && outOffset < outputLength; byte++) {
-                    result[outOffset++] = Number(val & 0xFFn);
-                    val >>= 8n;
-                }
-            }
-            if (outOffset < outputLength) {
-                this.keccakF(state);
-            }
-        }
-        return result;
-    }
-
-    /**
-     * Keccak Function
-     * @param state {bigint[]} State array
-     * @private
-     */
-    private static keccakF(state: bigint[]): void {
-        for (let round = 0; round < this.KECCAK_ROUNDS; round++) {
-            // Theta
-            const C = new Array(5);
-            for (let x = 0; x < 5; x++) {
-                C[x] = state[x] ^ state[x+5] ^ state[x+10] ^ state[x+15] ^ state[x+20];
-            }
-            const D = new Array(5);
-            for (let x = 0; x < 5; x++) {
-                D[x] = C[(x+4)%5] ^ this.rot(C[(x+1)%5], 1n);
-            }
-            for (let x = 0; x < 5; x++) {
-                for (let y = 0; y < 5; y++) {
-                    state[x+5*y] ^= D[x];
-                }
-            }
-
-            // Rho and Pi
-            let current = state[1];
-            for (let i = 0; i < 24; i++) {
-                const nextIdx = (2 * ((i + 1) % 5) + 5*Math.floor((i+1)/5)) % 25;
-                const temp = state[nextIdx];
-                state[nextIdx] = this.rot(current, BigInt(this.ROTATIONS[i]));
-                current = temp;
-            }
-
-            // Chi
-            for (let y = 0; y < 5; y++) {
-                const row = state.slice(y*5, y*5+5);
-                for (let x = 0; x < 5; x++) {
-                    state[y*5 + x] = row[x] ^ ((~row[(x+1)%5]) & row[(x+2)%5]);
-                }
-            }
-
-            // Iota
-            state[0] ^= this.RC[round];
-        }
-    }
-
-    /**
-     * Rotate function
-     * @param x {number}
-     * @param n {number}
-     * @private
-     */
-    private static rot(x: bigint, n: bigint): bigint {
-        const mask = (1n << 64n) - 1n;
-        return ((x << n) | (x >> (64n - n))) & mask;
-    }
-}

package/src/types.ts

@@ -1,75 +0,0 @@
-/**
- * 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, peerPublicKey: Uint8Array, ciphertext: Uint8Array): Promise<Uint8Array>;
-    decapsulateSync(privateKey: Uint8Array, peerPublicKey: Uint8Array, ciphertext: Uint8Array): Uint8Array;
-}
-
-/**
- * Crypto key pair
- */
-export interface ICryptoKeyPair {
-    publicKey : Uint8Array;
-    privateKey : Uint8Array;
-}
-
-/**
- * Crypto encapsulated
- */
-export interface ICryptoEncapsulated {
-    ciphertext: Uint8Array;
-    sharedSecret: Uint8Array;
-}

package/src/utils.ts

@@ -1,290 +0,0 @@
-/**
- * QuarkDash Crypto Utils
- *
- * @git             https://github.com/devsdaddy/quarkdash
- * @version         1.0.0
- * @author          Elijah Rastorguev
- * @build           1000
- * @website         https://dev.to/devsdaddy
- */
-import crypto from "crypto";
-import {Shake256} from "./shake";
-
-/**
- * Crypto Utils Class
- */
-export class QuarkDashUtils {
-    // Protected Constants
-    private static HEXChars : string = '0123456789abcdef';
-
-    /**
-     * Get Shake-256 result async
-     * @param data {Uint8Array} Bytes buffer
-     * @param len {number} Buffer length
-     * @return {Promise<Uint8Array>} Result buffer
-     */
-    public static async shake256(data: Uint8Array, len: number): Promise<Uint8Array> {
-        return await Shake256.hash(data, len);
-    }
-
-    /**
-     * Get Shake-256 result sync
-     * @param data {Uint8Array} Bytes buffer
-     * @param len {number} Buffer length
-     * @return {Uint8Array} Result buffer
-     */
-    public static shake256Sync(data: Uint8Array, len: number): Uint8Array {
-        return Shake256.hashSync(data, len);
-    }
-
-    /**
-     * Concat bytes
-     * @param arrays {Uint8Array|null|undefined} Input arrays for concat
-     * @returns {Uint8Array} Result buffer
-     */
-    public static concatBytes(...arrays: (Uint8Array|null|undefined)[]): Uint8Array {
-        const valid = arrays.filter(a => a != null) as Uint8Array[];
-        const total = valid.reduce((s, a) => s + a.length, 0);
-        const res = new Uint8Array(total);
-        let pos = 0;
-        for (const a of valid) {
-            res.set(a, pos);
-            pos += a.length;
-        }
-        return res;
-    }
-
-    /**
-     * Coerce Array
-     * @param arg {any} Argument
-     * @param copy {any} Copy
-     * @protected
-     */
-    public static coerceArray(arg : any, copy ? : any) : any {
-        let self = this
-
-        // ArrayBuffer view
-        if (arg.buffer && arg.name === 'Uint8Array') {
-            if (copy) {
-                if (arg.slice) {
-                    arg = arg.slice()
-                } else {
-                    arg = Array.prototype.slice.call(arg)
-                }
-            }
-
-            return arg
-        }
-
-        // It's an array; check it is a valid representation of a byte
-        if (Array.isArray(arg)) {
-            if (!self.checkInts(arg)) {
-                throw new Error('Array contains invalid value: ' + arg)
-            }
-
-            return new Uint8Array(arg)
-        }
-
-        // Something else, but behaves like an array (maybe a Buffer? Arguments?)
-        if (self.checkInt(arg.length) && self.checkInts(arg)) {
-            return new Uint8Array(arg)
-        }
-
-        throw new Error('unsupported array-like object')
-    }
-
-    /**
-     * Check if value is int
-     * @param value {any} Value
-     * @returns {boolean}
-     * @protected
-     */
-    public static checkInt(value: any) : boolean {
-        return parseInt(value) === value
-    }
-
-    /**
-     * Check Ints inside array
-     * @param arrayish {any} Array
-     * @returns {boolean} Any value is integer and between 0 and 255
-     * @protected
-     */
-    public static checkInts(arrayish : any) : boolean {
-        let self = this
-        if (!self.checkInt(arrayish.length)) {
-            return false
-        }
-
-        for (let i = 0; i < arrayish.length; i++) {
-            if (!self.checkInt(arrayish[i]) || arrayish[i] < 0 || arrayish[i] > 255) {
-                return false
-            }
-        }
-
-        return true
-    }
-
-    /**
-     * Get random bytes
-     * @param len {number} buffer length
-     * @returns {Uint8Array} Random bytes buffer
-     */
-    public static randomBytes(len: number): Uint8Array {
-        return crypto.getRandomValues(new Uint8Array(len));
-    }
-
-    /**
-     * Convert raw text to bytes array
-     * @param text {string} raw string
-     * @returns {any} bytes array
-     */
-    public static textToBytes(text : string) : any {
-        let self = this
-        let result = [],
-            i = 0
-        text = encodeURI(text)
-        while (i < text.length) {
-            let c = text.charCodeAt(i++)
-
-            // if it is a % sign, encode the following 2 bytes as a hex value
-            if (c === 37) {
-                result.push(parseInt(text.substr(i, 2), 16))
-                i += 2
-
-                // otherwise, just the actual byte
-            } else {
-                result.push(c)
-            }
-        }
-
-        return self.coerceArray(result)
-    }
-
-    /**
-     * Convert bytes array to raw string
-     * @param bytes {number[]|Uint8Array} Bytes array
-     * @returns {string} raw string
-     */
-    public static bytesToText(bytes : number[] | Uint8Array) : string {
-        return new TextDecoder().decode(bytes as Uint8Array);
-
-        let result = [],
-            i = 0
-
-        while (i < bytes.length) {
-            let c = bytes[i]
-
-            if (c < 128) {
-                result.push(String.fromCharCode(c))
-                i++
-            } else if (c > 191 && c < 224) {
-                result.push(String.fromCharCode(((c & 0x1f) << 6) | (bytes[i + 1] & 0x3f)))
-                i += 2
-            } else {
-                result.push(
-                    String.fromCharCode(
-                        ((c & 0x0f) << 12) | ((bytes[i + 1] & 0x3f) << 6) | (bytes[i + 2] & 0x3f),
-                    ),
-                )
-                i += 3
-            }
-        }
-
-        return result.join('')
-    }
-
-    /**
-     * Convert HEX string to bytes array
-     * @param text {string} HEX string
-     * @returns {number[]} bytes array
-     * @constructor
-     */
-    public static HEXToBytes(text : string) : number[] {
-        let result = []
-        for (let i = 0; i < text.length; i += 2) {
-            result.push(parseInt(text.substr(i, 2), 16))
-        }
-
-        return result
-    }
-
-    /**
-     * Convert bytes array to HEX string
-     * @param bytes {number[]|Uint8Array} Bytes array
-     * @returns {string} HEX String
-     */
-    public static bytesToHEX(bytes : number[] | Uint8Array) : string {
-        let self = this
-        let result = []
-        for (let i = 0; i < bytes.length; i++) {
-            let v = bytes[i]
-            result.push(self.HEXChars[(v & 0xf0) >> 4] + self.HEXChars[v & 0x0f])
-        }
-        return result.join('')
-    }
-
-    /**
-     * Constant time equal
-     * @param a {Uint8Array} first buffer
-     * @param b {Uint8Array} second buffer
-     * @returns {boolean} Equal or not
-     */
-    public static constantTimeEqual(a: Uint8Array, b: Uint8Array): boolean {
-        if (a.length !== b.length) return false;
-        let diff = 0;
-        for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];
-        return diff === 0;
-    }
-
-    /**
-     * Secure zero
-     * @param bytes {Uint8Array} bytes buffer
-     */
-    public static secureZero(bytes: Uint8Array): void {
-        for (let i = 0; i < bytes.length; i++) bytes[i] = 0;
-    }
-
-    /**
-     * Read U32 from buffer
-     * @param arr {Uint8Array} buffer
-     * @param off {number} Offset
-     * @returns {number} U32
-     * @private
-     */
-    public static readU32(arr:Uint8Array, off:number): number {
-        return (arr[off]|(arr[off+1]<<8)|(arr[off+2]<<16)|(arr[off+3]<<24))>>>0;
-    }
-
-    /**
-     * Write U32 to buffer
-     * @param v {number} U32
-     * @param arr {Uint8Array} Target buffer
-     * @param off {number} Offset
-     * @private
-     */
-    public static writeU32(v:number, arr:Uint8Array, off:number){
-        arr[off]=v&0xFF; arr[off+1]=(v>>8)&0xFF; arr[off+2]=(v>>16)&0xFF; arr[off+3]=(v>>24)&0xFF;
-    }
-
-    /**
-     * Read Uint32 Value
-     * @param arr {Uint8Array} Bytes buffer
-     * @param off {number} Offset
-     * @returns {number} Uint32 Value
-     */
-    public static readUint32(arr: Uint8Array, off: number): number {
-        return (arr[off] | (arr[off+1]<<8) | (arr[off+2]<<16) | (arr[off+3]<<24)) >>> 0;
-    }
-
-    /**
-     * Read Uint64 Value
-     * @param arr {Uint8Array} Bytes buffer
-     * @param off {number} offset
-     * @returns {bigint} Bigint
-     */
-    public static readUint64(arr: Uint8Array, off: number): bigint {
-        let v = 0n;
-        for (let i = 0; i < 8; i++) v |= BigInt(arr[off+i]) << BigInt(i*8);
-        return v;
-    }
-}

package/tsconfig.cjs.json

@@ -1,7 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "module": "CommonJS",
-    "outDir": "./dist/cjs"
-  }
-}

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "moduleResolution": "node",
-    "lib": ["ES2020", "DOM"],
-    "outDir": "./dist/esm",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": false,
-    "sourceMap": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "tests", "benchmarks"]
-}