@carecard/auth-util 3.1.13 → 3.1.15

package/tests/cryptoUtilAuth.test.ts

@@ -0,0 +1,97 @@
+import * as assert from 'assert';
+import * as cryptoUtilAuth from '../src';
+import * as keys from './keys/keys';
+
+describe('CryptoUtilAuth test', function () {
+  it('createBase64SignatureOfToken returns base64 signature of token', function () {
+    const algorithm = 'SHA256';
+    const token = 'Hi I am token';
+    const signature =
+      'G3uHnG5DIoi3YWaj+umNmCtzAfBMmxAGfkWxlXP9qTfEr48qJjIVIdD5ic5T9YSDMt+6+XsembuL2NP6h4xoe+qE/wRjNKXCF6Hg/VvBciOdZyUqX8TaiAbGsh6J2d42rjX1vchrqfrBgCW5kiyeZcTic8LQeNdL/2gO+F9bW8A=';
+
+    const returnedSignature = cryptoUtilAuth.createBase64SignatureOfToken(
+      token,
+      keys.privateKey,
+      algorithm,
+    );
+
+    assert.deepStrictEqual(returnedSignature, signature);
+  });
+
+  it('verifyBase64SignatureOfToken returns true or false', function () {
+    const algorithm = 'SHA256';
+    const token = 'Hi I am token';
+    const signature =
+      'G3uHnG5DIoi3YWaj+umNmCtzAfBMmxAGfkWxlXP9qTfEr48qJjIVIdD5ic5T9YSDMt+6+XsembuL2NP6h4xoe+qE/wRjNKXCF6Hg/VvBciOdZyUqX8TaiAbGsh6J2d42rjX1vchrqfrBgCW5kiyeZcTic8LQeNdL/2gO+F9bW8A=';
+    const temperedSignature = 'temper' + signature;
+    const expectedValueTrue = true;
+    const expectedValueFalse = false;
+
+    const returnedValue = cryptoUtilAuth.verifyBase64SignatureOfToken(
+      token,
+      signature,
+      keys.publicKey,
+      algorithm,
+    );
+    const returnedValueFalse = cryptoUtilAuth.verifyBase64SignatureOfToken(
+      token,
+      temperedSignature,
+      keys.publicKey,
+      algorithm,
+    );
+
+    assert.deepStrictEqual(returnedValue, expectedValueTrue);
+    assert.deepStrictEqual(returnedValueFalse, expectedValueFalse);
+  });
+
+  it('createHmacBase64 returns base 64 hmac', function () {
+    const algorithm = 'SHA256';
+    const token = 'Hi I am token';
+    const secret = 'My secret';
+    const expectedHmacBase64 = 'IpOkaPa1YPTXQYPr6adIGk3ACgeqWyV+nvB4+7Ox4Dg=';
+
+    const returnedHmacBase64 = cryptoUtilAuth.createHmacBase64(token, secret, algorithm);
+
+    assert.deepStrictEqual(returnedHmacBase64, expectedHmacBase64);
+  });
+
+  it('createSaltBase64 returns random base 64 string', function () {
+    const randomSalt = cryptoUtilAuth.createSaltBase64();
+
+    assert.deepStrictEqual(randomSalt.length, 44);
+  });
+
+  it('encryptStringAsciiToBase64 returns  base 64 and encrypted string', function () {
+    const plainTextString = 'This is some text for encryption';
+    const encryptedString = 'juggjf+C81QzXvqa8qE1GHTbrMQydtoFszKw2kFjGDduCpXwS01cVnYyYl9an7l7';
+    const salt = 'my salt';
+    const secret = 'top secret';
+    const algorithm = 'aes-192-cbc';
+
+    const encryptedText = cryptoUtilAuth.encryptStringAsciiToBase64(
+      plainTextString,
+      salt,
+      secret,
+      algorithm,
+    );
+
+    assert.deepStrictEqual(encryptedText, encryptedString);
+  });
+
+  it('decryptStringBase64ToAscii returns ascii string', function () {
+    const encryptedString = 'juggjf+C81QzXvqa8qE1GHTbrMQydtoFszKw2kFjGDduCpXwS01cVnYyYl9an7l7';
+    const plainTextString = 'This is some text for encryption';
+    const salt = 'my salt';
+    const secret = 'top secret';
+    const algorithm = 'aes-192-cbc';
+
+    const encryptedText = cryptoUtilAuth.decryptStringBase64ToAscii(
+      encryptedString,
+      salt,
+      secret,
+      algorithm,
+    );
+
+    assert.deepStrictEqual(encryptedText, plainTextString);
+  });
+});

