tedious-fabric 1.0.0

package/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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","ignoreList":[]}

package/lib/always-encrypted/keystore-provider-azure-key-vault.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keystore-provider-azure-key-vault.js","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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","ignoreList":[]}

package/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(e) { return e && e.__esModule ? e : { default: e }; }
+// 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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

package/lib/always-encrypted/symmetric-key-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"symmetric-key-cache.js","names":["_symmetricKey","_interopRequireDefault","require","_lruCache","e","__esModule","default","cache","LRU","getKey","keyInfo","options","trustedServerNameAE","Error","serverName","keyLookupValue","Buffer","from","encryptedKey","toString","keyStoreName","has","get","provider","encryptionKeyStoreProviders","plaintextKey","decryptColumnEncryptionKey","keyPath","algorithmName","encryptionKey","SymmetricKey","columnEncryptionKeyCacheTTL","set","exports"],"sources":["../../src/always-encrypted/symmetric-key-cache.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 EncryptionKeyInfo } from './types';\nimport SymmetricKey from './symmetric-key';\nimport { type InternalConnectionOptions as ConnectionOptions } from '../connection';\nimport LRU from 'lru-cache';\n\nconst cache = new LRU<string, SymmetricKey>(0);\n\nexport const getKey = async (keyInfo: EncryptionKeyInfo, options: ConnectionOptions): Promise<SymmetricKey> => {\n  if (!options.trustedServerNameAE) {\n    throw new Error('Server name should not be null in getKey');\n  }\n\n  const serverName: string = options.trustedServerNameAE;\n\n  const keyLookupValue = `${serverName}:${Buffer.from(keyInfo.encryptedKey).toString('base64')}:${keyInfo.keyStoreName}`;\n\n  if (cache.has(keyLookupValue)) {\n    return cache.get(keyLookupValue) as SymmetricKey;\n  } else {\n    const provider = options.encryptionKeyStoreProviders && options.encryptionKeyStoreProviders[keyInfo.keyStoreName];\n    if (!provider) {\n      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.`);\n    }\n\n    const plaintextKey: Buffer = await provider.decryptColumnEncryptionKey(keyInfo.keyPath, keyInfo.algorithmName, keyInfo.encryptedKey);\n\n    const encryptionKey = new SymmetricKey(plaintextKey);\n\n    if (options.columnEncryptionKeyCacheTTL > 0) {\n      cache.set(keyLookupValue, encryptionKey, options.columnEncryptionKeyCacheTTL);\n    }\n\n    return encryptionKey;\n  }\n};\n"],"mappings":";;;;;;AAIA,IAAAA,aAAA,GAAAC,sBAAA,CAAAC,OAAA;AAEA,IAAAC,SAAA,GAAAF,sBAAA,CAAAC,OAAA;AAA4B,SAAAD,uBAAAG,CAAA,WAAAA,CAAA,IAAAA,CAAA,CAAAC,UAAA,GAAAD,CAAA,KAAAE,OAAA,EAAAF,CAAA;AAN5B;AACA;;AAOA,MAAMG,KAAK,GAAG,IAAIC,iBAAG,CAAuB,CAAC,CAAC;AAEvC,MAAMC,MAAM,GAAG,MAAAA,CAAOC,OAA0B,EAAEC,OAA0B,KAA4B;EAC7G,IAAI,CAACA,OAAO,CAACC,mBAAmB,EAAE;IAChC,MAAM,IAAIC,KAAK,CAAC,0CAA0C,CAAC;EAC7D;EAEA,MAAMC,UAAkB,GAAGH,OAAO,CAACC,mBAAmB;EAEtD,MAAMG,cAAc,GAAG,GAAGD,UAAU,IAAIE,MAAM,CAACC,IAAI,CAACP,OAAO,CAACQ,YAAY,CAAC,CAACC,QAAQ,CAAC,QAAQ,CAAC,IAAIT,OAAO,CAACU,YAAY,EAAE;EAEtH,IAAIb,KAAK,CAACc,GAAG,CAACN,cAAc,CAAC,EAAE;IAC7B,OAAOR,KAAK,CAACe,GAAG,CAACP,cAAc,CAAC;EAClC,CAAC,MAAM;IACL,MAAMQ,QAAQ,GAAGZ,OAAO,CAACa,2BAA2B,IAAIb,OAAO,CAACa,2BAA2B,CAACd,OAAO,CAACU,YAAY,CAAC;IACjH,IAAI,CAACG,QAAQ,EAAE;MACb,MAAM,IAAIV,KAAK,CAAC,+EAA+EH,OAAO,CAACU,YAAY,2LAA2LT,OAAO,CAACa,2BAA2B,8LAA8L,CAAC;IAClhB;IAEA,MAAMC,YAAoB,GAAG,MAAMF,QAAQ,CAACG,0BAA0B,CAAChB,OAAO,CAACiB,OAAO,EAAEjB,OAAO,CAACkB,aAAa,EAAElB,OAAO,CAACQ,YAAY,CAAC;IAEpI,MAAMW,aAAa,GAAG,IAAIC,qBAAY,CAACL,YAAY,CAAC;IAEpD,IAAId,OAAO,CAACoB,2BAA2B,GAAG,CAAC,EAAE;MAC3CxB,KAAK,CAACyB,GAAG,CAACjB,cAAc,EAAEc,aAAa,EAAElB,OAAO,CAACoB,2BAA2B,CAAC;IAC/E;IAEA,OAAOF,aAAa;EACtB;AACF,CAAC;AAACI,OAAA,CAAAxB,MAAA,GAAAA,MAAA","ignoreList":[]}

