update

ArnavBalyan · ArnavBalyan · commit cf06df89b2e2 · 2025-09-29T05:42:40.000Z
diff --git a/parquet-cli/src/main/java/org/apache/parquet/cli/commands/ShowBloomFilterCommand.java b/parquet-cli/src/main/java/org/apache/parquet/cli/commands/ShowBloomFilterCommand.java
@@ -24,12 +24,16 @@
 import com.google.common.base.Preconditions;
 import com.google.common.collect.Lists;
 import java.io.IOException;
+import java.nio.charset.StandardCharsets;
 import java.util.List;
 import java.util.Optional;
 import org.apache.commons.text.TextStringBuilder;
+import org.apache.parquet.HadoopReadOptions;
 import org.apache.parquet.cli.BaseCommand;
 import org.apache.parquet.cli.Util;
 import org.apache.parquet.column.values.bloomfilter.BloomFilter;
+import org.apache.parquet.crypto.DecryptionKeyRetriever;
+import org.apache.parquet.crypto.FileDecryptionProperties;
 import org.apache.parquet.hadoop.BloomFilterReader;
 import org.apache.parquet.hadoop.ParquetFileReader;
 import org.apache.parquet.hadoop.metadata.BlockMetaData;
@@ -63,14 +67,31 @@ public ShowBloomFilterCommand(Logger console) {
       required = true)
   List<String> testValues;
 
+  @Parameter(
+      names = {"--footer-key"},
+      description = "Footer key for encrypted files (hex string, 16/24/32 bytes)")
+  String footerKeyHex;
+
+  @Parameter(
+      names = {"--column-key"},
+      description = "Column key for encrypted files (hex string, 16/24/32 bytes)")
+  String columnKeyHex;
+
   @Override
   @SuppressWarnings("unchecked")
   public int run() throws IOException {
     Preconditions.checkArgument(file != null, "A Parquet file is required.");
 
     InputFile in = HadoopInputFile.fromPath(qualifiedPath(file), getConf());
 
-    try (ParquetFileReader reader = ParquetFileReader.open(in)) {
+    FileDecryptionProperties decryptionProperties = createDecryptionProperties();
+
+    HadoopReadOptions.Builder optionsBuilder = HadoopReadOptions.builder(getConf());
+    if (decryptionProperties != null) {
+      optionsBuilder.withDecryption(decryptionProperties);
+    }
+
+    try (ParquetFileReader reader = ParquetFileReader.open(in, optionsBuilder.build())) {
       MessageType schema = reader.getFileMetaData().getSchema();
       PrimitiveType type = Util.primitive(columnPath, schema);
 
@@ -122,9 +143,57 @@ private Object getOriginalType(String value, PrimitiveType type) {
     }
   }
 
+  private FileDecryptionProperties createDecryptionProperties() {
+    if (footerKeyHex == null && columnKeyHex == null) {
+      return null;
+    }
+
+    SimpleKeyRetriever keyRetriever = new SimpleKeyRetriever();
+
+    FileDecryptionProperties.Builder builder =
+        FileDecryptionProperties.builder().withPlaintextFilesAllowed();
+
+    byte[] footerKey = hexToBytes(footerKeyHex);
+    builder.withFooterKey(footerKey);
+
+    byte[] columnKey = hexToBytes(columnKeyHex);
+    keyRetriever.putKey("col", columnKey);
+    builder.withKeyRetriever(keyRetriever);
+
+    return builder.build();
+  }
+
+  private static byte[] hexToBytes(String hex) {
+    int len = hex.length();
+    byte[] data = new byte[len / 2];
+    for (int i = 0; i < len; i += 2) {
+      data[i / 2] = (byte) ((Character.digit(hex.charAt(i), 16) << 4) | Character.digit(hex.charAt(i + 1), 16));
+    }
+    return data;
+  }
+
+  private static class SimpleKeyRetriever implements DecryptionKeyRetriever {
+    private final java.util.Map<String, byte[]> keyMap = new java.util.HashMap<>();
+
+    public void putKey(String keyId, byte[] keyBytes) {
+      keyMap.put(keyId, keyBytes);
+    }
+
+    @Override
+    public byte[] getKey(byte[] keyMetaData) {
+      String keyId = new String(keyMetaData, StandardCharsets.UTF_8);
+      return keyMap.get(keyId);
+    }
+  }
+
   @Override
   public List<String> getExamples() {
     return Lists.newArrayList(
-        "# Show bloom filter for column 'col' from a Parquet file", "-c col -v 1,2,3 -i sample.parquet");
+        "# Show bloom filter for column 'col' from a Parquet file",
+        "-c col -v 1,2,3 sample.parquet",
+        "# Show bloom filter for encrypted file with footer key",
+        "-c col -v 1,2,3 --footer-key 0102030405060708090a0b0c0d0e0f10 encrypted.parquet",
+        "# Show bloom filter for encrypted file with column key",
+        "-c col -v 1,2,3 --column-key 0102030405060708090a0b0c0d0e0f10 encrypted.parquet");
   }
 }
diff --git a/parquet-cli/src/test/java/org/apache/parquet/cli/commands/ShowBloomFilterCommandTest.java b/parquet-cli/src/test/java/org/apache/parquet/cli/commands/ShowBloomFilterCommandTest.java
@@ -19,10 +19,31 @@
 
 package org.apache.parquet.cli.commands;
 
