Crittografia modulare di parquet

Se i tuoi dati vengono memorizzati in formato columnar, è possibile utilizzare la crittografia modulare Parquet per crittografare colonne sensibili durante la scrittura dei file di Parquet e decodificare queste colonne durante la lettura dei file crittografati. Crittografare i dati a livello di colonna, consente di decidere quali colonne crittografare e come controllare l'accesso alla colonna.

Oltre a garantire la privacy, la crittografia modulare Parquet protegge anche l'integrità dei dati memorizzati. Qualsiasi manomissione con contenuto di file viene rilevato e attiva un'eccezione del lato reader.

Le funzioni principali includono:

  1. La crittografia modulare e la decodifica viene eseguita sul cluster Spark. Pertanto, i dati sensibili e le chiavi di crittografia non sono visibili allo storage.
  2. Le funzioni di Parquet standard, come ad esempio la codifica, la compressione, la proiezione di columnar e il predicato push - down, continuano a funzionare come di consueto su file con formato di codifica modulare Parquet.

  3. È possibile scegliere uno dei due algoritmi di codifica definiti nella specifica Parquet. Entrambi gli algoritmi supportano la crittografia delle colonne, tuttavia:

    • L'algoritmo predefinito AES-GCM fornisce una protezione completa contro la manomissione dei dati e delle parti dei metadati nei file di Parquet.
    • L'algoritmo alternativo AES-GCM-CTR supporta la protezione di integrità parziale dei file di Parquet. Solo le parti di metadati sono protette contro le manomissioni, non le parti di dati. Un vantaggio di questo algoritmo è che ha un sovraccarico di throughput inferiore rispetto all'algoritmo AES-GCM .
  4. È possibile scegliere quali colonne crittografare. Altre colonne non verranno crittografate, riducendo la sovraccarica di throughput.
  5. Diverse colonne possono essere crittografate con diverse chiavi.
  6. 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 scegliere di non crittografare i footers del file al fine di abilitare i lettori legacy (come ad esempio altre distribuzioni Spark che non supportano ancora la crittografia modulare di Parquet) per leggere le colonne non crittografate nei file crittografati.

  7. I tasti di crittografia possono essere gestiti in uno dei due modi:

    • Direttamente dalla tua applicazione. Consultare Gestione chiave per applicazione.

    • Tramite un sistema di gestione chiavi (KMS) che genera, memorizza e distrugge i tasti di crittografia utilizzati dal servizio Spark. Queste chiavi non lasciano mai il server KMS e quindi sono invisibili ad altri componenti, tra cui il servizio Spark. Consultare Gestione chiave da parte di KMS.

      Nota: Solo i tasti di crittografia master (MEKs) devono essere gestiti dalla propria applicazione o da un KMS.

      Per ogni colonna sensibile è necessario specificare quale chiave principale utilizzare per la crittografia. Inoltre, deve essere specificato un tasto master per il piè di pagina di ogni file crittografato (frame frame). Per impostazione predefinita, la chiave di piè di pagina verrà utilizzata per la crittografia a piè di pagina. Tuttavia, se si sceglie una modalità di testo semplice, il piè di pagina non verrà crittografato e la chiave verrà utilizzata solo per la verifica dell'integrità del piè di pagina.

      I parametri di crittografia possono essere passati tramite la configurazione standard Spark Hadoop , ad esempio impostando i valori di configurazione nella configurazione Hadoop dello SparkContext dell'applicazione:

      sc.hadoopConfiguration.set("<parameter name>" , "<parameter value>")

      In alternativa, è possibile passare i valori dei parametri attraverso le opzioni di scrittura:

      <data frame name>.write
.option("<parameter name>" , "<parameter value>")
.parquet("<write path>")

Parametri obbligatori

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

Parametri facoltativi

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

Esempi di utilizzo

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

Esempio di inoltro di un lavoro Spark che utilizza la crittografia modulare Parquet

Il seguente esempio mostra come inoltrare un lavoro Spark che utilizza la crittografia modulare di Parquet all'istanza di Spark. L'esempio include il modello personalizzato che specifica la versione Spark e le librerie di sistema preinstallate per la crittografia modulare Parquet, mostra come personalizzare le dimensioni hardware del cluster e aggiungere il percorso file al file di lavoro Scala InMemoryKMS.py.

Nota:

{
    "engine": {
        "type": "spark",
        "template_id": "spark-3.0.0-parquet-encryption-cp4d-template",
        "conf": {
            "spark.app.name": "InMemoryKMS",
            "spark.eventLog.enabled": "false"
        },
          "volumes": [{
                              "volume_name": "kms-volume",
                              "source_path": "KMS",
                              "mount_path": "/kms-app"
                 }],
        "size": {
            "num_workers": "2",
            "worker_size": {
                "cpu": 1,
                "memory": "4g"
            },
            "driver_size": {
                "cpu": 1,
                "memory": "4g"
            }
        }
    },
    "application_arguments": [],
    "application_jar": "/kms-app/InMemoryKMS.py",
    "main_class": "org.apache.spark.deploy.SparkSubmit"
}

Il contenuto del file di lavoro Scala 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

Argomento principale: Librerie e script