@nivinjoseph/n-sec 5.0.5 → 6.0.1

package/src/crypto/symmetric-encryption.ts

@@ -1,6 +1,6 @@
-import * as Crypto from "crypto";
-import { CryptoException } from "./crypto-exception";
 import { given } from "@nivinjoseph/n-defensive";
+import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
+import { CryptoException } from "./crypto-exception.js";
 
 
 // public
@@ -8,12 +8,12 @@ export class SymmetricEncryption
 {
     private constructor() { }
 
-    
+
     public static generateKey(): Promise<string>
     {
         return new Promise<string>((resolve, reject) =>
         {
-            Crypto.randomBytes(32, (err, buf) =>
+            randomBytes(32, (err, buf) =>
             {
                 if (err)
                 {
@@ -25,7 +25,7 @@ export class SymmetricEncryption
             });
         });
     }
-    
+
     public static encrypt(key: string, value: string): Promise<string>
     {
         return new Promise<string>((resolve, reject) =>
@@ -35,8 +35,8 @@ export class SymmetricEncryption
 
             key = key.trim();
             value = value.trim();
-            
-            Crypto.randomBytes(16, (err, buf) =>
+
+            randomBytes(16, (err, buf) =>
             {
                 if (err)
                 {
@@ -47,7 +47,7 @@ export class SymmetricEncryption
                 try 
                 {
                     const iv = buf;
-                    const cipher = Crypto.createCipheriv("AES-256-CBC", Buffer.from(key, "hex"), iv);
+                    const cipher = createCipheriv("AES-256-CBC", Buffer.from(key, "hex"), iv);
                     let encrypted = cipher.update(value, "utf8", "hex");
                     encrypted += cipher.final("hex");
                     const cipherText = `${encrypted}.${iv.toString("hex")}`;
@@ -60,7 +60,7 @@ export class SymmetricEncryption
             });
         });
     }
-    
+
     public static decrypt(key: string, value: string): string
     {
         given(key, "key").ensureHasValue().ensureIsString();
@@ -68,13 +68,13 @@ export class SymmetricEncryption
 
         key = key.trim();
         value = value.trim();
-        
+
         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);
+        const deCipher = createDecipheriv("AES-256-CBC", Buffer.from(key, "hex"), iv);
         let decrypted = deCipher.update(splitted[0], "hex", "utf8");
         decrypted += deCipher.final("utf8");
         return decrypted;

package/src/index.ts

@@ -1,26 +1,25 @@
 import "@nivinjoseph/n-ext";
 
-import { SymmetricEncryption } from "./crypto/symmetric-encryption";
-import { Hmac } from "./crypto/hmac";
-import { Hash } from "./crypto/hash";
-// import { DigitalSignature } from "./crypto/digital-signature";
-// import { AsymmetricEncryption } from "./crypto/asymmetric-encryption";
-import { CryptoException } from "./crypto/crypto-exception";
+import { Hash } from "./crypto/hash.js";
+import { Hmac } from "./crypto/hmac.js";
+import { SymmetricEncryption } from "./crypto/symmetric-encryption.js";
+// import { DigitalSignature } from "./crypto/digital-signature.js";
+// import { AsymmetricEncryption } from "./crypto/asymmetric-encryption.js";
+import { CryptoException } from "./crypto/crypto-exception.js";
 
-import { AlgType } from "./api-security/alg-type";
-import { Claim } from "./api-security/claim";
-import { ClaimsIdentity } from "./api-security/claims-identity";
-import { ExpiredTokenException } from "./api-security/expired-token-exception";
-import { InvalidTokenException } from "./api-security/invalid-token-exception";
-import { JsonWebToken } from "./api-security/json-web-token";
-import { SecurityToken } from "./api-security/security-token";
+import { AlgType } from "./api-security/alg-type.js";
+import { Claim } from "./api-security/claim.js";
+import { ClaimsIdentity } from "./api-security/claims-identity.js";
+import { ExpiredTokenException } from "./api-security/expired-token-exception.js";
+import { InvalidTokenException } from "./api-security/invalid-token-exception.js";
+import { JsonWebToken } from "./api-security/json-web-token.js";
+import { SecurityToken } from "./api-security/security-token.js";
 
 
 export
 {
-    SymmetricEncryption, Hmac, Hash,
+
+    AlgType, Claim, ClaimsIdentity,
     // DigitalSignature, AsymmetricEncryption,
-    CryptoException,
-    
-    AlgType, Claim, ClaimsIdentity, ExpiredTokenException, InvalidTokenException, JsonWebToken, SecurityToken
-};
+    CryptoException, ExpiredTokenException, Hash, Hmac, InvalidTokenException, JsonWebToken, SecurityToken, SymmetricEncryption
+};

package/test/asymmetric-encryption.test.ts

@@ -3,24 +3,24 @@
 // // import { CryptoException } from "./../src/crypto-exception";
 // import "@nivinjoseph/n-ext";
 
-// suite("AsymmetricEncryption", () =>
+// await describe("AsymmetricEncryption", () =>
 // {
-//     suite("generateKeyPair", () =>
+//     await describe("generateKeyPair", () =>
 //     { 
-//         test("should return string value that is not null, empty or whitespace", async () =>
+//         await test("should return string value that is not null, empty or whitespace", async () =>
 //         {
 //             let keyPair = await AsymmetricEncryption.generateKeyPair();
 //             Assert.ok(keyPair !== null && !keyPair.isEmptyOrWhiteSpace());
 //         });
         
-//         test("consecutive invocations must generate different values", async () =>
+//         await test("consecutive invocations must generate different values", async () =>
 //         {
 //             let keyPair1 = await AsymmetricEncryption.generateKeyPair();
 //             let keyPair2 = await AsymmetricEncryption.generateKeyPair();
 //             Assert.notStrictEqual(keyPair1, keyPair2);
 //         });
 
-//         // test("generate 3 KeyPairs", async () =>
+//         // await test("generate 3 KeyPairs", async () =>
 //         // {
 //         //     let keyPair1 = await AsymmetricEncryption.generateKeyPair();
 //         //     let keyPair2 = await AsymmetricEncryption.generateKeyPair();
@@ -34,9 +34,9 @@
 //         // });
 //     });
     
-//     suite("getPublicKey", () =>
+//     await describe("getPublicKey", () =>
 //     {
-//         test("should return a string value that is not null, empty, whitespace or same as the input when called with a valid keypair", async () =>
+//         await test("should return a string value that is not null, empty, whitespace or same as the input when called with a valid keypair", async () =>
 //         {
 //             let keyPair = await AsymmetricEncryption.generateKeyPair();
 //             let publicKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -44,7 +44,7 @@
 //             Assert.notStrictEqual(keyPair, publicKey);
 //         });
         
-//         test("multiple invocations should return the same value for the same keypair", async () =>
+//         await test("multiple invocations should return the same value for the same keypair", async () =>
 //         {
 //             let keyPair = await AsymmetricEncryption.generateKeyPair();
 //             let publicKey1 = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -52,7 +52,7 @@
 //             Assert.strictEqual(publicKey1, publicKey2);
 //         });
         
-//         test("should return different values for different keypairs", async () =>
+//         await test("should return different values for different keypairs", async () =>
 //         {
 //             let keyPair1 = await AsymmetricEncryption.generateKeyPair();
 //             let publicKey1 = await AsymmetricEncryption.getPublicKey(keyPair1);
@@ -63,7 +63,7 @@
 //             Assert.notStrictEqual(publicKey1, publicKey2);
 //         });
         
-//         // test("get 2 public keys with same key pair", async () =>
+//         // await test("get 2 public keys with same key pair", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let publicKey1 = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -75,7 +75,7 @@
 //         //     Assert.strictEqual(publicKey1, publicKey2);
 //         // });
         
-//         // test("throws CryptoException when key pair is null", async () =>
+//         // await test("throws CryptoException when key pair is null", async () =>
 //         // {
 //         //     try
 //         //     {
@@ -90,7 +90,7 @@
 //         //     Assert.ok(false);
 //         // });
         
-//         // test("throws CryptoException when key pair is undefined", async () =>
+//         // await test("throws CryptoException when key pair is undefined", async () =>
 //         // {
 //         //     try
 //         //     {
@@ -105,7 +105,7 @@
 //         //     Assert.ok(false);
 //         // });
         
-//         // test("throws CryptoException when key pair is empty String", async () =>
+//         // await test("throws CryptoException when key pair is empty String", async () =>
 //         // {
 //         //     try
 //         //     {
@@ -121,9 +121,9 @@
 //         // });
 //     });
     
-//     suite("encrypt", () =>
+//     await describe("encrypt", () =>
 //     {
-//         test("should return cipher text when called with a keypair and plain text value", async () =>
+//         await test("should return cipher text when called with a keypair and plain text value", async () =>
 //         {
 //             let keyPair = await AsymmetricEncryption.generateKeyPair();
 //             let value = "password";
@@ -133,7 +133,7 @@
 //             Assert.notStrictEqual(encrypted, keyPair);
 //         });
         
-//         test("should return cipher text when called with a public key and plain text value", async () =>
+//         await test("should return cipher text when called with a public key and plain text value", async () =>
 //         {
 //             let keyPair = await AsymmetricEncryption.generateKeyPair();
 //             let publicKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -144,7 +144,7 @@
 //             Assert.notStrictEqual(encrypted, keyPair);
 //         });
         
-//         // test("encrypt a string with public Key", async () =>
+//         // await test("encrypt a string with public Key", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let publicKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -153,7 +153,7 @@
 //         //     Assert.notStrictEqual(encrypt, "password");
 //         // });
         
-//         // test("encrypt twice using the same key pair", async () =>
+//         // await test("encrypt twice using the same key pair", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let encrypt1 = await AsymmetricEncryption.encrypt(keyPair, "password");
@@ -165,7 +165,7 @@
 //         //     Assert.strictEqual(encrypt2, encrypt1);
 //         // });
         
-//         // test("encrypt 2 strings using the same key pair", async () =>
+//         // await test("encrypt 2 strings using the same key pair", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let encrypt1 = await AsymmetricEncryption.encrypt(keyPair, "hello world");
@@ -177,7 +177,7 @@
 //         //     Assert.notStrictEqual(encrypt2, encrypt1);
 //         // });
         
-//         // test("throws CryptoException when key pair is null", async () =>
+//         // await test("throws CryptoException when key pair is null", async () =>
 //         // {
 //         //     try
 //         //     {
@@ -192,7 +192,7 @@
 //         //     Assert.ok(false);
 //         // });
         
-//         // test("throws CryptoException when key pair is undefined", async () =>
+//         // await test("throws CryptoException when key pair is undefined", async () =>
 //         // {
 //         //     try
 //         //     {
@@ -207,7 +207,7 @@
 //         //     Assert.ok(false);
 //         // });
         
-//         // test("throws CryptoException when key pair is empty string", async () =>
+//         // await test("throws CryptoException when key pair is empty string", async () =>
 //         // {
 //         //     try
 //         //     {
@@ -222,7 +222,7 @@
 //         //     Assert.ok(false);
 //         // });
         
-//         // test("throws CryptoException when key pair is empty string", async () =>
+//         // await test("throws CryptoException when key pair is empty string", async () =>
 //         // {
 //         //     try
 //         //     {
@@ -238,7 +238,7 @@
 //         //     Assert.ok(false);
 //         // });
         
-//         // test("throws CryptoException when key pair and value are empty strings", async () =>
+//         // await test("throws CryptoException when key pair and value are empty strings", async () =>
 //         // {
 //         //     try
 //         //     {
@@ -253,7 +253,7 @@
 //         //     Assert.ok(false);
 //         // });
         
-//         // test("encrypt using public key and key pair", async () =>
+//         // await test("encrypt using public key and key pair", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let encrypt1 = await AsymmetricEncryption.encrypt(keyPair, "hello world");
@@ -267,9 +267,9 @@
 //         // });
 //     });
     
-//     suite("decrypt", () =>
+//     await describe("decrypt", () =>
 //     {
-//         test("should return plain text when called with key pair and cipher text encrypted with key pair", async () =>
+//         await test("should return plain text when called with key pair and cipher text encrypted with key pair", async () =>
 //         {
 //             let keyPair = await AsymmetricEncryption.generateKeyPair();
 //             let value = "password";
@@ -278,7 +278,7 @@
 //             Assert.strictEqual(decrypted, value);
 //         });
         
-//         test("should return plain text when called with key pair and cipher text encrypted with public key of key pair", async () =>
+//         await test("should return plain text when called with key pair and cipher text encrypted with public key of key pair", async () =>
 //         {
 //             let keyPair = await AsymmetricEncryption.generateKeyPair();
 //             let publicKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -290,7 +290,7 @@
         
         
         
-//         // test("decrypt using public key when encrypted by key pair", async () =>
+//         // await test("decrypt using public key when encrypted by key pair", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let publicKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -300,7 +300,7 @@
 //         //     Assert.strictEqual(decrypt, "password");
 //         // });
         
-//         // test("decrypt using key pair when encrypted by public key", async () =>
+//         // await test("decrypt using key pair when encrypted by public key", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let publicKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -310,7 +310,7 @@
 //         //     Assert.strictEqual(decrypt, "password");
 //         // });
         
-//         // test("decrypt using key pair when encrypted by key pair", async () =>
+//         // await test("decrypt using key pair when encrypted by key pair", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let encrypt = await AsymmetricEncryption.encrypt(keyPair, "password");
@@ -318,7 +318,7 @@
 //         //     Assert.notStrictEqual(decrypt, "password");
 //         // });
         
-//         // test("decrypt using public key when encrypted by public key", async () =>
+//         // await test("decrypt using public key when encrypted by public key", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let publicKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -327,7 +327,7 @@
 //         //     Assert.notStrictEqual(decrypt, "password");
 //         // });
         
-//         // test("throws CryptoException when key is null", async () =>
+//         // await test("throws CryptoException when key is null", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let encrypt = await AsymmetricEncryption.encrypt(keyPair, "password");
@@ -344,7 +344,7 @@
 //         //     Assert.ok(false);
 //         // });
         
-//         // test("throws CryptoException when key is undefined", async () =>
+//         // await test("throws CryptoException when key is undefined", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let encrypt = await AsymmetricEncryption.encrypt(keyPair, "password");
@@ -361,7 +361,7 @@
 //         //     Assert.ok(false);
 //         // });
         
-//         // test("throws CryptoException when value is null", async () =>
+//         // await test("throws CryptoException when value is null", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let publicKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -378,7 +378,7 @@
 //         //     Assert.ok(false);
 //         // });
 
-//         // test("throws CryptoException when value is undefined", async () =>
+//         // await test("throws CryptoException when value is undefined", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let publicKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -395,7 +395,7 @@
 //         //     Assert.ok(false);
 //         // });
         
-//         // test("throws CryptoException when key and value is null", async () =>
+//         // await test("throws CryptoException when key and value is null", async () =>
 //         // {
 //         //     try
 //         //     {

package/test/digital-signature.test.ts

@@ -4,11 +4,11 @@
 // import "@nivinjoseph/n-ext";
 
 
-// suite("digitalSignature", () =>
+// await describe("digitalSignature", () =>
 // {
-//     suite("sign", () =>
+//     await describe("sign", () =>
 //     {   
-//         test("should return string value thats is not null, empty, whitespace, same as value or key pair when invoked with key pair and value", async () =>
+//         await test("should return string value thats is not null, empty, whitespace, same as value or key pair when invoked with key pair and value", async () =>
 //         {
 //             let keyPair = await AsymmetricEncryption.generateKeyPair();
 //             let value = "some value";
@@ -19,7 +19,7 @@
 //         });
         
         
-//         // test("should throw CryptoException when KeyPair is null", async () =>
+//         // await test("should throw CryptoException when KeyPair is null", async () =>
 //         // {
 //         //     try
 //         //     {
@@ -34,7 +34,7 @@
 //         //     assert.ok(false);
 //         // });
         
-//         // test("should throw CryptoException when KeyPair is undefined", async () =>
+//         // await test("should throw CryptoException when KeyPair is undefined", async () =>
 //         // {
 //         //     try
 //         //     {
@@ -49,7 +49,7 @@
 //         //     assert.ok(false);
 //         // });
         
-//         // test("should throw CryptoException when value is null", async () =>
+//         // await test("should throw CryptoException when value is null", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     try
@@ -65,7 +65,7 @@
 //         //     assert.ok(false);
 //         // });
         
-//         // test("should throw CryptoException when value is undefined", async () =>
+//         // await test("should throw CryptoException when value is undefined", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     try
@@ -81,7 +81,7 @@
 //         //     assert.ok(false);
 //         // });
         
-//         // test("should throw CryptoException when value is empty string", async () =>
+//         // await test("should throw CryptoException when value is empty string", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     try
@@ -97,7 +97,7 @@
 //         //     assert.ok(false);
 //         // });
         
-//         // test("should throw CryptoException when keyPair is empty string", async () =>
+//         // await test("should throw CryptoException when keyPair is empty string", async () =>
 //         // {
 //         //     try
 //         //     {
@@ -113,9 +113,9 @@
 //         // });
 //     });
     
-//     suite("verify", () =>
+//     await describe("verify", () =>
 //     {
-//         test("should return true when called with public key of key pair, value and signature of value generated using key pair", async () =>
+//         await test("should return true when called with public key of key pair, value and signature of value generated using key pair", async () =>
 //         {
 //             let keyPair = await AsymmetricEncryption.generateKeyPair();
 //             let publicKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -125,7 +125,7 @@
 //             Assert.strictEqual(verification, true);
 //         });
         
-//         test("should return false when called with unrelated public key, value and signature", async () =>
+//         await test("should return false when called with unrelated public key, value and signature", async () =>
 //         {
 //             let keyPair1 = await AsymmetricEncryption.generateKeyPair();
 //             let keyPair2 = await AsymmetricEncryption.generateKeyPair();
@@ -136,7 +136,7 @@
 //             Assert.strictEqual(verification, false);
 //         });
         
-//         test("should return false when called with tampered value", async () =>
+//         await test("should return false when called with tampered value", async () =>
 //         {
 //             let keyPair = await AsymmetricEncryption.generateKeyPair();
 //             let publicKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -147,7 +147,7 @@
 //             Assert.strictEqual(verification, false);
 //         });
         
-//         test("should return false when called with a tampered signature", async () =>
+//         await test("should return false when called with a tampered signature", async () =>
 //         {
 //             let keyPair = await AsymmetricEncryption.generateKeyPair();
 //             let publicKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -160,7 +160,7 @@
         
         
         
-//         // test("successfully verify the signed", async () =>
+//         // await test("successfully verify the signed", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let publicKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -169,7 +169,7 @@
 //         //     Assert.ok(verify);
 //         // });
         
-//         // test("un-verify modified signature", async () =>
+//         // await test("un-verify modified signature", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let publicKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -179,7 +179,7 @@
 //         //     Assert.ok(!verify);
 //         // });
         
-//         // test("un-verify when wrong public key is given", async () =>
+//         // await test("un-verify when wrong public key is given", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let signature = await DigitalSignature.sign(keyPair, "some-string");
@@ -189,7 +189,7 @@
 //         //     Assert.ok(!verify);
 //         // });
         
-//         // test("should throw CryptoException when public key is null", async () =>
+//         // await test("should throw CryptoException when public key is null", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let signature = await DigitalSignature.sign(keyPair, "some-string");
@@ -206,7 +206,7 @@
 //         //     Assert.ok(false);
 //         // });
         
-//         // test("should throw CryptoException when value is null", async () =>
+//         // await test("should throw CryptoException when value is null", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let signature = await DigitalSignature.sign(keyPair, "some-string");
@@ -224,7 +224,7 @@
 //         //     Assert.ok(false);
 //         // });
         
-//         // test("should throw CryptoException when value is empty string", async () =>
+//         // await test("should throw CryptoException when value is empty string", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let signature = await DigitalSignature.sign(keyPair, "some-string");
@@ -242,7 +242,7 @@
 //         //     Assert.ok(false);
 //         // });
         
-//         // test("should throw CryptoException when signature is null", async () =>
+//         // await test("should throw CryptoException when signature is null", async () =>
 //         // {
 //         //     let keyPair = await AsymmetricEncryption.generateKeyPair();
 //         //     let publicKey = await AsymmetricEncryption.getPublicKey(keyPair);
@@ -259,7 +259,7 @@
 //         //     Assert.ok(false);
 //         // });
         
-//         // test("should throw CryptoException when value, key pair and signature are all null", async () =>
+//         // await test("should throw CryptoException when value, key pair and signature are all null", async () =>
 //         // {
 //         //     try
 //         //     {