Merge pull request #49 from VirgilSecurity/v4.0.0-alpha.2

v4.0.0-alpha.2

guides/webpack.md

@@ -21,11 +21,6 @@ Second, you need to add a [rule](https://webpack.js.org/configuration/module/#ru
 }
 ```
 
-Third, you need to [disable mocking of Node.js modules and globals](https://webpack.js.org/configuration/node) in your Webpack config:
-```js
-node: false
-```
-
 Last, you need to import the library:
 ```js
 import { initCrypto, VirgilCrypto } 'virgil-crypto';

packages/base-crypto/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@virgilsecurity/base-crypto",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Virgil JavaScript Crypto Library is a high-level cryptographic library that allows you to perform all necessary operations for secure storing and transferring data and everything required to become HIPAA and GDPR compliant.",
   "main": "./dist/base-crypto.cjs.js",
   "module": "./dist/base-crypto.es.js",
@@ -19,7 +19,7 @@
     "lint": "eslint 'src/**/*.ts'"
   },
   "dependencies": {
-    "buffer": "^5.2.1"
+    "@virgilsecurity/data-utils": "^0.1.0"
   },
   "peerDependencies": {
     "@virgilsecurity/core-foundation": "^0.1.0"

packages/base-crypto/src/VirgilCrypto.ts

@@ -1,13 +1,13 @@
 import { FoundationModules } from '@virgilsecurity/core-foundation';
-import { Buffer as NodeBuffer } from 'buffer';
+import { Buffer as NodeBuffer, dataToUint8Array, toBuffer } from '@virgilsecurity/data-utils';
 
 import { DATA_SIGNATURE_KEY, DATA_SIGNER_ID_KEY } from './constants';
 import { getFoundationModules } from './foundationModules';
 import { HashAlgorithm, HashAlgorithmType } from './HashAlgorithm';
 import { KeyPairType, KeyPairTypeType } from './KeyPairType';
 import { getLowLevelPrivateKey } from './privateKeyUtils';
 import { Data, LowLevelPrivateKey, LowLevelPublicKey } from './types';
-import { dataToUint8Array, toArray, toBuffer } from './utils';
+import { toArray } from './utils';
 import { validatePrivateKey, validatePublicKey, validatePublicKeysArray } from './validators';
 import { VirgilPrivateKey } from './VirgilPrivateKey';
 import { VirgilPublicKey } from './VirgilPublicKey';

packages/base-crypto/src/VirgilStreamCipher.ts

@@ -1,7 +1,9 @@
+import { dataToUint8Array, toBuffer } from '@virgilsecurity/data-utils';
+
 import { DATA_SIGNATURE_KEY } from './constants';
 import { getFoundationModules } from './foundationModules';
 import { Data } from './types';
-import { dataToUint8Array, toArray, toBuffer } from './utils';
+import { toArray } from './utils';
 import { validatePublicKeysArray } from './validators';
 import { VirgilPublicKey } from './VirgilPublicKey';
 

packages/base-crypto/src/VirgilStreamDecipher.ts

@@ -1,8 +1,9 @@
+import { dataToUint8Array, toBuffer } from '@virgilsecurity/data-utils';
+
 import { DATA_SIGNATURE_KEY } from './constants';
 import { getFoundationModules } from './foundationModules';
 import { getLowLevelPrivateKey } from './privateKeyUtils';
 import { Data } from './types';
-import { dataToUint8Array, toBuffer } from './utils';
 import { validatePrivateKey } from './validators';
 import { VirgilPrivateKey } from './VirgilPrivateKey';
 

packages/base-crypto/src/VirgilStreamSigner.ts

@@ -1,7 +1,8 @@
+import { dataToUint8Array, toBuffer } from '@virgilsecurity/data-utils';
+
 import { getFoundationModules } from './foundationModules';
 import { getLowLevelPrivateKey } from './privateKeyUtils';
 import { Data } from './types';
-import { dataToUint8Array, toBuffer } from './utils';
 import { validatePrivateKey } from './validators';
 import { VirgilPrivateKey } from './VirgilPrivateKey';
 

packages/base-crypto/src/VirgilStreamVerifier.ts

@@ -1,6 +1,7 @@
+import { dataToUint8Array } from '@virgilsecurity/data-utils';
+
 import { getFoundationModules } from './foundationModules';
 import { Data } from './types';
-import { dataToUint8Array } from './utils';
 import { validatePublicKey } from './validators';
 import { VirgilPublicKey } from './VirgilPublicKey';
 

packages/base-crypto/src/constants.ts

@@ -1,11 +1,5 @@
-import { dataToUint8Array } from './utils';
+import { Buffer as NodeBuffer } from '@virgilsecurity/data-utils';
 
-export const DATA_SIGNATURE_KEY = dataToUint8Array({
-  value: 'VIRGIL-DATA-SIGNATURE',
-  encoding: 'utf8',
-});
+export const DATA_SIGNATURE_KEY = NodeBuffer.from('VIRGIL-DATA-SIGNATURE', 'utf8');
 
-export const DATA_SIGNER_ID_KEY = dataToUint8Array({
-  value: 'VIRGIL-DATA-SIGNER-ID',
-  encoding: 'utf8',
-});
+export const DATA_SIGNER_ID_KEY = NodeBuffer.from('VIRGIL-DATA-SIGNER-ID', 'utf8');

packages/base-crypto/src/index.ts

@@ -2,7 +2,7 @@ export { setFoundationModules } from './foundationModules';
 export { HashAlgorithm } from './HashAlgorithm';
 export { KeyPairType } from './KeyPairType';
 export { IPrivateKey, IPublicKey } from './interfaces';
-export { Data, VirgilKeyPair } from './types';
+export { VirgilKeyPair } from './types';
 export { VirgilCrypto } from './VirgilCrypto';
 export { VirgilPrivateKey } from './VirgilPrivateKey';
 export { VirgilPublicKey } from './VirgilPublicKey';

packages/base-crypto/src/types.ts

@@ -1,18 +1,7 @@
 import { VirgilPrivateKey } from './VirgilPrivateKey';
 import { VirgilPublicKey } from './VirgilPublicKey';
 
-export enum StringEncoding {
-  utf8 = 'utf8',
-  base64 = 'base64',
-  hex = 'hex',
-}
-
-export interface StringWithEncoding {
-  value: string;
-  encoding: keyof typeof StringEncoding;
-}
-
-export type Data = Uint8Array | StringWithEncoding | string;
+export type Data = import('@virgilsecurity/data-utils').Data;
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type LowLevelPrivateKey = any;

packages/base-crypto/src/utils.ts

@@ -1,29 +1,3 @@
-import { Buffer as NodeBuffer } from 'buffer';
-
-import { StringEncoding, Data } from './types';
-
-export const dataToUint8Array = (
-  data: Data,
-  defaultEncoding?: keyof typeof StringEncoding,
-): Uint8Array => {
-  if (typeof data === 'string') {
-    return NodeBuffer.from(data, defaultEncoding);
-  }
-  if (data instanceof Uint8Array) {
-    return data;
-  }
-  if (
-    typeof data === 'object' &&
-    typeof data.value === 'string' &&
-    typeof StringEncoding[data.encoding] !== 'undefined'
-  ) {
-    return NodeBuffer.from(data.value, data.encoding);
-  }
-  throw new TypeError('Invalid format of Data');
-};
-
 export const toArray = <T>(val?: T | T[]): T[] => {
   return val == null ? [] : Array.isArray(val) ? val : [val];
 };
-
-export const toBuffer = (array: Uint8Array) => NodeBuffer.from(array.buffer);

packages/benchmark/package.json

@@ -13,7 +13,7 @@
   "dependencies": {
     "benchmark": "^2.1.4",
     "buffer": "^5.2.1",
-    "virgil-crypto": "^4.0.0-alpha.0",
+    "virgil-crypto": "^4.0.0-alpha.2",
     "virgil-crypto-3": "npm:virgil-crypto@^3.2.6"
   },
   "devDependencies": {

packages/data-utils/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@virgilsecurity/data-utils",
+  "version": "0.1.0",
+  "description": "Library that contains different functions / classes that are used for data manipulation in different Virgil Security libraries.",
+  "main": "./dist/node.cjs.js",
+  "module": "./dist/node.es.js",
+  "browser": {
+    "./dist/node.cjs.js": "./dist/browser.cjs.js",
+    "./dist/node.es.js": "./dist/browser.es.js"
+  },
+  "typings": "./dist/types/node.d.ts",
+  "files": [
+    "dist"
+  ],
+  "repository": "https://github.com/VirgilSecurity/virgil-crypto-javascript/tree/master/packages/data-utils",
+  "author": "Virgil Security Inc. <support@virgilsecurity.com>",
+  "license": "BSD-3-Clause",
+  "scripts": {
+    "test": "mocha -r ts-node/register src/**/*.test.ts",
+    "build": "rollup -c",
+    "clean": "rimraf .rpt2_cache dist",
+    "prepare": "npm run clean && npm run build"
+  },
+  "dependencies": {
+    "buffer": "^5.2.1"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.1.7",
+    "@types/mocha": "^5.2.7",
+    "chai": "^4.2.0",
+    "mocha": "^6.1.4",
+    "rimraf": "^2.6.3",
+    "rollup": "^1.18.0",
+    "rollup-plugin-commonjs": "^10.0.2",
+    "rollup-plugin-node-resolve": "^5.2.0",
+    "rollup-plugin-typescript2": "^0.21.1",
+    "ts-node": "^8.3.0",
+    "typescript": "^3.5.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

packages/data-utils/rollup.config.js

@@ -0,0 +1,43 @@
+const path = require('path');
+
+const commonjs = require('rollup-plugin-commonjs');
+const nodeResolve = require('rollup-plugin-node-resolve');
+const typescript = require('rollup-plugin-typescript2');
+
+const FORMAT = {
+  CJS: 'cjs',
+  ES: 'es',
+};
+
+const sourcePath = path.join(__dirname, 'src');
+const outputPath = path.join(__dirname, 'dist');
+
+const createNodeEntry = format => ({
+  external: ['buffer/'],
+  input: path.join(sourcePath, 'node.ts'),
+  output: {
+    format,
+    file: path.join(outputPath, `node.${format}.js`),
+  },
+  plugins: [typescript({ useTsconfigDeclarationDir: true })],
+});
+
+const createBrowserEntry = format => ({
+  input: path.join(sourcePath, 'browser.ts'),
+  output: {
+    format,
+    file: path.join(outputPath, `browser.${format}.js`),
+  },
+  plugins: [
+    nodeResolve({ browser: true }),
+    commonjs(),
+    typescript({ useTsconfigDeclarationDir: true }),
+  ]
+});
+
+module.exports = [
+  createBrowserEntry(FORMAT.CJS),
+  createBrowserEntry(FORMAT.ES),
+  createNodeEntry(FORMAT.CJS),
+  createNodeEntry(FORMAT.ES),
+];

packages/data-utils/src/__tests__/browser.test.ts

@@ -0,0 +1,10 @@
+import { expect } from 'chai';
+
+import { Buffer as BrowserBuffer } from 'buffer/';
+
+describe('browser', () => {
+  it('exports correct Buffer', () => {
+    const { Buffer } = require('../browser');
+    expect(Buffer).to.eql(BrowserBuffer);
+  });
+});

packages/data-utils/src/__tests__/dataToUint8Array.test.ts

@@ -0,0 +1,47 @@
+import { expect } from 'chai';
+
+import { createDataToUint8ArrayFunction } from '../dataToUint8Array';
+
+describe('dataToUint8Array', () => {
+  let dataToUint8Array: ReturnType<typeof createDataToUint8ArrayFunction>;
+
+  before(() => {
+    dataToUint8Array = createDataToUint8ArrayFunction(Buffer);
+  });
+
+  it('returns Uint8Array based on a string that was converted to it using defaultEncoding', () => {
+    const data = 'data';
+    const result = dataToUint8Array(data, 'utf8');
+    const expected = Buffer.from(data, 'utf8');
+    expect(expected.equals(result)).to.be.true;
+  });
+
+  it('returns Uint8Array based on a string that was converted to it using default encoding (utf-8)', () => {
+    const data = 'data';
+    const result = dataToUint8Array(data);
+    const expected = Buffer.from(data, 'utf8');
+    expect(expected.equals(result)).to.be.true;
+  });
+
+  it('returns the same Uint8Array if argument is an instance of Uint8Array', () => {
+    const data = new Uint8Array(0);
+    const result = dataToUint8Array(data);
+    expect(result).to.eql(data);
+  });
+
+  it('throws if first argument is not a string / Data object / Uint8Array', () => {
+    const error = () => {
+      // @ts-ignore
+      dataToUint8Array(123);
+    };
+    expect(error).to.throw;
+  });
+
+  it('throws if Data object is invalid', () => {
+    const error = () => {
+      // @ts-ignore
+      dataToUint8Array({ value: 123, encoding: 'utf8' });
+    };
+    expect(error).to.throw;
+  });
+});

packages/data-utils/src/__tests__/node.test.ts

@@ -0,0 +1,8 @@
+import { expect } from 'chai';
+
+describe('node', () => {
+  it('exports correct Buffer', () => {
+    const { Buffer } = require('../node');
+    expect(Buffer).to.eql(global.Buffer);
+  });
+});

packages/data-utils/src/__tests__/toBuffer.test.ts

@@ -0,0 +1,17 @@
+import { expect } from 'chai';
+
+import { createToBufferFunction } from '../toBuffer';
+
+describe('toBuffer', () => {
+  let toBuffer: ReturnType<typeof createToBufferFunction>;
+
+  before(() => {
+    toBuffer = createToBufferFunction(Buffer);
+  });
+
+  it('returns correct buffer', () => {
+    const data = Buffer.from('data', 'utf8');
+    const result = toBuffer(data);
+    expect(result.buffer).to.eql(data.buffer);
+  });
+});

packages/data-utils/src/browser.ts

@@ -0,0 +1,11 @@
+import { Buffer as NodeBuffer } from 'buffer/';
+
+import { createDataToUint8ArrayFunction } from './dataToUint8Array';
+import { createToBufferFunction } from './toBuffer';
+
+export { Buffer } from 'buffer/';
+
+export * from './types';
+
+export const dataToUint8Array = createDataToUint8ArrayFunction(NodeBuffer);
+export const toBuffer = createToBufferFunction(NodeBuffer);