Kategorien:: Verschlüsselungsfunktionen

DECRYPT_RAW¶

Entschlüsselt einen BINARY-Wert mithilfe eines BINARY-Schlüssels.

Siehe auch:: ENCRYPT, ENCRYPT_RAW, DECRYPT, TRY_DECRYPT, TRY_DECRYPT_RAW

Syntax¶

DECRYPT_RAW( <value_to_decrypt> , <key> , <iv> ,
         [ [ [ <additional_authenticated_data> , ] <encryption_method> , ] <aead_tag> ]
       )

Copy

Argumente¶

Erforderlich:

value_to_decrypt

Der zu entschlüsselnde Binärwert.

key

Der Schlüssel zum Ver-/Entschlüsseln der Daten. Der Schlüssel muss ein BINARY-Wert sein. Der Schlüssel kann ein beliebiger Wert sein, solange die Länge korrekt ist. Für AES128 muss der Schlüssel beispielsweise 128 Bit (16 Byte) sein, und für AES256 muss der Schlüssel 256 Bit (32 Byte) sein.

Der zum Verschlüsseln des Werts verwendete Schlüssel muss zum Entschlüsseln des Werts verwendet werden.

iv

Dieser Parameter enthält den Initialisierungsvektor (IV), mit dem diese Daten verschlüsselt und entschlüsselt werden. Der IV muss ein BINARY-Wert einer bestimmten Länge sein:

Für GCM muss dieses Feld 96 Bit (12 Byte) lang sein. Bei der Verschlüsselungsmethode GCM kann dieses Feld zwar auch eine andere Größe haben, aber Snowflake unterstützt derzeit nur 96 Bit.
Für CCM sollten dies 56 Bit (7 Byte) sein.
Für ECB wird dieser Parameter nicht benötigt.
Für alle anderen unterstützten Verschlüsselungsmodi sollten dies 128 Bit (16 Byte) sein.

Dieser Wert wird verwendet, um die erste Verschlüsselungsrunde zu initialisieren. Sie sollten dieselbe Kombination aus IV und Schlüssel niemals mehr als einmal verwenden, insbesondere für Verschlüsselungsmodi wie GCM.

Wenn dieser Parameter auf NULL gesetzt ist, wählt die Implementierung bei jedem Aufruf einen neuen Pseudozufalls-IV.

Optional:

additional_authenticated_data

Zusätzliche authentifizierte Daten (AAD) sind zusätzliche Daten, deren Vertraulichkeit und Authentizität während des Entschlüsselungsprozesses sichergestellt sind. Diese AAD sind jedoch nicht verschlüsselt und nicht als ein Feld im Rückgabewert der Funktionen ENCRYPT und ENCRYPT_RAW enthalten.

Wenn AAD an die Verschlüsselungsfunktion (ENCRYPT oder ENCRYPT_RAW) übergeben werden, müssen dieselben AAD an die Entschlüsselungsfunktion (DECRYPT oder DECRYPT_RAW) übergeben werden. Wenn die an die Entschlüsselungsfunktion übergebenen AAD nicht mit den an die Verschlüsselungsfunktion übergebenen AAD übereinstimmen, schlägt die Entschlüsselung fehl.

Der Unterschied zwischen den AAD und der passphrase besteht darin, dass die Passphrase geheim gehalten werden soll (andernfalls ist die Verschlüsselung im Wesentlichen wertlos), während die AAD öffentlich gelassen werden können. Mithilfe der AAD wird authentifiziert, dass eine öffentliche Information und ein verschlüsselter Wert miteinander verknüpft sind. Der Beispielabschnitt zur ENCRYPT-Funktion enthält ein Beispiel, welches das Verhalten zeigt, wenn die AAD übereinstimmen, und das Verhalten, wenn diese nicht übereinstimmen.

Für ENCRYPT_RAW und DECRYPT_RAW sollten die AAD vom Datentyp BINARY sein. Für ENCRYPT und DECRYPT können die AAD entweder vom Datentyp VARCHAR oder BINARY sein und müssen nicht mit dem Datentyp des verschlüsselten Werts übereinstimmen.