package/tests/index.test.ts

@@ -0,0 +1,157 @@
+import * as assert from 'assert';
+import * as jwtUtilAuth from '../src/jwtUtilAuth';
+import * as pwdUtilAuth from '../src/pwdUtilAuth';
+import * as strEncryptUtil from '../src/strEncryptUtil';
+import * as keys from './keys/keys';
+
+describe('Index/JwtUtilAuth', function () {
+  it('createSignedJwtFromObject returns base64 url safe jwt', function () {
+    const header = {
+      alg: 'SHA512',
+      typ: 'JWT',
+    };
+    const payload = {
+      sub: '1234567890',
+      name: 'John Doe',
+      iat: 1516239022,
+      cpso: '81883',
+      roles: ['ph', 'ea'],
+    };
+    const expectedJwt =
+      'eyJhbGciOiJTSEE1MTIiLCJ0eXAiOiJKV1QifQ.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJjcHNvIjoiODE4ODMiLCJyb2xlcyI6WyJwaCIsImVhIl19.PWff8BvKP79ukuZrGEhyIw4HN86m99l4VZo9xL_Ul5EHQFC1RsEvxUig4z2sUZqAvQLcQjEhNR7hf0KkB7YeJTWZF4QLRX6GwC5SvE2kryrYSlZvop2SCbYdty38gzDw3xTdDzcJo0awE45Sk_ZlRnjgcDD-wXAW3i7ToXRcPxM';
+
+    const createdJwt = jwtUtilAuth.createSignedJwtFromObject(header, payload, keys.privateKey);
+
+    assert.deepStrictEqual(createdJwt, expectedJwt);
+  });
+
+  it('verifyJwtSignature returns true or false', function () {
+    const jwt =
+      'eyJhbGciOiJTSEE1MTIiLCJ0eXAiOiJKV1QifQ.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJjcHNvIjoiODE4ODMiLCJyb2xlcyI6WyJwaCIsImVhIl19.PWff8BvKP79ukuZrGEhyIw4HN86m99l4VZo9xL_Ul5EHQFC1RsEvxUig4z2sUZqAvQLcQjEhNR7hf0KkB7YeJTWZF4QLRX6GwC5SvE2kryrYSlZvop2SCbYdty38gzDw3xTdDzcJo0awE45Sk_ZlRnjgcDD-wXAW3i7ToXRcPxM';
+
+    const isVerified = jwtUtilAuth.verifyJwtSignature(jwt, keys.publicKey);
+
+    assert.deepStrictEqual(isVerified, true);
+  });
+
+  it('getHeaderPayloadFromJwt returns header, payload object', function () {
+    const jwt =
+      'eyJhbGciOiJTSEE1MTIiLCJ0eXAiOiJKV1QifQ.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJjcHNvIjoiODE4ODMiLCJyb2xlcyI6WyJwaCIsImVhIl19.PWff8BvKP79ukuZrGEhyIw4HN86m99l4VZo9xL_Ul5EHQFC1RsEvxUig4z2sUZqAvQLcQjEhNR7hf0KkB7YeJTWZF4QLRX6GwC5SvE2kryrYSlZvop2SCbYdty38gzDw3xTdDzcJo0awE45Sk_ZlRnjgcDD-wXAW3i7ToXRcPxM';
+
+    const expectedHeader = {
+      alg: 'SHA512',
+      typ: 'JWT',
+    };
+    const expectedPayload = {
+      sub: '1234567890',
+      name: 'John Doe',
+      iat: 1516239022,
+      cpso: '81883',
+      roles: ['ph', 'ea'],
+    };
+
+    const { header, payload } = jwtUtilAuth.getHeaderPayloadFromJwt(jwt);
+
+    assert.deepStrictEqual(header, expectedHeader);
+    assert.deepStrictEqual(payload, expectedPayload);
+  });
+});
+
+describe('Index/PwdUtilAuth', function () {
+  it('createPasswordHashWithRandomSalt called with save hash', function () {
+    const password = 'mySecretPassword';
+    const secret = 'bigSecret';
+    const algorithm = 'sha512';
+
+    const hash = pwdUtilAuth.createPasswordHashWithRandomSalt(password, secret, algorithm);
+
+    assert.deepStrictEqual(hash.length > 40, true);
+  });
+
+  it('createPasswordHashBasedOnSavedAlgorithmSalt called with saved hash', function () {
+    const savedHash =
+      '$1$c2hhNTEy$SOk/04Wn/ce1YIXHlUIqt5SgsuCCLIFjxpzHloVSxFh/z8JuLFshAaGNCkIRf47QSPCOJpkJ476N2eq1Yg1+yg==$6h29BnpUkqfrmtnY1xUrAGZcpcAl5cUEJ4Qjj+BGXbo=$';
+    const password = 'mySecretPassword';
+    const secret = 'bigSecret';
+
+    const hash = pwdUtilAuth.createPasswordHashBasedOnSavedAlgorithmSalt(
+      password,
+      savedHash,
+      secret,
+    );
+
+    assert.deepStrictEqual(hash, savedHash);
+  });
+});
+
+describe('Index/strEncryptUtil', function () {
+  it('encryptByPrivateKey', function () {
+    const textToEncrypt = 'Asymmetric encryption';
+    const expectedEncryptedString =
+      'VtwwLocyYdCreTBRifUmFuLRQ3Lrmw0RxDEN9zQh9lTJ2+6K/iLj7F5TDqm10hIKtfeajacs5HgEPGLb4whSpy7ggMtCNZQoujJNElNq2d7TScquYWi34cGlURzNTIUqC66afYYF2djq1QNVkWMzrnLMztrHem09+VlmA+eGLdc=';
+    const encryptionConfigObj = {
+      cipherAlgorithm: 'aes-256-cbc',
+      keyLength: 32,
+      privateKey: keys.privateKey,
+      plainTextEncoding: 'utf8',
+      encryptedTextEncoding: 'base64',
+    };
+
+    const encryptedString = strEncryptUtil.encryptByPrivateKey(encryptionConfigObj, textToEncrypt);
+
+    assert.deepStrictEqual(encryptedString, expectedEncryptedString);
+  });
+
+  it('decryptByPublicKey', function () {
+    const inputEncryptedString =
+      'VtwwLocyYdCreTBRifUmFuLRQ3Lrmw0RxDEN9zQh9lTJ2+6K/iLj7F5TDqm10hIKtfeajacs5HgEPGLb4whSpy7ggMtCNZQoujJNElNq2d7TScquYWi34cGlURzNTIUqC66afYYF2djq1QNVkWMzrnLMztrHem09+VlmA+eGLdc=';
+    const expectedText = 'Asymmetric encryption';
+    const decryptionConfigObj = {
+      cipherAlgorithm: 'aes-256-cbc',
+      keyLength: 32,
+      publicKey: keys.publicKey,
+      plainTextEncoding: 'utf8',
+      encryptedTextEncoding: 'base64',
+    };
+
+    const decryptedString = strEncryptUtil.decryptByPublicKey(
+      decryptionConfigObj,
+      inputEncryptedString,
+    );
+
+    assert.deepStrictEqual(decryptedString, expectedText);
+  });
+
+  it('encryptByKey', function () {
+    const textToEncrypt = 'This is some text for encryption';
+    const expectedEncryptedString =
+      '/RMgsfS/ANEngXOwjFDYqxutOLnaY7XxDiJK403KZTcp8D76qPzwUYcYAF+lle4I';
+    const encryptConfigObj = {
+      cipherAlgorithm: 'aes-256-cbc',
+      keyLength: 32,
+      encryptionKey: keys.privateKey,
+      plainTextEncoding: 'utf8',
+      encryptedTextEncoding: 'base64',
+    };
+
+    const encryptedString = strEncryptUtil.encryptByKey(encryptConfigObj, textToEncrypt);
+
+    assert.deepStrictEqual(encryptedString, expectedEncryptedString);
+  });
+
+  it('decryptByKey', function () {
+    const encryptedString = '/RMgsfS/ANEngXOwjFDYqxutOLnaY7XxDiJK403KZTcp8D76qPzwUYcYAF+lle4I';
+    const expectedText = 'This is some text for encryption';
+    const encryptConfigObj = {
+      cipherAlgorithm: 'aes-256-cbc',
+      keyLength: 32,
+      encryptionKey: keys.privateKey,
+      plainTextEncoding: 'utf8',
+      encryptedTextEncoding: 'base64',
+    };
+
+    const decryptedString = strEncryptUtil.decryptByKey(encryptConfigObj, encryptedString);
+
+    assert.deepStrictEqual(decryptedString, expectedText);
+  });
+});

