quarkdash 1.0.0

package/src/ringlwe.ts

@@ -0,0 +1,271 @@
+/**
+ * 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 Required Modules */
+import {ICryptoEncapsulated, ICryptoKeyPair, IKeyExchange} from "./types";
+import {QuarkDashUtils} from "./utils";
+
+/**
+ * Ring-LWE based key exchange implementation
+ */
+export class QuarkDashKeyExchange implements IKeyExchange {
+    // Ring-LWE Constants
+    private static readonly N = 256;
+    private static readonly Q = 7681n;
+    private static readonly ROOT = 7n;
+    private static readonly INV_N = this.modInverse(BigInt(this.N), this.Q);
+
+    /**
+     * Get small polygon
+     * @returns {bigint[]} Small polygon
+     * @private
+     */
+    private static smallPoly(): bigint[] {
+        const poly = new Array<bigint>(this.N);
+        for (let i=0;i<this.N;i++) {
+            const r = Math.random();
+            if (r<0.33) poly[i] = -1n;
+            else if (r<0.66) poly[i] = 0n;
+            else poly[i] = 1n;
+        }
+        return poly;
+    }
+
+    /**
+     * Uniform polygon
+     * @returns {bigint[]}
+     * @private
+     */
+    private static uniformPoly(): bigint[] {
+        const poly = new Array<bigint>(this.N);
+        const bytes = QuarkDashUtils.randomBytes(this.N*2);
+        for(let i=0;i<this.N;i++) {
+            const val = (bytes[2*i] | (bytes[2*i+1]<<8)) % Number(this.Q);
+            poly[i] = BigInt(val);
+        }
+        return poly;
+    }
+
+    /**
+     * NTT Operation
+     * @param poly {bigint[]} Polygon
+     * @private
+     */
+    private static ntt(poly: bigint[]): bigint[] {
+        const res = [...poly];
+        let len = 2;
+        while(len <= this.N) {
+            const wlen = this.powMod(this.ROOT, BigInt(this.N/len), this.Q);
+            for(let i=0;i<this.N;i+=len){
+                let w=1n;
+                for(let j=0;j<len/2;j++){
+                    const u=res[i+j];
+                    const v=(res[i+j+len/2]*w)%this.Q;
+                    res[i+j]=(u+v)%this.Q;
+                    res[i+j+len/2]=(u-v+this.Q)%this.Q;
+                    w=(w*wlen)%this.Q;
+                }
+            }
+            len<<=1;
+        }
+        return res;
+    }
+
+    /**
+     * Inverse NTT
+     * @param poly {bigint[]} Polygon
+     * @private
+     */
+    private static invNTT(poly: bigint[]): bigint[] {
+        const res = [...poly];
+        let len = this.N;
+        while(len >= 2){
+            const wlen = this.powMod(this.ROOT, BigInt(this.N/len), this.Q);
+            for(let i=0;i<this.N;i+=len){
+                let w=1n;
+                for(let j=0;j<len/2;j++){
+                    const u=res[i+j];
+                    const v=res[i+j+len/2];
+                    res[i+j]=(u+v)%this.Q;
+                    res[i+j+len/2]=((u-v+this.Q)*w)%this.Q;
+                    w=(w*wlen)%this.Q;
+                }
+            }
+            len>>=1;
+        }
+        for(let i=0;i<this.N;i++) res[i]=(res[i]*this.INV_N)%this.Q;
+        return res;
+    }
+
+    /**
+     * Multiply
+     * @param a {bigint[]} Polygon
+     * @param b {bigint[]} Polygon
+     * @returns {bigint[]} Multiplied polygons
+     */
+    public static multiply(a: bigint[], b: bigint[]): bigint[] {
+        const aNTT = this.ntt(a);
+        const bNTT = this.ntt(b);
+        const prod = new Array<bigint>(this.N);
+        for(let i=0;i<this.N;i++) prod[i]=(aNTT[i]*bNTT[i])%this.Q;
+        return this.invNTT(prod);
+    }
+
+    /**
+     * Serialize polygon
+     * @param poly {bigint[]} Polygon
+     * @returns {Uint8Array} Polygon buffer
+     * @private
+     */
+    private static serializePoly(poly: bigint[]): Uint8Array {
+        const bytes = new Uint8Array(this.N*2);
+        for(let i=0;i<this.N;i++) {
+            const val = Number(poly[i]);
+            bytes[2*i]=val&0xFF;
+            bytes[2*i+1]=(val>>8)&0xFF;
+        }
+        return bytes;
+    }
+
+    /**
+     * Deserialize Polygon
+     * @param bytes {Uint8Array} Polygon buffer
+     * @returns {bigint[]} Polygon
+     * @private
+     */
+    private static deserializePoly(bytes: Uint8Array): bigint[] {
+        const poly = new Array<bigint>(this.N);
+        for(let i=0;i<this.N;i++) {
+            const val = bytes[2*i] | (bytes[2*i+1]<<8);
+            poly[i]=BigInt(val);
+        }
+        return poly;
+    }
+
+    /**
+     * Round to bits
+     * @param poly {bigint[]} Polygon
+     * @returns {Uint8Array} rounded buffer
+     * @private
+     */
+    private static roundToBits(poly: bigint[]): Uint8Array {
+        const result = new Uint8Array(32);
+        for(let i=0;i<this.N;i++) {
+            const bit = (Number(poly[i]) > Number(this.Q)/2) ? 1 : 0;
+            if(bit) result[i>>3] |= (1<<(i&7));
+        }
+        return result;
+    }
+
+    /**
+     * Modular exponentiation
+     * @param base {bigint} Base
+     * @param exp {bigint} exponential
+     * @param mod {bigint} module
+     * @returns {bigint} Result of modular exponentiation
+     * @private
+     */
+    private static powMod(base: bigint, exp: bigint, mod: bigint): bigint {
+        let result=1n, b=base%mod, e=exp;
+        while(e>0n){ if(e&1n) result=(result*b)%mod; b=(b*b)%mod; e>>=1n; }
+        return result;
+    }
+
+    /**
+     * Modular inverse
+     * @param a {bigint}
+     * @param m {bigint}
+     * @returns {bigint} Inversion result
+     * @private
+     */
+    private static modInverse(a: bigint, m: bigint): bigint {
+        let [old_r,r]=[a,m], [old_s,s]=[1n,0n];
+        while(r!==0n){ const q=old_r/r; [old_r,r]=[r,old_r-q*r]; [old_s,s]=[s,old_s-q*s]; }
+        return (old_s%m+m)%m;
+    }
+
+    /**
+     * Generate crypto key pair async
+     * @returns {ICryptoKeyPair} Crypto key pair
+     * TODO: GPU Calculations
+     */
+    public async generateKeyPair(): Promise<ICryptoKeyPair> {
+        return this.generateKeyPairSync();
+    }
+
+    /**
+     * Generate crypto key pair sync
+     * @returns {ICryptoKeyPair} Crypto key pair
+     */
+    public generateKeyPairSync(): ICryptoKeyPair {
+        const a = QuarkDashKeyExchange.uniformPoly();
+        const s = QuarkDashKeyExchange.smallPoly();
+        const e = QuarkDashKeyExchange.smallPoly();
+        const as = QuarkDashKeyExchange.multiply(a,s);
+        const b = new Array<bigint>(QuarkDashKeyExchange.N);
+        for(let i=0; i<QuarkDashKeyExchange.N; i++) b[i] = (as[i]+e[i]) % QuarkDashKeyExchange.Q;
+        const pub = QuarkDashUtils.concatBytes(QuarkDashKeyExchange.serializePoly(a), QuarkDashKeyExchange.serializePoly(b));
+        const priv = QuarkDashKeyExchange.serializePoly(s);
+        return { publicKey: pub, privateKey: priv };
+    }
+
+    /**
+     * Encapsulate async
+     * @param publicKey {Uint8Array} Public key buffer
+     * @returns {Promise<ICryptoEncapsulated>} Encapsulated data
+     * TODO: GPU Calculations
+     */
+    public async encapsulate(publicKey: Uint8Array): Promise<ICryptoEncapsulated> {
+        return this.encapsulateSync(publicKey);
+    }
+
+    /**
+     * Encapsulate sync
+     * @param publicKey {Uint8Array} Public key buffer
+     * @returns {ICryptoEncapsulated} Encapsulated data
+     */
+    public encapsulateSync(publicKey: Uint8Array): ICryptoEncapsulated {
+        const aBytes = publicKey.slice(0, QuarkDashKeyExchange.N*2);
+        const bBytes = publicKey.slice(QuarkDashKeyExchange.N*2);
+        const a = QuarkDashKeyExchange.deserializePoly(aBytes);
+        const b = QuarkDashKeyExchange.deserializePoly(bBytes);
+        const sp = QuarkDashKeyExchange.smallPoly();
+        const ep = QuarkDashKeyExchange.smallPoly();
+        const uArr = QuarkDashKeyExchange.multiply(a,sp);
+        for(let i=0; i<QuarkDashKeyExchange.N; i++) uArr[i] = (uArr[i]+ep[i]) % QuarkDashKeyExchange.Q;
+        const w = QuarkDashKeyExchange.multiply(b,sp);
+        const shared = QuarkDashKeyExchange.roundToBits(w);
+        const ciphertext = QuarkDashKeyExchange.serializePoly(uArr);
+        return { ciphertext, sharedSecret: shared };
+    }
+
+    /**
+     * Decapsulate async
+     * @param privateKey {Uint8Array} Private key buffer
+     * @param ciphertext {Uint8Array} Cipher text buffer
+     * @returns {Promise<Uint8Array>} Buffer data
+     * TODO: GPU Calculations
+     */
+    public async decapsulate(privateKey: Uint8Array, ciphertext: Uint8Array): Promise<Uint8Array> {
+        return this.decapsulateSync(privateKey, ciphertext);
+    }
+
+    /**
+     * Decapsulate sync
+     * @param privateKey {Uint8Array} Private key buffer
+     * @param ciphertext {Uint8Array} Cipher text buffer
+     * @returns {Uint8Array} Buffer data
+     */
+    public decapsulateSync(privateKey: Uint8Array, ciphertext: Uint8Array): Uint8Array {
+        const s = QuarkDashKeyExchange.deserializePoly(privateKey);
+        const u = QuarkDashKeyExchange.deserializePoly(ciphertext);
+        const w = QuarkDashKeyExchange.multiply(u,s);
+        return QuarkDashKeyExchange.roundToBits(w);
+    }
+}