Die AAD werden nur von AEAD-aktivierten Verschlüsselungsmodi wie GCM (Standard) unterstützt.

encryption_method

Diese Zeichenfolge gibt die Methode zum Ver-/Entschlüsseln der Daten an. Diese Zeichenfolge enthält Unterfelder:

<algorithm>-<mode> [ /pad: <padding> ]

Copy

algorithm ist derzeit beschränkt auf:

'AES': Wenn eine Passphrase übergeben wird (z. B. an ENCRYPT), verwendet die Funktion die AES-256-Verschlüsselung (256 Bit). Wenn ein Schlüssel übergeben wird (z. B. an ENCRYPT_RAW), verwendet die Funktion abhängig von der Schlüssellänge eine 128-Bit-, 192-Bit- oder 256-Bit-Verschlüsselung.

Bei algorithm muss die Groß-/Kleinschreibung nicht beachtet werden.

mode gibt an, welcher Blockverschlüsselungsmodus zum Verschlüsseln von Meldungen verwendet werden soll. Die folgende Tabelle zeigt, welche Modi unterstützt werden und welche dieser Modi das Auffüllen unterstützen:

Modus	Auffüllen	Beschreibung
`'ECB'`	Ja	Jeder Block wird einzeln mit dem Schlüssel verschlüsselt. Dieser Modus wird im Allgemeinen nicht empfohlen und ist nur aus Gründen der Kompatibilität mit externen Implementierungen enthalten.
`'CBC'`	Ja	Der verschlüsselte Block ist XORed mit dem vorherigen Block.
`'GCM'`	Nein	Der Galois/Counter-Modus ist ein Hochleistungs-Verschlüsselungsmodus, der AEAD-aktiviert ist. AEAD sichert zusätzlich die Authentizität und Vertraulichkeit der verschlüsselten Daten durch Generieren eines AEAD-Tags. Zudem unterstützt AEAD die AAD (zusätzliche authentifizierte Daten).
`'CTR'`	Nein	Counter-Modus.
`'OFB'`	Nein	Output-Feedback-Modus. Der Verschlüsselungstext ist XORed mit dem Klartext eines Blocks.
`'CFB'`	Nein	Cipher-Feedback-Modus ist eine Kombination aus OFB und CBC.

Bei mode muss die Groß-/Kleinschreibung nicht beachtet werden.

padding gibt an, wie Nachrichten aufgefüllt werden sollen, deren Länge nicht ein Vielfaches der Blockgröße beträgt. Das Auffüllen gilt nur für die Modi ECB und CBC. Für andere Modi wird das Auffüllen ignoriert. Mögliche Werte für das Auffüllen sind:

'PKCS': Verwendet PKCS5 zum Auffüllen von Blöcken.

'NONE': Kein Auffüllen. Der Benutzer muss sich um das Auffüllen kümmern, wenn der Modus ECB oder CBC verwendet wird.

Bei padding muss die Groß-/Kleinschreibung nicht beachtet werden.

Standardeinstellung: 'AES-GCM'.

Wenn mode nicht angegeben ist, wird GCM verwendet.

Wenn padding nicht angegeben ist, wird PKCS verwendet.

aead_tag: Dieser BINARY-Wert wird für AEAD-aktivierte Entschlüsselungsmodi benötigt, um die Authentizität und Vertraulichkeit der verschlüsselten Daten zu überprüfen. Verwenden Sie das AEAD-Tag, das von der Funktion ENCRYPT_RAW zurückgegeben wurde. Ein Beispiel unten zeigt, wie Sie auf diesen Wert zugreifen und ihn verwenden.

Rückgabewerte¶

Die Funktion gibt den entschlüsselten Wert zurück. Der Datentyp des zurückgegebenen Werts ist BINARY.

Nutzungshinweise¶

