added cryptographic functions to slopes

Author: Collin K. Cusce

package-lock.json

@@ -29,6 +29,7 @@
     "@types/bn.js": "^4.11.6",
     "@types/create-hash": "^1.2.2",
     "@types/jest": "^24.0.25",
+    "@types/libsodium-wrappers": "^0.7.7",
     "@types/node": "^12.12.24",
     "clean-webpack-plugin": "^3.0.0",
     "expose-loader": "^0.7.5",
@@ -58,7 +59,7 @@
     "buffer": "^5.4.3",
     "create-hash": "^1.2.0",
     "elliptic": "^6.5.2",
-    "libsodium": "^0.7.6",
+    "libsodium-wrappers": "^0.7.6",
     "secp256k1": "^4.0.0",
     "store2": "^2.10.0"
   }

package.json

@@ -0,0 +1,179 @@
+/**
+ * @module Utils
+ */
+import { Buffer } from "buffer/";
+import libsodiumWrapper from 'libsodium-wrappers';
+import createHash from "create-hash";
+
+/**
+ * Helper utility for encryption and password hashing, browser-safe.
+ * Encryption is using XChaCha20Poly1305 with a random public nonce.
+ */
+export class CryptoHelpers {
+
+    protected memlimit:number = 524288000;
+    protected opslimit:number = 3;
+    protected libsodium:typeof libsodiumWrapper;
+
+    /**
+     * Retrieves the memory limit that can be spent generating password-safe hashes.
+     */
+    getMemoryLimit():number {
+        return this.memlimit;
+    }
+
+    /**
+     * Sets the memory limit that can be spent generating password-safe hashes.
+     * 
+     * @param memlimit The number representing the memory limit, in bytes, that the password-safe algorithm can use
+     */
+    setMemoryLimit(memlimit:number) {
+        this.memlimit = memlimit;
+    }
+
+    /**
+     * Retrieves the cpu limit that can be spent generating password-safe hashes.
+     */
+    getOpsLimit():number {
+        return this.opslimit;
+    }
+
+    /**
+     * Retrieves the cpu limit that can be spent generating password-safe hashes.
+     * 
+     * @param opslimit The number representing the cpu limit that the password-safe algorithm can use. Lower is faster.
+     */
+    setOpsLimit(opslimit:number) {
+        this.opslimit = opslimit;
+    }
+
+    /**
+     * @ignore
+     */
+    protected async sodium(): Promise<typeof libsodiumWrapper> {
+        if(!this.libsodium) this.libsodium = (libsodiumWrapper as typeof libsodiumWrapper);
+        await this.libsodium.ready;
+      
+        return this.libsodium;
+      }
+      
+
+    /**
+     * Internal-intended function for cleaning passwords.
+     * 
+     * @param password 
+     * @param salt 
+     */
+    async _pwcleaner(password:string,salt:Uint8Array):Promise<Uint8Array> {
+        let sodium:typeof libsodiumWrapper = await this.sodium();
+        let pw:Buffer = Buffer.from(password, 'utf8');
+        let slt:Buffer;
+        if(typeof salt === "undefined"){
+            slt = Buffer.from(sodium.randombytes_buf(sodium.crypto_pwhash_SALTBYTES));
+        } else {
+            slt = Buffer.from(salt);
+        }
+        let sha:Buffer = this.sha256(Buffer.concat([pw, slt]));
+        let pwsalted:Uint8Array = Uint8Array.from(sha);
+        return sodium.crypto_generichash(sodium.crypto_aead_xchacha20poly1305_ietf_KEYBYTES, pwsalted);
+    }
+
+    /**
+     * A SHA256 helper function.
+     * 
+     * @param message The message to hash
+     * 
+     * @returns A {@link https://github.com/feross/buffer|Buffer} containing the SHA256 hash of the message
+     */
+    sha256(message:string | Buffer | Uint8Array):Buffer {
+        let buff:Buffer;
+        if(typeof message === "string"){
+            buff = Buffer.from(message, "utf8");
+        } else {
+            buff = Buffer.from(message);
+        }
+        return Buffer.from(createHash('sha256').update(buff).digest()); // ensures correct Buffer class is used
+    }
+
+    /**
+     * Generates a randomized {@link https://github.com/feross/buffer|Buffer} to be used as a salt
+     */
+    async makeSalt():Promise<Buffer> {
+        let sodium:typeof libsodiumWrapper = await this.sodium();
+        return Buffer.from(sodium.randombytes_buf(sodium.crypto_pwhash_SALTBYTES));
+    }
+
+    /**
+     * Produces a password-safe hash.
+     * 
+     * @param password A string for the password 
+     * @param salt An optional {@link https://github.com/feross/buffer|Buffer} containing a salt used in the password hash
+     * 
+     * @returns An object containing the "salt" and the "hash" produced by this function, both as {@link https://github.com/feross/buffer|Buffer}.
+     */
+    async pwhash(password:string, salt:Buffer):Promise< {salt:Buffer; hash:Buffer} > {
+        let sodium:typeof libsodiumWrapper = await this.sodium();
+
+        let slt:Uint8Array;
+        if(typeof salt === "undefined"){
+            slt = await this.makeSalt();
+        } else {
+            slt = Uint8Array.from(salt);
+        }
+        let hash:Uint8Array = sodium.crypto_pwhash(32, password, slt, this.opslimit, this.memlimit, sodium.crypto_pwhash_ALG_DEFAULT);
+        return {salt:Buffer.from(slt), hash:Buffer.from(hash)};
+    }
+
+    /**
+     * Encrypts plaintext with the provided password using XChaCha20Poly1305.
+     * 
+     * @param password A string for the password
+     * @param plaintext The plaintext to encrypt
+     * @param salt An optional {@link https://github.com/feross/buffer|Buffer} for the salt to use in the encryption process
+     * 
+     * @returns An object containing the "salt", "nonce", and "ciphertext", all as {@link https://github.com/feross/buffer|Buffer}.
+     */
+    async encrypt(password:string, plaintext:Buffer | string, salt:Buffer = undefined):Promise< {salt:Buffer; nonce:Buffer; ciphertext:Buffer} > {
+        let sodium:typeof libsodiumWrapper = await this.sodium();
+        let slt:Uint8Array;
+        if(typeof salt === "undefined"){
+            slt = await this.makeSalt();
+        } else {
+            slt = Uint8Array.from(salt);
+        }
+
+        let pt:Uint8Array;
+        if(plaintext instanceof Buffer){
+            pt = Uint8Array.from(plaintext);
+        } else {
+            pt = Uint8Array.from(Buffer.from(plaintext, "utf8"));
+        }
+        let nonce:Uint8Array = sodium.randombytes_buf(sodium.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES);
+        let pkey:Uint8Array = await this._pwcleaner(password, slt);
+        let ciphertext:Uint8Array = sodium.crypto_aead_xchacha20poly1305_ietf_encrypt(pt, "AVALANCHE", null, nonce, pkey);
+    
+        return {
+            salt:Buffer.from(slt), 
+            nonce:Buffer.from(nonce), 
+            ciphertext:Buffer.from(ciphertext)
+        }
+
+    }
+
+    /**
+     * Decrypts ciphertext with the provided password, nonce, ans salt. 
+     * 
+     * @param password A string for the password
+     * @param ciphertext A {@link https://github.com/feross/buffer|Buffer} for the ciphertext
+     * @param salt A {@link https://github.com/feross/buffer|Buffer} for the salt
+     * @param nonce A {@link https://github.com/feross/buffer|Buffer} for the nonce
+     */
+    async decrypt(password:string, ciphertext:Buffer, salt:Buffer, nonce:Buffer):Promise<Buffer> {
+        let sodium:typeof libsodiumWrapper = await this.sodium();
+        let pkey:Uint8Array = await this._pwcleaner(password, Uint8Array.from(salt));
+        let pt:Uint8Array = sodium.crypto_aead_xchacha20poly1305_ietf_decrypt(null, Uint8Array.from(ciphertext), "AVALANCHE", Uint8Array.from(nonce), pkey);
+        return Buffer.from(pt);
+    } 
+
+    constructor() {}
+}