package/src/types.ts

@@ -0,0 +1,75 @@
+/**
+ * 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;
+}

package/src/utils.ts

@@ -0,0 +1,343 @@
+/**
+ * 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";
+
+/**
+ * Crypto Utils Class
+ */
+export class QuarkDashUtils {
+    // Protected Constants
+    private static HEXChars : string = '0123456789abcdef';
+
+    /**
+     * Run SHA256 async
+     * @param data {Uint8Array} Bytes buffer
+     * @return {Promise<Uint8Array>} Result
+     */
+    public static async sha256(data: Uint8Array): Promise<Uint8Array> {
+        const hash = await crypto.subtle.digest('SHA-256', data);
+        return new Uint8Array(hash);
+    }
+
+    /**
+     * Run SHA256 sync
+     * @param data {Uint8Array} Bytes buffer
+     * @return {Uint8Array} Result
+     */
+    public static sha256Sync(data: Uint8Array): Uint8Array {
+        if (typeof require !== 'undefined') {
+            const crypto = require('crypto');
+            const hash = crypto.createHash('sha256').update(data).digest();
+            return new Uint8Array(hash);
+        }
+        throw new Error('Synchronous SHA256 not available in browser');
+    }
+
+    /**
+     * 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> {
+        const result = new Uint8Array(len);
+        let counter = 0;
+        let offset = 0;
+        while (offset < len) {
+            const cnt = new Uint8Array(4);
+            cnt[0] = (counter >> 24) & 0xFF;
+            cnt[1] = (counter >> 16) & 0xFF;
+            cnt[2] = (counter >> 8) & 0xFF;
+            cnt[3] = counter & 0xFF;
+            const hash = await this.sha256(this.concatBytes(data, cnt));
+            const take = Math.min(hash.length, len - offset);
+            result.set(hash.slice(0, take), offset);
+            offset += take;
+            counter++;
+        }
+        return result;
+    }
+
+    /**
+     * 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 {
+        const result = new Uint8Array(len);
+        let counter = 0;
+        let offset = 0;
+        while (offset < len) {
+            const cnt = new Uint8Array(4);
+            cnt[0] = (counter >> 24) & 0xFF;
+            cnt[1] = (counter >> 16) & 0xFF;
+            cnt[2] = (counter >> 8) & 0xFF;
+            cnt[3] = counter & 0xFF;
+            const hash = this.sha256Sync(this.concatBytes(data, cnt));
+            const take = Math.min(hash.length, len - offset);
+            result.set(hash.slice(0, take), offset);
+            offset += take;
+            counter++;
+        }
+        return result;
+    }
+
+    /**
+     * 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

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