package/lib/always-encrypted/symmetric-key.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.SymmetricKey = void 0;
+// This code is based on the `mssql-jdbc` library published under the conditions of MIT license.
+// Copyright (c) 2019 Microsoft Corporation
+
+class SymmetricKey {
+  constructor(rootKey) {
+    if (!rootKey) {
+      throw new Error('Column encryption key cannot be null.');
+    } else if (0 === rootKey.length) {
+      throw new Error('Empty column encryption key specified.');
+    }
+    this.rootKey = rootKey;
+  }
+  zeroOutKey() {
+    this.rootKey = Buffer.alloc(this.rootKey.length);
+  }
+}
+exports.SymmetricKey = SymmetricKey;
+var _default = exports.default = SymmetricKey;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJTeW1tZXRyaWNLZXkiLCJjb25zdHJ1Y3RvciIsInJvb3RLZXkiLCJFcnJvciIsImxlbmd0aCIsInplcm9PdXRLZXkiLCJCdWZmZXIiLCJhbGxvYyIsImV4cG9ydHMiLCJfZGVmYXVsdCIsImRlZmF1bHQiXSwic291cmNlcyI6WyIuLi8uLi9zcmMvYWx3YXlzLWVuY3J5cHRlZC9zeW1tZXRyaWMta2V5LnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8vIFRoaXMgY29kZSBpcyBiYXNlZCBvbiB0aGUgYG1zc3FsLWpkYmNgIGxpYnJhcnkgcHVibGlzaGVkIHVuZGVyIHRoZSBjb25kaXRpb25zIG9mIE1JVCBsaWNlbnNlLlxuLy8gQ29weXJpZ2h0IChjKSAyMDE5IE1pY3Jvc29mdCBDb3Jwb3JhdGlvblxuXG5leHBvcnQgY2xhc3MgU3ltbWV0cmljS2V5IHtcbiAgZGVjbGFyZSByb290S2V5OiBCdWZmZXI7XG5cbiAgY29uc3RydWN0b3Iocm9vdEtleTogQnVmZmVyKSB7XG4gICAgaWYgKCFyb290S2V5KSB7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoJ0NvbHVtbiBlbmNyeXB0aW9uIGtleSBjYW5ub3QgYmUgbnVsbC4nKTtcbiAgICB9IGVsc2UgaWYgKDAgPT09IHJvb3RLZXkubGVuZ3RoKSB7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoJ0VtcHR5IGNvbHVtbiBlbmNyeXB0aW9uIGtleSBzcGVjaWZpZWQuJyk7XG4gICAgfVxuICAgIHRoaXMucm9vdEtleSA9IHJvb3RLZXk7XG4gIH1cblxuICB6ZXJvT3V0S2V5KCkge1xuICAgIHRoaXMucm9vdEtleSA9IEJ1ZmZlci5hbGxvYyh0aGlzLnJvb3RLZXkubGVuZ3RoKTtcbiAgfVxufVxuZXhwb3J0IGRlZmF1bHQgU3ltbWV0cmljS2V5O1xuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7QUFBQTtBQUNBOztBQUVPLE1BQU1BLFlBQVksQ0FBQztFQUd4QkMsV0FBV0EsQ0FBQ0MsT0FBZSxFQUFFO0lBQzNCLElBQUksQ0FBQ0EsT0FBTyxFQUFFO01BQ1osTUFBTSxJQUFJQyxLQUFLLENBQUMsdUNBQXVDLENBQUM7SUFDMUQsQ0FBQyxNQUFNLElBQUksQ0FBQyxLQUFLRCxPQUFPLENBQUNFLE1BQU0sRUFBRTtNQUMvQixNQUFNLElBQUlELEtBQUssQ0FBQyx3Q0FBd0MsQ0FBQztJQUMzRDtJQUNBLElBQUksQ0FBQ0QsT0FBTyxHQUFHQSxPQUFPO0VBQ3hCO0VBRUFHLFVBQVVBLENBQUEsRUFBRztJQUNYLElBQUksQ0FBQ0gsT0FBTyxHQUFHSSxNQUFNLENBQUNDLEtBQUssQ0FBQyxJQUFJLENBQUNMLE9BQU8sQ0FBQ0UsTUFBTSxDQUFDO0VBQ2xEO0FBQ0Y7QUFBQ0ksT0FBQSxDQUFBUixZQUFBLEdBQUFBLFlBQUE7QUFBQSxJQUFBUyxRQUFBLEdBQUFELE9BQUEsQ0FBQUUsT0FBQSxHQUNjVixZQUFZIiwiaWdub3JlTGlzdCI6W119