+import static org.apache.parquet.schema.PrimitiveType.PrimitiveTypeName.BINARY;
+import static org.apache.parquet.schema.PrimitiveType.PrimitiveTypeName.INT32;
+
 import java.io.File;
 import java.io.IOException;
+import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
 import org.apache.hadoop.conf.Configuration;
+import org.apache.hadoop.fs.Path;
+import org.apache.parquet.crypto.ColumnEncryptionProperties;
+import org.apache.parquet.crypto.FileEncryptionProperties;
+import org.apache.parquet.crypto.ParquetCipher;
+import org.apache.parquet.example.data.Group;
+import org.apache.parquet.example.data.simple.SimpleGroup;
+import org.apache.parquet.example.data.simple.SimpleGroupFactory;
+import org.apache.parquet.hadoop.ParquetWriter;
+import org.apache.parquet.hadoop.example.ExampleParquetWriter;
+import org.apache.parquet.hadoop.example.GroupWriteSupport;
+import org.apache.parquet.hadoop.metadata.ColumnPath;
+import org.apache.parquet.hadoop.metadata.CompressionCodecName;
+import org.apache.parquet.io.api.Binary;
+import org.apache.parquet.schema.MessageType;
+import org.apache.parquet.schema.Types;
 import org.junit.Assert;
 import org.junit.Test;
 
@@ -37,4 +58,98 @@ public void testShowBloomFilterCommand() throws IOException {
     command.setConf(new Configuration());
     Assert.assertEquals(0, command.run());
   }
+
+  @Test
+  public void testEncryptedFileWithBloomFilter() throws IOException {
+    File encryptedFile = createEncryptedFileWithBloomFilter();
+
+    ShowBloomFilterCommand command = new ShowBloomFilterCommand(createLogger());
+    command.file = encryptedFile.getAbsolutePath();
+    command.columnPath = "name";
+    command.testValues = Arrays.asList(new String[] {"test_value_1", "non_existent_value"});
+
+    command.footerKeyHex = "0102030405060708090a0b0c0d0e0f10";
+    command.columnKeyHex = "02030405060708090a0b0c0d0e0f1011";
+    command.setConf(new Configuration());
+
+    Assert.assertEquals(0, command.run());
+
+    encryptedFile.delete();
+  }
+
+  /**
+   * Creates an encrypted Parquet file with bloom filters for testing
+   */
+  private File createEncryptedFileWithBloomFilter() throws IOException {
+    MessageType schema = Types.buildMessage()
+        .required(INT32)
+        .named("id")
+        .required(BINARY)
+        .named("name")
+        .named("test_schema");
+
+    File tempFile = new File(getTempFolder(), "encrypted_bloom_test.parquet");
+    tempFile.deleteOnExit();
+
+    Configuration conf = new Configuration();
+    GroupWriteSupport.setSchema(schema, conf);
+
+    String[] encryptColumns = {"name"};
+    FileEncryptionProperties encryptionProperties =
+        createFileEncryptionProperties(encryptColumns, ParquetCipher.AES_GCM_CTR_V1, true);
+
+    SimpleGroupFactory factory = new SimpleGroupFactory(schema);
+    String[] testValues = {"test_value_1", "test_value_2", "another_test", "bloom_filter_test", "final_value"};
+
+    try (ParquetWriter<Group> writer = ExampleParquetWriter.builder(new Path(tempFile.toURI()))
+        .withConf(conf)
+        .withCompressionCodec(CompressionCodecName.UNCOMPRESSED)
+        .withEncryption(encryptionProperties)
+        .withBloomFilterEnabled("name", true)
+        .withPageSize(1024)
+        .withRowGroupSize(4096)
+        .build()) {
+
+      for (int i = 0; i < testValues.length; i++) {
+        SimpleGroup group = (SimpleGroup) factory.newGroup();
+        group.add("id", i + 1);
+        group.add("name", Binary.fromString(testValues[i]));
+        writer.write(group);
+      }
+    }
+
+    return tempFile;
+  }
+
+  private FileEncryptionProperties createFileEncryptionProperties(
+      String[] encryptColumns, ParquetCipher cipher, boolean footerEncryption) {
+
+    byte[] footerKey = {
+      0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10
+    };
+    byte[] columnKey = {
+      0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11
+    };
+
+    Map<ColumnPath, ColumnEncryptionProperties> columnPropertyMap = new HashMap<>();
+    for (String columnPath : encryptColumns) {
+      ColumnPath column = ColumnPath.fromDotString(columnPath);
+      ColumnEncryptionProperties columnProps = ColumnEncryptionProperties.builder(column)
+          .withKey(columnKey)
+          .withKeyMetaData("col".getBytes(StandardCharsets.UTF_8))
+          .build();
+      columnPropertyMap.put(column, columnProps);
+    }
+
+    FileEncryptionProperties.Builder builder = FileEncryptionProperties.builder(footerKey)
+        .withFooterKeyMetadata("footkey".getBytes(StandardCharsets.UTF_8))
+        .withAlgorithm(cipher)
+        .withEncryptedColumns(columnPropertyMap);
+
+    if (!footerEncryption) {
+      builder.withPlaintextFooter();
+    }
+
+    return builder.build();
+  }
 }
