Function DeserializeEncryptedFromStream

cpp/src/parquet/bloom_filter.cc:140–230

}

BlockSplitBloomFilter DeserializeEncryptedFromStream(
    const ReaderProperties& properties, ArrowInputStream* input,
    std::optional<int64_t> bloom_filter_length, Decryptor* decryptor,
    int16_t row_group_ordinal, int16_t column_ordinal) {
  ThriftDeserializer deserializer(properties);
  format::BloomFilterHeader header;

  // Read the length-prefixed ciphertext for the header.
  PARQUET_ASSIGN_OR_THROW(auto length_buf, input->Read(kCiphertextLengthSize));
  CheckBloomFilterShortRead(kCiphertextLengthSize, length_buf->size(),
                            "Bloom filter header length");

  const int64_t header_cipher_total_len =
      ParseCiphertextTotalLength(length_buf->data(), length_buf->size());
  if (ARROW_PREDICT_FALSE(header_cipher_total_len >
                          std::numeric_limits<int32_t>::max())) {
    throw ParquetException("Bloom filter header ciphertext length overflows int32");
  }
  if (bloom_filter_length && header_cipher_total_len > *bloom_filter_length) {
    throw ParquetException(
        "Bloom filter length less than encrypted bloom filter header length");
  }

  // Read the full header ciphertext and decrypt the Thrift header.
  auto header_cipher_buf =
      AllocateBuffer(properties.memory_pool(), header_cipher_total_len);
  std::memcpy(header_cipher_buf->mutable_data(), length_buf->data(),
              kCiphertextLengthSize);
  const int64_t header_cipher_remaining = header_cipher_total_len - kCiphertextLengthSize;
  PARQUET_ASSIGN_OR_THROW(auto read_size, input->Read(header_cipher_remaining,
                                                      header_cipher_buf->mutable_data() +
                                                          kCiphertextLengthSize));
  CheckBloomFilterShortRead(header_cipher_remaining, read_size, "Bloom filter header");

  // Bloom filter header and bitset are separate encrypted modules with different AADs.
  UpdateDecryptor(decryptor, row_group_ordinal, column_ordinal,
                  encryption::kBloomFilterHeader);
  auto header_cipher_len = static_cast<uint32_t>(header_cipher_total_len);
  try {
    deserializer.DeserializeMessage(header_cipher_buf->data(), &header_cipher_len,
                                    &header, decryptor);
  } catch (std::exception& e) {
    std::stringstream ss;
    ss << "Deserializing bloom filter header failed.\n" << e.what();
    throw ParquetException(ss.str());
  }
  if (ARROW_PREDICT_FALSE(header_cipher_len != header_cipher_total_len)) {
    std::stringstream ss;
    ss << "Encrypted bloom filter header length mismatch: expected "
       << header_cipher_total_len << " bytes, got " << header_cipher_len;
    throw ParquetException(ss.str());
  }
  PARQUET_THROW_NOT_OK(ValidateBloomFilterHeader(header));

  const int32_t bloom_filter_size = header.numBytes;
  UpdateDecryptor(decryptor, row_group_ordinal, column_ordinal,
                  encryption::kBloomFilterBitset);
  const int32_t bitset_cipher_len = decryptor->CiphertextLength(bloom_filter_size);