package/lib/always-encrypted/symmetric-key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"symmetric-key.js","names":["SymmetricKey","constructor","rootKey","Error","length","zeroOutKey","Buffer","alloc","exports","_default","default"],"sources":["../../src/always-encrypted/symmetric-key.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\nexport class SymmetricKey {\n  declare rootKey: Buffer;\n\n  constructor(rootKey: Buffer) {\n    if (!rootKey) {\n      throw new Error('Column encryption key cannot be null.');\n    } else if (0 === rootKey.length) {\n      throw new Error('Empty column encryption key specified.');\n    }\n    this.rootKey = rootKey;\n  }\n\n  zeroOutKey() {\n    this.rootKey = Buffer.alloc(this.rootKey.length);\n  }\n}\nexport default SymmetricKey;\n"],"mappings":";;;;;;AAAA;AACA;;AAEO,MAAMA,YAAY,CAAC;EAGxBC,WAAWA,CAACC,OAAe,EAAE;IAC3B,IAAI,CAACA,OAAO,EAAE;MACZ,MAAM,IAAIC,KAAK,CAAC,uCAAuC,CAAC;IAC1D,CAAC,MAAM,IAAI,CAAC,KAAKD,OAAO,CAACE,MAAM,EAAE;MAC/B,MAAM,IAAID,KAAK,CAAC,wCAAwC,CAAC;IAC3D;IACA,IAAI,CAACD,OAAO,GAAGA,OAAO;EACxB;EAEAG,UAAUA,CAAA,EAAG;IACX,IAAI,CAACH,OAAO,GAAGI,MAAM,CAACC,KAAK,CAAC,IAAI,CAACL,OAAO,CAACE,MAAM,CAAC;EAClD;AACF;AAACI,OAAA,CAAAR,YAAA,GAAAA,YAAA;AAAA,IAAAS,QAAA,GAAAD,OAAA,CAAAE,OAAA,GACcV,YAAY","ignoreList":[]}

package/lib/always-encrypted/types.d.ts