package/tests/indexStringUtilAuth.test.ts

@@ -0,0 +1,95 @@
+import * as assert from 'assert';
+import * as stringUtilAuth from '../src/stringUtilAuth';
+
+describe('StringUtilAuth test', function () {
+  it('makeStringUrlSafe returns url safe string', function (done) {
+    const urlUnsafeString = 'eyJhbGciOiJzaGE1MTIiL/CJ0e+XAiOiJKV1QifQ.eyJpZkkCI6IjEyMz===';
+    const urlSafeString = 'eyJhbGciOiJzaGE1MTIiL_CJ0e-XAiOiJKV1QifQ.eyJpZkkCI6IjEyMz';
+
+    const returnedString = stringUtilAuth.makeStringUrlSafe(urlUnsafeString);
+    assert.deepStrictEqual(returnedString, urlSafeString);
+    done();
+  });
+
+  it('reverseStringUrlSafe returns url safe string', function (done) {
+    const urlSafeString = 'eyJhbGciOiJzaGE1MTIiL_CJ0e-XAiOiJKV1QifQ.eyJpZkkCI6IjEyMz';
+    const urlUnsafeString = 'eyJhbGciOiJzaGE1MTIiL/CJ0e+XAiOiJKV1QifQ.eyJpZkkCI6IjEyMz===';
+
+    const returnedString = stringUtilAuth.reverseStringUrlSafe(urlSafeString);
+    assert.deepStrictEqual(returnedString, urlUnsafeString);
+    done();
+  });
+
+  it('asciiToBase64 returns base 64 string', function (done) {
+    const asciiString = 'How are you';
+    const base64String = 'SG93IGFyZSB5b3U=';
+
+    const returnedString = stringUtilAuth.asciiToBase64(asciiString);
+    assert.deepStrictEqual(returnedString, base64String);
+    done();
+  });
+
+  it('base64ToAscii returns ascii string', function (done) {
+    const base64String = 'SG93IGFyZSB5b3U=';
+    const asciiString = 'How are you';
+
+    const returnedString = stringUtilAuth.base64ToAscii(base64String);
+    assert.deepStrictEqual(returnedString, asciiString);
+    done();
+  });
+
+  it('dollarSignConnectedStringToAlgorithmHashSalt split at $ returns object', function (done) {
+    const inputHash = '$1$c2hhNTEy$eyJhbGciOiJzaG$OiJzaGE1MTIiL$';
+    const expectedObject = {
+      version: '1',
+      alg: 'c2hhNTEy',
+      hash: 'eyJhbGciOiJzaG',
+      salt: 'OiJzaGE1MTIiL',
+    };
+
+    const returnedObject = stringUtilAuth.dollarSignConnectedStringToAlgorithmHashSalt(inputHash);
+    assert.deepStrictEqual(returnedObject, expectedObject);
+    done();
+  });
+
+  it('dotConnectedStringToHeaderPayloadSignature split at . returns object', function (done) {
+    const inputString = 'c2hhNTEy.eyJhbGciOiJzaG.OiJzaGE1MTIiL';
+    const expectedObject = {
+      header: 'c2hhNTEy',
+      payload: 'eyJhbGciOiJzaG',
+      signature: 'OiJzaGE1MTIiL',
+    };
+
+    const returnedObject = stringUtilAuth.dotConnectedStringToHeaderPayloadSignature(inputString);
+    assert.deepStrictEqual(expectedObject, returnedObject);
+    done();
+  });
+
+  it('objectToBase64UrlSafeString returns url safe base64 string', function (done) {
+    const object = {
+      header: {
+        alg: 'HS512',
+        typ: 'JWT',
+      },
+    };
+    const expectedBase64String = 'eyJoZWFkZXIiOnsiYWxnIjoiSFM1MTIiLCJ0eXAiOiJKV1QifX0';
+
+    const returnedBase64String = stringUtilAuth.objectToBase64UrlSafeString(object);
+    assert.deepStrictEqual(returnedBase64String, expectedBase64String);
+    done();
+  });
+
+  it('urlSafeBase64ToObject returns object', function (done) {
+    const base64String = 'eyJoZWFkZXIiOnsiYWxnIjoiSFM1MTIiLCJ0eXAiOiJKV1QifX0';
+    const expectedObject = {
+      header: {
+        alg: 'HS512',
+        typ: 'JWT',
+      },
+    };
+
+    const returnedObject = stringUtilAuth.urlSafeBase64ToObject(base64String);
+    assert.deepStrictEqual(returnedObject, expectedObject);
+    done();
+  });
+});

