@carecard/auth-util 2.0.0 → 3.0.0

package/dist/esm/strEncryptUtil.js

@@ -1,97 +0,0 @@
-// src/strEncryptUtil.ts
-import * as crypto from 'crypto';
-/**
- * Derive a key using scrypt.
- */
-export function createKey(key, keyLength = 32) {
-    // scryptSync returns a Buffer
-    return crypto.scryptSync(key, key, keyLength);
-}
-/* --------------------------------------------------
- * Helpers
- * -------------------------------------------------- */
-function getErrorCodeOrFallback(error) {
-    // Safely narrow 'unknown' to read 'code' when available
-    if (typeof error === 'object' &&
-        error !== null &&
-        'code' in error &&
-        typeof error.code === 'string') {
-        return error.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, textToEncrypt) => {
-    try {
-        const encrypted = crypto.privateEncrypt(encryptionConfigObj.privateKey, Buffer.from(textToEncrypt, 'utf8'));
-        return encrypted.toString(encryptionConfigObj.encryptedTextEncoding);
-    }
-    catch (error) {
-        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, textToDecrypt) => {
-    try {
-        const decrypted = crypto.publicDecrypt(decryptionConfigObj.publicKey, Buffer.from(textToDecrypt, decryptionConfigObj.encryptedTextEncoding));
-        return decrypted.toString(decryptionConfigObj.plainTextEncoding);
-    }
-    catch (error) {
-        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, textToEncrypt) => {
-    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) {
-        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, textToDecrypt) => {
-    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) {
-        return getErrorCodeOrFallback(error);
-    }
-};

package/dist/esm/stringUtilAuth.d.ts

@@ -1,64 +0,0 @@
-/**
- * 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 declare const adjustBase64Padding: (base64String: string) => string;
-/**
- * Removes /, + and = from the string
- * @returns {string}
- */
-export declare const makeStringUrlSafe: (urlUnsafeString?: string) => string;
-/**
- * Put back /, + and = into the string
- * @returns {string}
- */
-export declare const reverseStringUrlSafe: (urlSafeString?: string) => string;
-/**
- * Encode string to base64 string
- * @param unCodedString
- * @returns {string}
- */
-export declare const asciiToBase64: (unCodedString: string) => string;
-/** Decode string from base64
- * @param codedString
- * @returns {string}
- */
-export declare const base64ToAscii: (codedString: string) => string;
-/**
- * Decompose $ connected string and return an object
- * return null if error
- * @param passwordHash
- */
-export declare const dollarSignConnectedStringToAlgorithmHashSalt: (passwordHash: string) => {
-    version: string;
-    alg: string;
-    hash: string;
-    salt: string;
-} | null;
-/**
- * Decompose . connected string and return an object with
- * {header: 'string', payload: 'string', signature: 'string'}
- * return null if error
- */
-export declare const dotConnectedStringToHeaderPayloadSignature: (jwt: string) => {
-    header: string;
-    payload: string;
-    signature: string;
-} | null;
-/**
- * Turns object into url safe string
- * @param object
- * @return {string}
- */
-export declare const objectToBase64UrlSafeString: (object: any) => string;
-/**
- * Turns base64 into object
- * @param urlSafeBase64String
- * @return {any}
- */
-export declare const urlSafeBase64ToObject: (urlSafeBase64String: string) => any;

package/dist/esm/stringUtilAuth.js

@@ -1,96 +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) => {
-    while (base64String.length % 4)
-        base64String += '=';
-    return base64String;
-};
-/**
- * Removes /, + and = from the string
- * @returns {string}
- */
-export const makeStringUrlSafe = (urlUnsafeString = '') => {
-    return urlUnsafeString.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
-};
-/**
- * Put back /, + and = into the string
- * @returns {string}
- */
-export const reverseStringUrlSafe = (urlSafeString = '') => {
-    let myString = urlSafeString.replace(/-/g, '+').replace(/_/g, '/');
-    return adjustBase64Padding(myString);
-};
-/**
- * Encode string to base64 string
- * @param unCodedString
- * @returns {string}
- */
-export const asciiToBase64 = (unCodedString) => {
-    return Buffer.from(unCodedString).toString('base64');
-};
-/** Decode string from base64
- * @param codedString
- * @returns {string}
- */
-export const base64ToAscii = (codedString) => {
-    return Buffer.from(codedString, 'base64').toString('ascii');
-};
-/**
- * Decompose $ connected string and return an object
- * return null if error
- * @param passwordHash
- */
-export const dollarSignConnectedStringToAlgorithmHashSalt = (passwordHash) => {
-    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) => {
-    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) => {
-    let stringAscii = JSON.stringify(object);
-    let base64String = asciiToBase64(stringAscii);
-    return makeStringUrlSafe(base64String);
-};
-/**
- * Turns base64 into object
- * @param urlSafeBase64String
- * @return {any}
- */
-export const urlSafeBase64ToObject = (urlSafeBase64String) => {
-    let base64String = reverseStringUrlSafe(urlSafeBase64String);
-    let stringAscii = base64ToAscii(base64String);
-    return JSON.parse(stringAscii);
-};

package/lib/strEncryptUtil.js

@@ -1,113 +0,0 @@
-const crypto = require( "crypto" );
-
-
-function createKey( key, keyLength = 32 ) {
-    return crypto.scryptSync( key, key, keyLength );
-}
-
-const encryptByPrivateKey = ( encryptionConfigObj, textToEncrypt ) => {
-    try {
-
-        const encrypted = crypto.privateEncrypt(
-            encryptionConfigObj.privateKey,
-            Buffer.from( textToEncrypt )
-        );
-
-        return encrypted.toString( encryptionConfigObj.encryptedTextEncoding );
-
-    } catch ( error ) {
-
-        return error.code;
-
-    }
-};
-
-const decryptByPublicKey = ( decryptionConfigObj, textToDecrypt ) => {
-    try {
-
-        const decrypted = crypto.publicDecrypt(
-            decryptionConfigObj.publicKey,
-            Buffer.from(
-                textToDecrypt,
-                decryptionConfigObj.encryptedTextEncoding
-            )
-        );
-
-        return decrypted.toString( decryptionConfigObj.plainTextEncoding );
-
-    } catch ( error ) {
-
-        return error.code;
-
-    }
-};
-
-const encryptByKey = ( encryptConfigObj = {}, textToEncrypt ) => {
-    try {
-
-        const iv = Buffer.alloc( 16, 0 );
-
-        const cipher = crypto.createCipheriv(
-            encryptConfigObj.cipherAlgorithm,
-            createKey(
-                encryptConfigObj.encryptionKey,
-                encryptConfigObj.keyLength
-            ),
-            iv
-        );
-
-        let encrypted = cipher.update(
-            textToEncrypt,
-            encryptConfigObj.plainTextEncoding,
-            encryptConfigObj.encryptedTextEncoding
-        );
-
-        encrypted += cipher.final( encryptConfigObj.encryptedTextEncoding );
-
-        return encrypted;
-
-    } catch ( error ) {
-
-        return error.code;
-
-    }
-};
-
-const decryptByKey = ( encryptConfigObj, textToDecrypt ) => {
-    try {
-
-        const iv = Buffer.alloc( 16, 0 );
-
-        const decipher = crypto.createDecipheriv(
-            encryptConfigObj.cipherAlgorithm,
-            createKey(
-                encryptConfigObj.encryptionKey,
-                encryptConfigObj.keyLength
-            ),
-            iv
-        );
-
-        let decrypted = decipher.update(
-            textToDecrypt,
-            encryptConfigObj.encryptedTextEncoding,
-            encryptConfigObj.plainTextEncoding
-        );
-
-        decrypted += decipher.final( encryptConfigObj.plainTextEncoding );
-
-        return decrypted;
-
-    } catch ( error ) {
-
-        return error.code;
-
-    }
-};
-
-
-module.exports = {
-    encryptByPrivateKey,
-    decryptByPublicKey,
-    encryptByKey,
-    decryptByKey
-}