@nivinjoseph/n-sec 4.0.6 → 5.0.2

package/package.json

@@ -1,12 +1,12 @@
 {
     "name": "@nivinjoseph/n-sec",
-    "version": "4.0.6",
+    "version": "5.0.2",
     "description": "Security library",
     "main": "./dist/index.js",
     "types": "./dist/index.d.ts",
     "scripts": {
         "ts-compile": "tsc -p .",
-        "ts-lint": "tslint -p . -c tslint.json",
+        "ts-lint": "eslint . --ext .ts",
         "ts-build": "npm run ts-compile && npm run ts-lint",
         "ts-build-dist": "npm run ts-build && tsc -p ./dist",
         "clean-src": "find ./src -name '*.js' -delete -o -name '*.map' -delete",
@@ -32,17 +32,18 @@
     },
     "homepage": "https://github.com/nivinjoseph/n-sec#readme",
     "devDependencies": {
-        "@types/mocha": "^8.2.2",
+        "@types/mocha": "^9.1.1",
         "@types/node": "^14.14.43",
-        "mocha": "^8.3.2",
-        "ts-node": "^9.1.1",
-        "tslint": "^6.1.3",
-        "typescript": "^4.2.4",
-        "typescript-tslint-plugin": "^0.5.5"
+        "@typescript-eslint/eslint-plugin": "^5.25.0",
+        "@typescript-eslint/parser": "^5.25.0",
+        "eslint": "^8.15.0",
+        "mocha": "^10.0.0",
+        "ts-node": "^10.7.0",
+        "typescript": "^4.6.4"
     },
     "dependencies": {
-        "@nivinjoseph/n-defensive": "^1.0.34",
-        "@nivinjoseph/n-exception": "^1.0.20",
-        "@nivinjoseph/n-ext": "^1.1.20"
+        "@nivinjoseph/n-defensive": "^1.0.39",
+        "@nivinjoseph/n-exception": "^1.0.26",
+        "@nivinjoseph/n-ext": "^1.1.35"
     }
 }

package/src/api-security/claim.ts

@@ -1,21 +1,20 @@
 import { given } from "@nivinjoseph/n-defensive";