package/tests/jwtUtilAuth.test.ts

@@ -0,0 +1,33 @@
+import * as assert from 'assert';
+import * as jwtUtilAuthFromFile from '../src/jwtUtilAuth';
+
+describe('JwtUtilAuth test', function () {
+  it('assembleJwt called with header, payload and signature returns jwt', function () {
+    const header = 'eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9';
+    const payload =
+      'eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWUsImlhdCI6MTUxNjIzOTAyMn0';
+    const signature =
+      '-DprLrW2OyqiAFiuWs14WO2TWp2EHtaX7a63dqrklk-xrjaZMrcPhpX4hkZw803SQx5HpGc-7VYBX8l82XlMZg';
+    const expectedJwt =
+      'eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWUsImlhdCI6MTUxNjIzOTAyMn0.-DprLrW2OyqiAFiuWs14WO2TWp2EHtaX7a63dqrklk-xrjaZMrcPhpX4hkZw803SQx5HpGc-7VYBX8l82XlMZg';
+
+    const returnedJwt = jwtUtilAuthFromFile._assembleJwt(header, payload, signature);
+    assert.deepStrictEqual(returnedJwt, expectedJwt);
+  });
+
+  it('splitJwtInToHeaderPayloadSignature splits jwt into its parts', function () {
+    const jwt =
+      'eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWUsImlhdCI6MTUxNjIzOTAyMn0.-DprLrW2OyqiAFiuWs14WO2TWp2EHtaX7a63dqrklk-xrjaZMrcPhpX4hkZw803SQx5HpGc-7VYBX8l82XlMZg';
+    const headerExpected = 'eyJhbGciOiJIUzUxMiIsInR5cCI6IkpXVCJ9';
+    const payloadExpected =
+      'eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWUsImlhdCI6MTUxNjIzOTAyMn0';
+    const signatureExpected =
+      '-DprLrW2OyqiAFiuWs14WO2TWp2EHtaX7a63dqrklk-xrjaZMrcPhpX4hkZw803SQx5HpGc-7VYBX8l82XlMZg';
+
+    const { header, payload, signature } =
+      jwtUtilAuthFromFile._splitJwtInToHeaderPayloadSignature(jwt);
+    assert.deepStrictEqual(header, headerExpected);
+    assert.deepStrictEqual(payload, payloadExpected);
+    assert.deepStrictEqual(signature, signatureExpected);
+  });
+});

