@carecard/auth-util 3.1.15 → 3.1.16

package/src/pwdUtilAuth.ts

@@ -1,78 +0,0 @@
-import * as cryptoUtilAuth from './cryptoUtilAuth';
-import * as stringUtilAuth from './stringUtilAuth';
-
-/**
- * Just assemble password together
- * @param algorithmBase64
- * @param hashBase64
- * @param saltBase64
- * @return {string}
- */
-export const _assemblePasswordHash = (
-  algorithmBase64: string,
-  hashBase64: string,
-  saltBase64: string,
-): string => {
-  return '$1$' + algorithmBase64 + '$' + hashBase64 + '$' + saltBase64 + '$';
-};
-
-/**
- * Break password into its parts does not reverse base64 encoding.
- * @param passwordHashStored
- * @return {{salt: *, version: *, alg: *, hash: *}}
- */
-export const _disassemblePasswordHash = (passwordHashStored: string): any => {
-  return stringUtilAuth.dollarSignConnectedStringToAlgorithmHashSalt(passwordHashStored);
-};
-
-/**
- * Creates password hash ready to be saved in database.
- * @param password
- * @param secret
- * @param salt
- * @param algorithm
- * @return {string}
- */
-export const _createPasswordHash = (
-  password: string,
-  secret: string,
-  salt: string,
-  algorithm: string,
-): string => {
-  const algorithmBase64 = stringUtilAuth.asciiToBase64(algorithm);
-  const hashBase64 = cryptoUtilAuth.createHmacBase64(password, secret, algorithm);
-  return _assemblePasswordHash(algorithmBase64, hashBase64, salt);
-};
-
-/**
- * Automatically adds random salt.
- * @param password
- * @param secret
- * @param algorithm
- * @return {string}
- */
-export const createPasswordHashWithRandomSalt = (
-  password: string,
-  secret: string,
-  algorithm: string,
-): string => {
-  const salt = cryptoUtilAuth.createSaltBase64();
-  return _createPasswordHash(password, secret, salt, algorithm);
-};
-
-/**
- * Creates hash based on saved hash in database.
- * @param password
- * @param savedPasswordHash
- * @param secret
- * @return {string}
- */
-export const createPasswordHashBasedOnSavedAlgorithmSalt = (
-  password: string,
-  savedPasswordHash: string,
-  secret: string,
-): string => {
-  const { alg, salt } = _disassemblePasswordHash(savedPasswordHash);
-  const algorithm = stringUtilAuth.base64ToAscii(alg);
-  return _createPasswordHash(password, secret, salt, algorithm);
-};

package/src/strEncryptUtil.ts

