Esecuzione con crittografia modulare Parquet

La crittografia modulare Parquet è disponibile solo nei notebook Spark eseguiti in un'istanza del servizio IBM Analytics Engine. La crittografia modulare di parquet non è supportata nei notebook che vengono eseguiti in un ambiente Spark.

Per abilitare la crittografia modulare di Parquet, impostare le seguenti proprietà classpath di Spark per puntare ai file jar di Parquet che implementano la crittografia modulare di Parquet e al file jar di gestione chiavi:

1. Navigare in Ambari > Spark> Config -> Personalizzato spark2-default.

2. Aggiungere i seguenti due parametri per puntare esplicitamente alla posizione dei file JAR. Assicurarsi di modificare i percorsi per utilizzare la versione effettiva dei file jar sul cluster.

   spark.driver.extraClassPath=/home/common/lib/parquetEncryption/ibm-parquet-kms-<latestversion>-jar-with-dependencies.jar:/home/common/lib/parquetEncryption/parquet-format-<latestversion>.jar:/home/common/lib/parquetEncryption/parquet-hadoop-<latestversion>.jar
   
   spark.executor.extraClassPath=/home/common/lib/parquetEncryption/ibm-parquet-<latestversion>-jar-with-dependencies.jar:/home/common/lib/parquetEncryption/parquet-format-<latestversion>.jar:/home/common/lib/parquetEncryption/parquet-hadoop-<latestversion>.jar
   

Parametri obbligatori

Per la scrittura dei dati crittografati sono richiesti i seguenti parametri:

• Elenco delle colonne da crittografare, con le chiavi di codifica master:

  parameter name: "encryption.column.keys"
  parameter value: "<master key ID>:<column>,<column>;<master key ID>:<column>,.."
  

• La chiave di piè di pagina:

  parameter name: "encryption.footer.key"
  parameter value: "<master key ID>"
  

  Ad esempio:

  dataFrame.write
  .option("encryption.footer.key" , "k1")
  .option("encryption.column.keys" , "k2:SSN,Address;k3:CreditCard")
  .parquet("<path to encrypted files>")
  

  Importante:

  Se non è impostato né il parametro encryption.column.keys né il parametro encryption.footer.key , il file non verrà codificato. Se solo uno di questi parametri è impostato, viene lanciata un'eccezione, perché questi parametri sono obbligatori per i file crittografati.

Parametri facoltativi

I seguenti parametri opzionali possono essere utilizzati quando si scrivono dati crittografati:

• L'algoritmo di codifica AES-GCM-CTR

  Per impostazione predefinita, la crittografia modulare Parquet utilizza l'algoritmo AES-GCM che fornisce una protezione completa contro la manomissione dei dati e dei metadati nei file di Parquet. Tuttavia, poiché Spark 2.3.0 viene eseguito su Java 8, che non supporta l'accelerazione AES nell'hardware CPU (aggiunta solo in Java 9), il sovraccarico di verifica dell'integrità dei dati può influire sulla velocità di trasmissione dei carichi di lavoro in determinate situazioni.

  Per compensare questo, è possibile disattivare il supporto di verifica dell'integrità dei dati e scrivere i file crittografati con l'algoritmo alternativo AES-GCM-CTR, che verifica l'integrità delle parti di metadati solo e non quella delle parti di dati, e ha un sovraccarico di throughput inferiore rispetto all'algoritmo AES-GCM .

  parameter name: "encryption.algorithm"
  parameter value: "AES_GCM_CTR_V1"
  

• Modalità di piè di testo semplice per i lettori legacy

  Per impostazione predefinita, il modulo principale di metadati Parquet (il footer di file) è crittografato per nascondere lo schema di file e l'elenco delle colonne sensibili. Tuttavia, è possibile decidere di non crittografare i fari di file al fine di abilitare altri lettori di Spark e Parquet (che non supportano ancora la crittografia modulare di Parquet) per leggere le colonne non crittografate nei file crittografati. Per commutare la crittografia del footer, impostare il seguente parametro:

  parameter name: "encryption.plaintext.footer"
  parameter value: "true"
  

  Importante:

  Il parametro encryption.footer.key deve essere specificato anche in modalità piè di pagina di testo semplice. Anche se il piè di pagina non è criptato, la chiave è utilizzata per firmare il contenuto di piè di pagina, il che significa che i nuovi lettori potrebbero verificarne l'integrità. I lettori legacy non sono interessati dall'aggiunta della firma del piè di pagina.