package/tests/keyGen.test.ts

@@ -0,0 +1,26 @@
+import * as assert from 'assert';
+import * as cryptoUtilAuth from '../src/cryptoUtilAuth';
+import { generateKeyPair } from '../src';
+
+describe('Create key to use with jwt', function () {
+  it('tests if keys created work', function () {
+    const { publicKey, privateKey } = generateKeyPair();
+
+    const algorithm = 'SHA256';
+    const token = 'Hi I am token';
+
+    const returnedSignature = cryptoUtilAuth.createBase64SignatureOfToken(
+      token,
+      privateKey,
+      algorithm,
+    );
+    const returnedValue = cryptoUtilAuth.verifyBase64SignatureOfToken(
+      token,
+      returnedSignature,
+      publicKey,
+      algorithm,
+    );
+
+    assert.deepStrictEqual(returnedValue, true);
+  });
+});

package/tests/keys/keys.ts

@@ -0,0 +1,24 @@
+export const privateKey =
+  '-----BEGIN RSA PRIVATE KEY-----\n' +
+  'MIICWgIBAAKBgF/34KV8D2pL57AiOSBYaNeCdVZEbXTOjR2J/UEH/F240gTxVT2K' +
+  'nXOP4W6OdFkSEsdDWLqhLO2OP68oakh3dm0Yzb8U+4Eos5Z3ZS+hgZCiutmm4Ef2' +
+  'krUshS8BI8MJvI4YPn4meJzaDz3SccQ2O9V6YpaYX1VqHO48qNGpg/LdAgMBAAEC' +
+  'gYBGlYAK9uY3nkB4EZPGsH/cEj3PB2EiClFMKpO0YvVA0ZDWxdGWA/+uYWLC98+n' +
+  'O13IZUY7bhQnXPqGD8msJwFYcCJahMtDlr0UvYVgTlYj7pVUjZEdj975vbSeVpu+' +
+  'MNK5KwQEel5phrpajpvX0feWjAKZQ7rt+xbAQ66azP4RwQJBALD8zJavNcSCUcKX' +
+  'Ll3gjgUOCeNxWGmy4Pj9QQV/SCUF0OPYl1tfS5+8hrDJRhElLaFon8TqAvZI+CxP' +
+  'cSBDrpkCQQCKz7Ys/O+NyNYC9eQuyUmLqgMQD9z3nJKbZrmhpGQNnTmkdBhdME3F' +
+  'Bn71GM6g5roDZPv8jbue1Rnma2vXDWTlAkBoiVh55BEY+XQ7QDplvn2D5M/YZBk5' +
+  'jSsuRb+C9LPzEiVYfpSfpoCvX5YakzdsZw41mOtNTn7jYyQaX+3Mhc15AkAQAzX4' +
+  'qpTXvjsxzDuuSfn56nq/95R928nts0PmqZgBGgn0NpA478GI4N70VxA+71611Yhb' +
+  '8d2azOpX8jxWam0hAkBeLsgPso9MiFXtRnl4jLt7X5CT673EY3oFSRq+ZJNE1pGQ' +
+  '7Z/g7Yg/WeznAvpqYx3b6m3DpPzrPU6KWQ/Gfs+L\n' +
+  '-----END RSA PRIVATE KEY-----';
+
+export const publicKey =
+  '-----BEGIN PUBLIC KEY-----\n' +
+  'MIGeMA0GCSqGSIb3DQEBAQUAA4GMADCBiAKBgF/34KV8D2pL57AiOSBYaNeCdVZE' +
+  'bXTOjR2J/UEH/F240gTxVT2KnXOP4W6OdFkSEsdDWLqhLO2OP68oakh3dm0Yzb8U' +
+  '+4Eos5Z3ZS+hgZCiutmm4Ef2krUshS8BI8MJvI4YPn4meJzaDz3SccQ2O9V6YpaY' +
+  'X1VqHO48qNGpg/LdAgMBAAE=\n' +
+  '-----END PUBLIC KEY-----';