@@ -1,159 +0,0 @@
-// src/strEncryptUtil.ts
-import * as crypto from 'crypto';
-
-/**
- * Derive a key using scrypt.
- */
-export function createKey(key: crypto.BinaryLike, keyLength = 32): Buffer {
-  // scryptSync returns a Buffer
-  return crypto.scryptSync(key, key, keyLength);
-}
-
-/* --------------------------------------------------
- * Config Types
- * -------------------------------------------------- */
-
-export interface EncryptionConfig {
-  privateKey: string | Buffer | crypto.KeyObject;
-  encryptedTextEncoding: BufferEncoding; // e.g., 'base64' | 'hex' | ...
-}
-
-export interface DecryptionConfig {
-  publicKey: string | Buffer | crypto.KeyObject;
-  encryptedTextEncoding: BufferEncoding; // encoding of input cipher text buffer
-  plainTextEncoding: BufferEncoding; // encoding for output text, e.g., 'utf8'
-}
-
-export interface SymmetricCryptoConfig {
-  cipherAlgorithm: string; // e.g., 'aes-256-cbc'
-  encryptionKey: crypto.BinaryLike; // passphrase or raw key-like data
-  keyLength: number; // e.g., 32 for aes-256
-  plainTextEncoding: BufferEncoding; // e.g., 'utf8'
-  encryptedTextEncoding: BufferEncoding; // e.g., 'base64' | 'hex'
-}
-
-/* --------------------------------------------------
- * Helpers
- * -------------------------------------------------- */
-
-function getErrorCodeOrFallback(error: unknown): string {
-  // Safely narrow 'unknown' to read 'code' when available
-  if (
-    typeof error === 'object' &&
-    error !== null &&
-    'code' in error &&
-    typeof (error as { code?: unknown }).code === 'string'
-  ) {
-    return (error as { code: string }).code;
-  }
-  if (error instanceof Error) {
-    // You can return message or name; using name keeps it short
-    return `ERROR:${error.name}`;
-  }
-  return 'UNKNOWN_ERROR';
-}
-
-/* --------------------------------------------------
- * Asymmetric Encryption (RSA or similar)
- * -------------------------------------------------- */
-
-/**
- * Encrypts text using a private key, returning an encoded cipher text string.
- * On error, returns a code string if present, otherwise a fallback.
- */
-export const encryptByPrivateKey = (
-  encryptionConfigObj: EncryptionConfig,
-  textToEncrypt: string,
-): string => {
-  try {
-    const encrypted = crypto.privateEncrypt(
-      encryptionConfigObj.privateKey,
-      Buffer.from(textToEncrypt, 'utf8'),
-    );
-    return encrypted.toString(encryptionConfigObj.encryptedTextEncoding);
-  } catch (error: unknown) {
-    return getErrorCodeOrFallback(error);
-  }
-};
-
-/**
- * Decrypts text using a public key, returning a plain text string.
- * On error, returns a code string if present, otherwise a fallback.
- */
-export const decryptByPublicKey = (
-  decryptionConfigObj: DecryptionConfig,
-  textToDecrypt: string,
-): string => {
-  try {
-    const decrypted = crypto.publicDecrypt(
-      decryptionConfigObj.publicKey,
-      Buffer.from(textToDecrypt, decryptionConfigObj.encryptedTextEncoding),
-    );
-    return decrypted.toString(decryptionConfigObj.plainTextEncoding);
-  } catch (error: unknown) {
-    return getErrorCodeOrFallback(error);
-  }
-};
-
-/* --------------------------------------------------
- * Symmetric Encryption (AES or similar)
- * -------------------------------------------------- */
-
-/**
- * Encrypts text using a symmetric algorithm and derived key, returning an encoded cipher string.
- * On error, returns a code string if present, otherwise a fallback.
- *
- * NOTE: This uses a zero IV (Buffer.alloc(16, 0)) which is generally **not recommended** for production.
- * Prefer a random IV per encryption and prepend/append it to the output for decryption.
- */
-export const encryptByKey = (
-  encryptConfigObj: SymmetricCryptoConfig,
-  textToEncrypt: string,
-): string => {
-  try {
-    const iv = Buffer.alloc(16, 0); // ⚠️ consider using a random IV for security
-    const key = createKey(encryptConfigObj.encryptionKey, encryptConfigObj.keyLength);
-
-    const cipher = crypto.createCipheriv(encryptConfigObj.cipherAlgorithm, key, iv);
-
-    let encrypted = cipher.update(
-      textToEncrypt,
-      encryptConfigObj.plainTextEncoding,
-      encryptConfigObj.encryptedTextEncoding,
-    );
-    encrypted += cipher.final(encryptConfigObj.encryptedTextEncoding);
-
-    return encrypted;
-  } catch (error: unknown) {
-    return getErrorCodeOrFallback(error);
-  }
-};
-
-/**
- * Decrypts a cipher string using a symmetric algorithm and derived key,
- * returning the plain text string. On error, returns a code string or fallback.
- *
- * NOTE: Must use the same IV that was used during encryption. Here it assumes a zero IV.
- */
-export const decryptByKey = (
-  encryptConfigObj: SymmetricCryptoConfig,
-  textToDecrypt: string,
-): string => {
-  try {
-    const iv = Buffer.alloc(16, 0); // ⚠️ must match the IV used in encryptByKey
-    const key = createKey(encryptConfigObj.encryptionKey, encryptConfigObj.keyLength);
-
-    const decipher = crypto.createDecipheriv(encryptConfigObj.cipherAlgorithm, key, iv);
-
-    let decrypted = decipher.update(
-      textToDecrypt,
-      encryptConfigObj.encryptedTextEncoding,
-      encryptConfigObj.plainTextEncoding,
-    );
-    decrypted += decipher.final(encryptConfigObj.plainTextEncoding);
-
-    return decrypted;
-  } catch (error: unknown) {
-    return getErrorCodeOrFallback(error);
-  }
-};

