"use strict";

// this is from https://github.com/matrix-org/browser-encrypt-attachment
// which is the library used by matrix-reack-sdk to encrypt and decrypt attachments
// just dropped in node-webcrypto-ossl to replace window.crypto
// and Buffer for base64 encoding/decoding instead of window.btoa/window.atob

/**
 * Encrypt an attachment.
 * @param {ArrayBuffer} plaintextBuffer The attachment data buffer.
 * @return {Promise} A promise that resolves with an object when the attachment is encrypted.
 *      The object has a "data" key with an ArrayBuffer of encrypted data and an "info" key
 *      with an object containing the info needed to decrypt the data.
 */
const {
  Crypto
} = require("node-webcrypto-ossl");

const crypto = new Crypto();

function encryptAttachment(plaintextBuffer) {
  var cryptoKey; // The AES key object.

  var exportedKey; // The AES key exported as JWK.

  var ciphertextBuffer; // ArrayBuffer of encrypted data.

  var sha256Buffer; // ArrayBuffer of digest.

  var ivArray; // Uint8Array of AES IV
  // Generate an IV where the first 8 bytes are random and the high 8 bytes
  // are zero. We set the counter low bits to 0 since it makes it unlikely
  // that the 64 bit counter will overflow.

  ivArray = new Uint8Array(16);
  crypto.getRandomValues(ivArray.subarray(0, 8)); // Load the encryption key.

  return crypto.subtle.generateKey({
    "name": "AES-CTR",
    length: 256
  }, true, ["encrypt", "decrypt"]).then(function (generateKeyResult) {
    cryptoKey = generateKeyResult; // Export the Key as JWK.

    return crypto.subtle.exportKey("jwk", cryptoKey);
  }).then(function (exportKeyResult) {
    exportedKey = exportKeyResult; // Encrypt the input ArrayBuffer.
    // Use half of the iv as the counter by setting the "length" to 64.

    return crypto.subtle.encrypt({
      name: "AES-CTR",
      counter: ivArray,
      length: 64
    }, cryptoKey, plaintextBuffer);
  }).then(function (encryptResult) {
    ciphertextBuffer = encryptResult; // SHA-256 the encrypted data.

    return crypto.subtle.digest("SHA-256", ciphertextBuffer);
  }).then(function (digestResult) {
    sha256Buffer = digestResult;
    return {
      data: ciphertextBuffer,
      info: {
        v: "v2",
        key: exportedKey,
        iv: encodeBase64(ivArray),
        hashes: {
          sha256: encodeBase64(new Uint8Array(sha256Buffer))
        }
      }
    };
  });
}
/**
 * Decrypt an attachment.
 * @param {ArrayBuffer} ciphertextBuffer The encrypted attachment data buffer.
 * @param {Object} info The information needed to decrypt the attachment.
 * @param {Object} info.key AES-CTR JWK key object.
 * @param {string} info.iv Base64 encoded 16 byte AES-CTR IV.
 * @param {string} info.hashes.sha256 Base64 encoded SHA-256 hash of the ciphertext.
 * @return {Promise} A promise that resolves with an ArrayBuffer when the attachment is decrypted.
 */


function decryptAttachment(ciphertextBuffer, info) {
  if (info === undefined || info.key === undefined || info.iv === undefined || info.hashes === undefined || info.hashes.sha256 === undefined) {
    throw new Error("Invalid info. Missing info.key, info.iv or info.hashes.sha256 key");
  }

  var cryptoKey; // The AES key object.

  var ivArray = decodeBase64(info.iv);
  var expectedSha256base64 = info.hashes.sha256; // Load the AES from the "key" key of the info object.

  return crypto.subtle.importKey("jwk", info.key, {
    "name": "AES-CTR"
  }, false, ["encrypt", "decrypt"]).then(function (importKeyResult) {
    cryptoKey = importKeyResult; // Check the sha256 hash

    return crypto.subtle.digest("SHA-256", ciphertextBuffer);
  }).then(function (digestResult) {
    if (encodeBase64(new Uint8Array(digestResult)) != expectedSha256base64) {
      throw new Error("Mismatched SHA-256 digest");
    }

    var counterLength;

    if (info.v == "v1" || info.v == "v2") {
      // Version 1 and 2 use a 64 bit counter.
      counterLength = 64;
    } else {
      // Version 0 uses a 128 bit counter.
      counterLength = 128;
    }

    return crypto.subtle.decrypt({
      name: "AES-CTR",
      counter: ivArray,
      length: counterLength
    }, cryptoKey, ciphertextBuffer);
  });
}
/**
 * Encode a typed array of uint8 as base64.
 * @param {Uint8Array} uint8Array The data to encode.
 * @return {string} The base64 without padding.
 */


function encodeBase64(uint8Array) {
  // Misinterpt the Uint8Array as Latin-1.
  // window.btoa expects a unicode string with codepoints in the range 0-255.
  var latin1String = String.fromCharCode.apply(null, uint8Array); // Use the builtin base64 encoder.
  // var paddedBase64 = window.btoa(latin1String);

  var paddedBase64 = Buffer.from(latin1String, 'binary').toString('base64'); // Calculate the unpadded length.

  var inputLength = uint8Array.length;
  var outputLength = 4 * Math.floor((inputLength + 2) / 3) + (inputLength + 2) % 3 - 2; // Return the unpadded base64.

  return paddedBase64.slice(0, outputLength);
}
/**
 * Decode a base64 string to a typed array of uint8.
 * This will decode unpadded base64, but will also accept base64 with padding.
 * @param {string} base64 The unpadded base64 to decode.
 * @return {Uint8Array} The decoded data.
 */


function decodeBase64(base64) {
  // Pad the base64 up to the next multiple of 4.
  var paddedBase64 = base64 + "===".slice(0, (4 - base64.length % 4) % 4); // Decode the base64 as a misinterpreted Latin-1 string.
  // window.atob returns a unicode string with codepoints in the range 0-255.
  // var latin1String = window.atob(paddedBase64);

  var latin1String = Buffer.from(paddedBase64, 'base64').toString('binary'); // Encode the string as a Uint8Array as Latin-1.

  var uint8Array = new Uint8Array(latin1String.length);

  for (var i = 0; i < latin1String.length; i++) {
    uint8Array[i] = latin1String.charCodeAt(i);
  }

  return uint8Array;
}

try {
  exports.encryptAttachment = encryptAttachment;
  exports.decryptAttachment = decryptAttachment;
} catch (e) {// Ignore unknown variable "exports" errors when this is loaded directly into a browser
  // This means that we can test it without having to use browserify.
  // The intention is that the library is used using browserify.
}