-import "@nivinjoseph/n-ext";
 
 
 // public
 export class Claim
 {
     private readonly _type: string;
-    private readonly _value: any;
+    private readonly _value: unknown;
     
     
     public get type(): string { return this._type; }
-    public get value(): any { return this._value; }
+    public get value(): unknown { return this._value; }
     
     
-    public constructor(type: string, value: any)
+    public constructor(type: string, value: unknown)
     {
-        given(type, "type").ensureHasValue().ensure(t => !t.isEmptyOrWhiteSpace());
+        given(type, "type").ensureHasValue().ensureIsString();
         
         this._type = type.trim();
         this._value = value;
@@ -24,6 +23,7 @@ export class Claim
     
     public equals(claim: Claim): boolean
     {
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         if (claim == null)
             return false;
 

package/src/api-security/claims-identity.ts

@@ -13,7 +13,7 @@ export class ClaimsIdentity
 
     public constructor(claims: ReadonlyArray<Claim>)
     {
-        given(claims, "claims").ensureHasValue();
+        given(claims, "claims").ensureHasValue().ensureIsArray();
 
         this._claims = [...claims];
     }

package/src/api-security/expired-token-exception.ts

@@ -1,6 +1,5 @@
 import { Exception } from "@nivinjoseph/n-exception";
 import { given } from "@nivinjoseph/n-defensive";
-import "@nivinjoseph/n-ext";
 
 
 // public
@@ -14,7 +13,7 @@ export class ExpiredTokenException extends Exception
     
     public constructor(token: string)
     {
-        given(token, "token").ensureHasValue().ensure(t => !t.isEmptyOrWhiteSpace());
+        given(token, "token").ensureHasValue().ensureIsString();
         token = token.trim();
         super(`Token '${token}' is expired.`);
         this._token = token;

package/src/api-security/invalid-token-exception.ts

@@ -1,6 +1,5 @@
 import { Exception } from "@nivinjoseph/n-exception";
 import { given } from "@nivinjoseph/n-defensive";
-import "@nivinjoseph/n-ext";
 
 
 // public
@@ -16,8 +15,8 @@ export class InvalidTokenException extends Exception
     
     public constructor(token: string, reason: string)
     {
-        given(token, "token").ensureHasValue().ensure(t => !t.isEmptyOrWhiteSpace());
-        given(reason, "reason").ensureHasValue().ensure(t => !t.isEmptyOrWhiteSpace());
+        given(token, "token").ensureHasValue().ensureIsString();
+        given(reason, "reason").ensureHasValue().ensureIsString();
         
         token = token.trim();
         super(`Token '${token}' is invalid because ${reason}.`);

package/src/api-security/json-web-token.ts

@@ -1,7 +1,6 @@
 import { Claim } from "./claim";
 import { InvalidOperationException } from "@nivinjoseph/n-exception";
 import { given } from "@nivinjoseph/n-defensive";
-import "@nivinjoseph/n-ext";
 import { InvalidTokenException } from "./invalid-token-exception";
 import { AlgType } from "./alg-type";
 import { Hmac } from "./../crypto/hmac";
@@ -32,14 +31,13 @@ export class JsonWebToken
     private constructor(issuer: string, algType: AlgType, key: string, isFullKey: boolean, expiry: number,
         claims: Array<Claim>)
     {
-        given(issuer, "issuer").ensureHasValue().ensure(t => !t.isEmptyOrWhiteSpace());
-        given(algType, "algType").ensureHasValue().ensure(t => t === 1 || t === 2);
-        given(key, "key").ensureHasValue().ensure(t => !t.isEmptyOrWhiteSpace());
-        given(isFullKey, "isFullKey").ensureHasValue();
-        given(expiry, "expiry").ensureHasValue();
-        given(claims, "claims")
-            .ensureHasValue()
-            .ensure(t => t.length > 0);
+        given(issuer, "issuer").ensureHasValue().ensureIsString();
+        given(algType, "algType").ensureHasValue().ensureIsEnum(AlgType);
+        given(key, "key").ensureHasValue().ensureIsString();
+        given(isFullKey, "isFullKey").ensureHasValue().ensureIsBoolean();
+        given(expiry, "expiry").ensureHasValue().ensureIsNumber();
+        given(claims, "claims").ensureHasValue().ensureIsArray()
+            .ensure(t => t.isNotEmpty, "cannot be empty");
         
         this._issuer = issuer.trim();
         this._algType = algType;
@@ -49,84 +47,61 @@ export class JsonWebToken
         this._claims = [...claims];
     }
     
-    public async generateToken(): Promise<string>
-    {
-        if (!this._isfullKey)
-            throw new InvalidOperationException("generating token using an instance created from token");    
-        
-        let header: Header = {
-            iss: this._issuer,
-            alg: this._algType,
-            exp: this._expiry
-        };
-        
-        let body: any = {};
-        this._claims.forEach(t => body[t.type] = t.value);
-        
-        let headerAndBody = this.toHex(header) + "." + this.toHex(body);
-        
-        // let signature = this._algType === AlgType.hmac
-        //     ? await Hmac.create(this._key, headerAndBody)
-        //     : await DigitalSignature.sign(this._key, headerAndBody);
-        
-        let signature = await Hmac.create(this._key, headerAndBody);
-        
-        let token = headerAndBody + "." + signature;
-        return token;
-    }
-    
-    
     public static fromClaims(issuer: string, algType: AlgType, key: string, expiry: number,
         claims: Array<Claim>): JsonWebToken
     {
         return new JsonWebToken(issuer, algType, key, true, expiry, claims);
     }
-    
-    public static async fromToken(issuer: string, algType: AlgType, key: string, token: string): Promise<JsonWebToken>
+
+    public static fromToken(issuer: string, algType: AlgType, key: string, token: string): JsonWebToken
     {
-        given(issuer, "issuer").ensureHasValue().ensure(t => !t.isEmptyOrWhiteSpace());
-        given(algType, "algType").ensureHasValue().ensure(t => t === 1 || t === 2);
-        given(key, "key").ensureHasValue().ensure(t => !t.isEmptyOrWhiteSpace());
-        given(token, "token").ensureHasValue().ensure(t => !t.isEmptyOrWhiteSpace());
-        
+        given(issuer, "issuer").ensureHasValue();
+        given(algType, "algType").ensureHasValue().ensureIsEnum(AlgType);
+        given(key, "key").ensureHasValue();
+        given(token, "token").ensureHasValue();
+
         issuer = issuer.trim();
         key = key.trim();
         token = token.trim();
-        
-        let tokenSplitted = token.split(".");
+
+        const tokenSplitted = token.split(".");
         if (tokenSplitted.length !== 3)
             throw new InvalidTokenException(token, "format is incorrect");
-        
-        let headerString = tokenSplitted[0];
-        let bodyString = tokenSplitted[1];
-        let signature = tokenSplitted[2];
-        
-        let header: Header = JsonWebToken.toObject(headerString) as Header;
-        let body: any = JsonWebToken.toObject(bodyString);
-        
+
+        const headerString = tokenSplitted[0];
+        const bodyString = tokenSplitted[1];
+        const signature = tokenSplitted[2];
+
+        const header: Header = JsonWebToken._toObject(headerString) as Header;
+        const body: any = JsonWebToken._toObject(bodyString);
+
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         if (header.iss === undefined || header.iss === null)
             throw new InvalidTokenException(token, "iss was not present");
-        
+
         if (header.iss !== issuer)
             throw new InvalidTokenException(token,
-                `iss was expected to be '${issuer}' but instead was '${header.iss}'`);    
-        
+                `iss was expected to be '${issuer}' but instead was '${header.iss}'`);
+
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         if (header.alg === undefined || header.alg === null)
             throw new InvalidTokenException(token, "alg was not present");
-        
+
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         if (header.alg !== algType)
             throw new InvalidTokenException(token,
-                `alg was expected to be '${algType}' but instead was '${header.alg}'`);    
-        
+                `alg was expected to be '${algType}' but instead was '${header.alg}'`);
+
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         if (header.exp === undefined || header.exp === null)
             throw new InvalidTokenException(token, "exp was not present");
-        
-        if (typeof (header.exp) !== "number")
+
+        if (typeof header.exp !== "number")
             throw new InvalidTokenException(token, `exp value '${header.exp}' is invalid`);
-        
+
         if (header.exp <= Date.now())
             throw new ExpiredTokenException(token);
-        
+
         // if (algType === AlgType.hmac)
         // {
         //     let computedSignature = await Hmac.create(key, headerString + "." + bodyString);
@@ -139,30 +114,56 @@ export class JsonWebToken
         //     if (!verification)
         //         throw new InvalidTokenException(token, "signature could not be verified");  
         // }    
-        
-        let computedSignature = await Hmac.create(key, headerString + "." + bodyString);
+
+        const computedSignature = Hmac.create(key, headerString + "." + bodyString);
         if (computedSignature !== signature)
-            throw new InvalidTokenException(token, "signature could not be verified");    
-        
-        let claims = new Array<Claim>();
-        for (let item in body)
-            claims.push(new Claim(item, body[item]));    
-        
+            throw new InvalidTokenException(token, "signature could not be verified");
+
+        const claims = new Array<Claim>();
+        for (const item in body)
+            claims.push(new Claim(item, body[item]));
+
         return new JsonWebToken(issuer, algType, key, false, header.exp, claims);
     }
+
+    private static _toObject(hex: string): object
+    {
+        const json = Buffer.from(hex.toLowerCase(), "hex").toString("utf8");
+        const obj = JSON.parse(json) as object;
+        return obj;
+    }
     
-    private toHex(obj: object): string
+    public generateToken(): string
     {
-        let json = JSON.stringify(obj);
-        let hex = Buffer.from(json, "utf8").toString("hex");
-        return hex.toUpperCase();
+        if (!this._isfullKey)
+            throw new InvalidOperationException("generating token using an instance created from token");    
+        
+        const header: Header = {
+            iss: this._issuer,
+            alg: this._algType,
+            exp: this._expiry
+        };
+        
+        const body: any = {};
+        this._claims.forEach(t => body[t.type] = t.value);
+        
+        const headerAndBody = this._toHex(header) + "." + this._toHex(body);
+        
+        // let signature = this._algType === AlgType.hmac
+        //     ? await Hmac.create(this._key, headerAndBody)
+        //     : await DigitalSignature.sign(this._key, headerAndBody);
+        
+        const signature = Hmac.create(this._key, headerAndBody);
+        
+        const token = headerAndBody + "." + signature;
+        return token;
     }
     
-    private static toObject(hex: string): object
+    private _toHex(obj: object): string
     {
-        let json = Buffer.from(hex.toLowerCase(), "hex").toString("utf8");
-        let obj = JSON.parse(json);
-        return obj;
+        const json = JSON.stringify(obj);
+        const hex = Buffer.from(json, "utf8").toString("hex");
+        return hex.toUpperCase();
     }
 }
 

package/src/crypto/hash.ts

@@ -1,5 +1,4 @@
 import { given } from "@nivinjoseph/n-defensive";
-import "@nivinjoseph/n-ext";
 import * as Crypto from "crypto";
 
 
@@ -9,26 +8,25 @@ export class Hash
     private constructor() { }
     
 
-    public static create(value: string): Promise<string>
+    public static create(value: string): string
     {
-        given(value, "value").ensureHasValue().ensureIsString().ensure(t => !t.isEmptyOrWhiteSpace());
-        
+        given(value, "value").ensureHasValue().ensureIsString();
         value = value.trim();
         
         const hash = Crypto.createHash("sha512");
         hash.update(value, "utf8");
-        return Promise.resolve(hash.digest("hex").toUpperCase());
+        return hash.digest("hex").toUpperCase();
     }
     
-    public static createUsingSalt(value: string, salt: string): Promise<string>
+    public static createUsingSalt(value: string, salt: string): string
     {
-        given(value, "value").ensureHasValue().ensureIsString().ensure(t => !t.isEmptyOrWhiteSpace());
-        given(salt, "salt").ensureHasValue().ensureIsString().ensure(t => !t.isEmptyOrWhiteSpace());
+        given(value, "value").ensureHasValue().ensureIsString();
+        given(salt, "salt").ensureHasValue().ensureIsString();
 
         value = value.trim();
         salt = salt.trim();
         
-        const reverse = (val: string) =>
+        const reverse = (val: string): string =>
         {
             let rev = "";
             for (let i = 0; i < val.length; i++)

package/src/crypto/hmac.ts

@@ -1,5 +1,4 @@
 import { given } from "@nivinjoseph/n-defensive";
-import "@nivinjoseph/n-ext";
 import * as Crypto from "crypto";
 
 
@@ -9,10 +8,10 @@ export class Hmac
     private constructor() { }
     
     
-    public static create(key: string, value: string): Promise<string>
+    public static create(key: string, value: string): string
     {
-        given(key, "key").ensureHasValue().ensureIsString().ensure(t => !t.isEmptyOrWhiteSpace());
-        given(value, "value").ensureHasValue().ensureIsString().ensure(t => !t.isEmptyOrWhiteSpace());
+        given(key, "key").ensureHasValue().ensureIsString();
+        given(value, "value").ensureHasValue().ensureIsString();
         
         key = key.trim();
         value = value.trim();
@@ -20,6 +19,6 @@ export class Hmac
         const hmac = Crypto.createHmac("sha256", Buffer.from(key, "hex"));
         
         hmac.update(value, "utf8");
-        return Promise.resolve(hmac.digest("hex").toUpperCase());
+        return hmac.digest("hex").toUpperCase();
     }
 }

package/src/crypto/symmetric-encryption.ts

@@ -1,7 +1,6 @@
 import * as Crypto from "crypto";
 import { CryptoException } from "./crypto-exception";
 import { given } from "@nivinjoseph/n-defensive";
-import "@nivinjoseph/n-ext";
 
 
 // public
@@ -29,14 +28,14 @@ export class SymmetricEncryption
     
     public static encrypt(key: string, value: string): Promise<string>
     {
-        given(key, "key").ensureHasValue().ensureIsString().ensure(t => !t.isEmptyOrWhiteSpace());
-        given(value, "value").ensureHasValue().ensureIsString().ensure(t => !t.isEmptyOrWhiteSpace());
-        
-        key = key.trim();
-        value = value.trim();
-        
         return new Promise<string>((resolve, reject) =>
         {
+            given(key, "key").ensureHasValue().ensureIsString();
+            given(value, "value").ensureHasValue().ensureIsString();
+
+            key = key.trim();
+            value = value.trim();
+            
             Crypto.randomBytes(16, (err, buf) =>
             {
                 if (err)
@@ -60,33 +59,24 @@ export class SymmetricEncryption
                 }
             });
         });
-        
-        
     }
     
-    public static decrypt(key: string, value: string): Promise<string>
+    public static decrypt(key: string, value: string): string
     {
-        given(key, "key").ensureHasValue().ensureIsString().ensure(t => !t.isEmptyOrWhiteSpace());
-        given(value, "value").ensureHasValue().ensureIsString().ensure(t => !t.isEmptyOrWhiteSpace());
+        given(key, "key").ensureHasValue().ensureIsString();
+        given(value, "value").ensureHasValue().ensureIsString();
 
         key = key.trim();
         value = value.trim();
         
-        try 
-        {
-            const splitted = value.split(".");
-            if (splitted.length !== 2)
-                throw new CryptoException("Invalid value.");
+        const splitted = value.split(".");
+        if (splitted.length !== 2)
+            throw new CryptoException("Invalid value.");
 
-            const iv = Buffer.from(splitted[1], "hex");
-            const deCipher = Crypto.createDecipheriv("AES-256-CBC", Buffer.from(key, "hex"), iv);
-            let decrypted = deCipher.update(splitted[0], "hex", "utf8");
-            decrypted += deCipher.final("utf8");
-            return Promise.resolve(decrypted);
-        }
-        catch (error)
-        {
-            return Promise.reject(error);
-        }
+        const iv = Buffer.from(splitted[1], "hex");
+        const deCipher = Crypto.createDecipheriv("AES-256-CBC", Buffer.from(key, "hex"), iv);
+        let decrypted = deCipher.update(splitted[0], "hex", "utf8");
+        decrypted += deCipher.final("utf8");
+        return decrypted;
     }
 }

package/test/hash.test.ts

@@ -2,34 +2,34 @@ import * as Assert from "assert";
 import { Hash } from "./../src/index";
 import "@nivinjoseph/n-ext";
 // import { CryptoException } from "./../src/crypto-exception";
-import "@nivinjoseph/n-ext";
 
 suite("Hash", () =>
 {
     suite("create", () =>
     {
-        test("must return a string value that is not null, empty, whitespace or same as input when called with a valid input", async () =>
+        test("must return a string value that is not null, empty, whitespace or same as input when called with a valid input", () =>
         {
-            let input = "hello world";
-            let hash = await Hash.create(input);
+            const input = "hello world";
+            const hash = Hash.create(input);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             Assert.ok(hash !== null && !hash.isEmptyOrWhiteSpace());
             Assert.notStrictEqual(hash, input);
         });
         
-        test("multiple invocations with the same input must return the same output", async () =>
+        test("multiple invocations with the same input must return the same output", () =>
         {
-            let input = "hello world";
-            let hash1 = await Hash.create(input);
-            let hash2 = await Hash.create(input);
+            const input = "hello world";
+            const hash1 = Hash.create(input);
+            const hash2 = Hash.create(input);
             Assert.strictEqual(hash1, hash2);
         });
         
-        test("multiple invocations with the different inputs must return different outputs", async () =>
+        test("multiple invocations with the different inputs must return different outputs", () =>
         {
-            let input1 = "hello world";
-            let hash1 = await Hash.create(input1);
-            let input2 = "goodbye world";
-            let hash2 = await Hash.create(input2);
+            const input1 = "hello world";
+            const hash1 = Hash.create(input1);
+            const input2 = "goodbye world";
+            const hash2 = Hash.create(input2);
             Assert.notStrictEqual(hash1, hash2);
         });
         
@@ -92,58 +92,59 @@ suite("Hash", () =>
     
     suite("createUsingSalt", () =>
     {
-        test("must return a string value that is not null, empty, whitespace or same as input or salt when called with a valid input and salt", async () =>
+        test("must return a string value that is not null, empty, whitespace or same as input or salt when called with a valid input and salt", () =>
         {
-            let input = "hello world";
-            let salt = "salt";
-            let hash = await Hash.createUsingSalt(input, salt);
+            const input = "hello world";
+            const salt = "salt";
+            const hash = Hash.createUsingSalt(input, salt);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             Assert.ok(hash !== null && !hash.isEmptyOrWhiteSpace());
             Assert.notStrictEqual(hash, input);
             Assert.notStrictEqual(hash, salt);
         });
 
-        test("multiple invocations with the same input and salt must return the same output", async () =>
+        test("multiple invocations with the same input and salt must return the same output", () =>
         {
-            let input = "hello world";
-            let salt = "salt";
-            let hash1 = await Hash.createUsingSalt(input, salt);
-            let hash2 = await Hash.createUsingSalt(input, salt);
+            const input = "hello world";
+            const salt = "salt";
+            const hash1 = Hash.createUsingSalt(input, salt);
+            const hash2 = Hash.createUsingSalt(input, salt);
             Assert.strictEqual(hash1, hash2);
         });
 
-        test("multiple invocations with different inputs and different salts must return different outputs", async () =>
+        test("multiple invocations with different inputs and different salts must return different outputs", () =>
         {
-            let input1 = "hello world";
-            let salt1 = "salt-1";
-            let hash1 = await Hash.createUsingSalt(input1, salt1);
+            const input1 = "hello world";
+            const salt1 = "salt-1";
+            const hash1 = Hash.createUsingSalt(input1, salt1);
             
-            let input2 = "goodbye world";
-            let salt2 = "salt-2";
-            let hash2 = await Hash.createUsingSalt(input2, salt2);
+            const input2 = "goodbye world";
+            const salt2 = "salt-2";
+            const hash2 = Hash.createUsingSalt(input2, salt2);
             
             Assert.notStrictEqual(hash1, hash2);
         });
         
-        test("multiple invocations with different inputs and the same salt must return different outputs", async () =>
+        test("multiple invocations with different inputs and the same salt must return different outputs", () =>
         {
-            let input1 = "hello world";
-            let salt1 = "salt-1";
-            let hash1 = await Hash.createUsingSalt(input1, salt1);
+            const input1 = "hello world";
+            const salt1 = "salt-1";
+            const hash1 = Hash.createUsingSalt(input1, salt1);
 
-            let input2 = "goodbye world";
-            let hash2 = await Hash.createUsingSalt(input2, salt1);
+            const input2 = "goodbye world";
+            const hash2 = Hash.createUsingSalt(input2, salt1);
 
             Assert.notStrictEqual(hash1, hash2);
         });
         
-        test("multiple invocations with the same input and different salts must return different outputs", async () =>
+        test("multiple invocations with the same input and different salts must return different outputs", () =>
         {
-            let input = "hello world";
-            let salt1 = "salt-1";
-            let hash1 = await Hash.createUsingSalt(input, salt1);
+            const input = "hello world";
+            const salt1 = "salt-1";
+            const hash1 = Hash.createUsingSalt(input, salt1);
 
-            let salt2 = "salt-2";
-            let hash2 = await Hash.createUsingSalt(input, salt2);
+            const salt2 = "salt-2";
+            const hash2 = Hash.createUsingSalt(input, salt2);
 
             Assert.notStrictEqual(hash1, hash2);
         });