parquet/column/
page_encryption.rs1use crate::basic::PageType;
6use crate::column::page::CompressedPage;
7use crate::encryption::ciphers::BlockEncryptor;
8use crate::encryption::encrypt::{FileEncryptor, encrypt_thrift_object};
9use crate::encryption::modules::{ModuleType, create_module_aad};
10use crate::errors::ParquetError;
11use crate::errors::Result;
12use crate::file::metadata::thrift::PageHeader;
13use bytes::Bytes;
14use std::io::Write;
15use std::sync::Arc;
16
17#[derive(Debug)]
18pub(crate) struct PageEncryptor {
20 file_encryptor: Arc<FileEncryptor>,
21 block_encryptor: Box<dyn BlockEncryptor>,
22 row_group_index: usize,
23 column_index: usize,
24 page_index: usize,
25}
26
27impl PageEncryptor {
28 pub fn create_if_column_encrypted(
30 file_encryptor: Option<&Arc<FileEncryptor>>,
31 row_group_index: usize,
32 column_index: usize,
33 column_path: &str,
34 ) -> Result<Option<Self>> {
35 match file_encryptor {
36 Some(file_encryptor) if file_encryptor.is_column_encrypted(column_path) => {
37 let block_encryptor = file_encryptor.get_column_encryptor(column_path)?;
38 Ok(Some(Self {
39 file_encryptor: file_encryptor.clone(),
40 block_encryptor,
41 row_group_index,
42 column_index,
43 page_index: 0,
44 }))
45 }
46 _ => Ok(None),
47 }
48 }
49
50 pub fn increment_page(&mut self) {
52 self.page_index += 1;
53 }
54
55 fn encrypt_page(&mut self, page: &CompressedPage) -> Result<Vec<u8>> {
56 let module_type = if page.compressed_page().is_data_page() {
57 ModuleType::DataPage
58 } else {
59 ModuleType::DictionaryPage
60 };
61 let aad = create_module_aad(
62 self.file_encryptor.file_aad(),
63 module_type,
64 self.row_group_index,
65 self.column_index,
66 Some(self.page_index),
67 )?;
68 let encrypted_buffer = self.block_encryptor.encrypt(page.data(), &aad)?;
69
70 Ok(encrypted_buffer)
71 }
72
73 pub fn encrypt_compressed_page(&mut self, page: CompressedPage) -> Result<CompressedPage> {
75 let encrypted_page = self.encrypt_page(&page)?;
76 Ok(page.with_new_compressed_buffer(Bytes::from(encrypted_page)))
77 }
78
79 pub fn encrypt_page_header<W: Write>(
81 &mut self,
82 page_header: &PageHeader,
83 sink: &mut W,
84 ) -> Result<()> {
85 let module_type = match page_header.r#type {
86 PageType::DATA_PAGE => ModuleType::DataPageHeader,
87 PageType::DATA_PAGE_V2 => ModuleType::DataPageHeader,
88 PageType::DICTIONARY_PAGE => ModuleType::DictionaryPageHeader,
89 PageType::INDEX_PAGE => {
90 return Err(general_err!(
91 "Unsupported page type for page header encryption: {:?}",
92 page_header.r#type
93 ));
94 }
95 };
96 let aad = create_module_aad(
97 self.file_encryptor.file_aad(),
98 module_type,
99 self.row_group_index,
100 self.column_index,
101 Some(self.page_index),
102 )?;
103
104 encrypt_thrift_object(page_header, &mut self.block_encryptor, sink, &aad)
105 }
106}