Verwenden Sie DECRYPT(), um mit ENCRYPT() verschlüsselte Daten zu entschlüsseln. Verwenden Sie nicht DECRYPT_RAW().
Verwenden Sie DECRYPT_RAW(), um mit ENCRYPT_RAW() verschlüsselte Daten zu entschlüsseln. Verwenden Sie nicht DECRYPT().
Die Parameter der Funktion sind aus Sicherheitsgründen maskiert. Vertrauliche Informationen wie die folgenden sind im Abfrageprotokoll und auch für Snowflake nicht sichtbar:
- Der zu verschlüsselnde oder zu entschlüsselnde Zeichenfolge- oder Binärwert.
- Die Passphrase oder der Schlüssel.
Die Funktionen verwenden eine FIPS-kompatible kryptografische Bibliothek, um die Ver- und Entschlüsselung effektiv durchzuführen.
Die Passphrase oder der Schlüssel zum Entschlüsseln eines Datenelements muss mit der Passphrase oder dem Schlüssel zum Verschlüsseln dieser Daten übereinstimmen.

Verwenden Sie beim Extrahieren von Feldern (Chiffretext, Initialisierungsvektor oder Tag) aus einem verschlüsselten Binärwert Folgendes:
```
as_binary(get(encrypted_value, '<field_name>'))
```
Copy
Verwenden Sie zum Beispiel:
```
as_binary(get(encrypted_value, 'ciphertext'))
```
Copy
Verwenden Sie nicht encrypted_value:field_name::binary. Der Feldzugriffsoperator : konvertiert den extrahierten Feldwert in eine Zeichenfolge. Da die Quelle jedoch BINARY ist, ist diese Zeichenfolge nicht immer eine gültige UTF-8-Zeichenfolge.

Beispiele¶

Dieses Beispiel zeigt die Ver- und Entschlüsselung.

Setzen Sie zur besseren Lesbarkeit BINARY_OUTPUT_FORMAT auf HEX:

ALTER SESSION SET BINARY_OUTPUT_FORMAT='HEX';

Copy

Erstellen Sie eine Tabelle, und laden Sie die Daten.

Vorsicht

Um dieses Beispiel zu vereinfachen, wird der Verschlüsselungs-/Entschlüsselungsschlüssel in der Tabelle gespeichert, die den verschlüsselten Wert enthält. Dieses Vorgehen ist unsicher. Der Schlüssel sollte niemals als unverschlüsselter Wert in der Tabelle gespeichert werden, die die verschlüsselten Daten speichert.

CREATE OR REPLACE TABLE binary_table (
    encryption_key BINARY,   -- DO NOT STORE REAL ENCRYPTION KEYS THIS WAY!
    initialization_vector BINARY(12), -- DO NOT STORE REAL IV'S THIS WAY!!
    binary_column BINARY,
    encrypted_binary_column VARIANT,
    aad_column BINARY);

INSERT INTO binary_table (encryption_key,
                          initialization_vector,
                          binary_column,
                          aad_column)
    SELECT SHA2_BINARY('NotSecretEnough', 256),
            SUBSTR(TO_BINARY(HEX_ENCODE('AlsoNotSecretEnough'), 'HEX'), 0, 12),
            TO_BINARY(HEX_ENCODE('Bonjour'), 'HEX'),
            TO_BINARY(HEX_ENCODE('additional data'), 'HEX')
    ;

Copy

Verschlüsseln:

UPDATE binary_table SET encrypted_binary_column =
    ENCRYPT_RAW(binary_column, 
        encryption_key, 
        initialization_vector, 
        aad_column,
        'AES-GCM');
+------------------------+-------------------------------------+
| number of rows updated | number of multi-joined rows updated |
|------------------------+-------------------------------------|
|                      1 |                                   0 |
+------------------------+-------------------------------------+

Copy

Dies zeigt den entsprechenden Aufruf der Funktion DECRYPT_RAW(). Der Initialisierungsvektor (IV) wird aus dem verschlüsselten Wert entnommen. Sie müssen den Initialisierungsvektor nicht separat speichern. In ähnlicher Weise wird auch das AEAD-Tag aus dem verschlüsselten Wert gelesen.

Vorsicht

