- Catégories :
DECRYPT_RAW¶
Déchiffre une valeur BINARY à l’aide d’une clé BINARY.
- Voir aussi :
ENCRYPT , ENCRYPT_RAW , DECRYPT , TRY_DECRYPT , TRY_DECRYPT_RAW
Syntaxe¶
DECRYPT_RAW( <value_to_decrypt> , <key> , <iv> ,
[ [ [ <additional_authenticated_data> , ] <encryption_method> , ] <aead_tag> ]
)
Arguments¶
Obligatoire :
value_to_decryptLa valeur binaire à déchiffrer.
keyLa clé à utiliser pour chiffrer/déchiffrer les données. La clé doit être une valeur BINARY. La clé peut avoir n’importe quelle valeur tant que la longueur est correcte. Par exemple, pour AES128, la clé doit être de 128 bits (16 octets) et pour AES256, la clé doit être de 256 bits (32 octets).
La clé utilisée pour chiffrer la valeur doit être utilisée pour déchiffrer la valeur.
ivCe paramètre contient le vecteur d’initialisation (IV) à utiliser pour chiffrer et déchiffrer cette donnée. L’IV doit être une valeur BINARY d’une longueur spécifique :
Pour GCM, ce champ doit être de 96 bits (12 octets). Alors que la méthode de chiffrement GCM permet à ce champ d’être d’une taille différente, Snowflake ne prend actuellement en charge que 96 bits.
Pour CCM, cela doit être 56 bits (7 octets).
Pour ECB, ce paramètre est inutile.
Pour tous les autres modes de chiffrement pris en charge, il doit s’agir de 128 bits (16 octets).
Cette valeur est utilisée pour initialiser le premier tour de chiffrement. Vous ne devez jamais utiliser le même IV ni la même combinaison de clés plus d’une fois, en particulier pour les modes de chiffrement comme GCM.
Si ce paramètre est défini sur NULL, l’implémentation choisira un nouveau IV pseudo-aléatoire lors de chaque appel.
Facultatif :
additional_authenticated_dataLes données authentifiées supplémentaires (AAD) sont des données supplémentaires dont la confidentialité et l’authenticité sont assurées pendant le processus de déchiffrement. Cependant, cet AAD n’est pas chiffré et n’est pas inclus en tant que champ dans la valeur renvoyée par la fonction ENCRYPT ou ENCRYPT_RAW.
Si AAD est transmis à la fonction de chiffrement (ENCRYPT ou ENCRYPT_RAW), alors le même AAD doit être transmis à la fonction de déchiffrement (DECRYPT ou DECRYPT_RAW). Si l’AAD transmis à la fonction de déchiffrement ne correspond pas à l’AAD transmis à la fonction de chiffrement, le déchiffrement échoue.
La différence entre l’AAD et la
passphraseest que la phrase secrète est destinée à être gardée secrète (sinon, le chiffrement est essentiellement sans valeur) tandis que l’AAD peut être laissé public. L’AAD permet d’authentifier qu’une information publique et une valeur chiffrée sont associées l’une à l’autre. La section d’exemples de la fonction ENCRYPT inclut un exemple montrant le comportement lorsque l’AAD correspond et le comportement lorsqu’il ne correspond pas.Pour ENCRYPT_RAW et DECRYPT_RAW, le type de données d’AAD doit être BINARY. Pour ENCRYPT et DECRYPT, le type de données d’AAD peut être VARCHAR ou BINARY, et n’a pas besoin de correspondre au type de données de la valeur qui a été chiffrée.
AAD est pris en charge uniquement par les modes de chiffrement activés par AEAD comme GCM (par défaut).
encryption_methodCette chaîne spécifie la méthode à utiliser pour chiffrer/déchiffrer les données. Cette chaîne contient des sous-champs :
<algorithm>-<mode> [ /pad: <padding> ]
L”
algorithmest actuellement limité à :'AES': lorsqu’une phrase secrète est transmise (par exemple à ENCRYPT), la fonction utilise le chiffrement AES-256 (256 bits). Lorsqu’une clé est transmise (par exemple à ENCRYPT_RAW), la fonction utilise un chiffrement de 128, 192 ou 256 bits, en fonction de la longueur de la clé.
L”
algorithmest insensible à la casse.Le
modespécifie le mode de chiffrement par bloc à utiliser pour chiffrer les messages. Le tableau suivant montre quels modes sont pris en charge et lesquels de ces modes prennent en charge le remplissage :Mode
Remplissage
Description
'ECB'Oui
Chiffrer chaque bloc individuellement avec la clé. Ce mode est généralement déconseillé et n’est inclus que pour des raisons de compatibilité avec les implémentations externes.
'CBC'Oui
Le bloc chiffré est XORed avec le bloc précédent.
'GCM'Non
Le mode Galois/compteur est un mode de chiffrement hautes performances activé par AEAD. AEAD assure en outre l’authenticité et la confidentialité des données chiffrées en générant une balise AEAD. De plus, AEAD prend en charge AAD (données authentifiées supplémentaires).
'CTR'Non
Mode compteur.
'OFB'Non
Retour de sortie. Le texte chiffré est XORed avec le texte brut d’un bloc.
'CFB'Non
Le retour de chiffrement est une combinaison de OFB et CBC.
Le
modeest insensible à la casse.Le
paddingspécifie comment remplir les messages dont la longueur n’est pas un multiple de la taille du bloc. Le remplissage est applicable uniquement pour les modes ECB et CBC ; le remplissage est ignoré pour les autres modes. Les valeurs possibles pour le remplissage sont les suivantes :'PKCS': utilise PKCS5 pour le remplissage de bloc.'NONE': pas de remplissage. L’utilisateur doit prendre soin du remplissage lors de l’utilisation du mode ECB ou CBC.
Le
paddingest insensible à la casse.Paramètre par défaut :
'AES-GCM'.Si le
moden’est pas spécifié, GCM est utilisé.Si le
paddingn’est pas spécifié, PKCS est utilisé.
aead_tagCette valeur BINARY est nécessaire pour les modes de déchiffrement compatibles avec AEAD pour vérifier l’authenticité et la confidentialité des données chiffrées. Utilisez la balise AEAD renvoyée par la fonction ENCRYPT_RAW. Un exemple ci-dessous montre comment accéder à cette valeur et l’utiliser.
Renvoie¶
La fonction renvoie la valeur déchiffrée. Le type de données de la valeur renvoyée est BINARY.
Notes sur l’utilisation¶
Pour déchiffrer les données chiffrées par
ENCRYPT(), utilisezDECRYPT(). N’utilisez pasDECRYPT_RAW().Pour déchiffrer les données chiffrées par
ENCRYPT_RAW(), utilisezDECRYPT_RAW(). N’utilisez pasDECRYPT().Les paramètres de la fonction sont masqués pour des raisons de sécurité. Les informations sensibles telles que les suivantes ne sont pas visibles dans le journal des requêtes et ne sont pas visibles par Snowflake :
Chaîne ou valeur binaire à chiffrer ou à déchiffrer.
La phrase secrète ou la clé.
Les fonctions utilisent une bibliothèque cryptographique compatible FIPS pour effectuer efficacement le chiffrement et le déchiffrement.
La phrase secrète ou la clé utilisée pour déchiffrer une donnée doit être la même que la phrase secrète ou la clé utilisée pour chiffrer ces données.
Lors de l’extraction de champs (texte chiffré, vecteur d’initialisation ou balise) à partir d’une valeur binaire chiffrée, utilisez :
as_binary(get(encrypted_value, '<field_name>'))
Par exemple, utilisez :
as_binary(get(encrypted_value, 'ciphertext'))
N’utilisez pas
encrypted_value:field_name::binary. L’opérateur d’accès au champ:convertit la valeur de champ extraite en une chaîne ; cependant, comme la source est BINARY, cette chaîne n’est pas toujours une chaîne UTF-8 valide.
Exemples¶
Cet exemple montre le chiffrement et le déchiffrement.
Pour plus de lisibilité, définissez BINARY_OUTPUT_FORMAT sur HEX :
ALTER SESSION SET BINARY_OUTPUT_FORMAT='HEX';Créez une table et chargez les données.
Prudence
Pour simplifier cet exemple, la clé de chiffrement/déchiffrement est stockée dans la table avec la valeur qui a été chiffrée. Cela n’est pas sûr ; la clé ne devrait jamais être stockée en tant que valeur non chiffrée dans la table qui stocke les données chiffrées.
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') ;Chiffrer :
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 | +------------------------+-------------------------------------+Cela montre l’appel correspondant à la fonction
DECRYPT_RAW(). Le vecteur d’initialisation (IV) est tiré de la valeur chiffrée ; vous n’avez pas besoin de stocker le vecteur d’initialisation séparément. De même, la balise AEAD est également lue à partir de la valeur chiffrée.Prudence
Pour simplifier cet exemple, la clé de chiffrement/déchiffrement est lue dans la table avec la valeur qui a été chiffrée. Cela n’est pas sûr ; la clé ne devrait jamais être stockée en tant que valeur non chiffrée dans la table qui stocke les données chiffrées.
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" | | | | | | | } | | | +----------------+----------------+---------+---------------------------------------------+----------------+-----------------------+L’exemple précédent a dupliqué un long appel vers
DECRYPT_RAW(). Vous pouvez utiliser une clause WITH pour réduire la duplication :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" | | | | | | | } | | | +----------------+----------------+---------+---------------------------------------------+---------------------------+-----------------------+