@@ -0,0 +1,73 @@
+import { CEKEntry } from './cek-entry';
+import { type BaseMetadata } from '../metadata-parser';
+export interface EncryptionKeyInfo {
+    encryptedKey: Buffer;
+    dbId: number;
+    keyId: number;
+    keyVersion: number;
+    mdVersion: Buffer;
+    keyPath: string;
+    keyStoreName: string;
+    algorithmName: string;
+}
+export declare enum SQLServerEncryptionType {
+    Deterministic = 1,
+    Randomized = 2,
+    PlainText = 0
+}
+export interface EncryptionAlgorithm {
+    encryptData: (plainText: Buffer) => Buffer;
+    decryptData: (cipherText: Buffer) => Buffer;
+}
+export interface CryptoMetadata {
+    cekEntry?: CEKEntry;
+    cipherAlgorithmId: number;
+    cipherAlgorithmName?: string;
+    normalizationRuleVersion: Buffer;
+    encryptionKeyInfo?: EncryptionKeyInfo;
+    ordinal: number;
+    encryptionType: SQLServerEncryptionType;
+    cipherAlgorithm?: EncryptionAlgorithm;
+    baseTypeInfo?: BaseMetadata;
+}
+export interface HashMap<T> {
+    [hash: string]: T;
+}
+export declare enum DescribeParameterEncryptionResultSet1 {
+    KeyOrdinal = 0,
+    DbId = 1,
+    KeyId = 2,
+    KeyVersion = 3,
+    KeyMdVersion = 4,
+    EncryptedKey = 5,
+    ProviderName = 6,
+    KeyPath = 7,
+    KeyEncryptionAlgorithm = 8
+}
+export declare enum DescribeParameterEncryptionResultSet2 {
+    ParameterOrdinal = 0,
+    ParameterName = 1,
+    ColumnEncryptionAlgorithm = 2,
+    ColumnEncrytionType = 3,
+    ColumnEncryptionKeyOrdinal = 4,
+    NormalizationRuleVersion = 5
+}
+export declare enum SQLServerStatementColumnEncryptionSetting {
+    /**
+     * if "Column Encryption Setting=Enabled" in the connection string, use Enabled. Otherwise, maps to Disabled.
+     */
+    UseConnectionSetting = 0,
+    /**
+     * Enables TCE for the command. Overrides the connection level setting for this command.
+     */
+    Enabled = 1,
+    /**
+     * Parameters will not be encrypted, only the ResultSet will be decrypted. This is an optimization for queries that
+     * do not pass any encrypted input parameters. Overrides the connection level setting for this command.
+     */
+    ResultSetOnly = 2,
+    /**
+     * Disables TCE for the command.Overrides the connection level setting for this command.
+     */
+    Disabled = 3
+}

package/lib/always-encrypted/types.js

