@nivinjoseph/n-sec 4.0.6 → 5.0.2

package/test/hmac.test.ts

@@ -9,9 +9,10 @@ suite("Hmac", () =>
     {
         test("should return string value that is not null, empty, whitespace or same as the key or input", async () =>
         {
-            let key = await SymmetricEncryption.generateKey();
-            let value = "hello world";
-            let hmac = await Hmac.create(key, value);
+            const key = await SymmetricEncryption.generateKey();
+            const value = "hello world";
+            const hmac = Hmac.create(key, value);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             Assert.ok(hmac !== null && !hmac.isEmptyOrWhiteSpace());
             Assert.notStrictEqual(hmac, key);
             Assert.notStrictEqual(hmac, value);
@@ -19,42 +20,42 @@ suite("Hmac", () =>
         
         test("multiple invocations with the same key and value must return the same output", async () =>
         {
-            let key = await SymmetricEncryption.generateKey();
-            let value = "hello world";
-            let hmac1 = await Hmac.create(key, value);
-            let hmac2 = await Hmac.create(key, value);
+            const key = await SymmetricEncryption.generateKey();
+            const value = "hello world";
+            const hmac1 = Hmac.create(key, value);
+            const hmac2 = Hmac.create(key, value);
             Assert.strictEqual(hmac1, hmac2);
         });
         
         test("multiple invocations with different keys and different values must return different outputs", async () =>
         {
-            let key1 = await SymmetricEncryption.generateKey();
-            let value1 = "hello world";
-            let hmac1 = await Hmac.create(key1, value1);
+            const key1 = await SymmetricEncryption.generateKey();
+            const value1 = "hello world";
+            const hmac1 = Hmac.create(key1, value1);
             
-            let key2 = await SymmetricEncryption.generateKey();
-            let value2 = "goodbye world";
-            let hmac2 = await Hmac.create(key2, value2);
+            const key2 = await SymmetricEncryption.generateKey();
+            const value2 = "goodbye world";
+            const hmac2 = Hmac.create(key2, value2);
             Assert.notStrictEqual(hmac1, hmac2);
         });
         
         test("multiple invocations with the same key and different values must return different outputs", async () =>
         {
-            let key = await SymmetricEncryption.generateKey();
-            let value1 = "hello world";
-            let value2 = "goodbye world";
-            let hmac1 = await Hmac.create(key, value1);
-            let hmac2 = await Hmac.create(key, value2);
+            const key = await SymmetricEncryption.generateKey();
+            const value1 = "hello world";
+            const value2 = "goodbye world";
+            const hmac1 = Hmac.create(key, value1);
+            const hmac2 = Hmac.create(key, value2);
             Assert.notStrictEqual(hmac1, hmac2);
         });
         
         test("multiple invocations with different keys and the same value must return different outputs", async () =>
         {
-            let key1 = await SymmetricEncryption.generateKey();
-            let key2 = await SymmetricEncryption.generateKey();
-            let value = "hello world";
-            let hmac1 = await Hmac.create(key1, value);
-            let hmac2 = await Hmac.create(key2, value);
+            const key1 = await SymmetricEncryption.generateKey();
+            const key2 = await SymmetricEncryption.generateKey();
+            const value = "hello world";
+            const hmac1 = Hmac.create(key1, value);
+            const hmac2 = Hmac.create(key2, value);
             Assert.notStrictEqual(hmac1, hmac2);
         });
         

package/test/json-web-token.test.ts

@@ -14,11 +14,12 @@ suite("Json Web Token ", () =>
     
         test("should successfully create a token using hmac with one claim", async () =>
         {
-            let claim = new Claim("this_claim", "ThisValue");
-            let key = await SymmetricEncryption.generateKey();
-            let time = Date.now();
-            let token = await JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim]).generateToken();
-            let jwt = await JsonWebToken.fromToken("issuer1", 1, key, token);
+            const claim = new Claim("this_claim", "ThisValue");
+            const key = await SymmetricEncryption.generateKey();
+            const time = Date.now();
+            const token = JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim]).generateToken();
+            const jwt = JsonWebToken.fromToken("issuer1", 1, key, token);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             Assert.ok(jwt !== null || jwt !== undefined);
             Assert.strictEqual(jwt.issuer, "issuer1");
             Assert.strictEqual(jwt.algType, 1);
@@ -28,12 +29,13 @@ suite("Json Web Token ", () =>
 
         test("should successfully create a token using hmac with 2 claims", async () =>
         {
-            let claim1 = new Claim("this_claim", "ThisValue");
-            let claim2 = new Claim("that_claim", "ThatValue");
-            let key = await SymmetricEncryption.generateKey();
-            let time = Date.now();
-            let token = await JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim1, claim2]).generateToken();
-            let jwt = await JsonWebToken.fromToken("issuer1", 1, key, token);
+            const claim1 = new Claim("this_claim", "ThisValue");
+            const claim2 = new Claim("that_claim", "ThatValue");
+            const key = await SymmetricEncryption.generateKey();
+            const time = Date.now();
+            const token = JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim1, claim2]).generateToken();
+            const jwt = JsonWebToken.fromToken("issuer1", 1, key, token);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             Assert.ok(jwt !== null || jwt !== undefined);
             Assert.strictEqual(jwt.issuer, "issuer1");
             Assert.strictEqual(jwt.algType, 1);
@@ -43,12 +45,13 @@ suite("Json Web Token ", () =>
 
         test("should successfully create a token using hmac with 2 claims", async () =>
         {
-            let claim1 = new Claim("this_claim", "ThisValue");
-            let claim2 = new Claim("that_claim", "ThatValue");
-            let key = await SymmetricEncryption.generateKey();
-            let time = Date.now();
-            let token = await JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim1, claim2]).generateToken();
-            let jwt = await JsonWebToken.fromToken("issuer1", 1, key, token);
+            const claim1 = new Claim("this_claim", "ThisValue");
+            const claim2 = new Claim("that_claim", "ThatValue");
+            const key = await SymmetricEncryption.generateKey();
+            const time = Date.now();
+            const token = JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim1, claim2]).generateToken();
+            const jwt = JsonWebToken.fromToken("issuer1", 1, key, token);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             Assert.ok(jwt !== null || jwt !== undefined);
             Assert.strictEqual(jwt.issuer, "issuer1");
             Assert.strictEqual(jwt.algType, 1);
@@ -58,14 +61,14 @@ suite("Json Web Token ", () =>
 
         test("should throw an exception when getting JWT with a different issuer that what was user to generate token", async () =>
         {
-            let claim1 = new Claim("this_claim", "ThisValue");
-            let claim2 = new Claim("that_claim", "ThatValue");
-            let key = await SymmetricEncryption.generateKey();
-            let time = Date.now();
-            let token = await JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim1, claim2]).generateToken();
+            const claim1 = new Claim("this_claim", "ThisValue");
+            const claim2 = new Claim("that_claim", "ThatValue");
+            const key = await SymmetricEncryption.generateKey();
+            const time = Date.now();
+            const token = JsonWebToken.fromClaims("issuer1", 1, key, time + 10000000, [claim1, claim2]).generateToken();
             try
             {
-                await JsonWebToken.fromToken("notTheIssuer", 1, key, token);
+                JsonWebToken.fromToken("notTheIssuer", 1, key, token);
             }
             catch (exp)
             {
@@ -78,14 +81,14 @@ suite("Json Web Token ", () =>
         
         test("should throw an exception when getting JWT when the token is expired", async () =>
         {
-            let claim1 = new Claim("this_claim", "ThisValue");
-            let claim2 = new Claim("that_claim", "ThatValue");
-            let key = await SymmetricEncryption.generateKey();
-            let time = Date.now();
-            let token = await JsonWebToken.fromClaims("issuer1", 1, key, time, [claim1, claim2]).generateToken();
+            const claim1 = new Claim("this_claim", "ThisValue");
+            const claim2 = new Claim("that_claim", "ThatValue");
+            const key = await SymmetricEncryption.generateKey();
+            const time = Date.now();
+            const token = JsonWebToken.fromClaims("issuer1", 1, key, time, [claim1, claim2]).generateToken();
             try
             {
-                await JsonWebToken.fromToken("issuer1", 1, key, token);
+                JsonWebToken.fromToken("issuer1", 1, key, token);
             }
             catch (exp)
             {
@@ -96,37 +99,39 @@ suite("Json Web Token ", () =>
             Assert.ok(false);
         });
         
-        test("should throw an exception when getting JWT algorithm given is different than what was used for the token generation", async () =>
-        {
-            let claim1 = new Claim("this_claim", "ThisValue");
-            let claim2 = new Claim("that_claim", "ThatValue");
-            let key = await SymmetricEncryption.generateKey();
-            let time = Date.now();
-            let token = await JsonWebToken.fromClaims("issuer1", 1, key, time + 1000000, [claim1, claim2]).generateToken();
-            try
-            {
-                await JsonWebToken.fromToken("issuer1", 2, key, token);
-            }
-            catch (exp)
-            {
-                Assert.ok(exp instanceof InvalidTokenException);
-                Assert.equal(exp.message, `Token '${token}' is invalid because alg was expected to be '${2}' but instead was '${1}'.`);
-                return;
-            }
-            Assert.ok(false);
-        });
+        // TODO: right now we only support one alg type. When we support others, we should uncomment this test
+        // test("should throw an exception when getting JWT algorithm given is different than what was used for the token generation", async () =>
+        // {
+        //     let claim1 = new Claim("this_claim", "ThisValue");
+        //     let claim2 = new Claim("that_claim", "ThatValue");
+        //     let key = await SymmetricEncryption.generateKey();
+        //     let time = Date.now();
+        //     let token = JsonWebToken.fromClaims("issuer1", 1, key, time + 1000000, [claim1, claim2]).generateToken();
+        //     try
+        //     {
+        //         JsonWebToken.fromToken("issuer1", 2, key, token);
+        //     }
+        //     catch (exp)
+        //     {
+        //         console.log(exp);
+        //         Assert.ok(exp instanceof InvalidTokenException);
+        //         Assert.equal(exp.message, `Token '${token}' is invalid because alg was expected to be '${2}' but instead was '${1}'.`);
+        //         return;
+        //     }
+        //     Assert.ok(false);
+        // });
         
         test("should throw an exception when getting JWT key given is different than what was used for the token generation", async () =>
         {
-            let claim1 = new Claim("this_claim", "ThisValue");
-            let claim2 = new Claim("that_claim", "ThatValue");
-            let key = await SymmetricEncryption.generateKey();
-            let key2 = await SymmetricEncryption.generateKey();
-            let time = Date.now();
-            let token = await JsonWebToken.fromClaims("issuer1", 1, key, time + 1000000, [claim1, claim2]).generateToken();
+            const claim1 = new Claim("this_claim", "ThisValue");
+            const claim2 = new Claim("that_claim", "ThatValue");
+            const key = await SymmetricEncryption.generateKey();
+            const key2 = await SymmetricEncryption.generateKey();
+            const time = Date.now();
+            const token = JsonWebToken.fromClaims("issuer1", 1, key, time + 1000000, [claim1, claim2]).generateToken();
             try
             {
-                await JsonWebToken.fromToken("issuer1", 1, key2, token);
+                JsonWebToken.fromToken("issuer1", 1, key2, token);
             }
             catch (exp)
             {
@@ -139,15 +144,15 @@ suite("Json Web Token ", () =>
         
         test("should throw an exception when getting JWT when the token is tampered with", async () =>
         {
-            let claim1 = new Claim("this_claim", "ThisValue");
-            let claim2 = new Claim("that_claim", "ThatValue");
-            let key = await SymmetricEncryption.generateKey();
-            let time = Date.now();
-            let token = await JsonWebToken.fromClaims("issuer1", 1, key, time + 1000000, [claim1, claim2]).generateToken();
+            const claim1 = new Claim("this_claim", "ThisValue");
+            const claim2 = new Claim("that_claim", "ThatValue");
+            const key = await SymmetricEncryption.generateKey();
+            const time = Date.now();
+            let token = JsonWebToken.fromClaims("issuer1", 1, key, time + 1000000, [claim1, claim2]).generateToken();
             token = token + "someStuff";
             try
             {
-                await JsonWebToken.fromToken("issuer1", 1, key, token);
+                JsonWebToken.fromToken("issuer1", 1, key, token);
             }
             catch (exp)
             {

package/test/other.test.ts

@@ -4,11 +4,11 @@ suite("Other", () =>
 {
     test("encoding decoding", () =>
     {
-        let text = "moonlight43iuj90/;msdnnksdkdkdk[[[][][";
-        let encodedText = Buffer.from(text, "utf8").toString("base64");
+        const text = "moonlight43iuj90/;msdnnksdkdkdk[[[][][";
+        const encodedText = Buffer.from(text, "utf8").toString("base64");
         Assert.notStrictEqual(encodedText, text);
         
-        let decodedText = Buffer.from(encodedText, "base64").toString("utf8");
+        const decodedText = Buffer.from(encodedText, "base64").toString("utf8");
         Assert.notStrictEqual(decodedText, encodedText);
         Assert.strictEqual(decodedText, text);
     });

package/test/symmetric-encryption.test.ts

@@ -10,16 +10,17 @@ suite("SymmetricEncryption", () =>
     { 
         test("must return string value that is not null, empty or whitespace", async () =>
         {
-            let key = await SymmetricEncryption.generateKey();
+            const key = await SymmetricEncryption.generateKey();
             console.log("key", key);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             Assert.ok(key !== null && !key.isEmptyOrWhiteSpace());
         });
         
         
         test("consecutive calls must yield unique values", async () =>
         {
-            let key1 = await SymmetricEncryption.generateKey();
-            let key2 = await SymmetricEncryption.generateKey();
+            const key1 = await SymmetricEncryption.generateKey();
+            const key2 = await SymmetricEncryption.generateKey();
             Assert.notStrictEqual(key1, key2);
         });
     });    
@@ -28,9 +29,10 @@ suite("SymmetricEncryption", () =>
     { 
         test("must return cipher text value when called with key and plain text value", async () =>
         {
-            let key = "E25B269440F88601C453CD171D76EDDC11D8CF33230742DF8CAD5873D28F78B2";
-            let value = "password";
-            let encrypted = await SymmetricEncryption.encrypt(key, value);
+            const key = "E25B269440F88601C453CD171D76EDDC11D8CF33230742DF8CAD5873D28F78B2";
+            const value = "password";
+            const encrypted = await SymmetricEncryption.encrypt(key, value);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
             Assert.ok(encrypted !== null);
             Assert.notStrictEqual(encrypted, value);
         });
@@ -171,10 +173,10 @@ suite("SymmetricEncryption", () =>
     {
         test("must return plain text value when called with key and cipher text value", async () =>
         {
-            let key = await SymmetricEncryption.generateKey();
-            let value = "password";
-            let encrypted = await SymmetricEncryption.encrypt(key, value);
-            let decrypted = await SymmetricEncryption.decrypt(key, encrypted);
+            const key = await SymmetricEncryption.generateKey();
+            const value = "password";
+            const encrypted = await SymmetricEncryption.encrypt(key, value);
+            const decrypted = SymmetricEncryption.decrypt(key, encrypted);
             Assert.strictEqual(decrypted, value);
         });
           

package/tsconfig.json

@@ -3,9 +3,9 @@
         "module": "commonjs",
         "target": "es2015",
         "strict": true,
-        "strictNullChecks": false,
-        "strictFunctionTypes": false,
-        "noImplicitThis": false,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "noImplicitThis": true,
         "noImplicitReturns": true,
         "noUnusedLocals": true,
         "noUnusedParameters": true,
@@ -14,15 +14,13 @@
         "sourceMap": true,
         "experimentalDecorators": true,
         "emitDecoratorMetadata": true,
-        "removeComments": true,
+        "removeComments": false,
         "forceConsistentCasingInFileNames": true,
         "incremental": false,
-        "plugins": [
-            {
-                "name": "typescript-tslint-plugin",
-                "configFile": "./tslint.json",
-                "alwaysShowRuleFailuresAsWarnings": false
-            }
-        ]
+        "skipLibCheck": true,
+        "importHelpers": true,
+        "noEmitHelpers": true,
+        "noImplicitOverride": true,
+        "pretty": true
     }
 }

package/dist/crypto/uuid.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"uuid.js","sourceRoot":"","sources":["../../src/crypto/uuid.ts"],"names":[],"mappings":";;AAAA,6BAA6B;AAI7B,MAAa,IAAI;IAEb,gBAAwB,CAAC;IAGlB,MAAM,CAAC,MAAM;QAEhB,OAAO,IAAI,CAAC,EAAE,EAAE,CAAC;IACrB,CAAC;CACJ;AATD,oBASC","sourcesContent":["import * as uuid from \"uuid\";\n\n\n// public\nexport class Uuid\n{\n    private constructor() { }\n    \n    \n    public static create(): string\n    {\n        return uuid.v4();\n    }\n}"]}

package/tslint.json

@@ -1,64 +0,0 @@
-{
-    "defaultSeverity": "error",
-    "rules": {
-        "class-name": true,
-        "comment-format": [
-            true,
-            "check-space"
-        ],
-        "indent": [
-            true,
-            "spaces"
-        ],
-        "no-duplicate-variable": true,
-        "no-eval": true,
-        "no-internal-module": true,
-        "no-trailing-whitespace": false,
-        "no-var-keyword": true,
-        "no-default-export": true,
-        "one-line": [
-            true,
-            "check-whitespace"
-        ],
-        "quotemark": [
-            true,
-            "double"
-        ],
-        "semicolon": [
-            true,
-            "always"
-        ],
-        "triple-equals": [
-            true,
-            "allow-null-check"
-        ],
-        "typedef-whitespace": [
-            true,
-            {
-                "call-signature": "nospace",
-                "index-signature": "nospace",
-                "parameter": "nospace",
-                "property-declaration": "nospace",
-                "variable-declaration": "nospace"
-            }
-        ],
-        "variable-name": [
-            true,
-            "ban-keywords"
-        ],
-        "whitespace": [
-            true,
-            "check-branch",
-            "check-decl",
-            "check-operator",
-            "check-separator",
-            "check-type"
-        ],
-        "interface-name": [
-            true,
-            "never-prefix"
-        ],
-        "await-promise": true,
-        "no-floating-promises": true
-    }
-}