Um dieses Beispiel zu vereinfachen, wird der Verschlüsselungs-/Entschlüsselungsschlüssel aus der Tabelle gelesen, die den verschlüsselten Wert enthält. Dieses Vorgehen ist unsicher. Der Schlüssel sollte niemals als unverschlüsselter Wert in der Tabelle gespeichert werden, die die verschlüsselten Daten speichert.

SELECT 'Bonjour' as original_value,
       binary_column,
       hex_decode_string(to_varchar(binary_column)) as decoded,
       encrypted_binary_column,
       decrypt_raw(as_binary(get(encrypted_binary_column, 'ciphertext')),
                  encryption_key,
                  as_binary(get(encrypted_binary_column, 'iv')),
                  aad_column,
                  'AES-GCM',
                  as_binary(get(encrypted_binary_column, 'tag')))
           as decrypted,
       hex_decode_string(to_varchar(decrypt_raw(as_binary(get(encrypted_binary_column, 'ciphertext')),
                  encryption_key,
                  as_binary(get(encrypted_binary_column, 'iv')),
                  aad_column,
                  'AES-GCM',
                  as_binary(get(encrypted_binary_column, 'tag')))
                  ))
           as decrypted_and_decoded
    FROM binary_table;
+----------------+----------------+---------+---------------------------------------------+----------------+-----------------------+
| ORIGINAL_VALUE | BINARY_COLUMN  | DECODED | ENCRYPTED_BINARY_COLUMN                     | DECRYPTED      | DECRYPTED_AND_DECODED |
|----------------+----------------+---------+---------------------------------------------+----------------+-----------------------|
| Bonjour        | 426F6E6A6F7572 | Bonjour | {                                           | 426F6E6A6F7572 | Bonjour               |
|                |                |         |   "ciphertext": "CA2F4A383F6F55",           |                |                       |
|                |                |         |   "iv": "416C736F4E6F745365637265",         |                |                       |
|                |                |         |   "tag": "91F28FBC6A2FE9B213D1C44B8D75D147" |                |                       |
|                |                |         | }                                           |                |                       |
+----------------+----------------+---------+---------------------------------------------+----------------+-----------------------+

Copy

Im vorherigen Beispiel wurde ein langer Aufruf von DECRYPT_RAW() dupliziert. Sie können eine WITH-Klausel verwenden, um die Duplizierung zu reduzieren:

WITH
    decrypted_but_not_decoded as (
        decrypt_raw(as_binary(get(encrypted_binary_column, 'ciphertext')),
                      encryption_key,
                      as_binary(get(encrypted_binary_column, 'iv')),
                      aad_column,
                      'AES-GCM',
                      as_binary(get(encrypted_binary_column, 'tag')))
    )
SELECT 'Bonjour' as original_value,
       binary_column,
       hex_decode_string(to_varchar(binary_column)) as decoded,
       encrypted_binary_column,
       decrypted_but_not_decoded,
       hex_decode_string(to_varchar(decrypted_but_not_decoded))
           as decrypted_and_decoded
    FROM binary_table;
+----------------+----------------+---------+---------------------------------------------+---------------------------+-----------------------+
| ORIGINAL_VALUE | BINARY_COLUMN  | DECODED | ENCRYPTED_BINARY_COLUMN                     | DECRYPTED_BUT_NOT_DECODED | DECRYPTED_AND_DECODED |
|----------------+----------------+---------+---------------------------------------------+---------------------------+-----------------------|
| Bonjour        | 426F6E6A6F7572 | Bonjour | {                                           | 426F6E6A6F7572            | Bonjour               |
|                |                |         |   "ciphertext": "CA2F4A383F6F55",           |                           |                       |
|                |                |         |   "iv": "416C736F4E6F745365637265",         |                           |                       |
|                |                |         |   "tag": "91F28FBC6A2FE9B213D1C44B8D75D147" |                           |                       |
|                |                |         | }                                           |                           |                       |
+----------------+----------------+---------+---------------------------------------------+---------------------------+-----------------------+

Copy