Esempi di utilizzo

I seguenti frammenti di codice di esempio per Python mostrano come creare frame di dati, scritti in file parquet crittografati e letti da file parquet crittografati.

• Python: Scrittura dei dati crittografati:

  from pyspark.sql import Row
  
  squaresDF = spark.createDataFrame(
      sc.parallelize(range(1, 6))
      .map(lambda i: Row(int_column=i, square_int_column=i ** 2)))
  
  sc._jsc.hadoopConfiguration().set("encryption.key.list",
      "key1: AAECAwQFBgcICQoLDA0ODw==, key2: AAECAAECAAECAAECAAECAA==")
  sc._jsc.hadoopConfiguration().set("encryption.column.keys",
      "key1:square_int_column")
  sc._jsc.hadoopConfiguration().set("encryption.footer.key", "key2")
  
  encryptedParquetPath = "squares.parquet.encrypted"
  squaresDF.write.parquet(encryptedParquetPath)
  

• Python: Lettura dei dati crittografati:

  sc._jsc.hadoopConfiguration().set("encryption.key.list",
      "key1: AAECAwQFBgcICQoLDA0ODw==, key2: AAECAAECAAECAAECAAECAA==")
  
  encryptedParquetPath = "squares.parquet.encrypted"
  parquetFile = spark.read.parquet(encryptedParquetPath)
  parquetFile.show()
  

Il contenuto del file di lavoro Python InMemoryKMS.py è il seguente:

from pyspark.sql import SparkSession
from pyspark import SparkContext
from pyspark.sql import Row

if __name__ == "__main__":
    spark = SparkSession \
        .builder \
        .appName("InMemoryKMS") \
        .getOrCreate()
    sc = spark.sparkContext
    ##KMS operation
    print("Setup InMemoryKMS")
    hconf = sc._jsc.hadoopConfiguration()
    encryptedParquetFullName = "testparquet.encrypted"
    print("Write Encrypted Parquet file")
    hconf.set("encryption.key.list", "key1: AAECAwQFBgcICQoLDA0ODw==, key2: AAECAAECAAECAAECAAECAA==")
    btDF = spark.createDataFrame(sc.parallelize(range(1, 6)).map(lambda i: Row(ssn=i,  value=i ** 2)))
    btDF.write.mode("overwrite").option("encryption.column.keys", "key1:ssn").option("encryption.footer.key", "key2").parquet(encryptedParquetFullName)
    print("Read Encrypted Parquet file")
    encrDataDF = spark.read.parquet(encryptedParquetFullName)
    encrDataDF.createOrReplaceTempView("bloodtests")
    queryResult = spark.sql("SELECT ssn, value FROM bloodtests")
    queryResult.show(10)
    sc.stop()
    spark.stop()

Interni di gestione delle chiavi di cifratura

Quando si scrive un file Parquet, viene generata una chiave di codifica dati casuale (DEK) per ogni colonna crittografata e per il piè di pagina. Questi tasti sono utilizzati per crittografare i dati e i moduli di metadati presenti nel file Parquet.

La chiave di codifica dei dati viene quindi crittografata con una chiave di crittografia chiave (KEK), generata anche all'interno di Spark / Parquet per ogni chiave principale. La chiave di crittografia chiave è crittografata con una chiave di codifica principale (MEK) localmente.

I tasti di crittografia dei dati crittografati e chiavi di crittografia chiave sono memorizzati nei metadati del file Parquet, insieme all'identità chiave principale. Ogni tasto di crittografia chiave ha un'identità unica (generata localmente come un valore casuale 16 - byte sicuro), memorizzata anche nei metadati del file.

Quando si legge un file di Parquet, l'identificativo della chiave di codifica principale (MEK) e il tasto crittografato della chiave crittografata (KEK) con il relativo identificativo e la chiave di codifica dei dati crittografati (DEK) vengono estratti dai metadati del file.

La chiave di crittografia chiave viene decodificata con la chiave di codifica master localmente. Poi la chiave di codifica dei dati (DEK) viene decodificata localmente, utilizzando la chiave di codifica chiave (KEK).

Ulteriori informazioni

• Ccodifica modulare di Parquet

Argomento principale: Notebook e script