package/tests/pwdUtilAuth.test.ts

@@ -0,0 +1,40 @@
+import * as assert from 'assert';
+import * as pwdUtilAuth from '../src/pwdUtilAuth';
+
+describe('PwdUtilAuth test', function () {
+  it('assemblePasswordHash called with algorithmBase64, hashBase64, saltBase64 returns password hash', function () {
+    const algorithmBase64 = 'c2hhMjU2';
+    const hashBase64 = 'c2hhMjU2';
+    const saltBase64 = 'c2hhMjU2';
+    const expectedHash = '$1$c2hhMjU2$c2hhMjU2$c2hhMjU2$';
+
+    const returnedHash = pwdUtilAuth._assemblePasswordHash(algorithmBase64, hashBase64, saltBase64);
+
+    assert.deepStrictEqual(returnedHash, expectedHash);
+  });
+
+  it('disassemblePasswordHash called with save hash', function () {
+    const savedHash = '$1$c2hhMjU2$c2hhMjU$c2hhMjU2$';
+    const hashBase64 = 'c2hhMjU';
+    const saltBase64 = 'c2hhMjU2';
+
+    const { version, alg, hash, salt } = pwdUtilAuth._disassemblePasswordHash(savedHash);
+
+    assert.deepStrictEqual(salt, saltBase64);
+    assert.deepStrictEqual(hash, hashBase64);
+    assert.deepStrictEqual(version, '1');
+    assert.deepStrictEqual(alg, 'c2hhMjU2');
+  });
+
+  it('createPasswordHash called with save hash', function () {
+    const password = 'bigSecret*2';
+    const secret = '240gTxVT2KnXOP4W6OdFkSEsdDWLqhLO2OP68o';
+    const algorithm = 'sha512';
+    const salt = '6h29BnpUkqfrmtnY1xUrAGZcpcAl5cUEJ4Qjj+BGXbo=';
+    const expectedHash =
+      '$1$c2hhNTEy$rNPXY0aVOYsdenIAWdfxDL6d6247s+ScI9kcDvEBkipNo7S9QDy6utTqTcQLY3+tufc0f7AvmdocotW7bDIyYA==$6h29BnpUkqfrmtnY1xUrAGZcpcAl5cUEJ4Qjj+BGXbo=$';
+    const hash = pwdUtilAuth._createPasswordHash(password, secret, salt, algorithm);
+
+    assert.deepStrictEqual(hash, expectedHash);
+  });
+});

package/tsconfig.base.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "lib": ["ES2020", "ES2021", "dom"],
+    "declaration": true,
+    "strict": true,
+    "moduleResolution": "Node",
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "isolatedModules": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/tsconfig.cjs.json

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

package/tsconfig.esm.json

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