ncrypt-js 2.0.0 → 2.1.0

package/README.md

@@ -1,30 +1,22 @@
 # NcryptJs
 
-[![Build Status](https://travis-ci.com/ajimae/ncrypt-js.svg?branch=master)](https://travis-ci.com/ajimae/ncrypt-js) [![Coverage Status](https://coveralls.io/repos/github/ajimae/ncrypt-js/badge.svg)](https://coveralls.io/github/ajimae/ncrypt-js) ![NPM](https://img.shields.io/npm/l/ncrypt-js)
+[![Build Status](https://travis-ci.com/ajimae/ncrypt-js.svg?branch=master)](https://travis-ci.com/ajimae/ncrypt-js) [![Coverage Status](https://coveralls.io/repos/github/ajimae/ncrypt-js/badge.svg)](https://coveralls.io/github/ajimae/ncrypt-js) [![NPM](https://img.shields.io/npm/l/ncrypt-js)](https://www.npmjs.com/package/ncrypt-js/v/2.0.0#license)
 
-![GitHub release (latest by date)](https://img.shields.io/github/v/release/ajimae/ncrypt-js) ![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/ajimae/ncrypt-js) ![GitHub issues](https://img.shields.io/github/issues/ajimae/ncrypt-js)
+[![GitHub release (latest by date)](https://img.shields.io/github/v/release/ajimae/ncrypt-js)](https://github.com/ajimae/ncrypt-js/releases) [![GitHub code size in bytes](https://img.shields.io/github/languages/code-size/ajimae/ncrypt-js)](https://github/languages/code-size/ajimae/ncrypt-js) [![GitHub issues](https://img.shields.io/github/issues/ajimae/ncrypt-js)](https://github.com/ajimae/ncrypt-js/issues)
 
 **_NcryptJs_** is a light weight javascript data encryption and decryption library. This library implements the nodejs default crypto functionality as a mid-channel cipher in addition to a simple and elegant custom data encoding and encryption algorithm.
 
-<!-- ```diff
-- const ReduxThunk = require('redux-thunk')
-+ const ReduxThunk = require('redux-thunk').default
-``` -->
-
 ## Contents
 
 * [NcryptJs](#NcryptJs)
   * [Contents](#contents)
-  <!-- * [Changes Log (What's New)](#changes-log-whats-new) -->
   * [Getting Started](#getting-started)
     * [Installation](#installation)
   * [Documentation](#documentation)
-    * [NcryptJs Functions](#ncryptjs-functions)
-    * [Using `encrypt()` and `decrypt()`](#using-encrypt-and-decrypt)
-    * [Using default imports](#Using-default-imports)
-    <!-- * [Change the Secret Key](#change-the-secret-key)
-    * [Object Encryption](#object-encryption)
-    * [Random Key Generator](#random-key-generator) -->
+    * [NcryptJs Methods](#ncryptjs-methods)
+    * [Using the `randomString()` methods](#using-randomstring-method)
+    * [Using `encrypt()` and `decrypt()` methods](#using-encrypt-and-decrypt-methods)
+    * [Using default imports](#using-default-imports)
   * [Built With](#built-with)
   * [Contribution](#contribution)
   * [Version Management](#version-management)
@@ -82,23 +74,38 @@ However, if you are using ECMAScript 5 and older, use the require statement:
 
 **_NcryptJs_** is a simple library with only two two exposed functions. This is all intentional mainly to keep everything simple. This is a complete documentation of the library and how to use it in your project. All examples work on both ECMAScript 6 (and later) and ECMAScript 5 (and older).
 
-### NcryptJs Functions
+### NcryptJs Methods
 
 
-### List of **_NcryptJs_** functions.
+### List of **_NcryptJs_** Methods.
 
 
 
-| Functions                                                                                              | Description                                                                                            | Parameters                                                                                             | Return                                                                                                 |
+| Methods                                                                                              | Description                                                                                            | Parameters                                                                                             | Return                                                                                                 |
 | -------------------------------------------------------------                                          | --------------------------------------------------------------------------------------                 | -----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------                                                                             | ----------------------------------------------------------------------------------------------------------------                                                                                                |
+| [_static_] **randomString()**                                                                                          | Random String.                                                                                     |**size**: _number_ - An optional size of the generated `randomBytes`. <br/>**enc:** _base64/hex_ - Encoding used for encoding the `randomBytes` defaults to _`base64`_ |**encoded**: _string_ - encoded string.                                                                    |
 | **encrypt()**                                                                                          | Encrypts data.                                                                                     |**data**: _object/string/number/boolean_ - The data to be encrypted. <br/>|**ciphered**: _string_ - encrypted data.                                                                    |
 | **decrypt()**                                                                                          | Decrypts the encrypted or ciphered data                                                                 | **encodedData**: string - The encrypted data: _string_ to be decrypted.                        | **data**: _string/object/number/boolean_ - The decrypted or original data (it might be string or object, depends on the initial input data type).
 
 
+### Using randomString method
+
+The `randomString()` static method can generate [random bytes](https://nodejs.org/api/crypto.html#cryptorandombytessize-callback) encoded into a `hexadecimal` or `base64` strings. This string can be useful in a variety of use cases e.g to generate database ids, to generate a unique string for a list, a unique serial strings etc.
 
-### Using `encrypt()` and `decrypt()` functons - As of version 1.1.0 this is deprecated, an object must be created first.
+```ts
+var ncrypt = require('ncrypt-js');
 
-To encrypt and decrypt data, simply use `encrypt()` and `decrypt()` functions respectively. This will use `AES-256-CBC` encryption algorithm as the mid-channel cipher.
+var randomStr = ncrypt.randomString(8, 'base64');
+console.log(randomStr) // t78WcmYAFOY=
+
+// signature
+ncrypt.randomString(size?: number, enc?: 'base64' | 'hex');
+```
+
+### Using encrypt() and decrypt() methods
+The `encrypt()` and `decrypt()` methods as of version 2.0.0 directly importing or invoking these methods is deprecated, an object must be created with a secret first, before the methods can now be invoked on the created object.
+
+To `encrypt` and `decrypt` data, simply use `encrypt()` and `decrypt()` methods respectively. This will use `AES-256-CBC` encryption algorithm as the mid-channel cipher.
 
 ```diff
 - var { encrypt, decrypt } = require("ncrypt-js");
@@ -108,7 +115,7 @@ To encrypt and decrypt data, simply use `encrypt()` and `decrypt()` functions re
 var data = "Hello World!";
 var _secretKey = "some-super-secret-key";
 
-+ var { encodeData, decodeData } = new ncrypt(_secretKey);
++ var { encrypt, decrypt } = new ncrypt(_secretKey);
 
 // encrypting super sensitive data here
 - var encryptedData = encrypt(data, _secretKey);
@@ -177,6 +184,26 @@ var decryptedObject = ncryptObject.decrypt(encryptedObject);
 console.log("... and then decryption...");
 console.log("Decipher Text : " + decryptedObject);
 console.log("...done.");
+````
+If you are using any sort of environmental key-value store, e.g `.env` and for additional security, you can add the following to your environment.
+
+```bash
+# .env
+
+# used internally to set the `key`
+KEY='sshhhh this is a super secret key'
+
+# used internally to set the `encoding` - ['base64' | 'binary' | 'hex' | 'ucs-2' | 'ucs2' | 'utf16le']
+NCRPT_ENC='hex'
+
+SECRET='this is our hashing secret'
+```
+Then when creating your object, you can use the SECRET from your environment e.g:
+```
+...
+var ncrypt = require('ncrypt-js');
+var { encrypt, decrypt } = new ncrypt(process.env.SECRET);
+...
 ```
 
 ## Built With 

package/{index.ts → dist/index.d.ts}

@@ -1,7 +1,3 @@
 import ncrypt from './src/ncrypt';
-
-module.exports = ncrypt;
 export default ncrypt;
-export {
-  ncrypt
-}
+export { ncrypt };

package/dist/index.js

@@ -7,4 +7,3 @@ const ncrypt_1 = __importDefault(require("./src/ncrypt"));
 exports.ncrypt = ncrypt_1.default;
 module.exports = ncrypt_1.default;
 exports.default = ncrypt_1.default;
-//# sourceMappingURL=index.js.map

package/dist/src/ncrypt.d.ts

@@ -0,0 +1,90 @@
+/**
+ * @class Ncrypt
+ * @type {Ncrypt.<object>}
+ */
+export default class Ncrypt {
+    /**
+     * encryption secret.
+     * @type {secret.<string>} secret
+     */
+    private secret;
+    /**
+     * algorithm used for encoding message
+     */
+    private readonly algorithm;
+    /**
+     * ecoding for encrypted stirng
+     */
+    private readonly enc;
+    /**
+     * crypto random initial vector generated from core node {crypto} module
+     */
+    private readonly initialVector;
+    /**
+     * crypto random key generated from core node {crypto} module
+     * {note}: please read the value for KEY from your app's environment
+     */
+    private readonly key;
+    /**
+     * object constructor
+     * @param {secret.<string>} secret
+     */
+    constructor(secret: string);
+    /**
+     * convert all entered text to decimal equivalent character codes
+     * @param {text.<string>} text to be converted
+     * @return {Array.<number>} array of character codes
+     */
+    private convertTextToDecimal;
+    /**
+     * encode provided secret on decimal character codes
+     * @param {charCode.<number, number[]>} charCodes
+     * @returns {*.<number>} decimal string
+     */
+    private applySecretToCharacters;
+    /**
+     * convert character bytes to hexadecimal equivalent
+     * @param {number.<number>} number
+     * @returns {*.<string>} hexadecimal string
+     */
+    private convertByteToHexadecimal;
+    /**
+     * intermediate data encoder function
+     * @param {string.<any>} text
+     * @param secret
+     * @returns {string} encrypted or cipher text
+     */
+    private encode;
+    /**
+     * intermediate data decoder function
+     * @param {string.<any>} text
+     * @returns {string.<string>} decrypted data
+     */
+    private decode;
+    /**
+     * generate random strings
+     * @example
+     *
+     * var fs = require('fs');
+     * var ncrypt = require('ncrypt-js');
+     *
+     * console.log(ncrypt.randomString(8, 'base64')); // g3lzZ48TW6w==
+     *
+     * @param {size.<number>} size
+     * @param {enc.<string>} enc
+     * @returns {*.<string>} string
+     */
+    static randomString(size?: number, enc?: 'hex' | 'base64'): string;
+    /**
+     * data to be encrypted
+     * @param {data.<stirng>} data
+     * @returns {*.<string>} encrypted text
+     */
+    encrypt(data: string | number | boolean | object): string;
+    /**
+     * text be decrypted
+     * @param {text.<stirng>} text
+     * @returns {*.<string>} decrypted data
+     */
+    decrypt(text: string): string | number | boolean | object;
+}

package/dist/src/ncrypt.js

@@ -1,76 +1,152 @@
 "use strict";
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("./utils");
+const crypto = __importStar(require("crypto"));
+/**
+ * @class Ncrypt
+ * @type {Ncrypt.<object>}
+ */
 class Ncrypt {
     /**
      * object constructor
-     * @param text
-     * @param secret
+     * @param {secret.<string>} secret
      */
     constructor(secret) {
+        /**
+         * algorithm used for encoding message
+         */
+        this.algorithm = 'aes-256-cbc';
+        /**
+         * ecoding for encrypted stirng
+         */
+        this.enc = (process.env.NCRYPT_ENC) || 'hex';
+        /**
+         * crypto random initial vector generated from core node {crypto} module
+         */
+        this.initialVector = crypto.randomBytes(16);
+        /**
+         * crypto random key generated from core node {crypto} module
+         * {note}: please read the value for KEY from your app's environment
+         */
+        this.key = crypto.scryptSync(process.env.KEY || 'please provide a KEY in your .env file or config', 'salt', 32);
         /**
          * convert all entered text to decimal equivalent character codes
-         * @param {data.<string>} data to be converted
+         * @param {text.<string>} text to be converted
          * @return {Array.<number>} array of character codes
          */
-        this.convertTextToDecimal = (data) => data.split('').map((value) => value.charCodeAt(0));
+        this.convertTextToDecimal = (text) => {
+            return text.split('').map((value) => value.charCodeAt(0));
+        };
         /**
          * encode provided secret on decimal character codes
-         * @param {charCode<number[], *>} character codes
+         * @param {charCode.<number, number[]>} charCodes
+         * @returns {*.<number>} decimal string
          */
-        this.applySecretToCharacters = (charCodes) => this.convertTextToDecimal(this.secret)
-            .reduce((firstValue, secondValue) => (firstValue ^ secondValue), charCodes);
+        this.applySecretToCharacters = (charCodes) => {
+            return this.convertTextToDecimal(this.secret)
+                .reduce((firstValue, secondValue) => (firstValue ^ secondValue), charCodes);
+        };
         /**
          * convert character bytes to hexadecimal equivalent
-         * @param {number.<number>}
-         * @returns {string} hexadecimal string
+         * @param {number.<number>} number
+         * @returns {*.<string>} hexadecimal string
          */
         this.convertByteToHexadecimal = (number) => {
-            return ("0" + Number(number).toString(16)).substr(-2);
+            return ('0' + Number(number).toString(16)).substr(-2);
         };
         /**
-         * process data to be encrypted
-         * @param {}
-         * @returns {string.<string>} encoded string data
+         * intermediate data encoder function
+         * @param {string.<any>} text
+         * @param secret
+         * @returns {string} encrypted or cipher text
          */
-        this.encrypt = (data) => {
-            /**
-             * this does the actual processing return a string
-             * resulting from charCode conversion, salting and
-             * hexadecimal mapping
-             *
-             */
-            // if (data == void 0) throw new Error('invalid data was entered, enter data of type object, number, string or boolean to be encrypted.');
-            try {
-                const encodedMessage = JSON.stringify(data).split('')
-                    .map(this.convertTextToDecimal)
-                    .map(this.applySecretToCharacters)
-                    .map(this.convertByteToHexadecimal)
-                    .join('');
-                return utils_1.encode(encodedMessage);
-            }
-            catch (error) {
-                throw new Error('invalid data was entered, enter data of type object, number, string or boolean to be encrypted.');
+        this.encode = (text) => {
+            let cipher = crypto.createCipheriv(this.algorithm, Buffer.from(this.key), this.initialVector);
+            let encrypted = cipher.update(text);
+            encrypted = Buffer.concat([encrypted, cipher.final()]);
+            return `${this.initialVector.toString(this.enc)}.${encrypted.toString(this.enc)}`;
+        };
+        /**
+         * intermediate data decoder function
+         * @param {string.<any>} text
+         * @returns {string.<string>} decrypted data
+         */
+        this.decode = (text) => {
+            if (typeof text !== 'string') {
+                throw new TypeError('argument must be a string, or a string-like object');
             }
+            const iv = text.split('.')[0];
+            const encryptedData = text.split('.')[1];
+            let _iv = Buffer.from(iv, this.enc);
+            let encryptedText = Buffer.from(encryptedData, this.enc);
+            let decipher = crypto.createDecipheriv(this.algorithm, Buffer.from(this.key), _iv);
+            let decrypted = decipher.update(encryptedText);
+            decrypted = Buffer.concat([decrypted, decipher.final()]);
+            return decrypted.toString();
         };
+        this.secret = secret;
+        // bind public instnace methods
+        this.encrypt = this.encrypt.bind(this);
+        this.decrypt = this.decrypt.bind(this);
+    }
+    /**
+     * generate random strings
+     * @example
+     *
+     * var fs = require('fs');
+     * var ncrypt = require('ncrypt-js');
+     *
+     * console.log(ncrypt.randomString(8, 'base64')); // g3lzZ48TW6w==
+     *
+     * @param {size.<number>} size
+     * @param {enc.<string>} enc
+     * @returns {*.<string>} string
+     */
+    static randomString(size, enc = 'base64') {
+        return crypto.randomBytes(size || 64).toString(enc);
+    }
+    /**
+     * data to be encrypted
+     * @param {data.<stirng>} data
+     * @returns {*.<string>} encrypted text
+     */
+    encrypt(data) {
         /**
-         * decodes encoded string resulting from util encryption
-         * @param {string.<stirng>} encodeData
-         * @returns {decodedData.<string>} decoded data
+         * this does the actual processing return a string
+         * resulting from charCode conversion, salting and
+         * hexadecimal mapping
          */
-        this.decrypt = (text) => {
-            const encodeData = utils_1.decode(text);
-            const data = encodeData.match(/.{1,2}/g)
-                .map((hex) => parseInt(hex, 16))
+        try {
+            const encodedMessage = JSON.stringify(data).split('')
+                .map(this.convertTextToDecimal)
                 .map(this.applySecretToCharacters)
-                .map((charCode) => String.fromCharCode(charCode))
+                .map(this.convertByteToHexadecimal)
                 .join('');
-            const arr = [];
-            arr.push(data);
-            return JSON.parse(data);
-        };
-        this.secret = secret;
+            return this.encode(encodedMessage);
+        }
+        catch (e) {
+            throw new Error('invalid data was entered, enter data of type object, number, string or boolean to be encrypted.' + e);
+        }
+    }
+    /**
+     * text be decrypted
+     * @param {text.<stirng>} text
+     * @returns {*.<string>} decrypted data
+     */
+    decrypt(text) {
+        const encodeData = this.decode(text);
+        const data = (encodeData).match(/.{1,2}/g)
+            .map((hex) => parseInt(hex, 16))
+            .map(this.applySecretToCharacters)
+            .map((charCode) => String.fromCharCode(charCode))
+            .join('');
+        return JSON.parse(data);
     }
 }
 exports.default = Ncrypt;
-//# sourceMappingURL=ncrypt.js.map

package/package.json

@@ -1,14 +1,12 @@
 {
   "name": "ncrypt-js",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "a light weight javascript data encryption and decryption library",
   "main": "dist/index.js",
   "scripts": {
-    "start": "npm run build && node dist/index",
-    "start:dev": "ts-node index.ts",
     "clean": "rm -rf dist",
-    "prepare": "npm run build",
-    "build": "tsc --outDir dist",
+    "prepare": "yarn build",
+    "build": "yarn clean;tsc --outDir dist",
     "test": "cross-env TS_NODE_FILES=true nyc mocha --exit --require ts-node/register --colors test/**/*.ts",
     "coverage": "nyc report --reporter=text-lcov | coveralls"
   },
@@ -30,7 +28,7 @@
     "decryption",
     "javascript-library"
   ],
-  "author": "meeky",
+  "author": "ajimae",
   "license": "MIT",
   "bugs": {
     "url": "https://github.com/ajimae/ncrypt-js/issues"
@@ -48,12 +46,15 @@
     "mocha-lcov-reporter": "^1.3.0",
     "nyc": "^14.1.1",
     "ts-node": "^8.6.2",
-    "typescript": "^3.8.3"
+    "typescript": "3.8.3"
   },
+  "files": [
+    "dist",
+    "package.json",
+    "LICENSE",
+    "tsconfig.json"
+  ],
   "dependencies": {
-    "crypto": "^1.0.1",
-    "dotenv": "^8.2.0",
-    "handlebars": "^4.7.3",
-    "simple-crypto-js": "^2.2.0"
+    "crypto": "^1.0.1"
   }
 }

package/tsconfig.json

@@ -6,7 +6,8 @@
       "esModuleInterop": true,
       "noImplicitAny": true,
       "moduleResolution": "node",
-      "sourceMap": true,
+      "declaration": true,
+      "sourceMap": false,
       "outDir": "dist",
       "baseUrl": ".",
       "paths": {

package/.nycrc

@@ -1,29 +0,0 @@
-{
-  "cache": false,
-  "check-coverage": false,
-  "extension": [
-    ".ts"
-  ],
-  "require": [
-    "ts-node/register"
-  ],
-  "include": [
-    "**/*js",
-    "**/*ts"
-  ],
-  "exclude": [
-    "dist/**",
-    "coverage/**",
-    "node_modules/**",
-    "**/*.d.ts",
-    "**/*.test.ts"
-  ],
-  "sourceMap": true,
-  "reporter": [
-    "html",
-    "text",
-    "text-summary"
-  ],
-  "all": true,
-  "instrument": true
-}

package/.travis.yml

@@ -1,11 +0,0 @@
-language: node_js
-node_js:
-  - "node"
-cache:
-  directories:
-    - "node_modules"
-script:
-  - npm test
-after_success:
-  - npm run coverage
-  - ./cc-test-reporter after-build --exit-code $TRAVIS_TEST_RESULT

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":";;;;;AAAA,0DAAkC;AAKhC,iBALK,gBAAM,CAKL;AAHR,MAAM,CAAC,OAAO,GAAG,gBAAM,CAAC;AACxB,kBAAe,gBAAM,CAAC"}

package/dist/src/ncrypt.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ncrypt.js","sourceRoot":"","sources":["../../src/ncrypt.ts"],"names":[],"mappings":";;AACA,mCAAyC;AAEzC,MAAqB,MAAM;IAazB;;;;OAIG;IACH,YAAY,MAAc;QAI1B;;;;WAIG;QACH,yBAAoB,GAAG,CAAC,IAAY,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;QAE5F;;;WAGG;QACH,4BAAuB,GAAG,CAAC,SAAqC,EAAE,EAAE,CAAC,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,MAAM,CAAC;aACxG,MAAM,CAAC,CAAC,UAAe,EAAE,WAAgB,EAAE,EAAE,CAAC,CAAC,UAAU,GAAG,WAAW,CAAC,EAAE,SAAS,CAAC,CAAA;QAEvF;;;;WAIG;QACH,6BAAwB,GAAG,CAAC,MAAc,EAAE,EAAE;YAC5C,OAAO,CAAC,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QACxD,CAAC,CAAA;QAED;;;;WAIG;QACH,YAAO,GAAG,CAAC,IAAwC,EAAE,EAAE;YACrD;;;;;eAKG;YACH,0IAA0I;YAC1I,IAAI;gBACF,MAAM,cAAc,GAAG,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC;qBAClD,GAAG,CAAC,IAAI,CAAC,oBAAoB,CAAC;qBAC9B,GAAG,CAAC,IAAI,CAAC,uBAAuB,CAAC;qBACjC,GAAG,CAAC,IAAI,CAAC,wBAAwB,CAAC;qBAClC,IAAI,CAAC,EAAE,CAAC,CAAC;gBAEZ,OAAO,cAAM,CAAC,cAAc,CAAC,CAAC;aAC/B;YAAC,OAAO,KAAK,EAAE;gBACd,MAAM,IAAI,KAAK,CAAC,iGAAiG,CAAC,CAAC;aACpH;QACH,CAAC,CAAA;QAED;;;;WAIG;QACH,YAAO,GAAG,CAAC,IAAY,EAAE,EAAE;YACzB,MAAM,UAAU,GAAG,cAAM,CAAC,IAAI,CAAC,CAAC;YAE9B,MAAM,IAAI,GAAG,UAAU,CAAC,KAAK,CAAC,SAAS,CAAC;iBACrC,GAAG,CAAC,CAAC,GAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;iBACpC,GAAG,CAAC,IAAI,CAAC,uBAAuB,CAAC;iBACjC,GAAG,CAAC,CAAC,QAAa,EAAE,EAAE,CAAC,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;iBACrD,IAAI,CAAC,EAAE,CAAC,CAAC;YAEV,MAAM,GAAG,GAAG,EAAE,CAAC;YACf,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAEjB,OAAO,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QAC5B,CAAC,CAAA;QAtEC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;CAsEF;AA1FD,yBA0FC"}

package/dist/src/utils.js

@@ -1,49 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const crypto_1 = __importDefault(require("crypto")); // this is necessary for some version of nodejs without crypto module
-const algorithm = 'aes-256-cbc';
-/**
- * crypto random initial vector generated from core node {crypto} module
- */
-const initialVector = crypto_1.default.randomBytes(16);
-/**
- * crypto random key generated from core node {crypto} module
- *
- * {note}: please read the value for KEY from your app's environment
- */
-const _key = process.env.KEY || 'please provide a KEY in your .env file or config';
-const key = crypto_1.default.scryptSync(_key, 'salt', 32);
-/**
- * intermediate data encoder function
- * @param {string.<any>} text
- * @param secret
- * @returns {string} encrypted or cipher text
- */
-exports.encode = (text) => {
-    let cipher = crypto_1.default.createCipheriv(algorithm, Buffer.from(key), initialVector);
-    let encrypted = cipher.update(text);
-    encrypted = Buffer.concat([encrypted, cipher.final()]);
-    return `${initialVector.toString('hex')}.${encrypted.toString('hex')}`;
-};
-/**
- * intermediate data decoder function
- * @param {string.<any>} text
- * @returns {string.<string>} decrypted data
- */
-exports.decode = (text) => {
-    if (typeof text !== 'string') {
-        throw new TypeError('argument must be a string, or a string-like object');
-    }
-    const iv = text.split('.')[0];
-    const encryptedData = text.split('.')[1];
-    let _iv = Buffer.from(iv, 'hex');
-    let encryptedText = Buffer.from(encryptedData, 'hex');
-    let decipher = crypto_1.default.createDecipheriv(algorithm, Buffer.from(key), _iv);
-    let decrypted = decipher.update(encryptedText);
-    decrypted = Buffer.concat([decrypted, decipher.final()]);
-    return decrypted.toString();
-};
-//# sourceMappingURL=utils.js.map

package/dist/src/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/utils.ts"],"names":[],"mappings":";;;;;AAAA,oDAA4B,CAAI,qEAAqE;AAErG,MAAM,SAAS,GAAG,aAAa,CAAC;AAEhC;;GAEG;AACH,MAAM,aAAa,GAAW,gBAAM,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;AAErD;;;;GAIG;AACH,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,kDAAkD,CAAC;AACnF,MAAM,GAAG,GAAW,gBAAM,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC;AAExD;;;;;GAKG;AACU,QAAA,MAAM,GAAG,CAAC,IAAY,EAAE,EAAE;IACrC,IAAI,MAAM,GAAG,gBAAM,CAAC,cAAc,CAAC,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,aAAa,CAAC,CAAC;IAC/E,IAAI,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAEpC,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IACvD,OAAO,GAAG,aAAa,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,SAAS,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;AACzE,CAAC,CAAA;AAED;;;;GAIG;AACU,QAAA,MAAM,GAAG,CAAC,IAAY,EAAE,EAAE;IAErC,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;QAC5B,MAAM,IAAI,SAAS,CAAC,oDAAoD,CAAC,CAAC;KAC3E;IAED,MAAM,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9B,MAAM,aAAa,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IAEzC,IAAI,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IACjC,IAAI,aAAa,GAAG,MAAM,CAAC,IAAI,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;IACtD,IAAI,QAAQ,GAAG,gBAAM,CAAC,gBAAgB,CAAC,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC;IACzE,IAAI,SAAS,GAAG,QAAQ,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;IAE/C,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IACzD,OAAO,SAAS,CAAC,QAAQ,EAAE,CAAC;AAC9B,CAAC,CAAA"}

package/src/ncrypt.d.ts

@@ -1,8 +0,0 @@
-
-export interface INcrypt {
-  convertTextToDecimal(text: string): number[];
-  applySecretToCharacters(charCodes: number[] | number): number;
-  convertByteToHexadecimal(number: number): string;
-  encrypt(text: object | string | number | boolean): string;
-  decrypt(data: string): string;
-}

package/src/ncrypt.ts

@@ -1,94 +0,0 @@
-import { INcrypt } from './ncrypt.d';
-import { encode, decode } from './utils';
-
-export default class Ncrypt implements INcrypt {
-
-  /**
-   * ncrypt namespace.
-   * @type {string.<*>}
-   */
-  private secret: string;
-
-  /**
-   * ncrypt namespace.
-   * @type {string.<*>}
-   */
-  private text: string;
-  /**
-   * object constructor
-   * @param text 
-   * @param secret 
-   */
-  constructor(secret: string) {
-    this.secret = secret;
-  }
-
-  /**
-   * convert all entered text to decimal equivalent character codes
-   * @param {data.<string>} data to be converted
-   * @return {Array.<number>} array of character codes
-   */
-  convertTextToDecimal = (data: string) => data.split('').map((value) => value.charCodeAt(0));
-
-  /**
-   * encode provided secret on decimal character codes
-   * @param {charCode<number[], *>} character codes
-   */
-  applySecretToCharacters = (charCodes: number[] | number | string) => this.convertTextToDecimal(this.secret)
-    .reduce((firstValue: any, secondValue: any) => (firstValue ^ secondValue), charCodes)
-
-  /**
-   * convert character bytes to hexadecimal equivalent
-   * @param {number.<number>}
-   * @returns {string} hexadecimal string
-   */
-  convertByteToHexadecimal = (number: number) => {
-    return ("0" + Number(number).toString(16)).substr(-2);
-  }
-
-  /**
-   * process data to be encrypted
-   * @param {}
-   * @returns {string.<string>} encoded string data
-   */
-  encrypt = (data: object | string | number | boolean) => {
-    /**
-     * this does the actual processing return a string
-     * resulting from charCode conversion, salting and 
-     * hexadecimal mapping
-     * 
-     */
-    // if (data == void 0) throw new Error('invalid data was entered, enter data of type object, number, string or boolean to be encrypted.');
-    try {
-      const encodedMessage = JSON.stringify(data).split('')
-        .map(this.convertTextToDecimal)
-        .map(this.applySecretToCharacters)
-        .map(this.convertByteToHexadecimal)
-        .join('');
-
-      return encode(encodedMessage);
-    } catch (error) {
-      throw new Error('invalid data was entered, enter data of type object, number, string or boolean to be encrypted.');
-    }
-  }
-
-  /**
-   * decodes encoded string resulting from util encryption
-   * @param {string.<stirng>} encodeData 
-   * @returns {decodedData.<string>} decoded data
-   */
-  decrypt = (text: string) => {
-    const encodeData = decode(text);
-
-      const data = encodeData.match(/.{1,2}/g)
-        .map((hex: any) => parseInt(hex, 16))
-        .map(this.applySecretToCharacters)
-        .map((charCode: any) => String.fromCharCode(charCode))
-        .join('');
-
-        const arr = [];
-        arr.push(data);
-
-      return JSON.parse(data);
-  }
-}

package/src/utils.ts

@@ -1,53 +0,0 @@
-import crypto from 'crypto';    // this is necessary for some version of nodejs without crypto module
-
-const algorithm = 'aes-256-cbc';
-
-/**
- * crypto random initial vector generated from core node {crypto} module
- */
-const initialVector: Buffer = crypto.randomBytes(16);
-
-/**
- * crypto random key generated from core node {crypto} module
- * 
- * {note}: please read the value for KEY from your app's environment
- */
-const _key = process.env.KEY || 'please provide a KEY in your .env file or config';
-const key: Buffer = crypto.scryptSync(_key, 'salt', 32);
-
-/**
- * intermediate data encoder function
- * @param {string.<any>} text 
- * @param secret
- * @returns {string} encrypted or cipher text
- */
-export const encode = (text: string) => {
-  let cipher = crypto.createCipheriv(algorithm, Buffer.from(key), initialVector);
-  let encrypted = cipher.update(text);
-
-  encrypted = Buffer.concat([encrypted, cipher.final()]);
-  return `${initialVector.toString('hex')}.${encrypted.toString('hex')}`;
-}
-
-/**
- * intermediate data decoder function
- * @param {string.<any>} text
- * @returns {string.<string>} decrypted data
- */
-export const decode = (text: string) => {
-
-  if (typeof text !== 'string') {
-    throw new TypeError('argument must be a string, or a string-like object');
-  }
-
-  const iv = text.split('.')[0];
-  const encryptedData = text.split('.')[1];
-
-  let _iv = Buffer.from(iv, 'hex');
-  let encryptedText = Buffer.from(encryptedData, 'hex');
-  let decipher = crypto.createDecipheriv(algorithm, Buffer.from(key), _iv);
-  let decrypted = decipher.update(encryptedText);
-
-  decrypted = Buffer.concat([decrypted, decipher.final()]);
-  return decrypted.toString();
-}

package/test/ncrypt.test.ts

@@ -1,135 +0,0 @@
-import * as chai from "chai";
-
-import ncrypt from '../index';
-
-const expect = chai.expect;
-
-const object = {
-  NcryptJs: "is great.",
-  You: "should try it!"
-};
-const string: string = "ncrypt-js is great.";
-const number: number = 19960404;
-const boolean: boolean = false;
-const _nullData: any = null;
-
-const _secret = 'shhh its a secret';
-
-const { encrypt, decrypt } = new ncrypt(_secret);
-
-const encryptString = encrypt(string);
-const encryptNumber = encrypt(number);
-const encryptObject = encrypt(object);
-const encryptBoolean = encrypt(boolean);
-const encryptNullData = encrypt(_nullData);
-
-const decryptString = decrypt(encryptString);
-const decryptNumber = decrypt(encryptNumber);
-const decryptObject = decrypt(encryptObject);
-const decryptBoolean = decrypt(encryptBoolean);
-const decryptNullData = encrypt(_nullData);
-
-describe('Encrytion', () => {
-  it('should be able to encrypt a string', () => {
-    expect(string).to.be.a('string');
-    expect(typeof encryptString).to.eql('string');
-  });
-
-  it('should be able to encrypt an object', () => {
-    expect(object).to.be.a('object');
-    expect(typeof encryptObject).to.eql('string');
-  });
-
-  it('should be able to encrypt a number', () => {
-    expect(number).to.be.a('number');
-    expect(typeof encryptNumber).to.eql('string');
-  });
-
-  it('should be able to encrypt a boolean', () => {
-    expect(boolean).to.be.a('boolean');
-    expect(typeof encryptBoolean).to.eql('string');
-  });
-});
-
-describe('Decrytion', () => {
-  it('should be able to decrypt original string', () => {
-    expect(decryptString).to.be.eql(string);
-    expect(typeof decryptString).to.eql('string');
-  });
-
-  it('should be able to decrypt original object', () => {
-    expect(decryptObject).to.be.eql(object);
-    expect(typeof decryptObject).to.eql('object');
-  });
-
-  it('should be able to decrypt original number', () => {
-    expect(decryptNumber).to.be.eql(number);
-    expect(typeof decryptNumber).to.eql('number');
-  });
-
-  it('should be able to decrypt original boolean', () => {
-    expect(decryptBoolean).to.be.eql(boolean);
-    expect(typeof decryptBoolean).to.eql('boolean');
-  });
-});
-
-describe('Error handling and validations', () => {
-  it('should error when secret is not provided', () => {
-    try {
-      encrypt('nullSecret');
-    } catch (error) {
-      expect(error.message).equal('must be initialized with a secret key of type string');
-    }
-  });
-
-  it('should error when non-string data is passed as decryption string', () => {
-    try {
-      const nonStringData = 12345;
-      //@ts-ignore
-      decrypt(nonStringData);
-    } catch (error) {
-      expect(error.message).equal('argument must be a string, or a string-like object');
-    }
-  });
-
-  it('should error when a non string data type is to be decrypted', () => {
-    try {
-      const nonStringData: any = void(0);
-      decrypt(nonStringData);
-    } catch (error) {
-      expect(error.message).equal('argument must be a string, or a string-like object');
-    }
-  });
-  
-  it('should error when a non string data type is to be decrypted', () => {
-    try {
-      decrypt(decryptNullData);
-    } catch (error) {
-      expect(error.message).equal('argument must be a string, or a string-like object');
-    }
-  });
-
-  it('should throw an error when an undefined data is to be encrypted', () => {
-    try {
-      encrypt(undefined);
-    } catch (error) {
-      expect(error.message).equal('invalid data was entered, enter data of type object, number, string or boolean to be encrypted.');
-    }
-  });
-
-  it('should throw an error when an undefined data is to be encrypted', () => {
-    try {
-      encrypt(null);
-    } catch (error) {
-      expect(error.message).equal('no data was entered, enter data of type object, number, string or boolean to be encrypted.');
-    }
-  });
-  
-  it('should throw an error when an null data is to be encrypted', () => {
-    try {
-      encrypt(encryptNullData);
-    } catch (error) {
-      expect(error.message).equal('invalid data was entered, enter data of type object, number, string or boolean to be encrypted.');
-    }
-  });
-});