src/utils/crypto.ts

@@ -0,0 +1,44 @@
+import { Buffer } from "buffer/";
+import {CryptoHelpers} from "src/utils/crypto";
+
+describe("CryptoHelpers", () => {
+    test("instantiation and vars", () => {
+        let ch:CryptoHelpers = new CryptoHelpers();
+        
+        let ml = ch.getMemoryLimit();
+        ch.setMemoryLimit(400);
+        let mlupdated = ch.getMemoryLimit();
+        
+        expect(ml).not.toBe(mlupdated);
+
+        let ol = ch.getOpsLimit();
+        ch.setOpsLimit(1);
+        let olupdated = ch.getOpsLimit();
+
+        expect(ol).not.toBe(olupdated);
+    });
+    test("encrypt and decrypt", async () => {
+        let pw:string = "password12345";
+        let ch:CryptoHelpers = new CryptoHelpers();
+
+        let msg:string = "I am the very model of a modern major general";
+        let resp:{salt: Buffer; nonce: Buffer; ciphertext: Buffer} = await ch.encrypt(pw, msg);
+        let pt1:Buffer = await ch.decrypt(pw, resp.ciphertext, resp.salt, resp.nonce);
+        expect(pt1.toString("utf8")).toBe(msg);
+
+        let resp2:{salt: Buffer; nonce: Buffer; ciphertext: Buffer} = await ch.encrypt(pw, msg, resp.salt);
+        let pt2:Buffer = await ch.decrypt(pw, resp2.ciphertext, resp2.salt, resp2.nonce);
+        expect(pt2.toString("utf8")).toBe(msg);
+    });
+
+    test("pwhash", async () => {
+        let pw:string = "password12345";
+        let ch:CryptoHelpers = new CryptoHelpers();
+        let salt:Buffer = await ch.makeSalt();
+
+        let ph1:{salt: Buffer; hash: Buffer} = await ch.pwhash(pw, salt);
+        
+        let sha:Buffer = Buffer.from(await ch._pwcleaner(pw, salt));
+        expect(sha.toString("hex")).not.toBe(ph1.hash.toString("hex"))
+    });
+});