package/src/stringUtilAuth.ts

@@ -1,102 +0,0 @@
-'use strict';
-/**
- * For incoming jwt token validation, splitting and parsing.
- * For outgoing jwt token assembling to jwt, make it url safe.
- */
-
-/**
- * Adjusts padding of base64String
- * @param base64String
- * @return {*}
- */
-export const adjustBase64Padding = (base64String: string): string => {
-  while (base64String.length % 4) base64String += '=';
-  return base64String;
-};
-
-/**
- * Removes /, + and = from the string
- * @returns {string}
- */
-export const makeStringUrlSafe = (urlUnsafeString: string = ''): string => {
-  return urlUnsafeString.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
-};
-
-/**
- * Put back /, + and = into the string
- * @returns {string}
- */
-export const reverseStringUrlSafe = (urlSafeString: string = ''): string => {
-  let myString = urlSafeString.replace(/-/g, '+').replace(/_/g, '/');
-  return adjustBase64Padding(myString);
-};
-
-/**
- * Encode string to base64 string
- * @param unCodedString
- * @returns {string}
- */
-export const asciiToBase64 = (unCodedString: string): string => {
-  return Buffer.from(unCodedString).toString('base64');
-};
-
-/** Decode string from base64
- * @param codedString
- * @returns {string}
- */
-export const base64ToAscii = (codedString: string): string => {
-  return Buffer.from(codedString, 'base64').toString('ascii');
-};
-
-/**
- * Decompose $ connected string and return an object
- * return null if error
- * @param passwordHash
- */
-export const dollarSignConnectedStringToAlgorithmHashSalt = (passwordHash: string) => {
-  const splitStringArray = passwordHash.split('$');
-  if (splitStringArray.length !== 6) return null;
-  return {
-    version: splitStringArray[1],
-    alg: splitStringArray[2],
-    hash: splitStringArray[3],
-    salt: splitStringArray[4],
-  };
-};
-
-/**
- * Decompose . connected string and return an object with
- * {header: 'string', payload: 'string', signature: 'string'}
- * return null if error
- */
-export const dotConnectedStringToHeaderPayloadSignature = (jwt: string) => {
-  const splitJWT = jwt.split('.');
-  if (splitJWT.length !== 3) return null;
-  return {
-    header: splitJWT[0],
-    payload: splitJWT[1],
-    signature: splitJWT[2],
-  };
-};
-
-/**
- * Turns object into url safe string
- * @param object
- * @return {string}
- */
-export const objectToBase64UrlSafeString = (object: any): string => {
-  let stringAscii = JSON.stringify(object);
-  let base64String = asciiToBase64(stringAscii);
-  return makeStringUrlSafe(base64String);
-};
-
-/**
- * Turns base64 into object
- * @param urlSafeBase64String
- * @return {any}
- */
-export const urlSafeBase64ToObject = (urlSafeBase64String: string): any => {
-  let base64String = reverseStringUrlSafe(urlSafeBase64String);
-  let stringAscii = base64ToAscii(base64String);
-  return JSON.parse(stringAscii);
-};

package/tests/cryptoUtilAuth.test.ts

@@ -1,97 +0,0 @@
-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

@@ -1,157 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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();
-  });
-});