plugin-data-source-mssql 2.0.0 → 2.0.2

package/dist/node_modules/tedious/lib/always-encrypted/get-parameter-encryption-metadata.js

@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getParameterEncryptionMetadata = void 0;
+var _types = require("./types");
+var _cekEntry = require("./cek-entry");
+var _keyCrypto = require("./key-crypto");
+var _dataType = require("../data-type");
+var _request = _interopRequireDefault(require("../request"));
+var _rpcrequestPayload = _interopRequireDefault(require("../rpcrequest-payload"));
+var _packet = require("../packet");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// This code is based on the `mssql-jdbc` library published under the conditions of MIT license.
+// Copyright (c) 2019 Microsoft Corporation
+
+const getParameterEncryptionMetadata = (connection, request, callback) => {
+  if (request.cryptoMetadataLoaded === true) {
+    return callback();
+  }
+  const metadataRequest = new _request.default('sp_describe_parameter_encryption', error => {
+    if (error) {
+      return callback(error);
+    }
+    const decryptSymmetricKeyPromises = [];
+    const cekList = [];
+    let paramCount = 0;
+    for (const columns of resultRows) {
+      try {
+        const isFirstRecordSet = columns.some(col => (col && col.metadata && col.metadata.colName) === 'database_id');
+        if (isFirstRecordSet === true) {
+          const currentOrdinal = columns[_types.DescribeParameterEncryptionResultSet1.KeyOrdinal].value;
+          let cekEntry;
+          if (!cekList[currentOrdinal]) {
+            cekEntry = new _cekEntry.CEKEntry(currentOrdinal);
+            cekList[cekEntry.ordinal] = cekEntry;
+          } else {
+            cekEntry = cekList[currentOrdinal];
+          }
+          cekEntry.add(columns[_types.DescribeParameterEncryptionResultSet1.EncryptedKey].value, columns[_types.DescribeParameterEncryptionResultSet1.DbId].value, columns[_types.DescribeParameterEncryptionResultSet1.KeyId].value, columns[_types.DescribeParameterEncryptionResultSet1.KeyVersion].value, columns[_types.DescribeParameterEncryptionResultSet1.KeyMdVersion].value, columns[_types.DescribeParameterEncryptionResultSet1.KeyPath].value, columns[_types.DescribeParameterEncryptionResultSet1.ProviderName].value, columns[_types.DescribeParameterEncryptionResultSet1.KeyEncryptionAlgorithm].value);
+        } else {
+          paramCount++;
+          const paramName = columns[_types.DescribeParameterEncryptionResultSet2.ParameterName].value;
+          const paramIndex = request.parameters.findIndex(param => paramName === `@${param.name}`);
+          const cekOrdinal = columns[_types.DescribeParameterEncryptionResultSet2.ColumnEncryptionKeyOrdinal].value;
+          const cekEntry = cekList[cekOrdinal];
+          if (cekEntry && cekList.length < cekOrdinal) {
+            return callback(new Error(`Internal error. The referenced column encryption key ordinal "${cekOrdinal}" is missing in the encryption metadata returned by sp_describe_parameter_encryption. Max ordinal is "${cekList.length}".`));
+          }
+          const encType = columns[_types.DescribeParameterEncryptionResultSet2.ColumnEncrytionType].value;
+          if (_types.SQLServerEncryptionType.PlainText !== encType) {
+            request.parameters[paramIndex].cryptoMetadata = {
+              cekEntry: cekEntry,
+              ordinal: cekOrdinal,
+              cipherAlgorithmId: columns[_types.DescribeParameterEncryptionResultSet2.ColumnEncryptionAlgorithm].value,
+              encryptionType: encType,
+              normalizationRuleVersion: Buffer.from([columns[_types.DescribeParameterEncryptionResultSet2.NormalizationRuleVersion].value])
+            };
+            decryptSymmetricKeyPromises.push((0, _keyCrypto.decryptSymmetricKey)(request.parameters[paramIndex].cryptoMetadata, connection.config.options));
+          } else if (request.parameters[paramIndex].forceEncrypt === true) {
+            return callback(new Error(`Cannot execute statement or procedure ${request.sqlTextOrProcedure} because Force Encryption was set as true for parameter ${paramIndex + 1} and the database expects this parameter to be sent as plaintext. This may be due to a configuration error.`));
+          }
+        }
+      } catch {
+        return callback(new Error(`Internal error. Unable to parse parameter encryption metadata in statement or procedure "${request.sqlTextOrProcedure}"`));
+      }
+    }
+    if (paramCount !== request.parameters.length) {
+      return callback(new Error(`Internal error. Metadata for some parameters in statement or procedure "${request.sqlTextOrProcedure}" is missing in the resultset returned by sp_describe_parameter_encryption.`));
+    }
+    return Promise.all(decryptSymmetricKeyPromises).then(() => {
+      request.cryptoMetadataLoaded = true;
+      process.nextTick(callback);
+    }, error => {
+      process.nextTick(callback, error);
+    });
+  });
+  metadataRequest.addParameter('tsql', _dataType.typeByName.NVarChar, request.sqlTextOrProcedure);
+  if (request.parameters.length) {
+    metadataRequest.addParameter('params', _dataType.typeByName.NVarChar, metadataRequest.makeParamsParameter(request.parameters));
+  }
+  const resultRows = [];
+  metadataRequest.on('row', columns => {
+    resultRows.push(columns);
+  });
+  connection.makeRequest(metadataRequest, _packet.TYPE.RPC_REQUEST, new _rpcrequestPayload.default(metadataRequest.sqlTextOrProcedure, metadataRequest.parameters, connection.currentTransactionDescriptor(), connection.config.options, connection.databaseCollation));
+};
+exports.getParameterEncryptionMetadata = getParameterEncryptionMetadata;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_types","require","_cekEntry","_keyCrypto","_dataType","_request","_interopRequireDefault","_rpcrequestPayload","_packet","obj","__esModule","default","getParameterEncryptionMetadata","connection","request","callback","cryptoMetadataLoaded","metadataRequest","Request","error","decryptSymmetricKeyPromises","cekList","paramCount","columns","resultRows","isFirstRecordSet","some","col","metadata","colName","currentOrdinal","DescribeParameterEncryptionResultSet1","KeyOrdinal","value","cekEntry","CEKEntry","ordinal","add","EncryptedKey","DbId","KeyId","KeyVersion","KeyMdVersion","KeyPath","ProviderName","KeyEncryptionAlgorithm","paramName","DescribeParameterEncryptionResultSet2","ParameterName","paramIndex","parameters","findIndex","param","name","cekOrdinal","ColumnEncryptionKeyOrdinal","length","Error","encType","ColumnEncrytionType","SQLServerEncryptionType","PlainText","cryptoMetadata","cipherAlgorithmId","ColumnEncryptionAlgorithm","encryptionType","normalizationRuleVersion","Buffer","from","NormalizationRuleVersion","push","decryptSymmetricKey","config","options","forceEncrypt","sqlTextOrProcedure","Promise","all","then","process","nextTick","addParameter","TYPES","NVarChar","makeParamsParameter","on","makeRequest","TYPE","RPC_REQUEST","RpcRequestPayload","currentTransactionDescriptor","databaseCollation","exports"],"sources":["../../src/always-encrypted/get-parameter-encryption-metadata.ts"],"sourcesContent":["// This code is based on the `mssql-jdbc` library published under the conditions of MIT license.\n// Copyright (c) 2019 Microsoft Corporation\n\nimport { SQLServerEncryptionType, type CryptoMetadata, DescribeParameterEncryptionResultSet1, DescribeParameterEncryptionResultSet2 } from './types';\nimport { CEKEntry } from './cek-entry';\nimport { decryptSymmetricKey } from './key-crypto';\nimport { typeByName as TYPES, type Parameter } from '../data-type';\nimport Request from '../request';\nimport Connection from '../connection';\nimport RpcRequestPayload from '../rpcrequest-payload';\nimport { TYPE } from '../packet';\n\nexport const getParameterEncryptionMetadata = (connection: Connection, request: Request, callback: (error?: Error) => void) => {\n  if (request.cryptoMetadataLoaded === true) {\n    return callback();\n  }\n\n  const metadataRequest = new Request('sp_describe_parameter_encryption', (error) => {\n    if (error) {\n      return callback(error);\n    }\n\n    const decryptSymmetricKeyPromises: Promise<void>[] = [];\n    const cekList: CEKEntry[] = [];\n    let paramCount = 0;\n\n    for (const columns of resultRows) {\n      try {\n        const isFirstRecordSet = columns.some((col: any) => (col && col.metadata && col.metadata.colName) === 'database_id');\n        if (isFirstRecordSet === true) {\n          const currentOrdinal = columns[DescribeParameterEncryptionResultSet1.KeyOrdinal].value;\n          let cekEntry: CEKEntry;\n          if (!cekList[currentOrdinal]) {\n            cekEntry = new CEKEntry(currentOrdinal);\n            cekList[cekEntry.ordinal] = cekEntry;\n          } else {\n            cekEntry = cekList[currentOrdinal];\n          }\n          cekEntry.add(columns[DescribeParameterEncryptionResultSet1.EncryptedKey].value,\n                       columns[DescribeParameterEncryptionResultSet1.DbId].value,\n                       columns[DescribeParameterEncryptionResultSet1.KeyId].value,\n                       columns[DescribeParameterEncryptionResultSet1.KeyVersion].value,\n                       columns[DescribeParameterEncryptionResultSet1.KeyMdVersion].value,\n                       columns[DescribeParameterEncryptionResultSet1.KeyPath].value,\n                       columns[DescribeParameterEncryptionResultSet1.ProviderName].value,\n                       columns[DescribeParameterEncryptionResultSet1.KeyEncryptionAlgorithm].value);\n        } else {\n          paramCount++;\n          const paramName: string = columns[DescribeParameterEncryptionResultSet2.ParameterName].value;\n          const paramIndex: number = request.parameters.findIndex((param: Parameter) => paramName === `@${param.name}`);\n          const cekOrdinal: number = columns[DescribeParameterEncryptionResultSet2.ColumnEncryptionKeyOrdinal].value;\n          const cekEntry: CEKEntry = cekList[cekOrdinal];\n\n          if (cekEntry && cekList.length < cekOrdinal) {\n            return callback(new Error(`Internal error. The referenced column encryption key ordinal \"${cekOrdinal}\" is missing in the encryption metadata returned by sp_describe_parameter_encryption. Max ordinal is \"${cekList.length}\".`));\n          }\n\n          const encType = columns[DescribeParameterEncryptionResultSet2.ColumnEncrytionType].value;\n          if (SQLServerEncryptionType.PlainText !== encType) {\n            request.parameters[paramIndex].cryptoMetadata = {\n              cekEntry: cekEntry,\n              ordinal: cekOrdinal,\n              cipherAlgorithmId: columns[DescribeParameterEncryptionResultSet2.ColumnEncryptionAlgorithm].value,\n              encryptionType: encType,\n              normalizationRuleVersion: Buffer.from([columns[DescribeParameterEncryptionResultSet2.NormalizationRuleVersion].value]),\n            };\n            decryptSymmetricKeyPromises.push(decryptSymmetricKey(request.parameters[paramIndex].cryptoMetadata as CryptoMetadata, connection.config.options));\n          } else if (request.parameters[paramIndex].forceEncrypt === true) {\n            return callback(new Error(`Cannot execute statement or procedure ${request.sqlTextOrProcedure} because Force Encryption was set as true for parameter ${paramIndex + 1} and the database expects this parameter to be sent as plaintext. This may be due to a configuration error.`));\n          }\n        }\n      } catch {\n        return callback(new Error(`Internal error. Unable to parse parameter encryption metadata in statement or procedure \"${request.sqlTextOrProcedure}\"`));\n      }\n    }\n\n    if (paramCount !== request.parameters.length) {\n      return callback(new Error(`Internal error. Metadata for some parameters in statement or procedure \"${request.sqlTextOrProcedure}\" is missing in the resultset returned by sp_describe_parameter_encryption.`));\n    }\n\n    return Promise.all(decryptSymmetricKeyPromises).then(() => {\n      request.cryptoMetadataLoaded = true;\n      process.nextTick(callback);\n    }, (error) => {\n      process.nextTick(callback, error);\n    });\n  });\n\n  metadataRequest.addParameter('tsql', TYPES.NVarChar, request.sqlTextOrProcedure);\n  if (request.parameters.length) {\n    metadataRequest.addParameter('params', TYPES.NVarChar, metadataRequest.makeParamsParameter(request.parameters));\n  }\n\n  const resultRows: any[] = [];\n\n  metadataRequest.on('row', (columns: any) => {\n    resultRows.push(columns);\n  });\n\n  connection.makeRequest(metadataRequest, TYPE.RPC_REQUEST, new RpcRequestPayload(metadataRequest.sqlTextOrProcedure!, metadataRequest.parameters, connection.currentTransactionDescriptor(), connection.config.options, connection.databaseCollation));\n};\n"],"mappings":";;;;;;AAGA,IAAAA,MAAA,GAAAC,OAAA;AACA,IAAAC,SAAA,GAAAD,OAAA;AACA,IAAAE,UAAA,GAAAF,OAAA;AACA,IAAAG,SAAA,GAAAH,OAAA;AACA,IAAAI,QAAA,GAAAC,sBAAA,CAAAL,OAAA;AAEA,IAAAM,kBAAA,GAAAD,sBAAA,CAAAL,OAAA;AACA,IAAAO,OAAA,GAAAP,OAAA;AAAiC,SAAAK,uBAAAG,GAAA,WAAAA,GAAA,IAAAA,GAAA,CAAAC,UAAA,GAAAD,GAAA,KAAAE,OAAA,EAAAF,GAAA;AAVjC;AACA;;AAWO,MAAMG,8BAA8B,GAAGA,CAACC,UAAsB,EAAEC,OAAgB,EAAEC,QAAiC,KAAK;EAC7H,IAAID,OAAO,CAACE,oBAAoB,KAAK,IAAI,EAAE;IACzC,OAAOD,QAAQ,CAAC,CAAC;EACnB;EAEA,MAAME,eAAe,GAAG,IAAIC,gBAAO,CAAC,kCAAkC,EAAGC,KAAK,IAAK;IACjF,IAAIA,KAAK,EAAE;MACT,OAAOJ,QAAQ,CAACI,KAAK,CAAC;IACxB;IAEA,MAAMC,2BAA4C,GAAG,EAAE;IACvD,MAAMC,OAAmB,GAAG,EAAE;IAC9B,IAAIC,UAAU,GAAG,CAAC;IAElB,KAAK,MAAMC,OAAO,IAAIC,UAAU,EAAE;MAChC,IAAI;QACF,MAAMC,gBAAgB,GAAGF,OAAO,CAACG,IAAI,CAAEC,GAAQ,IAAK,CAACA,GAAG,IAAIA,GAAG,CAACC,QAAQ,IAAID,GAAG,CAACC,QAAQ,CAACC,OAAO,MAAM,aAAa,CAAC;QACpH,IAAIJ,gBAAgB,KAAK,IAAI,EAAE;UAC7B,MAAMK,cAAc,GAAGP,OAAO,CAACQ,4CAAqC,CAACC,UAAU,CAAC,CAACC,KAAK;UACtF,IAAIC,QAAkB;UACtB,IAAI,CAACb,OAAO,CAACS,cAAc,CAAC,EAAE;YAC5BI,QAAQ,GAAG,IAAIC,kBAAQ,CAACL,cAAc,CAAC;YACvCT,OAAO,CAACa,QAAQ,CAACE,OAAO,CAAC,GAAGF,QAAQ;UACtC,CAAC,MAAM;YACLA,QAAQ,GAAGb,OAAO,CAACS,cAAc,CAAC;UACpC;UACAI,QAAQ,CAACG,GAAG,CAACd,OAAO,CAACQ,4CAAqC,CAACO,YAAY,CAAC,CAACL,KAAK,EACjEV,OAAO,CAACQ,4CAAqC,CAACQ,IAAI,CAAC,CAACN,KAAK,EACzDV,OAAO,CAACQ,4CAAqC,CAACS,KAAK,CAAC,CAACP,KAAK,EAC1DV,OAAO,CAACQ,4CAAqC,CAACU,UAAU,CAAC,CAACR,KAAK,EAC/DV,OAAO,CAACQ,4CAAqC,CAACW,YAAY,CAAC,CAACT,KAAK,EACjEV,OAAO,CAACQ,4CAAqC,CAACY,OAAO,CAAC,CAACV,KAAK,EAC5DV,OAAO,CAACQ,4CAAqC,CAACa,YAAY,CAAC,CAACX,KAAK,EACjEV,OAAO,CAACQ,4CAAqC,CAACc,sBAAsB,CAAC,CAACZ,KAAK,CAAC;QAC3F,CAAC,MAAM;UACLX,UAAU,EAAE;UACZ,MAAMwB,SAAiB,GAAGvB,OAAO,CAACwB,4CAAqC,CAACC,aAAa,CAAC,CAACf,KAAK;UAC5F,MAAMgB,UAAkB,GAAGnC,OAAO,CAACoC,UAAU,CAACC,SAAS,CAAEC,KAAgB,IAAKN,SAAS,KAAM,IAAGM,KAAK,CAACC,IAAK,EAAC,CAAC;UAC7G,MAAMC,UAAkB,GAAG/B,OAAO,CAACwB,4CAAqC,CAACQ,0BAA0B,CAAC,CAACtB,KAAK;UAC1G,MAAMC,QAAkB,GAAGb,OAAO,CAACiC,UAAU,CAAC;UAE9C,IAAIpB,QAAQ,IAAIb,OAAO,CAACmC,MAAM,GAAGF,UAAU,EAAE;YAC3C,OAAOvC,QAAQ,CAAC,IAAI0C,KAAK,CAAE,iEAAgEH,UAAW,yGAAwGjC,OAAO,CAACmC,MAAO,IAAG,CAAC,CAAC;UACpO;UAEA,MAAME,OAAO,GAAGnC,OAAO,CAACwB,4CAAqC,CAACY,mBAAmB,CAAC,CAAC1B,KAAK;UACxF,IAAI2B,8BAAuB,CAACC,SAAS,KAAKH,OAAO,EAAE;YACjD5C,OAAO,CAACoC,UAAU,CAACD,UAAU,CAAC,CAACa,cAAc,GAAG;cAC9C5B,QAAQ,EAAEA,QAAQ;cAClBE,OAAO,EAAEkB,UAAU;cACnBS,iBAAiB,EAAExC,OAAO,CAACwB,4CAAqC,CAACiB,yBAAyB,CAAC,CAAC/B,KAAK;cACjGgC,cAAc,EAAEP,OAAO;cACvBQ,wBAAwB,EAAEC,MAAM,CAACC,IAAI,CAAC,CAAC7C,OAAO,CAACwB,4CAAqC,CAACsB,wBAAwB,CAAC,CAACpC,KAAK,CAAC;YACvH,CAAC;YACDb,2BAA2B,CAACkD,IAAI,CAAC,IAAAC,8BAAmB,EAACzD,OAAO,CAACoC,UAAU,CAACD,UAAU,CAAC,CAACa,cAAc,EAAoBjD,UAAU,CAAC2D,MAAM,CAACC,OAAO,CAAC,CAAC;UACnJ,CAAC,MAAM,IAAI3D,OAAO,CAACoC,UAAU,CAACD,UAAU,CAAC,CAACyB,YAAY,KAAK,IAAI,EAAE;YAC/D,OAAO3D,QAAQ,CAAC,IAAI0C,KAAK,CAAE,yCAAwC3C,OAAO,CAAC6D,kBAAmB,2DAA0D1B,UAAU,GAAG,CAAE,6GAA4G,CAAC,CAAC;UACvR;QACF;MACF,CAAC,CAAC,MAAM;QACN,OAAOlC,QAAQ,CAAC,IAAI0C,KAAK,CAAE,4FAA2F3C,OAAO,CAAC6D,kBAAmB,GAAE,CAAC,CAAC;MACvJ;IACF;IAEA,IAAIrD,UAAU,KAAKR,OAAO,CAACoC,UAAU,CAACM,MAAM,EAAE;MAC5C,OAAOzC,QAAQ,CAAC,IAAI0C,KAAK,CAAE,2EAA0E3C,OAAO,CAAC6D,kBAAmB,6EAA4E,CAAC,CAAC;IAChN;IAEA,OAAOC,OAAO,CAACC,GAAG,CAACzD,2BAA2B,CAAC,CAAC0D,IAAI,CAAC,MAAM;MACzDhE,OAAO,CAACE,oBAAoB,GAAG,IAAI;MACnC+D,OAAO,CAACC,QAAQ,CAACjE,QAAQ,CAAC;IAC5B,CAAC,EAAGI,KAAK,IAAK;MACZ4D,OAAO,CAACC,QAAQ,CAACjE,QAAQ,EAAEI,KAAK,CAAC;IACnC,CAAC,CAAC;EACJ,CAAC,CAAC;EAEFF,eAAe,CAACgE,YAAY,CAAC,MAAM,EAAEC,oBAAK,CAACC,QAAQ,EAAErE,OAAO,CAAC6D,kBAAkB,CAAC;EAChF,IAAI7D,OAAO,CAACoC,UAAU,CAACM,MAAM,EAAE;IAC7BvC,eAAe,CAACgE,YAAY,CAAC,QAAQ,EAAEC,oBAAK,CAACC,QAAQ,EAAElE,eAAe,CAACmE,mBAAmB,CAACtE,OAAO,CAACoC,UAAU,CAAC,CAAC;EACjH;EAEA,MAAM1B,UAAiB,GAAG,EAAE;EAE5BP,eAAe,CAACoE,EAAE,CAAC,KAAK,EAAG9D,OAAY,IAAK;IAC1CC,UAAU,CAAC8C,IAAI,CAAC/C,OAAO,CAAC;EAC1B,CAAC,CAAC;EAEFV,UAAU,CAACyE,WAAW,CAACrE,eAAe,EAAEsE,YAAI,CAACC,WAAW,EAAE,IAAIC,0BAAiB,CAACxE,eAAe,CAAC0D,kBAAkB,EAAG1D,eAAe,CAACiC,UAAU,EAAErC,UAAU,CAAC6E,4BAA4B,CAAC,CAAC,EAAE7E,UAAU,CAAC2D,MAAM,CAACC,OAAO,EAAE5D,UAAU,CAAC8E,iBAAiB,CAAC,CAAC;AACvP,CAAC;AAACC,OAAA,CAAAhF,8BAAA,GAAAA,8BAAA"}

