Skip to main content

parquet/column/
page_encryption.rs

1// SPDX-License-Identifier: Apache-2.0
2// SPDX-FileCopyrightText: See the NOTICE file distributed with this work for additional information regarding copyright ownership
3// SPDX-FileContributor: Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements
4
5use 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)]
18/// Encrypts page headers and page data for columns
19pub(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    /// Create a [`PageEncryptor`] for a column if it should be encrypted
29    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    /// Update the page index after a data page has been processed
51    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    /// Encrypt compressed column page data
74    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    /// Encrypt a column page header
80    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}