@trustvc/trustvc 2.9.1 → 2.10.0

package/dist/cjs/open-attestation/decrypt.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var forge = require('node-forge');
+var utils = require('./utils');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var forge__default = /*#__PURE__*/_interopDefault(forge);
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const decryptString = /* @__PURE__ */ __name(({ cipherText, tag, iv, key, type }) => {
+  if (type !== utils.ENCRYPTION_PARAMETERS.version) {
+    throw new Error(`Expecting version ${utils.ENCRYPTION_PARAMETERS.version} but got ${type}`);
+  }
+  const keyBytestring = forge__default.default.util.hexToBytes(key);
+  const cipherTextBytestring = forge__default.default.util.decode64(cipherText);
+  const ivBytestring = forge__default.default.util.decode64(iv);
+  const tagBytestring = forge__default.default.util.decode64(tag);
+  const decipher = forge__default.default.cipher.createDecipher("AES-GCM", keyBytestring);
+  decipher.start({
+    iv: ivBytestring,
+    tagLength: utils.ENCRYPTION_PARAMETERS.tagLength,
+    tag: forge__default.default.util.createBuffer(tagBytestring, "raw")
+  });
+  decipher.update(forge__default.default.util.createBuffer(cipherTextBytestring, "raw"));
+  const success = decipher.finish();
+  if (!success) {
+    throw new Error("Error decrypting message");
+  }
+  return utils.decodeDocument(decipher.output.data);
+}, "decryptString");
+
+exports.decryptString = decryptString;

package/dist/cjs/open-attestation/encrypt.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var forge = require('node-forge');
+var utils = require('./utils');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var forge__default = /*#__PURE__*/_interopDefault(forge);
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const generateIv = /* @__PURE__ */ __name((ivLengthInBits = utils.ENCRYPTION_PARAMETERS.ivLength) => {
+  const iv = forge__default.default.random.getBytesSync(ivLengthInBits / 8);
+  return forge__default.default.util.encode64(iv);
+}, "generateIv");
+const makeCipher = /* @__PURE__ */ __name((encryptionKey = utils.generateEncryptionKey()) => {
+  const iv = generateIv();
+  const cipher = forge__default.default.cipher.createCipher(
+    utils.ENCRYPTION_PARAMETERS.algorithm,
+    forge__default.default.util.hexToBytes(encryptionKey)
+  );
+  cipher.start({
+    iv: forge__default.default.util.decode64(iv),
+    tagLength: utils.ENCRYPTION_PARAMETERS.tagLength
+  });
+  return { cipher, encryptionKey, iv };
+}, "makeCipher");
+const encryptString = /* @__PURE__ */ __name((document, key) => {
+  if (typeof document !== "string") {
+    throw new Error("encryptString only accepts strings");
+  }
+  const { cipher, encryptionKey, iv } = makeCipher(key);
+  const buffer = forge__default.default.util.createBuffer(utils.encodeDocument(document));
+  cipher.update(buffer);
+  cipher.finish();
+  const encryptedMessage = forge__default.default.util.encode64(cipher.output.data);
+  const tag = forge__default.default.util.encode64(cipher.mode.tag.data);
+  return {
+    cipherText: encryptedMessage,
+    iv,
+    tag,
+    key: encryptionKey,
+    type: utils.ENCRYPTION_PARAMETERS.version
+  };
+}, "encryptString");
+
+exports.encryptString = encryptString;

package/dist/cjs/open-attestation/index.js

@@ -5,36 +5,46 @@ var types = require('./types');
 var utils = require('./utils');
 var verify = require('./verify');
 var wrap = require('./wrap');
+var encrypt = require('./encrypt');
+var decrypt = require('./decrypt');
 
 
 
+Object.defineProperty(exports, "encryptString", {
+  enumerable: true,
+  get: function () { return encrypt.encryptString; }
+});
+Object.defineProperty(exports, "decryptString", {
+  enumerable: true,
+  get: function () { return decrypt.decryptString; }
+});
 Object.keys(sign).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return sign[k]; }
-	});
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return sign[k]; }
+  });
 });
 Object.keys(types).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return types[k]; }
-	});
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return types[k]; }
+  });
 });
 Object.keys(utils).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return utils[k]; }
-	});
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return utils[k]; }
+  });
 });
 Object.keys(verify).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return verify[k]; }
-	});
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return verify[k]; }
+  });
 });
 Object.keys(wrap).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return wrap[k]; }
-	});
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return wrap[k]; }
+  });
 });

package/dist/cjs/open-attestation/utils.js

@@ -1,7 +1,46 @@
 'use strict';
 
+var forge = require('node-forge');
 var tradetrust = require('@tradetrust-tt/tradetrust');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var forge__default = /*#__PURE__*/_interopDefault(forge);
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const ENCRYPTION_PARAMETERS = Object.freeze({
+  algorithm: "AES-GCM",
+  keyLength: 256,
+  // Key length in bits
+  ivLength: 96,
+  // IV length in bits: NIST suggests 12 bytes
+  tagLength: 128,
+  // GCM authentication tag length in bits, see link above for explanation
+  version: "OPEN-ATTESTATION-TYPE-1"
+  // Type 1 using the above params without compression
+});
+const generateEncryptionKey = /* @__PURE__ */ __name((keyLengthInBits = ENCRYPTION_PARAMETERS.keyLength) => {
+  if (!Number.isInteger(keyLengthInBits) || ![128, 192, 256].includes(keyLengthInBits)) {
+    throw new Error("keyLengthInBits must be one of 128, 192, or 256");
+  }
+  const encryptionKey = forge__default.default.random.getBytesSync(keyLengthInBits / 8);
+  return forge__default.default.util.bytesToHex(encryptionKey);
+}, "generateEncryptionKey");
+const encodeDocument = /* @__PURE__ */ __name((document) => {
+  const bytes = forge__default.default.util.encodeUtf8(document);
+  const standard = forge__default.default.util.encode64(bytes);
+  const s = standard.replace(/\+/g, "-").replace(/\//g, "_");
+  const trim = s.endsWith("==") ? 2 : s.endsWith("=") ? 1 : 0;
+  return trim ? s.slice(0, -trim) : s;
+}, "encodeDocument");
+const decodeDocument = /* @__PURE__ */ __name((encoded) => {
+  let normalized = encoded.replace(/-/g, "+").replace(/_/g, "/");
+  const pad = normalized.length % 4;
+  if (pad) normalized += "=".repeat(4 - pad);
+  const decoded = forge__default.default.util.decode64(normalized);
+  return forge__default.default.util.decodeUtf8(decoded);
+}, "decodeDocument");
 const {
   isTransferableAsset,
   isDocumentRevokable,
@@ -42,7 +81,11 @@ Object.defineProperty(exports, "validateSchema", {
   enumerable: true,
   get: function () { return tradetrust.validateSchema; }
 });
+exports.ENCRYPTION_PARAMETERS = ENCRYPTION_PARAMETERS;
+exports.decodeDocument = decodeDocument;
 exports.diagnose = diagnose;
+exports.encodeDocument = encodeDocument;
+exports.generateEncryptionKey = generateEncryptionKey;
 exports.getAssetId = getAssetId;
 exports.getDocumentData = getDocumentData;
 exports.getIssuerAddress = getIssuerAddress;