package/dist/node_modules/tedious/lib/always-encrypted/key-crypto.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateAndGetEncryptionAlgorithmName = exports.encryptWithKey = exports.decryptWithKey = exports.decryptSymmetricKey = void 0;
+var _symmetricKeyCache = require("./symmetric-key-cache");
+var _aeadAes256CbcHmacAlgorithm = require("./aead-aes-256-cbc-hmac-algorithm");
+var _aeadAes256CbcHmacEncryptionKey = require("./aead-aes-256-cbc-hmac-encryption-key");
+// This code is based on the `mssql-jdbc` library published under the conditions of MIT license.
+// Copyright (c) 2019 Microsoft Corporation
+
+const validateAndGetEncryptionAlgorithmName = (cipherAlgorithmId, cipherAlgorithmName) => {
+  if (cipherAlgorithmId !== 2) {
+    throw new Error('Custom cipher algorithm not supported.');
+  }
+  return _aeadAes256CbcHmacAlgorithm.algorithmName;
+};
+exports.validateAndGetEncryptionAlgorithmName = validateAndGetEncryptionAlgorithmName;
+const encryptWithKey = async (plaintext, md, options) => {
+  if (!options.trustedServerNameAE) {
+    throw new Error('Server name should not be null in EncryptWithKey');
+  }
+  if (!md.cipherAlgorithm) {
+    await decryptSymmetricKey(md, options);
+  }
+  if (!md.cipherAlgorithm) {
+    throw new Error('Cipher Algorithm should not be null in EncryptWithKey');
+  }
+  const cipherText = md.cipherAlgorithm.encryptData(plaintext);
+  if (!cipherText) {
+    throw new Error('Internal error. Ciphertext value cannot be null.');
+  }
+  return cipherText;
+};
+exports.encryptWithKey = encryptWithKey;
+const decryptWithKey = (cipherText, md, options) => {
+  if (!options.trustedServerNameAE) {
+    throw new Error('Server name should not be null in DecryptWithKey');
+  }
+
+  // if (!md.cipherAlgorithm) {
+  //   await decryptSymmetricKey(md, options);
+  // }
+
+  if (!md.cipherAlgorithm) {
+    throw new Error('Cipher Algorithm should not be null in DecryptWithKey');
+  }
+  const plainText = md.cipherAlgorithm.decryptData(cipherText);
+  if (!plainText) {
+    throw new Error('Internal error. Plaintext value cannot be null.');
+  }
+  return plainText;
+};
+exports.decryptWithKey = decryptWithKey;
+const decryptSymmetricKey = async (md, options) => {
+  if (!md) {
+    throw new Error('md should not be null in DecryptSymmetricKey.');
+  }
+  if (!md.cekEntry) {
+    throw new Error('md.EncryptionInfo should not be null in DecryptSymmetricKey.');
+  }
+  if (!md.cekEntry.columnEncryptionKeyValues) {
+    throw new Error('md.EncryptionInfo.ColumnEncryptionKeyValues should not be null in DecryptSymmetricKey.');
+  }
+  let symKey;
+  let encryptionKeyInfoChosen;
+  const CEKValues = md.cekEntry.columnEncryptionKeyValues;
+  let lastError;
+  for (const CEKValue of CEKValues) {
+    try {
+      symKey = await (0, _symmetricKeyCache.getKey)(CEKValue, options);
+      if (symKey) {
+        encryptionKeyInfoChosen = CEKValue;
+        break;
+      }
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  if (!symKey) {
+    if (lastError) {
+      throw lastError;
+    } else {
+      throw new Error('Exception while decryption of encrypted column encryption key.');
+    }
+  }
+  const algorithmName = validateAndGetEncryptionAlgorithmName(md.cipherAlgorithmId, md.cipherAlgorithmName);
+  const cipherAlgorithm = new _aeadAes256CbcHmacAlgorithm.AeadAes256CbcHmac256Algorithm(new _aeadAes256CbcHmacEncryptionKey.AeadAes256CbcHmac256EncryptionKey(symKey.rootKey, algorithmName), md.encryptionType);
+  md.cipherAlgorithm = cipherAlgorithm;
+  md.encryptionKeyInfo = encryptionKeyInfoChosen;
+};
+exports.decryptSymmetricKey = decryptSymmetricKey;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_symmetricKeyCache","require","_aeadAes256CbcHmacAlgorithm","_aeadAes256CbcHmacEncryptionKey","validateAndGetEncryptionAlgorithmName","cipherAlgorithmId","cipherAlgorithmName","Error","algorithmName","exports","encryptWithKey","plaintext","md","options","trustedServerNameAE","cipherAlgorithm","decryptSymmetricKey","cipherText","encryptData","decryptWithKey","plainText","decryptData","cekEntry","columnEncryptionKeyValues","symKey","encryptionKeyInfoChosen","CEKValues","lastError","CEKValue","getKey","error","AeadAes256CbcHmac256Algorithm","AeadAes256CbcHmac256EncryptionKey","rootKey","encryptionType","encryptionKeyInfo"],"sources":["../../src/always-encrypted/key-crypto.ts"],"sourcesContent":["// This code is based on the `mssql-jdbc` library published under the conditions of MIT license.\n// Copyright (c) 2019 Microsoft Corporation\n\nimport { type CryptoMetadata, type EncryptionKeyInfo } from './types';\nimport { type InternalConnectionOptions as ConnectionOptions } from '../connection';\nimport SymmetricKey from './symmetric-key';\nimport { getKey } from './symmetric-key-cache';\nimport { AeadAes256CbcHmac256Algorithm, algorithmName } from './aead-aes-256-cbc-hmac-algorithm';\nimport { AeadAes256CbcHmac256EncryptionKey } from './aead-aes-256-cbc-hmac-encryption-key';\n\nexport const validateAndGetEncryptionAlgorithmName = (cipherAlgorithmId: number, cipherAlgorithmName?: string): string => {\n  if (cipherAlgorithmId !== 2) {\n    throw new Error('Custom cipher algorithm not supported.');\n  }\n\n  return algorithmName;\n};\n\nexport const encryptWithKey = async (plaintext: Buffer, md: CryptoMetadata, options: ConnectionOptions): Promise<Buffer> => {\n  if (!options.trustedServerNameAE) {\n    throw new Error('Server name should not be null in EncryptWithKey');\n  }\n\n  if (!md.cipherAlgorithm) {\n    await decryptSymmetricKey(md, options);\n  }\n\n  if (!md.cipherAlgorithm) {\n    throw new Error('Cipher Algorithm should not be null in EncryptWithKey');\n  }\n\n  const cipherText: Buffer = md.cipherAlgorithm.encryptData(plaintext);\n\n  if (!cipherText) {\n    throw new Error('Internal error. Ciphertext value cannot be null.');\n  }\n\n  return cipherText;\n};\n\nexport const decryptWithKey = (cipherText: Buffer, md: CryptoMetadata, options: ConnectionOptions): Buffer => {\n  if (!options.trustedServerNameAE) {\n    throw new Error('Server name should not be null in DecryptWithKey');\n  }\n\n  // if (!md.cipherAlgorithm) {\n  //   await decryptSymmetricKey(md, options);\n  // }\n\n  if (!md.cipherAlgorithm) {\n    throw new Error('Cipher Algorithm should not be null in DecryptWithKey');\n  }\n\n  const plainText: Buffer = md.cipherAlgorithm.decryptData(cipherText);\n\n  if (!plainText) {\n    throw new Error('Internal error. Plaintext value cannot be null.');\n  }\n\n  return plainText;\n};\n\nexport const decryptSymmetricKey = async (md: CryptoMetadata, options: ConnectionOptions): Promise<void> => {\n  if (!md) {\n    throw new Error('md should not be null in DecryptSymmetricKey.');\n  }\n\n  if (!md.cekEntry) {\n    throw new Error('md.EncryptionInfo should not be null in DecryptSymmetricKey.');\n  }\n\n  if (!md.cekEntry.columnEncryptionKeyValues) {\n    throw new Error('md.EncryptionInfo.ColumnEncryptionKeyValues should not be null in DecryptSymmetricKey.');\n  }\n\n  let symKey: SymmetricKey | undefined;\n  let encryptionKeyInfoChosen: EncryptionKeyInfo | undefined;\n  const CEKValues: EncryptionKeyInfo[] = md.cekEntry.columnEncryptionKeyValues;\n  let lastError: Error | undefined;\n\n  for (const CEKValue of CEKValues) {\n    try {\n      symKey = await getKey(CEKValue, options);\n      if (symKey) {\n        encryptionKeyInfoChosen = CEKValue;\n        break;\n      }\n    } catch (error: any) {\n      lastError = error;\n    }\n  }\n\n  if (!symKey) {\n    if (lastError) {\n      throw lastError;\n    } else {\n      throw new Error('Exception while decryption of encrypted column encryption key.');\n    }\n  }\n\n  const algorithmName = validateAndGetEncryptionAlgorithmName(md.cipherAlgorithmId, md.cipherAlgorithmName);\n  const cipherAlgorithm = new AeadAes256CbcHmac256Algorithm(new AeadAes256CbcHmac256EncryptionKey(symKey.rootKey, algorithmName), md.encryptionType);\n\n  md.cipherAlgorithm = cipherAlgorithm;\n  md.encryptionKeyInfo = encryptionKeyInfoChosen as EncryptionKeyInfo;\n};\n"],"mappings":"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"}

package/dist/node_modules/tedious/lib/always-encrypted/keystore-provider-azure-key-vault.d.ts

@@ -0,0 +1,21 @@
+export declare class ColumnEncryptionAzureKeyVaultProvider {
+    readonly name: string;
+    private url;
+    private readonly rsaEncryptionAlgorithmWithOAEPForAKV;
+    private readonly firstVersion;
+    private credentials;
+    private readonly azureKeyVaultDomainName;
+    private keyClient;
+    constructor(clientId: string, clientKey: string, tenantId: string);
+    decryptColumnEncryptionKey(masterKeyPath: string, encryptionAlgorithm: string, encryptedColumnEncryptionKey: Buffer): Promise<Buffer>;
+    encryptColumnEncryptionKey(masterKeyPath: string, encryptionAlgorithm: string, columnEncryptionKey: Buffer): Promise<Buffer>;
+    private getMasterKey;
+    private createKeyClient;
+    private createCryptoClient;
+    private parsePath;
+    private azureKeyVaultSignedHashedData;
+    private azureKeyVaultWrap;
+    private azureKeyVaultUnWrap;
+    private getAKVKeySize;
+    private validateEncryptionAlgorithm;
+}

package/dist/node_modules/tedious/lib/always-encrypted/keystore-provider-azure-key-vault.js

@@ -0,0 +1,247 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ColumnEncryptionAzureKeyVaultProvider = void 0;
+var _identity = require("@azure/identity");
+var _keyvaultKeys = require("@azure/keyvault-keys");
+var _crypto = require("crypto");
+var _url = require("url");
+// This code is based on the `mssql-jdbc` library published under the conditions of MIT license.
+// Copyright (c) 2019 Microsoft Corporation
+
+class ColumnEncryptionAzureKeyVaultProvider {
+  constructor(clientId, clientKey, tenantId) {
+    this.name = 'AZURE_KEY_VAULT';
+    this.azureKeyVaultDomainName = 'vault.azure.net';
+    this.rsaEncryptionAlgorithmWithOAEPForAKV = 'RSA-OAEP';
+    this.firstVersion = Buffer.from([0x01]);
+    this.credentials = new _identity.ClientSecretCredential(tenantId, clientId, clientKey);
+  }
+  async decryptColumnEncryptionKey(masterKeyPath, encryptionAlgorithm, encryptedColumnEncryptionKey) {
+    if (!encryptedColumnEncryptionKey) {
+      throw new Error('Internal error. Encrypted column encryption key cannot be null.');
+    }
+    if (encryptedColumnEncryptionKey.length === 0) {
+      throw new Error('Internal error. Empty encrypted column encryption key specified.');
+    }
+    encryptionAlgorithm = this.validateEncryptionAlgorithm(encryptionAlgorithm);
+    const masterKey = await this.getMasterKey(masterKeyPath);
+    const keySizeInBytes = this.getAKVKeySize(masterKey);
+    const cryptoClient = this.createCryptoClient(masterKey);
+    if (encryptedColumnEncryptionKey[0] !== this.firstVersion[0]) {
+      throw new Error(`Specified encrypted column encryption key contains an invalid encryption algorithm version ${Buffer.from([encryptedColumnEncryptionKey[0]]).toString('hex')}. Expected version is ${Buffer.from([this.firstVersion[0]]).toString('hex')}.`);
+    }
+    let currentIndex = this.firstVersion.length;
+    const keyPathLength = encryptedColumnEncryptionKey.readInt16LE(currentIndex);
+    currentIndex += 2;
+    const cipherTextLength = encryptedColumnEncryptionKey.readInt16LE(currentIndex);
+    currentIndex += 2;
+    currentIndex += keyPathLength;
+    if (cipherTextLength !== keySizeInBytes) {
+      throw new Error(`The specified encrypted column encryption key's ciphertext length: ${cipherTextLength} does not match the ciphertext length: ${keySizeInBytes} when using column master key (Azure Key Vault key) in ${masterKeyPath}. The encrypted column encryption key may be corrupt, or the specified Azure Key Vault key path may be incorrect.`);
+    }
+    const signatureLength = encryptedColumnEncryptionKey.length - currentIndex - cipherTextLength;
+    if (signatureLength !== keySizeInBytes) {
+      throw new Error(`The specified encrypted column encryption key's signature length: ${signatureLength} does not match the signature length: ${keySizeInBytes} when using column master key (Azure Key Vault key) in ${masterKeyPath}. The encrypted column encryption key may be corrupt, or the specified Azure Key Vault key path may be incorrect.`);
+    }
+    const cipherText = Buffer.alloc(cipherTextLength);
+    encryptedColumnEncryptionKey.copy(cipherText, 0, currentIndex, currentIndex + cipherTextLength);
+    currentIndex += cipherTextLength;
+    const signature = Buffer.alloc(signatureLength);
+    encryptedColumnEncryptionKey.copy(signature, 0, currentIndex, currentIndex + signatureLength);
+    const hash = Buffer.alloc(encryptedColumnEncryptionKey.length - signature.length);
+    encryptedColumnEncryptionKey.copy(hash, 0, 0, encryptedColumnEncryptionKey.length - signature.length);
+    const messageDigest = (0, _crypto.createHash)('sha256');
+    messageDigest.update(hash);
+    const dataToVerify = messageDigest.digest();
+    if (!dataToVerify) {
+      throw new Error('Hash should not be null while decrypting encrypted column encryption key.');
+    }
+    const verifyKey = await cryptoClient.verify('RS256', dataToVerify, signature);
+    if (!verifyKey.result) {
+      throw new Error(`The specified encrypted column encryption key signature does not match the signature computed with the column master key (Asymmetric key in Azure Key Vault) in ${masterKeyPath}. The encrypted column encryption key may be corrupt, or the specified path may be incorrect.`);
+    }
+    const decryptedCEK = await this.azureKeyVaultUnWrap(cryptoClient, encryptionAlgorithm, cipherText);
+    return decryptedCEK;
+  }
+  async encryptColumnEncryptionKey(masterKeyPath, encryptionAlgorithm, columnEncryptionKey) {
+    if (!columnEncryptionKey) {
+      throw new Error('Column encryption key cannot be null.');
+    }
+    if (columnEncryptionKey.length === 0) {
+      throw new Error('Empty column encryption key specified.');
+    }
+    encryptionAlgorithm = this.validateEncryptionAlgorithm(encryptionAlgorithm);
+    const masterKey = await this.getMasterKey(masterKeyPath);
+    const keySizeInBytes = this.getAKVKeySize(masterKey);
+    const cryptoClient = this.createCryptoClient(masterKey);
+    const version = Buffer.from([this.firstVersion[0]]);
+    const masterKeyPathBytes = Buffer.from(masterKeyPath.toLowerCase(), 'utf8');
+    const keyPathLength = Buffer.alloc(2);
+    keyPathLength[0] = masterKeyPathBytes.length & 0xff;
+    keyPathLength[1] = masterKeyPathBytes.length >> 8 & 0xff;
+    const cipherText = await this.azureKeyVaultWrap(cryptoClient, encryptionAlgorithm, columnEncryptionKey);
+    const cipherTextLength = Buffer.alloc(2);
+    cipherTextLength[0] = cipherText.length & 0xff;
+    cipherTextLength[1] = cipherText.length >> 8 & 0xff;
+    if (cipherText.length !== keySizeInBytes) {
+      throw new Error('CipherText length does not match the RSA key size.');
+    }
+    const dataToHash = Buffer.alloc(version.length + keyPathLength.length + cipherTextLength.length + masterKeyPathBytes.length + cipherText.length);
+    let destinationPosition = version.length;
+    version.copy(dataToHash, 0, 0, version.length);
+    keyPathLength.copy(dataToHash, destinationPosition, 0, keyPathLength.length);
+    destinationPosition += keyPathLength.length;
+    cipherTextLength.copy(dataToHash, destinationPosition, 0, cipherTextLength.length);
+    destinationPosition += cipherTextLength.length;
+    masterKeyPathBytes.copy(dataToHash, destinationPosition, 0, masterKeyPathBytes.length);
+    destinationPosition += masterKeyPathBytes.length;
+    cipherText.copy(dataToHash, destinationPosition, 0, cipherText.length);
+    const messageDigest = (0, _crypto.createHash)('sha256');
+    messageDigest.update(dataToHash);
+    const dataToSign = messageDigest.digest();
+    const signedHash = await this.azureKeyVaultSignedHashedData(cryptoClient, dataToSign);
+    if (signedHash.length !== keySizeInBytes) {
+      throw new Error('Signed hash length does not match the RSA key size.');
+    }
+    const verifyKey = await cryptoClient.verify('RS256', dataToSign, signedHash);
+    if (!verifyKey.result) {
+      throw new Error('Invalid signature of the encrypted column encryption key computed.');
+    }
+    const encryptedColumnEncryptionKeyLength = version.length + cipherTextLength.length + keyPathLength.length + cipherText.length + masterKeyPathBytes.length + signedHash.length;
+    const encryptedColumnEncryptionKey = Buffer.alloc(encryptedColumnEncryptionKeyLength);
+    let currentIndex = 0;
+    version.copy(encryptedColumnEncryptionKey, currentIndex, 0, version.length);
+    currentIndex += version.length;
+    keyPathLength.copy(encryptedColumnEncryptionKey, currentIndex, 0, keyPathLength.length);
+    currentIndex += keyPathLength.length;
+    cipherTextLength.copy(encryptedColumnEncryptionKey, currentIndex, 0, cipherTextLength.length);
+    currentIndex += cipherTextLength.length;
+    masterKeyPathBytes.copy(encryptedColumnEncryptionKey, currentIndex, 0, masterKeyPathBytes.length);
+    currentIndex += masterKeyPathBytes.length;
+    cipherText.copy(encryptedColumnEncryptionKey, currentIndex, 0, cipherText.length);
+    currentIndex += cipherText.length;
+    signedHash.copy(encryptedColumnEncryptionKey, currentIndex, 0, signedHash.length);
+    return encryptedColumnEncryptionKey;
+  }
+  async getMasterKey(masterKeyPath) {
+    if (!masterKeyPath) {
+      throw new Error('Master key path cannot be null or undefined');
+    }
+    const keyParts = this.parsePath(masterKeyPath);
+    this.createKeyClient(keyParts.vaultUrl);
+    return await this.keyClient.getKey(keyParts.name, keyParts.version ? {
+      version: keyParts.version
+    } : {});
+  }
+  createKeyClient(keyVaultUrl) {
+    if (!keyVaultUrl) {
+      throw new Error('Cannot create key client with null or undefined keyVaultUrl');
+    }
+    if (!this.keyClient) {
+      this.url = keyVaultUrl;
+      this.keyClient = new _keyvaultKeys.KeyClient(keyVaultUrl, this.credentials);
+    }
+  }
+  createCryptoClient(masterKey) {
+    if (!masterKey) {
+      throw new Error('Cannot create CryptographyClient with null or undefined masterKey');
+    }
+    return new _keyvaultKeys.CryptographyClient(masterKey, this.credentials);
+  }
+  parsePath(masterKeyPath) {
+    if (!masterKeyPath || masterKeyPath.trim() === '') {
+      throw new Error('Azure Key Vault key path cannot be null.');
+    }
+    let baseUri;
+    try {
+      baseUri = (0, _url.parse)(masterKeyPath, true, true);
+    } catch {
+      throw new Error(`Invalid keys identifier: ${masterKeyPath}. Not a valid URI`);
+    }
+    if (!baseUri.hostname || !baseUri.hostname.toLowerCase().endsWith(this.azureKeyVaultDomainName)) {
+      throw new Error(`Invalid Azure Key Vault key path specified: ${masterKeyPath}.`);
+    }
+
+    // Path is of the form '/collection/name[/version]'
+    const segments = (baseUri.pathname || '').split('/');
+    if (segments.length !== 3 && segments.length !== 4) {
+      throw new Error(`Invalid keys identifier: ${masterKeyPath}. Bad number of segments: ${segments.length}`);
+    }
+    if ('keys' !== segments[1]) {
+      throw new Error(`Invalid keys identifier: ${masterKeyPath}. segment [1] should be "keys", found "${segments[1]}"`);
+    }
+    const vaultUrl = `${baseUri.protocol}//${baseUri.host}`;
+    const name = segments[2];
+    const version = segments.length === 4 ? segments[3] : undefined;
+    return {
+      vaultUrl,
+      name,
+      version
+    };
+  }
+  async azureKeyVaultSignedHashedData(cryptoClient, dataToSign) {
+    if (!cryptoClient) {
+      throw new Error('Azure KVS Crypto Client is not defined.');
+    }
+    const signedData = await cryptoClient.sign('RS256', dataToSign);
+    return Buffer.from(signedData.result);
+  }
+  async azureKeyVaultWrap(cryptoClient, encryptionAlgorithm, columnEncryptionKey) {
+    if (!cryptoClient) {
+      throw new Error('Azure KVS Crypto Client is not defined.');
+    }
+    if (!columnEncryptionKey) {
+      throw new Error('Column encryption key cannot be null.');
+    }
+    const wrappedKey = await cryptoClient.wrapKey(encryptionAlgorithm, columnEncryptionKey);
+    return Buffer.from(wrappedKey.result);
+  }
+  async azureKeyVaultUnWrap(cryptoClient, encryptionAlgorithm, encryptedColumnEncryptionKey) {
+    if (!cryptoClient) {
+      throw new Error('Azure KVS Crypto Client is not defined.');
+    }
+    if (!encryptionAlgorithm) {
+      throw new Error('Encryption Algorithm cannot be null or undefined');
+    }
+    if (!encryptedColumnEncryptionKey) {
+      throw new Error('Encrypted column encryption key cannot be null.');
+    }
+    if (encryptedColumnEncryptionKey.length === 0) {
+      throw new Error('Encrypted Column Encryption Key length should not be zero.');
+    }
+    const unwrappedKey = await cryptoClient.unwrapKey(encryptionAlgorithm, encryptedColumnEncryptionKey);
+    return Buffer.from(unwrappedKey.result);
+  }
+  getAKVKeySize(retrievedKey) {
+    if (!retrievedKey) {
+      throw new Error('Retrieved key cannot be null or undefined');
+    }
+    const key = retrievedKey.key;
+    if (!key) {
+      throw new Error(`Key does not exist ${retrievedKey.name}`);
+    }
+    const kty = key && key.kty && key.kty.toString().toUpperCase();
+    if (!kty || 'RSA'.localeCompare(kty, 'en') !== 0) {
+      throw new Error(`Cannot use a non-RSA key: ${kty}.`);
+    }
+    const keyLength = key && key.n && key.n.length;
+    return keyLength || 0;
+  }
+  validateEncryptionAlgorithm(encryptionAlgorithm) {
+    if (!encryptionAlgorithm) {
+      throw new Error('Key encryption algorithm cannot be null.');
+    }
+    if ('RSA_OAEP'.localeCompare(encryptionAlgorithm.toUpperCase(), 'en') === 0) {
+      encryptionAlgorithm = 'RSA-OAEP';
+    }
+    if (this.rsaEncryptionAlgorithmWithOAEPForAKV.localeCompare(encryptionAlgorithm.trim().toUpperCase(), 'en') !== 0) {
+      throw new Error(`Invalid key encryption algorithm specified: ${encryptionAlgorithm}. Expected value: ${this.rsaEncryptionAlgorithmWithOAEPForAKV}.`);
+    }
+    return encryptionAlgorithm;
+  }
+}
+exports.ColumnEncryptionAzureKeyVaultProvider = ColumnEncryptionAzureKeyVaultProvider;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_identity","require","_keyvaultKeys","_crypto","_url","ColumnEncryptionAzureKeyVaultProvider","constructor","clientId","clientKey","tenantId","name","azureKeyVaultDomainName","rsaEncryptionAlgorithmWithOAEPForAKV","firstVersion","Buffer","from","credentials","ClientSecretCredential","decryptColumnEncryptionKey","masterKeyPath","encryptionAlgorithm","encryptedColumnEncryptionKey","Error","length","validateEncryptionAlgorithm","masterKey","getMasterKey","keySizeInBytes","getAKVKeySize","cryptoClient","createCryptoClient","toString","currentIndex","keyPathLength","readInt16LE","cipherTextLength","signatureLength","cipherText","alloc","copy","signature","hash","messageDigest","createHash","update","dataToVerify","digest","verifyKey","verify","result","decryptedCEK","azureKeyVaultUnWrap","encryptColumnEncryptionKey","columnEncryptionKey","version","masterKeyPathBytes","toLowerCase","azureKeyVaultWrap","dataToHash","destinationPosition","dataToSign","signedHash","azureKeyVaultSignedHashedData","encryptedColumnEncryptionKeyLength","keyParts","parsePath","createKeyClient","vaultUrl","keyClient","getKey","keyVaultUrl","url","KeyClient","CryptographyClient","trim","baseUri","parse","hostname","endsWith","segments","pathname","split","protocol","host","undefined","signedData","sign","wrappedKey","wrapKey","unwrappedKey","unwrapKey","retrievedKey","key","kty","toUpperCase","localeCompare","keyLength","n","exports"],"sources":["../../src/always-encrypted/keystore-provider-azure-key-vault.ts"],"sourcesContent":["// This code is based on the `mssql-jdbc` library published under the conditions of MIT license.\n// Copyright (c) 2019 Microsoft Corporation\n\nimport { ClientSecretCredential } from '@azure/identity';\nimport { CryptographyClient, type KeyWrapAlgorithm, KeyClient, type KeyVaultKey } from '@azure/keyvault-keys';\nimport { createHash } from 'crypto';\nimport { parse } from 'url';\n\ninterface ParsedKeyPath {\n  vaultUrl: string;\n  name: string;\n  version?: string | undefined;\n}\n\nexport class ColumnEncryptionAzureKeyVaultProvider {\n  declare public readonly name: string;\n  declare private url: undefined | string;\n  declare private readonly rsaEncryptionAlgorithmWithOAEPForAKV: string;\n  declare private readonly firstVersion: Buffer;\n  declare private credentials: ClientSecretCredential;\n  declare private readonly azureKeyVaultDomainName: string;\n  declare private keyClient: undefined | KeyClient;\n\n  constructor(clientId: string, clientKey: string, tenantId: string) {\n    this.name = 'AZURE_KEY_VAULT';\n    this.azureKeyVaultDomainName = 'vault.azure.net';\n    this.rsaEncryptionAlgorithmWithOAEPForAKV = 'RSA-OAEP';\n    this.firstVersion = Buffer.from([0x01]);\n    this.credentials = new ClientSecretCredential(tenantId, clientId, clientKey);\n  }\n\n  async decryptColumnEncryptionKey(masterKeyPath: string, encryptionAlgorithm: string, encryptedColumnEncryptionKey: Buffer): Promise<Buffer> {\n    if (!encryptedColumnEncryptionKey) {\n      throw new Error('Internal error. Encrypted column encryption key cannot be null.');\n    }\n\n    if (encryptedColumnEncryptionKey.length === 0) {\n      throw new Error('Internal error. Empty encrypted column encryption key specified.');\n    }\n\n    encryptionAlgorithm = this.validateEncryptionAlgorithm(encryptionAlgorithm);\n\n    const masterKey = await this.getMasterKey(masterKeyPath);\n\n    const keySizeInBytes = this.getAKVKeySize(masterKey);\n\n    const cryptoClient = this.createCryptoClient(masterKey);\n\n    if (encryptedColumnEncryptionKey[0] !== this.firstVersion[0]) {\n      throw new Error(`Specified encrypted column encryption key contains an invalid encryption algorithm version ${Buffer.from([encryptedColumnEncryptionKey[0]]).toString('hex')}. Expected version is ${Buffer.from([this.firstVersion[0]]).toString('hex')}.`);\n    }\n\n    let currentIndex = this.firstVersion.length;\n    const keyPathLength: number = encryptedColumnEncryptionKey.readInt16LE(currentIndex);\n\n    currentIndex += 2;\n\n    const cipherTextLength: number = encryptedColumnEncryptionKey.readInt16LE(currentIndex);\n\n    currentIndex += 2;\n\n    currentIndex += keyPathLength;\n\n    if (cipherTextLength !== keySizeInBytes) {\n      throw new Error(`The specified encrypted column encryption key's ciphertext length: ${cipherTextLength} does not match the ciphertext length: ${keySizeInBytes} when using column master key (Azure Key Vault key) in ${masterKeyPath}. The encrypted column encryption key may be corrupt, or the specified Azure Key Vault key path may be incorrect.`);\n    }\n\n    const signatureLength: number = encryptedColumnEncryptionKey.length - currentIndex - cipherTextLength;\n\n    if (signatureLength !== keySizeInBytes) {\n      throw new Error(`The specified encrypted column encryption key's signature length: ${signatureLength} does not match the signature length: ${keySizeInBytes} when using column master key (Azure Key Vault key) in ${masterKeyPath}. The encrypted column encryption key may be corrupt, or the specified Azure Key Vault key path may be incorrect.`);\n    }\n\n    const cipherText = Buffer.alloc(cipherTextLength);\n    encryptedColumnEncryptionKey.copy(cipherText, 0, currentIndex, currentIndex + cipherTextLength);\n    currentIndex += cipherTextLength;\n\n    const signature = Buffer.alloc(signatureLength);\n    encryptedColumnEncryptionKey.copy(signature, 0, currentIndex, currentIndex + signatureLength);\n\n    const hash = Buffer.alloc(encryptedColumnEncryptionKey.length - signature.length);\n    encryptedColumnEncryptionKey.copy(hash, 0, 0, encryptedColumnEncryptionKey.length - signature.length);\n\n    const messageDigest = createHash('sha256');\n    messageDigest.update(hash);\n\n    const dataToVerify: Buffer = messageDigest.digest();\n\n    if (!dataToVerify) {\n      throw new Error('Hash should not be null while decrypting encrypted column encryption key.');\n    }\n\n    const verifyKey = await cryptoClient.verify('RS256', dataToVerify, signature);\n    if (!verifyKey.result) {\n      throw new Error(`The specified encrypted column encryption key signature does not match the signature computed with the column master key (Asymmetric key in Azure Key Vault) in ${masterKeyPath}. The encrypted column encryption key may be corrupt, or the specified path may be incorrect.`);\n    }\n\n    const decryptedCEK: Buffer = await this.azureKeyVaultUnWrap(cryptoClient, encryptionAlgorithm, cipherText);\n\n    return decryptedCEK;\n  }\n\n  async encryptColumnEncryptionKey(masterKeyPath: string, encryptionAlgorithm: string, columnEncryptionKey: Buffer): Promise<Buffer> {\n    if (!columnEncryptionKey) {\n      throw new Error('Column encryption key cannot be null.');\n    }\n\n    if (columnEncryptionKey.length === 0) {\n      throw new Error('Empty column encryption key specified.');\n    }\n\n    encryptionAlgorithm = this.validateEncryptionAlgorithm(encryptionAlgorithm);\n\n    const masterKey = await this.getMasterKey(masterKeyPath);\n\n    const keySizeInBytes = this.getAKVKeySize(masterKey);\n\n    const cryptoClient = this.createCryptoClient(masterKey);\n\n    const version = Buffer.from([this.firstVersion[0]]);\n\n    const masterKeyPathBytes: Buffer = Buffer.from(masterKeyPath.toLowerCase(), 'utf8');\n\n    const keyPathLength: Buffer = Buffer.alloc(2);\n\n    keyPathLength[0] = masterKeyPathBytes.length & 0xff;\n    keyPathLength[1] = masterKeyPathBytes.length >> 8 & 0xff;\n\n    const cipherText: Buffer = await this.azureKeyVaultWrap(cryptoClient, encryptionAlgorithm, columnEncryptionKey);\n\n    const cipherTextLength: Buffer = Buffer.alloc(2);\n\n    cipherTextLength[0] = cipherText.length & 0xff;\n    cipherTextLength[1] = cipherText.length >> 8 & 0xff;\n\n    if (cipherText.length !== keySizeInBytes) {\n      throw new Error('CipherText length does not match the RSA key size.');\n    }\n\n    const dataToHash: Buffer = Buffer.alloc(version.length + keyPathLength.length + cipherTextLength.length + masterKeyPathBytes.length + cipherText.length);\n    let destinationPosition: number = version.length;\n    version.copy(dataToHash, 0, 0, version.length);\n\n    keyPathLength.copy(dataToHash, destinationPosition, 0, keyPathLength.length);\n    destinationPosition += keyPathLength.length;\n\n    cipherTextLength.copy(dataToHash, destinationPosition, 0, cipherTextLength.length);\n    destinationPosition += cipherTextLength.length;\n\n    masterKeyPathBytes.copy(dataToHash, destinationPosition, 0, masterKeyPathBytes.length);\n    destinationPosition += masterKeyPathBytes.length;\n\n    cipherText.copy(dataToHash, destinationPosition, 0, cipherText.length);\n\n    const messageDigest = createHash('sha256');\n\n    messageDigest.update(dataToHash);\n\n    const dataToSign: Buffer = messageDigest.digest();\n\n    const signedHash: Buffer = await this.azureKeyVaultSignedHashedData(cryptoClient, dataToSign);\n    if (signedHash.length !== keySizeInBytes) {\n      throw new Error('Signed hash length does not match the RSA key size.');\n    }\n\n    const verifyKey = await cryptoClient.verify('RS256', dataToSign, signedHash);\n\n    if (!verifyKey.result) {\n      throw new Error('Invalid signature of the encrypted column encryption key computed.');\n    }\n\n    const encryptedColumnEncryptionKeyLength: number = version.length + cipherTextLength.length + keyPathLength.length + cipherText.length + masterKeyPathBytes.length + signedHash.length;\n    const encryptedColumnEncryptionKey: Buffer = Buffer.alloc(encryptedColumnEncryptionKeyLength);\n\n    let currentIndex = 0;\n    version.copy(encryptedColumnEncryptionKey, currentIndex, 0, version.length);\n    currentIndex += version.length;\n\n    keyPathLength.copy(encryptedColumnEncryptionKey, currentIndex, 0, keyPathLength.length);\n    currentIndex += keyPathLength.length;\n\n    cipherTextLength.copy(encryptedColumnEncryptionKey, currentIndex, 0, cipherTextLength.length);\n    currentIndex += cipherTextLength.length;\n\n    masterKeyPathBytes.copy(encryptedColumnEncryptionKey, currentIndex, 0, masterKeyPathBytes.length);\n    currentIndex += masterKeyPathBytes.length;\n\n    cipherText.copy(encryptedColumnEncryptionKey, currentIndex, 0, cipherText.length);\n    currentIndex += cipherText.length;\n\n    signedHash.copy(encryptedColumnEncryptionKey, currentIndex, 0, signedHash.length);\n\n    return encryptedColumnEncryptionKey;\n  }\n\n  private async getMasterKey(masterKeyPath: string): Promise<KeyVaultKey> {\n    if (!masterKeyPath) {\n      throw new Error('Master key path cannot be null or undefined');\n    }\n    const keyParts = this.parsePath(masterKeyPath);\n\n    this.createKeyClient(keyParts.vaultUrl);\n\n    return await (this.keyClient as KeyClient).getKey(keyParts.name, keyParts.version ? { version: keyParts.version } : {});\n  }\n\n  private createKeyClient(keyVaultUrl: string): void {\n    if (!keyVaultUrl) {\n      throw new Error('Cannot create key client with null or undefined keyVaultUrl');\n    }\n    if (!this.keyClient) {\n      this.url = keyVaultUrl;\n      this.keyClient = new KeyClient(keyVaultUrl, this.credentials);\n    }\n  }\n\n  private createCryptoClient(masterKey: KeyVaultKey): CryptographyClient {\n    if (!masterKey) {\n      throw new Error('Cannot create CryptographyClient with null or undefined masterKey');\n    }\n    return new CryptographyClient(masterKey, this.credentials);\n  }\n\n  private parsePath(masterKeyPath: string): ParsedKeyPath {\n    if (!masterKeyPath || masterKeyPath.trim() === '') {\n      throw new Error('Azure Key Vault key path cannot be null.');\n    }\n\n    let baseUri;\n    try {\n      baseUri = parse(masterKeyPath, true, true);\n    } catch {\n      throw new Error(`Invalid keys identifier: ${masterKeyPath}. Not a valid URI`);\n    }\n\n    if (!baseUri.hostname || !baseUri.hostname.toLowerCase().endsWith(this.azureKeyVaultDomainName)) {\n      throw new Error(`Invalid Azure Key Vault key path specified: ${masterKeyPath}.`);\n    }\n\n    // Path is of the form '/collection/name[/version]'\n    const segments = (baseUri.pathname || '').split('/');\n    if (segments.length !== 3 && segments.length !== 4) {\n      throw new Error(\n        `Invalid keys identifier: ${masterKeyPath}. Bad number of segments: ${segments.length}`\n      );\n    }\n\n    if ('keys' !== segments[1]) {\n      throw new Error(\n        `Invalid keys identifier: ${masterKeyPath}. segment [1] should be \"keys\", found \"${segments[1]}\"`\n      );\n    }\n\n    const vaultUrl = `${baseUri.protocol}//${baseUri.host}`;\n    const name = segments[2];\n    const version = segments.length === 4 ? segments[3] : undefined;\n    return {\n      vaultUrl,\n      name,\n      version\n    };\n  }\n\n  private async azureKeyVaultSignedHashedData(cryptoClient: CryptographyClient, dataToSign: Buffer): Promise<Buffer> {\n    if (!cryptoClient) {\n      throw new Error('Azure KVS Crypto Client is not defined.');\n    }\n\n    const signedData = await cryptoClient.sign('RS256', dataToSign);\n\n    return Buffer.from(signedData.result);\n  }\n\n  private async azureKeyVaultWrap(cryptoClient: CryptographyClient, encryptionAlgorithm: string, columnEncryptionKey: Buffer): Promise<Buffer> {\n    if (!cryptoClient) {\n      throw new Error('Azure KVS Crypto Client is not defined.');\n    }\n\n    if (!columnEncryptionKey) {\n      throw new Error('Column encryption key cannot be null.');\n    }\n\n    const wrappedKey = await cryptoClient.wrapKey(encryptionAlgorithm as KeyWrapAlgorithm, columnEncryptionKey);\n\n    return Buffer.from(wrappedKey.result);\n  }\n\n  private async azureKeyVaultUnWrap(cryptoClient: CryptographyClient, encryptionAlgorithm: string, encryptedColumnEncryptionKey: Buffer): Promise<Buffer> {\n    if (!cryptoClient) {\n      throw new Error('Azure KVS Crypto Client is not defined.');\n    }\n\n    if (!encryptionAlgorithm) {\n      throw new Error('Encryption Algorithm cannot be null or undefined');\n    }\n\n    if (!encryptedColumnEncryptionKey) {\n      throw new Error('Encrypted column encryption key cannot be null.');\n    }\n\n    if (encryptedColumnEncryptionKey.length === 0) {\n      throw new Error('Encrypted Column Encryption Key length should not be zero.');\n    }\n\n    const unwrappedKey = await cryptoClient.unwrapKey(encryptionAlgorithm as KeyWrapAlgorithm, encryptedColumnEncryptionKey);\n\n    return Buffer.from(unwrappedKey.result);\n  }\n\n  private getAKVKeySize(retrievedKey: KeyVaultKey): number {\n    if (!retrievedKey) {\n      throw new Error('Retrieved key cannot be null or undefined');\n    }\n    const key = retrievedKey.key;\n\n    if (!key) {\n      throw new Error(`Key does not exist ${retrievedKey.name}`);\n    }\n\n    const kty: string | undefined = key && key.kty && key.kty.toString().toUpperCase();\n\n    if (!kty || 'RSA'.localeCompare(kty, 'en') !== 0) {\n      throw new Error(`Cannot use a non-RSA key: ${kty}.`);\n    }\n\n    const keyLength = key && key.n && key.n.length;\n\n    return keyLength || 0;\n  }\n\n  private validateEncryptionAlgorithm(encryptionAlgorithm: string): string {\n    if (!encryptionAlgorithm) {\n      throw new Error('Key encryption algorithm cannot be null.');\n    }\n\n    if ('RSA_OAEP'.localeCompare(encryptionAlgorithm.toUpperCase(), 'en') === 0) {\n      encryptionAlgorithm = 'RSA-OAEP';\n    }\n\n    if (this.rsaEncryptionAlgorithmWithOAEPForAKV.localeCompare(encryptionAlgorithm.trim().toUpperCase(), 'en') !== 0) {\n      throw new Error(`Invalid key encryption algorithm specified: ${encryptionAlgorithm}. Expected value: ${this.rsaEncryptionAlgorithmWithOAEPForAKV}.`);\n    }\n\n    return encryptionAlgorithm;\n  }\n}\n"],"mappings":"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"}

package/dist/node_modules/tedious/lib/always-encrypted/symmetric-key-cache.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getKey = void 0;
+var _symmetricKey = _interopRequireDefault(require("./symmetric-key"));
+var _lruCache = _interopRequireDefault(require("lru-cache"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// This code is based on the `mssql-jdbc` library published under the conditions of MIT license.
+// Copyright (c) 2019 Microsoft Corporation
+
+const cache = new _lruCache.default(0);
+const getKey = async (keyInfo, options) => {
+  if (!options.trustedServerNameAE) {
+    throw new Error('Server name should not be null in getKey');
+  }
+  const serverName = options.trustedServerNameAE;
+  const keyLookupValue = `${serverName}:${Buffer.from(keyInfo.encryptedKey).toString('base64')}:${keyInfo.keyStoreName}`;
+  if (cache.has(keyLookupValue)) {
+    return cache.get(keyLookupValue);
+  } else {
+    const provider = options.encryptionKeyStoreProviders && options.encryptionKeyStoreProviders[keyInfo.keyStoreName];
+    if (!provider) {
+      throw new Error(`Failed to decrypt a column encryption key. Invalid key store provider name: ${keyInfo.keyStoreName}. A key store provider name must denote either a system key store provider or a registered custom key store provider. Valid (currently registered) custom key store provider names are: ${options.encryptionKeyStoreProviders}. Please verify key store provider information in column master key definitions in the database, and verify all custom key store providers used in your application are registered properly.`);
+    }
+    const plaintextKey = await provider.decryptColumnEncryptionKey(keyInfo.keyPath, keyInfo.algorithmName, keyInfo.encryptedKey);
+    const encryptionKey = new _symmetricKey.default(plaintextKey);
+    if (options.columnEncryptionKeyCacheTTL > 0) {
+      cache.set(keyLookupValue, encryptionKey, options.columnEncryptionKeyCacheTTL);
+    }
+    return encryptionKey;
+  }
+};
+exports.getKey = getKey;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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