VirgilSecurity · snanovskyi · Aug 21, 2019 · Aug 21, 2019 · Aug 21, 2019 · Aug 21, 2019
diff --git a/packages/base-crypto/package.json b/packages/base-crypto/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@virgilsecurity/base-crypto",
-  "version": "0.3.0",
+  "version": "0.4.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,6 +19,7 @@
     "lint": "eslint 'src/**/*.ts'"
   },
   "dependencies": {
+    "@virgilsecurity/crypto-types": "^0.1.0",
     "@virgilsecurity/data-utils": "^0.1.0"
   },
   "peerDependencies": {

diff --git a/packages/base-crypto/src/VirgilCrypto.ts b/packages/base-crypto/src/VirgilCrypto.ts
@@ -6,7 +6,7 @@ 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 { ICrypto, Data, LowLevelPrivateKey, LowLevelPublicKey } from './types';
 import { toArray } from './utils';
 import { validatePrivateKey, validatePublicKey, validatePublicKeysArray } from './validators';
 import { VirgilPrivateKey } from './VirgilPrivateKey';
@@ -21,7 +21,7 @@ export interface VirgilCryptoOptions {
   defaultKeyPairType?: KeyPairTypeType[keyof KeyPairTypeType];
 }
 
-export class VirgilCrypto {
+export class VirgilCrypto implements ICrypto {
   readonly useSha256Identifiers: boolean;
   readonly defaultKeyPairType: KeyPairTypeType[keyof KeyPairTypeType];
 

diff --git a/packages/base-crypto/src/VirgilPrivateKey.ts b/packages/base-crypto/src/VirgilPrivateKey.ts
@@ -1,6 +1,5 @@
-import { IPrivateKey } from './interfaces';
 import { setLowLevelPrivateKey } from './privateKeyUtils';
-import { LowLevelPrivateKey } from './types';
+import { IPrivateKey, LowLevelPrivateKey } from './types';
 
 export class VirgilPrivateKey implements IPrivateKey {
   public identifier: Uint8Array;

diff --git a/packages/base-crypto/src/VirgilPublicKey.ts b/packages/base-crypto/src/VirgilPublicKey.ts
@@ -1,5 +1,4 @@
-import { IPublicKey } from './interfaces';
-import { LowLevelPublicKey } from './types';
+import { IPublicKey, LowLevelPublicKey } from './types';
 
 export class VirgilPublicKey implements IPublicKey {
   public identifier: Uint8Array;

diff --git a/packages/base-crypto/src/index.ts b/packages/base-crypto/src/index.ts
@@ -1,7 +1,6 @@
 export { setFoundationModules } from './foundationModules';
 export { HashAlgorithm } from './HashAlgorithm';
 export { KeyPairType } from './KeyPairType';
-export { IPrivateKey, IPublicKey } from './interfaces';
 export { VirgilKeyPair } from './types';
 export { VirgilCrypto } from './VirgilCrypto';
 export { VirgilPrivateKey } from './VirgilPrivateKey';

diff --git a/packages/base-crypto/src/interfaces.ts b/packages/base-crypto/src/interfaces.ts
diff --git a/packages/base-crypto/src/types.ts b/packages/base-crypto/src/types.ts
@@ -1,6 +1,11 @@
 import { VirgilPrivateKey } from './VirgilPrivateKey';
 import { VirgilPublicKey } from './VirgilPublicKey';
 
+export type IPrivateKey = import('@virgilsecurity/crypto-types').IPrivateKey;
+export type IPublicKey = import('@virgilsecurity/crypto-types').IPublicKey;
+export type IKeyPair = import('@virgilsecurity/crypto-types').IKeyPair;
+export type ICrypto = import('@virgilsecurity/crypto-types').ICrypto;
+
 export type Data = import('@virgilsecurity/data-utils').Data;
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -9,7 +14,7 @@ export type LowLevelPrivateKey = any;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type LowLevelPublicKey = any;
 
-export interface VirgilKeyPair {
+export interface VirgilKeyPair extends IKeyPair {
   privateKey: VirgilPrivateKey;
   publicKey: VirgilPublicKey;
 }
diff --git a/packages/benchmark/package.json b/packages/benchmark/package.json
@@ -13,7 +13,7 @@
   "dependencies": {
     "benchmark": "^2.1.4",
     "buffer": "^5.2.1",
-    "virgil-crypto": "^4.0.0-alpha.2",
+    "virgil-crypto": "^4.0.0-alpha.3",
     "virgil-crypto-3": "npm:virgil-crypto@^3.2.6"
   },
   "devDependencies": {

diff --git a/packages/crypto-types/index.d.ts b/packages/crypto-types/index.d.ts
@@ -0,0 +1,71 @@
+export interface IPrivateKey {}
+
+export interface IPublicKey {}
+
+export interface IKeyPair {
+  privateKey: IPrivateKey;
+  publicKey: IPublicKey;
+}
+
+export interface ICrypto {
+  generateKeys(keyPairType?: unknown): IKeyPair;
+  generateKeysFromKeyMaterial(keyMaterial: Uint8Array, keyPairType?: unknown): IKeyPair;
+  importPrivateKey(rawPrivateKey: Uint8Array): IPrivateKey;
+  exportPrivateKey(privateKey: IPrivateKey): Uint8Array;
+  importPublicKey(rawPublicKey: Uint8Array): IPublicKey;
+  exportPublicKey(publicKey: IPublicKey): Uint8Array;
+  encrypt(data: Uint8Array, publicKey: IPublicKey | IPublicKey[]): Uint8Array;
+  decrypt(encryptedData: Uint8Array, privateKey: IPrivateKey): Uint8Array;
+  calculateHash(data: Uint8Array, algorithm?: unknown): Uint8Array;
+  extractPublicKey(privateKey: IPrivateKey): IPublicKey;
+  calculateSignature(data: Uint8Array, privateKey: IPrivateKey): Uint8Array;
+  verifySignature(data: Uint8Array, signature: Uint8Array, publicKey: IPublicKey): boolean;
+  signThenEncrypt(
+    data: Uint8Array,
+    privateKey: IPrivateKey,
+    publicKey: IPublicKey | IPublicKey[],
+  ): Uint8Array;
+  decryptThenVerify(
+    encryptedData: Uint8Array,
+    privateKey: IPrivateKey,
+    publicKey: IPublicKey | IPublicKey[],
+  ): Uint8Array;
+  getRandomBytes(length: number): Uint8Array;
+  signThenEncryptDetached(
+    data: Uint8Array,
+    privateKey: IPrivateKey,
+    publicKey: IPublicKey | IPublicKey[],
+  ): { encryptedData: Uint8Array, metadata: Uint8Array };
+  decryptThenVerifyDetached(
+    encryptedData: Uint8Array,
+    metadata: Uint8Array,
+    privateKey: IPrivateKey,
+    publicKey: IPublicKey | IPublicKey[],
+  ): Uint8Array;
+}
+
+export interface IAccessTokenSigner {
+  getAlgorithm(): string;
+  generateTokenSignature(
+    token: Uint8Array,
+    privateKey: IPrivateKey,
+  ): Uint8Array;
+  verifyTokenSignature(
+    token: Uint8Array,
+    signature: Uint8Array,
+    publicKey: IPublicKey,
+  ): boolean;
+}
+
+export interface ICardCrypto {
+  generateSignature(data: Uint8Array, privateKey: IPrivateKey): Uint8Array;
+  verifySignature(data: Uint8Array, signature: Uint8Array, publicKey: IPublicKey): boolean;
+  exportPublicKey(publicKey: IPublicKey): Uint8Array;
+  importPublicKey(rawPublicKey: Uint8Array): IPublicKey;
+  generateSha512(data: Uint8Array): Uint8Array;
+}
+
+export interface IPrivateKeyExporter {
+  exportPrivateKey(privateKey: IPrivateKey): Uint8Array;
+  importPrivateKey(rawPrivateKey: Uint8Array): IPrivateKey;
+}
diff --git a/packages/crypto-types/package.json b/packages/crypto-types/package.json
@@ -0,0 +1,15 @@
+{
+  "name": "@virgilsecurity/crypto-types",
+  "version": "0.1.0",
+  "description": "Types for Virgil JavaScript libraries",
+  "typings": "./index.d.ts",
+  "files": [
+    "index.d.ts"
+  ],
+  "repository": "https://github.com/VirgilSecurity/virgil-crypto-javascript/tree/master/packages/crypto-types",
+  "author": "Virgil Security Inc. <support@virgilsecurity.com>",
+  "license": "BSD-3-Clause",
+  "publishConfig": {
+    "access": "public"
+  }
+}
diff --git a/packages/sdk-crypto/package.json b/packages/sdk-crypto/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@virgilsecurity/sdk-crypto",
-  "version": "0.3.0",
+  "version": "0.4.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/sdk-crypto.cjs.js",
   "module": "./dist/sdk-crypto.es.js",
@@ -16,11 +16,11 @@
     "clean": "rimraf .rpt2_cache dist",
     "prepare": "npm run clean && npm run build"
   },
-  "peerDependencies": {
-    "@virgilsecurity/base-crypto": "^0.3.0"
+  "dependencies": {
+    "@virgilsecurity/crypto-types": "^0.1.0",
+    "@virgilsecurity/data-utils": "^0.1.0"
   },
   "devDependencies": {
-    "@virgilsecurity/base-crypto": "^0.3.0",
     "rimraf": "^2.6.3",
     "rollup": "^1.14.6",
     "rollup-plugin-typescript2": "^0.21.1",

diff --git a/packages/sdk-crypto/src/VirgilAccessTokenSigner.ts b/packages/sdk-crypto/src/VirgilAccessTokenSigner.ts
@@ -1,11 +1,11 @@
-import { VirgilCrypto, VirgilPrivateKey, VirgilPublicKey } from '@virgilsecurity/base-crypto';
+import { dataToUint8Array } from '@virgilsecurity/data-utils';
 
-import { Data } from './types';
+import { IPrivateKey, IPublicKey, ICrypto, IAccessTokenSigner, Data } from './types';
 
-export class VirgilAccessTokenSigner {
-  readonly virgilCrypto: VirgilCrypto;
+export class VirgilAccessTokenSigner implements IAccessTokenSigner {
+  readonly virgilCrypto: ICrypto;
 
-  constructor(virgilCrypto: VirgilCrypto) {
+  constructor(virgilCrypto: ICrypto) {
     if (virgilCrypto == null) {
       throw new Error('`virgilCrypto` is required');
     }
@@ -16,11 +16,14 @@ export class VirgilAccessTokenSigner {
     return 'VEDS512';
   }
 
-  generateTokenSignature(token: Data, privateKey: VirgilPrivateKey) {
-    return this.virgilCrypto.calculateSignature(token, privateKey);
+  generateTokenSignature(token: Data, privateKey: IPrivateKey) {
+    const myToken = dataToUint8Array(token, 'utf8');
+    return this.virgilCrypto.calculateSignature(myToken, privateKey);
   }
 
-  verifyTokenSignature(token: Data, signature: Data, publicKey: VirgilPublicKey) {
-    return this.virgilCrypto.verifySignature(token, signature, publicKey);
+  verifyTokenSignature(token: Data, signature: Data, publicKey: IPublicKey) {
+    const myToken = dataToUint8Array(token, 'utf8');
+    const mySignature = dataToUint8Array(signature, 'base64');
+    return this.virgilCrypto.verifySignature(myToken, mySignature, publicKey);
   }
 };
diff --git a/packages/sdk-crypto/src/VirgilCardCrypto.ts b/packages/sdk-crypto/src/VirgilCardCrypto.ts
@@ -1,34 +1,39 @@
-import { VirgilCrypto, VirgilPrivateKey, VirgilPublicKey } from '@virgilsecurity/base-crypto';
+import { dataToUint8Array } from '@virgilsecurity/data-utils';
 
-import { Data } from './types';
+import { IPrivateKey, IPublicKey, ICrypto, ICardCrypto, Data } from './types';
 
-export class VirgilCardCrypto {
-  readonly virgilCrypto: VirgilCrypto;
+export class VirgilCardCrypto implements ICardCrypto {
+  readonly virgilCrypto: ICrypto;
 
-  constructor(virgilCrypto: VirgilCrypto) {
+  constructor(virgilCrypto: ICrypto) {
     if (virgilCrypto == null) {
       throw new Error('`virgilCrypto` is required');
     }
     this.virgilCrypto = virgilCrypto;
   }
 
-  generateSignature(data: Data, privateKey: VirgilPrivateKey) {
-    return this.virgilCrypto.calculateSignature(data, privateKey);
+  generateSignature(data: Data, privateKey: IPrivateKey) {
+    const myData = dataToUint8Array(data, 'utf8');
+    return this.virgilCrypto.calculateSignature(myData, privateKey);
   }
 
-  verifySignature(data: Data, signature: Data, publicKey: VirgilPublicKey) {
-    return this.virgilCrypto.verifySignature(data, signature, publicKey);
+  verifySignature(data: Data, signature: Data, publicKey: IPublicKey) {
+    const myData = dataToUint8Array(data, 'utf8');
+    const mySignature = dataToUint8Array(signature, 'base64');
+    return this.virgilCrypto.verifySignature(myData, mySignature, publicKey);
   }
 
-  exportPublicKey(publicKey: VirgilPublicKey) {
+  exportPublicKey(publicKey: IPublicKey) {
     return this.virgilCrypto.exportPublicKey(publicKey);
   }
 
   importPublicKey(publicKeyData: Data) {
-    return this.virgilCrypto.importPublicKey(publicKeyData);
+    const myPublicKeyData = dataToUint8Array(publicKeyData, 'base64');
+    return this.virgilCrypto.importPublicKey(myPublicKeyData);
   }
 
   generateSha512(data: Data) {
-    return this.virgilCrypto.calculateHash(data, this.virgilCrypto.hashAlgorithm.SHA512);
+    const myData = dataToUint8Array(data, 'utf8');
+    return this.virgilCrypto.calculateHash(myData);
   }
 }
diff --git a/packages/sdk-crypto/src/VirgilPrivateKeyExporter.ts b/packages/sdk-crypto/src/VirgilPrivateKeyExporter.ts
@@ -1,22 +1,23 @@
-import { VirgilCrypto, VirgilPrivateKey } from '@virgilsecurity/base-crypto';
+import { dataToUint8Array } from '@virgilsecurity/data-utils';
 
-import { Data } from './types';
+import { IPrivateKey, ICrypto, IPrivateKeyExporter, Data } from './types';
 
-export class VirgilPrivateKeyExporter {
-  readonly virgilCrypto: VirgilCrypto;
+export class VirgilPrivateKeyExporter implements IPrivateKeyExporter {
+  readonly virgilCrypto: ICrypto;
 
-  constructor(virgilCrypto: VirgilCrypto) {
+  constructor(virgilCrypto: ICrypto) {
     if (virgilCrypto == null) {
       throw new Error('`virgilCrypto` is required');
     }
     this.virgilCrypto = virgilCrypto;
   }
 
-  exportPrivateKey(key: VirgilPrivateKey) {
+  exportPrivateKey(key: IPrivateKey) {
     return this.virgilCrypto.exportPrivateKey(key);
   }
 
   importPrivateKey(keyData: Data) {
-    return this.virgilCrypto.importPrivateKey(keyData);
+    const myKeyData = dataToUint8Array(keyData, 'base64');
+    return this.virgilCrypto.importPrivateKey(myKeyData);
   }
 }
diff --git a/packages/sdk-crypto/src/types.ts b/packages/sdk-crypto/src/types.ts
@@ -1 +1,8 @@
+export type IPrivateKey = import('@virgilsecurity/crypto-types').IPrivateKey;
+export type IPublicKey = import('@virgilsecurity/crypto-types').IPublicKey;
+export type ICrypto = import('@virgilsecurity/crypto-types').ICrypto;
+export type IAccessTokenSigner = import('@virgilsecurity/crypto-types').IAccessTokenSigner;
+export type ICardCrypto = import('@virgilsecurity/crypto-types').ICardCrypto;
+export type IPrivateKeyExporter = import('@virgilsecurity/crypto-types').IPrivateKeyExporter;
+
 export type Data = import('@virgilsecurity/data-utils').Data;
diff --git a/packages/virgil-crypto/package.json b/packages/virgil-crypto/package.json
@@ -1,6 +1,6 @@
 {
   "name": "virgil-crypto",
-  "version": "4.0.0-alpha.2",
+  "version": "4.0.0-alpha.3",
   "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/node.cjs.js",
   "module": "./dist/node.es.js",
@@ -25,9 +25,9 @@
     "prepare": "npm run clean && npm run build"
   },
   "dependencies": {
-    "@virgilsecurity/base-crypto": "^0.3.0",
+    "@virgilsecurity/base-crypto": "^0.4.0",
     "@virgilsecurity/core-foundation": "^0.1.0",
-    "@virgilsecurity/sdk-crypto": "^0.3.0"
+    "@virgilsecurity/sdk-crypto": "^0.4.0"
   },
   "devDependencies": {
     "lodash": "^4.17.15",

diff --git a/packages/webpack-demo/package.json b/packages/webpack-demo/package.json
@@ -11,7 +11,7 @@
     "build": "webpack"
   },
   "dependencies": {
-    "virgil-crypto": "^4.0.0-alpha.2"
+    "virgil-crypto": "^4.0.0-alpha.3"
   },
   "devDependencies": {
     "file-loader": "^4.1.0",