Method EncryptInternal

be/src/util/openssl-util.cc:462–563

}

Status EncryptionKey::EncryptInternal(
    bool encrypt, const uint8_t* data, int64_t len, uint8_t* out, int64_t* out_len) {
  DCHECK(initialized_);
  DCHECK_GE(len, 0);
  if (IsEcbMode()) {
    if ((encrypt && len > numeric_limits<int>::max() - AES_BLOCK_SIZE)
        || (!encrypt && len > numeric_limits<int>::max())) {
      return Status("Input buffer length exceeds the supported length for ECB mode.");
    }
  }

  const char* err_context = encrypt ? "encrypting" : "decrypting";
  // Create and initialize the context for encryption.
  // If it is ECB mode then padding will be enabled
  // for this ctx, otherwise it will be disabled.
  bool padding_enabled = IsEcbMode();
  int padding_flag = padding_enabled ? 1 : 0;
  ScopedEVPCipherCtx ctx(padding_flag);

  // Start encryption/decryption. We use a 128/256-bit AES key and support GCM, CTR
  // CFB and ECB for encryption and decryption. When the cipher block mode is either
  // GCM, CTR or CFB(stream cipher), it supports arbitrary length ciphertexts - it
  // doesn't have to be a multiple of 16 bytes. While for ECB decryption,
  // the length has to be multiples of 16. Additionally, CTR mode is
  // well-optimized (instruction level parallelism) with hardware acceleration
  // on x86 and PowerPC.

  // In the first initialization, only evpCipher is initialized, and in the second
  // initialization, the key and IV vector are set. This approach is necessary because a
  // variable-length IV vector is used. Therefore, in GCM mode, the IV length must be
  // initialized before setting the IV vector.
  const EVP_CIPHER* evpCipher = GetCipher();
  DCHECK(evpCipher != nullptr);
  int success = encrypt ?
      EVP_EncryptInit_ex(ctx.ctx, evpCipher, nullptr, nullptr, nullptr):
      EVP_DecryptInit_ex(ctx.ctx, evpCipher, nullptr, nullptr, nullptr);
  if (success != 1) {
    return OpenSSLErr(encrypt ? "EVP_EncryptInit_ex" : "EVP_DecryptInit_ex", err_context);
  }

  if (IsGcmMode()) {
    // Set iv_vector for GCM mode.
    if (EVP_CIPHER_CTX_ctrl(ctx.ctx, EVP_CTRL_GCM_SET_IVLEN, iv_length_, nullptr)!= 1) {
      return OpenSSLErr("EVP_CIPHER_CTX_ctrl", err_context);
    }
  }
  // setting iv after changing iv len, see https://github.com/openssl/openssl/pull/22590
  success = encrypt ? EVP_EncryptInit_ex(ctx.ctx, nullptr, nullptr, key_, iv_):
                      EVP_DecryptInit_ex(ctx.ctx, nullptr, nullptr, key_, iv_);
  if (success != 1) {
    return OpenSSLErr(encrypt ? "EVP_EncryptInit_ex" : "EVP_DecryptInit_ex", err_context);
  }

  // The OpenSSL encryption APIs use INT for buffer lengths. To support larger buffers,
  // larger buffers need to be chunked into smaller parts.
  int64_t output_offset = 0;
  int64_t input_offset = 0;
  while (input_offset < len) {