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

A TDS driver, for connecting to MS SQLServer databases.

"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 = void 0;
    this.url = void 0;
    this.rsaEncryptionAlgorithmWithOAEPForAKV = void 0;
    this.firstVersion = void 0;
    this.credentials = void 0;
    this.azureKeyVaultDomainName = void 0;
    this.keyClient = void 0;
    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":["ColumnEncryptionAzureKeyVaultProvider","constructor","clientId","clientKey","tenantId","name","url","rsaEncryptionAlgorithmWithOAEPForAKV","firstVersion","credentials","azureKeyVaultDomainName","keyClient","Buffer","from","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","update","dataToVerify","digest","verifyKey","verify","result","decryptedCEK","azureKeyVaultUnWrap","encryptColumnEncryptionKey","columnEncryptionKey","version","masterKeyPathBytes","toLowerCase","azureKeyVaultWrap","dataToHash","destinationPosition","dataToSign","signedHash","azureKeyVaultSignedHashedData","encryptedColumnEncryptionKeyLength","keyParts","parsePath","createKeyClient","vaultUrl","getKey","keyVaultUrl","KeyClient","CryptographyClient","trim","baseUri","hostname","endsWith","segments","pathname","split","protocol","host","undefined","signedData","sign","wrappedKey","wrapKey","unwrappedKey","unwrapKey","retrievedKey","key","kty","toUpperCase","localeCompare","keyLength","n"],"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, KeyWrapAlgorithm, KeyClient, 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  public readonly name: string;\n  private url: undefined | string;\n  private readonly rsaEncryptionAlgorithmWithOAEPForAKV: string;\n  private readonly firstVersion: Buffer;\n  private credentials: ClientSecretCredential;\n  private readonly azureKeyVaultDomainName: string;\n  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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"}