Running Prettier

Author: rossphelan

README.md

@@ -1,5 +1,5 @@
-const forge = require('node-forge');
-const utils = require('../utils/utils');
+const forge = require("node-forge");
+const utils = require("../utils/utils");
 const c = require("../utils/constants");
 
 /**
@@ -11,18 +11,25 @@ const c = require("../utils/constants");
  * @constructor
  */
 function FieldLevelCrypto(config) {
-
   isValidConfig.call(this, config);
 
   // Load public certificate (for encryption)
-  this.encryptionCertificate = utils.readPublicCertificate(config.encryptionCertificate);
+  this.encryptionCertificate = utils.readPublicCertificate(
+    config.encryptionCertificate
+  );
 
   // Load private key (for decryption)
   this.privateKey = utils.getPrivateKey(config);
 
   this.encoding = config.dataEncoding;
 
-  this.publicKeyFingerprint = config.publicKeyFingerprint || utils.computePublicFingerprint(config, this.encryptionCertificate, this.encoding);
+  this.publicKeyFingerprint =
+    config.publicKeyFingerprint ||
+    utils.computePublicFingerprint(
+      config,
+      this.encryptionCertificate,
+      this.encoding
+    );
 
   this.publicKeyFingerprintFieldName = config.publicKeyFingerprintFieldName;
 
@@ -51,24 +58,32 @@ function FieldLevelCrypto(config) {
     const enc = encryptionParams || this.newEncryptionParams(options);
 
     // Create Cipher
-    const cipher = forge.cipher.createCipher('AES-CBC', enc.secretKey);
+    const cipher = forge.cipher.createCipher("AES-CBC", enc.secretKey);
 
     // Encrypt payload
-    cipher.start({iv: enc.iv});
+    cipher.start({ iv: enc.iv });
     cipher.update(forge.util.createBuffer(data, c.UTF8));
     cipher.finish();
     const encrypted = cipher.output.getBytes();
 
     const encryptedData = {
-      [this.encryptedValueFieldName]: utils.bytesToString(encrypted, this.encoding),
+      [this.encryptedValueFieldName]: utils.bytesToString(
+        encrypted,
+        this.encoding
+      ),
       iv: utils.bytesToString(enc.iv, this.encoding),
-      [this.encryptedKeyFieldName]: utils.bytesToString(enc.encryptedKey, this.encoding)
+      [this.encryptedKeyFieldName]: utils.bytesToString(
+        enc.encryptedKey,
+        this.encoding
+      ),
     };
     if (this.publicKeyFingerprint) {
-      encryptedData[this.publicKeyFingerprintFieldName] = this.publicKeyFingerprint;
+      encryptedData[this.publicKeyFingerprintFieldName] =
+        this.publicKeyFingerprint;
     }
     if (this.oaepHashingAlgorithmFieldName) {
-      encryptedData[this.oaepHashingAlgorithmFieldName] = this.oaepHashingAlgorithm.replace("-", "");
+      encryptedData[this.oaepHashingAlgorithmFieldName] =
+        this.oaepHashingAlgorithm.replace("-", "");
     }
     return encryptedData;
   };
@@ -83,16 +98,29 @@ function FieldLevelCrypto(config) {
    * @param encryptedKey Encrypted key
    * @returns {Object} Decrypted Json object
    */
-  this.decryptData = function (encryptedData, iv, oaepHashingAlgorithm, encryptedKey) {
-    const decryptedKey = this.privateKey.decrypt(utils.stringToBytes(encryptedKey, this.encoding), 'RSA-OAEP',
-      createOAEPOptions('RSA-OAEP', oaepHashingAlgorithm));
+  this.decryptData = function (
+    encryptedData,
+    iv,
+    oaepHashingAlgorithm,
+    encryptedKey
+  ) {
+    const decryptedKey = this.privateKey.decrypt(
+      utils.stringToBytes(encryptedKey, this.encoding),
+      "RSA-OAEP",
+      createOAEPOptions("RSA-OAEP", oaepHashingAlgorithm)
+    );
 
     // Init decipher
-    const decipher = forge.cipher.createDecipher('AES-CBC', decryptedKey);
+    const decipher = forge.cipher.createDecipher("AES-CBC", decryptedKey);
 
     // Decrypt payload
-    decipher.start({iv: utils.stringToBytes(iv, this.encoding)});
-    decipher.update(forge.util.createBuffer(utils.stringToBytes(encryptedData, this.encoding), c.BINARY));
+    decipher.start({ iv: utils.stringToBytes(iv, this.encoding) });
+    decipher.update(
+      forge.util.createBuffer(
+        utils.stringToBytes(encryptedData, this.encoding),
+        c.BINARY
+      )
+    );
     decipher.finish();
 
     try {
@@ -115,11 +143,15 @@ function FieldLevelCrypto(config) {
     const iv = options["iv"] || forge.random.getBytesSync(16);
 
     // Generate a secret key (should be 128 (or 256) bits)
-    const secretKey = options["secretKey"] || generateSecretKey('AES', 128, 'SHA-256');
+    const secretKey =
+      options["secretKey"] || generateSecretKey("AES", 128, "SHA-256");
 
     // Encrypt secret key with issuer key
-    const encryptedKey = this.encryptionCertificate.publicKey.encrypt(secretKey,
-      'RSA-OAEP', createOAEPOptions('RSA-OAEP', this.oaepHashingAlgorithm));
+    const encryptedKey = this.encryptionCertificate.publicKey.encrypt(
+      secretKey,
+      "RSA-OAEP",
+      createOAEPOptions("RSA-OAEP", this.oaepHashingAlgorithm)
+    );
 
     return {
       iv: iv,
@@ -130,24 +162,23 @@ function FieldLevelCrypto(config) {
       encoded: {
         iv: utils.bytesToString(iv, this.encoding),
         secretKey: utils.bytesToString(secretKey, this.encoding),
-        encryptedKey: utils.bytesToString(encryptedKey, this.encoding)
-      }
+        encryptedKey: utils.bytesToString(encryptedKey, this.encoding),
+      },
     };
   };
-
 }
 
 /**
  * @private
  */
 function createOAEPOptions(asymmetricCipher, oaepHashingAlgorithm) {
-  if (asymmetricCipher.includes('OAEP') && oaepHashingAlgorithm !== null) {
+  if (asymmetricCipher.includes("OAEP") && oaepHashingAlgorithm !== null) {
     const mdForOaep = createMessageDigest(oaepHashingAlgorithm);
     return {
       md: mdForOaep,
       mgf1: {
-        md: mdForOaep
-      }
+        md: mdForOaep,
+      },
     };
   }
 }
@@ -157,27 +188,26 @@ function createOAEPOptions(asymmetricCipher, oaepHashingAlgorithm) {
  */
 function createMessageDigest(digest) {
   switch (digest.toUpperCase()) {
-    case 'SHA-256':
-    case 'SHA256':
+    case "SHA-256":
+    case "SHA256":
       return forge.md.sha256.create();
-    case 'SHA-512':
-    case 'SHA512':
+    case "SHA-512":
+    case "SHA512":
       return forge.md.sha512.create();
   }
 }
 
-
 /**
  * @private
  */
 function generateSecretKey(algorithm, size, digest) {
-  if (algorithm === 'AES') {
+  if (algorithm === "AES") {
     const key = forge.random.getBytesSync(size / 8);
     const md = createMessageDigest(digest);
     md.update(key);
     return md.digest().getBytes(16);
   }
-  throw new Error('Unsupported symmetric algorithm');
+  throw new Error("Unsupported symmetric algorithm");
 }
 
 /**
@@ -186,23 +216,40 @@ function generateSecretKey(algorithm, size, digest) {
  * @private
  */
 function isValidConfig(config) {
-  const propertiesBasic = ["oaepPaddingDigestAlgorithm", "dataEncoding", "encryptionCertificate", "encryptedValueFieldName"];
+  const propertiesBasic = [
+    "oaepPaddingDigestAlgorithm",
+    "dataEncoding",
+    "encryptionCertificate",
+    "encryptedValueFieldName",
+  ];
   const propertiesField = ["ivFieldName", "encryptedKeyFieldName"];
-  const propertiesHeader = ["ivHeaderName", "encryptedKeyHeaderName", "oaepHashingAlgorithmHeaderName"];
+  const propertiesHeader = [
+    "ivHeaderName",
+    "encryptedKeyHeaderName",
+    "oaepHashingAlgorithmHeaderName",
+  ];
   const contains = (props) => {
     return props.every((elem) => {
       return config[elem] !== null && typeof config[elem] !== "undefined";
     });
   };
-  if (typeof config !== 'object' || config === null) {
+  if (typeof config !== "object" || config === null) {
     throw Error("Config not valid: config should be an object.");
   }
-  if (config["paths"] === null || typeof config["paths"] === "undefined" ||
-    !(config["paths"] instanceof Array)) {
+  if (
+    config["paths"] === null ||
+    typeof config["paths"] === "undefined" ||
+    !(config["paths"] instanceof Array)
+  ) {
     throw Error("Config not valid: paths should be an array of path element.");
   }
-  if (!contains(propertiesBasic) || (!contains(propertiesField) && !contains(propertiesHeader))) {
-    throw Error("Config not valid: please check that all the properties are defined.");
+  if (
+    !contains(propertiesBasic) ||
+    (!contains(propertiesField) && !contains(propertiesHeader))
+  ) {
+    throw Error(
+      "Config not valid: please check that all the properties are defined."
+    );
   }
   if (config["paths"].length === 0) {
     throw Error("Config not valid: paths should be not empty.");
@@ -215,25 +262,39 @@ function isValidConfig(config) {
 }
 
 function validateFingerprint(config, contains) {
-  const propertiesFingerprint = ["publicKeyFingerprintType", "publicKeyFingerprintFieldName", "publicKeyFingerprintHeaderName"];
+  const propertiesFingerprint = [
+    "publicKeyFingerprintType",
+    "publicKeyFingerprintFieldName",
+    "publicKeyFingerprintHeaderName",
+  ];
   const propertiesOptionalFingerprint = ["publicKeyFingerprint"];
-  if (!contains(propertiesOptionalFingerprint)
-    && (config[propertiesFingerprint[1]] || config[propertiesFingerprint[2]])
-    && config[propertiesFingerprint[0]] !== "certificate" && config[propertiesFingerprint[0]] !== "publicKey") {
-    throw Error("Config not valid: propertiesFingerprint should be: 'certificate' or 'publicKey'");
+  if (
+    !contains(propertiesOptionalFingerprint) &&
+    (config[propertiesFingerprint[1]] || config[propertiesFingerprint[2]]) &&
+    config[propertiesFingerprint[0]] !== "certificate" &&
+    config[propertiesFingerprint[0]] !== "publicKey"
+  ) {
+    throw Error(
+      "Config not valid: propertiesFingerprint should be: 'certificate' or 'publicKey'"
+    );
   }
 }
 
 function validateRootMapping(config) {
   function multipleRoots(elem) {
-    return elem.length !== 1 && elem.some((item) => {
-      return item.obj === "$" || item.element === "$";
-    });
+    return (
+      elem.length !== 1 &&
+      elem.some((item) => {
+        return item.obj === "$" || item.element === "$";
+      })
+    );
   }
 
   config.paths.forEach((path) => {
     if (multipleRoots(path.toEncrypt) || multipleRoots(path.toDecrypt)) {
-      throw Error("Config not valid: found multiple configurations encrypt/decrypt with root mapping");
+      throw Error(
+        "Config not valid: found multiple configurations encrypt/decrypt with root mapping"
+      );
     }
   });
 }