@@ -0,0 +1,61 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SQLServerStatementColumnEncryptionSetting = exports.SQLServerEncryptionType = exports.DescribeParameterEncryptionResultSet2 = exports.DescribeParameterEncryptionResultSet1 = void 0;
+// This code is based on the `mssql-jdbc` library published under the conditions of MIT license.
+// Copyright (c) 2019 Microsoft Corporation
+let SQLServerEncryptionType = exports.SQLServerEncryptionType = /*#__PURE__*/function (SQLServerEncryptionType) {
+  SQLServerEncryptionType[SQLServerEncryptionType["Deterministic"] = 1] = "Deterministic";
+  SQLServerEncryptionType[SQLServerEncryptionType["Randomized"] = 2] = "Randomized";
+  SQLServerEncryptionType[SQLServerEncryptionType["PlainText"] = 0] = "PlainText";
+  return SQLServerEncryptionType;
+}({});
+// Fields in the first resultset of "sp_describe_parameter_encryption"
+// We expect the server to return the fields in the resultset in the same order as mentioned below.
+// If the server changes the below order, then transparent parameter encryption will break.
+let DescribeParameterEncryptionResultSet1 = exports.DescribeParameterEncryptionResultSet1 = /*#__PURE__*/function (DescribeParameterEncryptionResultSet1) {
+  DescribeParameterEncryptionResultSet1[DescribeParameterEncryptionResultSet1["KeyOrdinal"] = 0] = "KeyOrdinal";
+  DescribeParameterEncryptionResultSet1[DescribeParameterEncryptionResultSet1["DbId"] = 1] = "DbId";
+  DescribeParameterEncryptionResultSet1[DescribeParameterEncryptionResultSet1["KeyId"] = 2] = "KeyId";
+  DescribeParameterEncryptionResultSet1[DescribeParameterEncryptionResultSet1["KeyVersion"] = 3] = "KeyVersion";
+  DescribeParameterEncryptionResultSet1[DescribeParameterEncryptionResultSet1["KeyMdVersion"] = 4] = "KeyMdVersion";
+  DescribeParameterEncryptionResultSet1[DescribeParameterEncryptionResultSet1["EncryptedKey"] = 5] = "EncryptedKey";
+  DescribeParameterEncryptionResultSet1[DescribeParameterEncryptionResultSet1["ProviderName"] = 6] = "ProviderName";
+  DescribeParameterEncryptionResultSet1[DescribeParameterEncryptionResultSet1["KeyPath"] = 7] = "KeyPath";
+  DescribeParameterEncryptionResultSet1[DescribeParameterEncryptionResultSet1["KeyEncryptionAlgorithm"] = 8] = "KeyEncryptionAlgorithm";
+  return DescribeParameterEncryptionResultSet1;
+}({}); // Fields in the second resultset of "sp_describe_parameter_encryption"
+// We expect the server to return the fields in the resultset in the same order as mentioned below.
+// If the server changes the below order, then transparent parameter encryption will break.
+let DescribeParameterEncryptionResultSet2 = exports.DescribeParameterEncryptionResultSet2 = /*#__PURE__*/function (DescribeParameterEncryptionResultSet2) {
+  DescribeParameterEncryptionResultSet2[DescribeParameterEncryptionResultSet2["ParameterOrdinal"] = 0] = "ParameterOrdinal";
+  DescribeParameterEncryptionResultSet2[DescribeParameterEncryptionResultSet2["ParameterName"] = 1] = "ParameterName";
+  DescribeParameterEncryptionResultSet2[DescribeParameterEncryptionResultSet2["ColumnEncryptionAlgorithm"] = 2] = "ColumnEncryptionAlgorithm";
+  DescribeParameterEncryptionResultSet2[DescribeParameterEncryptionResultSet2["ColumnEncrytionType"] = 3] = "ColumnEncrytionType";
+  DescribeParameterEncryptionResultSet2[DescribeParameterEncryptionResultSet2["ColumnEncryptionKeyOrdinal"] = 4] = "ColumnEncryptionKeyOrdinal";
+  DescribeParameterEncryptionResultSet2[DescribeParameterEncryptionResultSet2["NormalizationRuleVersion"] = 5] = "NormalizationRuleVersion";
+  return DescribeParameterEncryptionResultSet2;
+}({});
+let SQLServerStatementColumnEncryptionSetting = exports.SQLServerStatementColumnEncryptionSetting = /*#__PURE__*/function (SQLServerStatementColumnEncryptionSetting) {
+  /**
+   * if "Column Encryption Setting=Enabled" in the connection string, use Enabled. Otherwise, maps to Disabled.
+   */
+  SQLServerStatementColumnEncryptionSetting[SQLServerStatementColumnEncryptionSetting["UseConnectionSetting"] = 0] = "UseConnectionSetting";
+  /**
+   * Enables TCE for the command. Overrides the connection level setting for this command.
+   */
+  SQLServerStatementColumnEncryptionSetting[SQLServerStatementColumnEncryptionSetting["Enabled"] = 1] = "Enabled";
+  /**
+   * Parameters will not be encrypted, only the ResultSet will be decrypted. This is an optimization for queries that
+   * do not pass any encrypted input parameters. Overrides the connection level setting for this command.
+   */
+  SQLServerStatementColumnEncryptionSetting[SQLServerStatementColumnEncryptionSetting["ResultSetOnly"] = 2] = "ResultSetOnly";
+  /**
+   * Disables TCE for the command.Overrides the connection level setting for this command.
+   */
+  SQLServerStatementColumnEncryptionSetting[SQLServerStatementColumnEncryptionSetting["Disabled"] = 3] = "Disabled";
+  return SQLServerStatementColumnEncryptionSetting;
+}({});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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