Tous les produits
Search

Ce produit

    MaxCompute:Fonctions de chiffrement

    Centre de documentation

    MaxCompute:Fonctions de chiffrement

    Dernière mise à jour :Sep 15, 2026

    MaxCompute SQL propose des fonctions de chiffrement et de déchiffrement pour sécuriser vos données. Cette rubrique détaille la syntaxe, les paramètres et les exemples relatifs aux fonctions de chiffrement.

    Chiffrement des données dans MaxCompute

    • Chiffrement à clé unique : vous permet de générer une clé unique pour chiffrer ou déchiffrer aléatoirement des colonnes spécifiques. Vous êtes responsable du stockage de la clé générée.

      单一密钥加密.jpg

      Le tableau suivant décrit les fonctions de chiffrement et de déchiffrement à clé unique dans MaxCompute SQL.

      Fonction

      Description

      SYM_DECRYPT

      Déchiffre une colonne spécifiée, chiffrée de manière aléatoire, et renvoie le texte en clair sous forme de type BINARY.

      SYM_ENCRYPT

      Chiffre aléatoirement une colonne spécifiée et renvoie le texte chiffré sous forme de type BINARY.

    • Chiffrement à clés multiples : un keyset est un objet de gestion des clés dans MaxCompute qui peut contenir une ou plusieurs clés. Vous pouvez ajouter manuellement des clés à un keyset, effectuer une rotation des clés et afficher les clés d'origine.

      多密钥加密.jpg

      Le tableau suivant décrit les fonctions de chiffrement et de déchiffrement à clés multiples dans MaxCompute SQL.

      Fonction

      Description

      NEW_KEYSET

      Crée un keyset basé sur un type d'algorithme spécifié.

      ADD_KEY_TO_KEYSET

      Ajoute une nouvelle clé à un keyset et la définit comme clé principale.

      KEYSET_TO_JSON

      Convertit un keyset de type BINARY au format JSON lisible par l'homme afin que vous puissiez consulter ses détails.

      KEYSET_FROM_JSON

      Convertit une chaîne de keyset au format JSON vers le type BINARY.

      ROTATE_KEYSET

      Génère une nouvelle clé et la définit comme clé principale.

    • Chiffrement à clés multiples avec intégration KMS : MaxCompute s'intègre à KMS pour le chiffrement des données. MaxCompute génère un keyset de base et le chiffre avec une clé maître client (CMK) issue de KMS pour créer un keyset encapsulé (wrapped keyset). Vous êtes responsable du stockage de ce keyset encapsulé. Pour déchiffrer les données, vous devez fournir le keyset encapsulé. MaxCompute utilise ensuite la CMK KMS pour déchiffrer le keyset encapsulé en un keyset de base, qu'il utilise ensuite pour déchiffrer les données.

      keyset.jpg

      Le tableau suivant décrit les fonctions de chiffrement et de déchiffrement à clés multiples avec intégration KMS dans MaxCompute SQL.

      Fonction

      Description

      NEW_WRAPPED_KEYSET

      Crée un nouveau keyset encapsulé. Cette opération nécessite un rôle (spécifié par role_arn) disposant de l'autorisation d'utiliser une clé maître client (CMK) KMS. Vous pouvez éventuellement spécifier une chaîne de rôles (spécifiée par role_chain) pour permettre à d'autres comptes Alibaba Cloud de déchiffrer le keyset.

      REWRAP_KEYSET

      Rechiffre un keyset encapsulé à l'aide d'une clé KMS spécifiée.

      ROTATE_WRAPPED_KEYSET

      Déchiffre un keyset encapsulé existant, effectue une rotation des clés internes, puis le rechiffre avec la clé KMS d'origine.

      USE_WRAPPED_KEYSET

      Déchiffre un keyset encapsulé en un keyset de base pour l'utiliser comme paramètre dans les fonctions de chiffrement ou de déchiffrement. Vous pouvez également utiliser cette fonction pour afficher les métadonnées du keyset encapsulé à des fins de maintenance.

      ENHANCED_SYM_ENCRYPT

      Chiffre les données à l'aide d'un keyset spécifié.

      ENHANCED_SYM_DECRYPT

      Déchiffre les données à l'aide d'un keyset spécifié.

    Notes

    Après la mise à niveau vers MaxCompute 2.0, certaines fonctions ont été étendues. Pour utiliser des fonctions impliquant les nouveaux types de données (TINYINT, SMALLINT, INT, FLOAT, VARCHAR, TIMESTAMP ou BINARY), exécutez l'instruction suivante pour activer le nouveau système de types de données :

    • Au niveau de la session : pour utiliser les nouveaux types de données, ajoutez set odps.sql.type.system.odps2=true; avant votre instruction SQL et soumettez-les ensemble.

    • Au niveau du projet : le propriétaire du projet peut configurer ce paramètre selon les besoins. La configuration prend effet après 10 à 15 minutes. Utilisez la commande suivante :

      setproject odps.sql.type.system.odps2=true;

      Pour plus d'informations sur setproject, consultez Opérations sur les projets. Pour les notes relatives à l'activation des types de données au niveau du projet, consultez Guide des versions des types de données.

    SYM_DECRYPT

    • Syntaxe

      binary sym_decrypt(binary <value_to_decrypt>,
                   binary <key>
                   [,string <encryption_method> ,
                    [ string <additional_authenticated_data> ]
                   ]
                  )

    • Description

      Déchiffre les données chiffrées de manière aléatoire dans une colonne de table spécifiée.

    • Paramètres

      • value_to_decrypt : obligatoire. Les données à déchiffrer, qui doivent être de type BINARY.

      • key : obligatoire. La clé de déchiffrement. Il doit s'agir d'une valeur BINARY de 256 bits.

      • encryption_method : facultatif. La méthode de chiffrement. Vous devez spécifier la même méthode que celle utilisée pour chiffrer les données.

      • additional_authenticated_data : facultatif. Les données d'authentification supplémentaires (AAD) permettant de vérifier l'authenticité et l'intégrité des données. Si vous avez fourni des AAD lors du chiffrement, vous devez également les fournir pour le déchiffrement.

    • Valeur de retour

      Renvoie le texte en clair sous forme de type BINARY. Si nécessaire, vous pouvez utiliser la fonction CAST pour convertir les données BINARY au type STRING.

    • Exemples

      Les exemples suivants montrent comment déchiffrer les données d'une table qui ont été chiffrées avec la fonction SYM_ENCRYPT.

      • Exemple 1 : déchiffrez des données chiffrées avec une clé en texte clair.

        -- Decrypt the id_card_no column.
INSERT OVERWRITE TABLE mf_user_info
SELECT id,
       name,
       gender,
       CAST(sym_decrypt(unbase64(id_card_no),
                        CAST('b75585cf321cdcad42451690cdb7bfc4' AS BINARY)
                       ) AS STRING) AS id_card_no,
       tel
FROM mf_user_info;

-- Query the decrypted data.
SELECT * FROM mf_user_info;

      • Exemple 2 : déchiffrez des données chiffrées avec une table de clés.

        -- Decrypt the id_card_no column with AAD verification.
INSERT OVERWRITE TABLE mf_user_info
SELECT id,
       name,
       gender,
       CAST(sym_decrypt(unbase64(id_card_no),
                        CAST('b75585cf321cdcad42451690cdb7bfc4' AS BINARY),
                        'AES-GCM-256',
                        'test'
                       ) AS STRING) AS id_card_no,
       tel
FROM mf_user_info;

-- Query the decrypted data.
SELECT * FROM mf_user_info;

        La commande renvoie le résultat suivant :

        +------------+------+--------+------------+-------------+
| id         | name | gender | id_card_no | tel         |
+------------+------+--------+------------+-------------+
| 1          | bob  | male   | 0001       | 13900001234 |
| 2          | allen| male   | 0011       | 13900001111 |
| 3          | kate | female | 0111       | 13900002222 |
| 4          | annie| female | 1111       | 13900003333 |
+------------+------+--------+------------+-------------+

    SYM_ENCRYPT

    • Syntaxe

      binary sym_encrypt(string|binary <value_to_encrypt>,
                   binary <key>
                   [,string <encryption_method> ,
                      [ string <additional_authenticated_data> ]
                    ]
                  )

    • Description

      Chiffre une colonne spécifiée à l'aide d'un chiffrement randomisé.

    • Paramètres

      • value_to_encrypt : obligatoire. Les données à chiffrer. Seuls les types STRING et BINARY sont pris en charge.

      • key : obligatoire. La clé de chiffrement. Elle doit être longue de 256 bits et de type BINARY.

      • encryption_method : facultatif. La méthode de chiffrement. Le seul algorithme pris en charge est AES-GCM-256, qui est la valeur par défaut.

      • additional_authenticated_data : facultatif. Les données d'authentification supplémentaires (AAD) utilisées pour vérifier l'authenticité et l'intégrité des données. Ce paramètre est pris en charge uniquement par les algorithmes de chiffrement authentifié avec données associées (AEAD), tels que AES-GCM.

    • Valeur de retour

      Renvoie le texte chiffré sous forme de valeur BINARY.

      • La valeur de retour contient le vecteur d'initialisation (IV), le texte chiffré et la balise AEAD, dans cet ordre.

      • La fonction est non déterministe, ce qui signifie qu'elle renvoie un texte chiffré différent pour chaque chiffrement, même avec le même texte en clair et la même clé.

    • Données d'exemple

      -- Create the table.
create table mf_user_info(id bigint,
                          name string,
                          gender string,
                          id_card_no string,
                          tel string);

-- Insert sample data.
insert overwrite table mf_user_info values(1,"bob","male","0001","13900001234"),
                                           (2,"allen","male","0011","13900001111"),
                                           (3,"kate","female","0111","13900002222"),
                                           (4,"annie","female","1111","13900003333");

-- Query the table.
select * from mf_user_info;

    • Exemple 1 : chiffrez des données à l'aide d'une clé en texte clair

      Chiffrez les colonnes de la table mf_user_info en vous basant sur les données d'exemple. Exécutez la commande suivante :

      • Chiffrement avec AES-GCM-256 (sans AAD)

        -- Encrypt the id_card_no column.
insert overwrite table mf_user_info
select id,
       name,
       gender,
       base64(sym_encrypt(id_card_no,
                cast('b75585cf321cdcad42451690cdb7bfc4' as binary)
              )) as id_card_no,
       tel
from mf_user_info;

select * from mf_user_info;

        Résultat :

        +------------+------+--------+------------+-----+
| id         | name | gender | id_card_no | tel |
+------------+------+--------+------------+-----+
| 1          | bob  | male   | frgJZAEAQMeEuHqpS8lK9VxQhgPYpZ317V+oUla/xEc= | 13900001234|
| 2          | allen| male   | frgJZAIAQMeEuHqpLeXQfETsFSLJxBwHhPx6tpzWUg4= | 13900001111|
| 3          | kate | female | frgJZAMAQMeEuHqpdphXAU6iWelWenlDnVy+R0HMvAY= | 13900002222|
| 4          | annie| female | frgJZAQAQMeEuHqpR5c8bj21dYCeM0C25bLRZIrP71c= | 13900003333|
+------------+------+--------+------------+-----+

      • Chiffrement avec AES-GCM-256 et AAD

        Transmettez une valeur AAD pour lier le texte chiffré à un contexte spécifique. Le déchiffrement échoue si l'AAD ne correspond pas.

        -- Encrypt the id_card_no column with AAD.
insert overwrite table mf_user_info
select id,
       name,
       gender,
       base64(sym_encrypt(id_card_no,
                cast('b75585cf321cdcad42451690cdb7bfc4' as binary),
                'AES-GCM-256',
                'test'
              )) as id_card_no,
       tel
from mf_user_info;

select * from mf_user_info;

        Résultat :

        +------------+------+--------+------------+-----+
| id         | name | gender | id_card_no | tel |
+------------+------+--------+------------+-----+
| 1          | bob  | male   | gJ0QaAEAoGGWVw90H/zETg... | 13900001234|
| 2          | allen| male   | gJ0QaAIAoGGWVw90TpNFC0... | 13900001111|
| 3          | kate | female | gJ0QaAMAoGGWVw90KaQ8Vm... | 13900002222|
| 4          | annie| female | gJ0QaAQAoGGWVw90nYCAS1... | 13900003333|
+------------+------+--------+------------+-----+

    • Exemple 2 : chiffrez des données à l'aide d'une table de clés

      Pour éviter de transmettre des clés en texte clair dans SQL, stockez les clés dans une table MaxCompute et joignez-la à la table cible au moment du chiffrement.

      Notes sur la gestion des clés :

      • Vous êtes responsable de la création et de la gestion des clés. MaxCompute ne stocke pas les clés ni aucune correspondance entre les clés et le texte chiffré. Si une clé est perdue, les données chiffrées ne peuvent pas être récupérées.

      • Pour empêcher l'exposition des clés, n'accordez pas d'accès direct à la table de clés. Créez plutôt une vue sécurisée qui appelle la fonction de déchiffrement ; les utilisateurs accèdent aux données via la vue sans jamais voir la clé en texte clair.

      • Si les données à chiffrer sont de type BINARY, exécutez set odps.sql.type.system.odps2=true; pour activer l'édition des types de données MaxCompute V2.0.

      -- Create a key table.
create table mf_id_key(id bigint, key binary);

-- Insert a key.
insert overwrite table mf_id_key
  values (1, cast('b75585cf321cdcad42451690cdb7bfc4' as binary));

-- Verify the key table.
select * from mf_id_key;

      Résultat :

      +------------+----------------------------------+
| id         | key                              |
+------------+----------------------------------+
| 1          | b75585cf321cdcad42451690cdb7bfc4 |
+------------+----------------------------------+
      -- Encrypt the id_card_no column using the key table.
insert overwrite table mf_user_info
select /*+mapjoin(b)*/
      a.id,
      a.name,
      a.gender,
      base64(sym_encrypt(a.id_card_no, b.key)) as id_card_no,
      a.tel
from mf_user_info as a join mf_id_key as b on a.id >= b.id;

-- Query the encrypted result.
select * from mf_user_info;

      Résultat :

      +------------+------+--------+------------+-----+
| id         | name | gender | id_card_no | tel |
+------------+------+--------+------------+-----+
| 1          | bob  | male   | 9esKZAEAoBquXVJo3ZptvoI09XuM4bSFTqF1mXH1BO4= | 13900001234|
| 2          | allen| male   | 9esKZAIAoBquXVJoJYqnXieAANih7FR59luePvdHB9U= | 13900001111|
| 3          | kate | female | 9esKZAMAoBquXVJoppwxgVwPYBnvjIMklWLmJ/sU0Y8= | 13900002222|
| 4          | annie| female | 9esKZAQAoBquXVJoB85RUFCLMbdyEBSz7LdS4M3Guvk= | 13900003333|
+------------+------+--------+------------+-----+

    NEW_KEYSET

    • Syntaxe

      binary NEW_KEYSET(string <key_type>, [string <description>])

    • Description

      Crée un keyset basé sur le type d'algorithme spécifié.

    • Paramètres

      • key_type : obligatoire. Le type d'algorithme utilisé pour créer une clé de données. Les algorithmes pris en charge incluent AES-GCM-256, AES-SIV-CMAC-128 et AES-SIV-CMAC-256.

      • description : facultatif. La description de la clé de données.

    • Valeur de retour

      Renvoie un keyset de type BINARY.

      Remarque

      Vous pouvez utiliser la fonction HEX pour convertir une valeur BINARY en valeur STRING, et la fonction UNHEX pour convertir une valeur STRING en valeur BINARY.

    • Exemple

      select hex(NEW_KEYSET('AES-GCM-256', 'hello world'));

      Le résultat suivant est renvoyé.

      +------------+
| _c0        |
+------------+
| 0A10577567735A514541554D42776E684C4212580A330A0B4145532D47434D2D323536122017F7A430B9D4B59B55454FD4B486216059F1B748CE0502D901EBEACEAB6569191801200210011A10577567735A514541554D42776E684C4220022A0B68656C6C6F20776F726C64 |
+------------+

    ADD_KEY_TO_KEYSET

    • Syntaxe

      binary ADD_KEY_TO_KEYSET(binary <keyset>, string <key_type>, binary <raw_key>, [string <description>])

    • Description

      Ajoute une clé à un keyset et configure la clé comme clé principale.

    • Paramètres

      • keyset : obligatoire. Ce paramètre spécifie un keyset existant de type BINARY.

      • key_type : obligatoire. Ce paramètre spécifie le type d'algorithme de la clé que vous souhaitez ajouter. Valeurs valides : AES-GCM-256, AES-SIV-CMAC-128 et AES-SIV-CMAC-256.

      • raw_key : obligatoire. Ce paramètre spécifie la clé que vous souhaitez ajouter et configurer comme clé principale. La clé est de type BINARY.

      • description : facultatif. Ce paramètre fournit une description de la clé de données.

    • Valeur de retour

      Renvoie un keyset BINARY.

      Remarque

      Vous pouvez utiliser la fonction HEX pour convertir les valeurs BINARY en STRING, et la fonction UNHEX pour convertir les valeurs STRING en BINARY.

    • Exemple

      select hex(ADD_KEY_TO_KEYSET(unhex ('0A1072384D715A414541385044643351534C12580A330A0B4145532D47434D2D323536122026A8FB1126DF4F5B5DD03C180E6919565D7716CBB291815EFB5BBF30F8BEF9AF1801200210011A1072384D715A414541385044643351534C20022A0B68656C6C6F20776F726C64'), 'AES-SIV-CMAC-128', unhex('b75585cf321cdcad42451690cdb7bfc49c26092f60f854e72d43244c55620a3d'),'description') );

      Le résultat suivant est renvoyé :

      +------------+
| _c0        |
+------------+
| 0A10596530735A5145414150447273424C4212580A330A0B4145532D47434D2D323536122026A8FB1126DF4F5B5DD03C180E6919565D7716CBB291815EFB5BBF30F8BEF9AF1801200210011A1072384D715A414541385044643351534C20022A0B68656C6C6F20776F726C64125D0A380A104145532D5349562D434D41432D3132381220B75585CF321CDCAD42451690CDB7BFC49C26092F60F854E72D43244C55620A3D1801200110011A10596530735A5145414150447273424C4220022A0B6465736372697074696F6E |
+------------+

    KEYSET_FROM_JSON

    • Syntaxe

      BINARY KEYSET_FROM_JSON(STRING <json_keyset>)

    • description

      La fonction KEYSET_FROM_JSON convertit une chaîne keyset au format JSON vers le type BINARY.

    • Paramètres

      json_keyset : Obligatoire. STRING. Chaîne keyset au format JSON.

    • Valeur renvoyée

      Renvoie le keyset sous forme de valeur BINARY.

      Remarque

      Pour convertir entre les valeurs BINARY et STRING, utilisez les fonctions HEX et UNHEX.

    • Exemple

      SELECT HEX(KEYSET_FROM_JSON('{
    "key": [{
            "description": "hello world",
            "key_id": "r8MqZAEA8PDd3QSL",
            "key_meta_data": {
                "key_material_origin": "Origin_ALIYUN_MAXCOMPUTE",
                "key_material_type": "SYMMETRIC",
                "type": "AES-GCM-256",
                "value": "Jqj7ESbfT1td0DwYDmkZVl13FsuykYFe+1u/MPi++a8="},
            "output_prefix_type": "PREFIX_ALIYUN_MAXCOMPUTE",
            "status": "ENABLED"}],
    "primary_key_id": "r8MqZAEA8PDd3QSL"}')) ;

      La requête renvoie le résultat suivant :

      +------------+
| _c0        |
+------------+
| 0A1072384D715A414541385044643351534C12580A330A0B4145532D47434D2D323536122026A8FB1126DF4F5B5DD03C180E6919565D7716CBB291815EFB5BBF30F8BEF9AF1801200210011A1072384D715A414541385044643351534C20022A0B68656C6C6F20776F726C64 |
+------------+

    KEYSET_TO_JSON

    • Syntaxe

      STRING KEYSET_TO_JSON(BINARY <keyset>)

    • description

      Convertit un keyset de type BINARY en une chaîne JSON lisible. Après la conversion, vous pouvez consulter les détails du keyset.

    • Paramètres

      keyset : obligatoire. Valeur de type BINARY. Ce paramètre spécifie un keyset existant.

    • Valeur renvoyée

      Un keyset au format JSON est renvoyé. description des paramètres :

      • key_id : ID de la clé.

      • key_material_origin : origine de la clé.

      • key_material_type : type de chiffrement de la clé.

      • type : type d'algorithme de la clé.

      • value : valeur de la clé.

      • output_prefix_type : format du texte chiffré après le chiffrement.

      Remarque

      Vous pouvez utiliser HEX pour convertir le type BINARY en type STRING ou utiliser UNHEX pour convertir le type STRING en type BINARY selon vos besoins métier.

    • Exemples

      SELECT KEYSET_TO_JSON(unhex ('0A1072384D715A414541385044643351534C12580A330A0B4145532D47434D2D323536122026A8FB1126DF4F5B5DD03C180E6919565D7716CBB291815EFB5BBF30F8BEF9AF1801200210011A1072384D715A414541385044643351534C20022A0B68656C6C6F20776F726C64')) ;

      Le résultat suivant est renvoyé :

       +------------+
| _c0        |
+------------+
| {
    "key": [{
            "description": "hello world",
            "key_id": "r8MqZAEA8PDd3QSL",
            "key_meta_data": {
                "key_material_origin": "Origin_ALIYUN_MAXCOMPUTE",
                "key_material_type": "SYMMETRIC",
                "type": "AES-GCM-256",
                "value": "Jqj7ESbfT1td0DwYDmkZVl13FsuykYFe+1u/MPi++a8="},
            "output_prefix_type": "PREFIX_ALIYUN_MAXCOMPUTE",
            "status": "ENABLED"}],
    "primary_key_id": "r8MqZAEA8PDd3QSL"} |
+------------+

    ROTATE_KEYSET

    • Syntaxe

      binary ROTATE_KEYSET(binary <keyset>, string <key_type>, [string <description> ])

    • description

      Permet au système de générer automatiquement une nouvelle clé et de configurer cette dernière comme clé principale.

    • Paramètres

      • keyset : obligatoire. Valeur de type BINARY. Ce paramètre spécifie le keyset que vous souhaitez mettre à jour.

      • key_type : obligatoire. Ce paramètre spécifie le type d'algorithme de la nouvelle clé. Valeurs valides : AES-GCM-256, AES-SIV-CMAC-128 et AES-SIV-CMAC-256.

      • description : facultatif. Ce paramètre fournit une description de la nouvelle clé de données.

    • Valeur renvoyée

      Renvoie un keyset BINARY.

      Remarque

      Utilisez la fonction HEX pour convertir BINARY en STRING, et la fonction UNHEX pour convertir STRING en BINARY.

    • Exemple

      select ROTATE_KEYSET(unhex ('0A1072384D715A414541385044643351534C12580A330A0B4145532D47434D2D323536122026A8FB1126DF4F5B5DD03C180E6919565D7716CBB291815EFB5BBF30F8BEF9AF1801200210011A1072384D715A414541385044643351534C20022A0B68656C6C6F20776F726C64'), 'AES-SIV-CMAC-256', 'hello world') ;

      Le résultat suivant est renvoyé :

      +------------+
| _c0        |
+------------+
| =0A=10BVIuZQEAcHHPLfn1=12X=0A3=0A=0BAES-GCM-256=12=20&=A8=FB=11&=DFO[]=D0<=18=0Ei=19V]w=16=CB=B2=91=81^=FB[=BF0=F8=BE=F9=AF=18=01=20=02=10=01=1A=10r8MqZAEA8PDd3QSL=20=02*=0Bhello=20world=12}=0AX=0A=10AES-SIV-CMAC-256=12@=9D=AD=B7=D6=AF=01=B2=9D=CE=C3=02y=A9=DB=E1=17q>'F=DC=F5=EF=FFI=7F=F0w)=95F=07>=9C=EDqn=DF=0E=1E=16bP&=D3=7F>gV=CBl=8AGJCm=93=FF=F9=96=AD=1A=C0=BC=18=01=20=02=10=01=1A=10BVIuZQEAcHHPLfn1=20=02*=0Bhello=20world |
+-----------

    NEW_WRAPPED_KEYSET

    • Syntaxe

      binary NEW_WRAPPED_KEYSET(string <kms_cmk_arn> , string <role-arn>, string <key_type>
[, string <description>, [string <role_chain>]])

    • description

      Vous pouvez utiliser MaxCompute avec KMS pour gérer les clés. Vous pouvez générer un keyset encapsulé en chiffrant un keyset à l'aide d'une clé KMS. Une fois le keyset encapsulé généré, vous devez l'enregistrer et le stocker manuellement pour les opérations ultérieures de chiffrement et de déchiffrement des données basées sur les clés KMS. Lors du processus de chiffrement ou de déchiffrement, toutes les clés sont générées automatiquement par le système. Vous ne pouvez pas afficher la clé d'origine utilisée pour le chiffrement et le déchiffrement. Ainsi, les données peuvent être chiffrées ou déchiffrées de manière plus sécurisée. La fonction NEW_WRAPPED_KEYSET suppose l'Alibaba Cloud Resource Name (ARN) d'un rôle autorisé à utiliser les ARN de clé maître client (CMK) KMS dans MaxCompute et à créer un keyset encapsulé. L'ARN du rôle est spécifié par role_arn. L'ARN CMK KMS est spécifié par kms_cmk_arn. La fonction sert également à accorder à d'autres comptes Alibaba Cloud les permissions nécessaires pour utiliser des keysets encapsulés via role_chain.

      Avant d'utiliser la fonction NEW_WRAPPED_KEYSET , assurez-vous que les conditions préalables suivantes sont remplies :

      • KMS est activé et une instance KMS est créée.

      • Une clé KMS est créée et l'ARN de clé spécifié par kms_cmk_arn est obtenu.

      • Un rôle RAM est créé et MaxCompute est autorisé à accéder à KMS. L'ARN du rôle RAM est obtenu. L'ARN du rôle est spécifié par role_arn.

      Pour plus d'informations, consultez la section « Activer KMS et accorder des permissions sur KMS » dans Activer KMS et configurer les permissions.

    • Paramètres

      • kms_cmk_arn : obligatoire. Ce paramètre spécifie l'ARN de la CMK KMS utilisée pour chiffrer un keyset. La valeur du paramètre est au format 'acs:kms:<RegionId>:<UserId>:key/<CmkId>'. RegionId spécifie l'ID de région, UserId spécifie l'ID utilisateur et CmkId spécifie l'ID de la CMK. Vous pouvez obtenir l'ARN depuis la page Détails de la clé dans la console KMS.

      • role_arn : obligatoire. Ce paramètre spécifie l'ARN du rôle RAM disposant des permissions sur KMS. Le rôle doit être assumé par MaxCompute. La valeur du paramètre est au format 'acs:ram:${<userAID>}:role/${<roleName>}'. userAID spécifie l'ID utilisateur et roleName spécifie le nom du rôle.

      • key_type : obligatoire. Ce paramètre spécifie le type d'algorithme de la clé dans le keyset nouvellement généré. Valeurs valides : AES-GCM-256, AES-SIV-CMAC-128 et AES-SIV-CMAC-256.

      • description : facultatif. Ce paramètre fournit une description de la clé.

      • role_chain : facultatif. Ce paramètre spécifie la chaîne de rôles pour l'autorisation des utilisateurs. La valeur du paramètre est au format 'acs:ram:<userAID>:role/<roleName2>,acs:ram:<userBID>:role/<roleName3>},...'. Vous pouvez utiliser les chaînes de rôles pour appeler des keysets encapsulés entre différents comptes Alibaba Cloud.

    • Valeur renvoyée

      Un keyset encapsulé de type BINARY est renvoyé. Vous pouvez utiliser la fonction HEX pour convertir le keyset encapsulé de type BINARY en un keyset de type STRING selon vos besoins métier. Pour plus d'informations sur la fonction HEX, consultez HEX.

    • Exemples

      • Créez un keyset encapsulé.

        select hex(NEW_WRAPPED_KEYSET('acs:kms:cn-hangzhou:1**************7:key/key-hzz****************1t','acs:ram::1**************7:role/kms', 'AES-GCM-256', 'hello'));

        Le résultat suivant est renvoyé :

        +-----+
| _c0 |
+-----+
| 613256354C576836656A59314D6D59344E7A6B7A624452754D6D3434627A49786443317A655859786358426F4E6A4D78434A373434582F54756C5A547A4E69337562786F4B3543412F616655573262786D345A41306B464C674A2F5758324F4E514E346746306F303236376D35335A6471797237366E57565A6836387A52687A4A673945784B6E677568794A376E6F4A68573677684B5A555A42786E4A383742536C4D46326A374F71474F4C414A6B665779694557394D58664876576E306C6D49777052746A77325643707A4259517277327944354343396C50586F31346A4351506253612F3044394C4C6E6E622F747A6B57316E4F564A6C5359354B35526130537565584F33507856773D |
+-----+

      • Créez un keyset encapsulé et autorisez d'autres rôles à appeler ce keyset encapsulé.

        select hex(NEW_WRAPPED_KEYSET('acs:kms:cn-hangzhou:1**************7:key/key-hzz****************1t','acs:ram::1**************7:role/kms', 'AES-GCM-256', 'hello','acs:ram::1**************7:role/kms1'));

        Le résultat suivant est renvoyé :

        +-----+
| _c0 |
+-----+
| 613256354C576836656A59314D6D59344E7A6B7A624452754D6D3434627A49786443317A655859786358426F4E6A4D784D59716D4C767954716B3562444779574C7A387965774966432F516B4A59616F57623648364A546A62434F7A7A42634F517A687A6E526F36543866714E4E63555546566874696C4A3947713556667A2F7851757A55686467504C517A2B6C433337485A535449744B53714E396B6639587666487A4D7957643842334D3179392F67423774726835437A556F786A74614571612F5A3543447668524A7731426566525647796A77574974476243475A4E594550714E767963532B333432743347396B714777626C54336F57706939706E437A667A4E4D6F4C63714F453D |
+-----+

    REWRAP_KEYSET

    • Syntaxe

      binary REWRAP_KEYSET(string <kms_cmk_arn> , string <role-arn>, string <wrapped_keyset>, [string <role_chain>])

    • description

      MaxCompute s'intègre à KMS pour gérer les clés. Une clé KMS chiffre un keyset généré pour créer un keyset encapsulé. La fonction REWRAP_KEYSET rechiffre un keyset encapsulé généré par la fonction NEW_WRAPPED_KEYSET à l'aide d'une nouvelle clé KMS.

      Avant d'utiliser la fonction REWRAP_KEYSET , effectuez les tâches suivantes :

      • Vous disposez d'un keyset encapsulé généré par la fonction NEW_WRAPPED_KEYSET . Pour plus d'informations, consultez NEW_WRAPPED_KEYSET.

      • Créez une nouvelle clé KMS et obtenez son Alibaba Cloud Resource Name (ARN) (kms_cmk_arn). Accordez au rôle RAM la permission d'utiliser la nouvelle clé. Pour plus d'informations, consultez Activer KMS et finaliser la configuration.

    • Paramètres

      • kms_cmk_arn : Obligatoire.

        ARN de la clé maître client (CMK) KMS utilisé pour rechiffrer le keyset. Le format est 'acs:kms:<RegionId>:<UserId>:key/<CmkId>'. L'ARN contient l'ID de région, l'ID utilisateur et l'ID de la CMK. Obtenez l'ARN depuis la page des détails de la clé dans la console Key Management Service. Pour plus d'informations, consultez Activer KMS et finaliser la configuration.

      • role_arn : Obligatoire.

        ARN du rôle RAM disposant des permissions sur les anciennes et nouvelles clés KMS. Ce rôle doit être accordé à MaxCompute. Le format est 'acs:ram:${<userAID>}:role/${<roleName>}'. L'ARN contient l'ID utilisateur et le nom du rôle. Pour obtenir l'ARN, consultez Activer KMS et finaliser la configuration.

      • wrapped_keyset : Obligatoire.

        Le keyset encapsulé à rechiffrer.

      • role_chain : facultatif. Ce paramètre spécifie la chaîne de rôles pour l'autorisation des utilisateurs. La valeur du paramètre est au format 'acs:ram:<userAID>:role/<roleName2>,acs:ram:<userBID>:role/<roleName3>},...'. Vous pouvez utiliser les chaînes de rôles pour appeler des keysets encapsulés entre différents comptes Alibaba Cloud.

    • Valeur renvoyée

      Un keyset encapsulé de type BINARY est renvoyé. Vous pouvez utiliser la fonction HEX pour convertir le keyset encapsulé de type BINARY en un keyset de type STRING selon vos besoins métier. Pour plus d'informations sur la fonction HEX, consultez HEX.

    • Exemples

      Remarque

      Vous pouvez exécuter l'exemple de code suivant contenant des variables dans l'éditeur de code, ou intégrer les variables directement dans l'instruction SQL. MaxCompute ne prend pas en charge les portées de variables entre plusieurs instructions SQL.

      • Rechiffrez un keyset encapsulé :

        SELECT hex(REWRAP_KEYSET('acs:kms:cn-hangzhou:1**************7:key/key-hzz******************', 'acs:ram::1**************7:role/kms', unhex('<wrapped_keyset>')));

      • Rechiffrez un keyset encapsulé et autorisez les rôles d'autres comptes Alibaba Cloud à l'appeler :

        SELECT hex(REWRAP_KEYSET('acs:kms:cn-hangzhou:1**************7:key/key-hzz******************', 'acs:ram:${<UserId>}:role/${<roleName>}', unhex('<wrapped_keyset>'), 'acs:ram:${<UserAId>}:role/${<roleName2>},acs:ram:${<UserBId>}:role/${<roleName3>}')));

    ROTATE_WRAPPED_KEYSET

    • Syntaxe

      binary ROTATE_WRAPPED_KEYSET(string <kms_cmk_arn> , string <role-arn>, string <wrapped_keyset>,string <key_type> [,string description,[string <role_chain>]])

    • description

      Vous pouvez utiliser MaxCompute avec KMS pour gérer les clés. Vous pouvez générer un keyset encapsulé en chiffrant un keyset à l'aide d'une clé KMS. La fonction ROTATE_WRAPPED_KEYSET utilise une nouvelle clé KMS et un nouvel algorithme de clé pour rechiffrer un keyset encapsulé généré à l'aide de la fonction NEW_WRAPPED_KEYSET . Contrairement à la fonction REWRAP_KEYSET , la fonction ROTATE_WRAPPED_KEYSET permet d'utiliser un nouvel algorithme de clé pour le rechiffrement.

      Avant d'utiliser la fonction ROTATE_WRAPPED_KEYSET , assurez-vous que les conditions préalables suivantes sont remplies :

      • Un keyset encapsulé est généré à l'aide de la fonction NEW_WRAPPED_KEYSET . Pour plus d'informations, consultez NEW_WRAPPED_KEYSET.

      • Une clé KMS est créée et l'ARN de clé spécifié par kms_cmk_arn est obtenu. Un rôle RAM reçoit les permissions pour utiliser la nouvelle clé.

    • Paramètres

      • kms_cmk_arn : obligatoire. Ce paramètre spécifie l'ARN de la clé maître client (CMK) KMS que vous souhaitez utiliser pour rechiffrer un keyset encapsulé. La valeur du paramètre est au format 'acs:kms:<RegionId>:<UserId>:key/<CmkId>'. RegionId spécifie l'ID de région, UserId spécifie l'ID utilisateur et CmkId spécifie l'ID de la CMK. Vous pouvez obtenir l'ARN depuis la page Détails de la clé dans la console KMS.

      • role_arn : obligatoire. Ce paramètre spécifie l'ARN du rôle RAM disposant des permissions sur les anciennes et nouvelles clés KMS. La valeur du paramètre est au format 'acs:ram:${<userAID>}:role/${<roleName>}'. userAID spécifie l'ID utilisateur et roleName spécifie le nom du rôle.

      • wrapped_keyset : obligatoire. Ce paramètre spécifie le keyset encapsulé que vous souhaitez rechiffrer.

      • key_type : obligatoire. Ce paramètre spécifie le type d'algorithme de la clé dans le keyset nouvellement généré. Valeurs valides : AES-GCM-256, AES-SIV-CMAC-128 et AES-SIV-CMAC-256.

      • description : facultatif. Ce paramètre fournit une description de la clé.

      • role_chain : facultatif. Ce paramètre spécifie la chaîne de rôles pour l'autorisation des utilisateurs. La valeur du paramètre est au format 'acs:ram:<userAID>:role/<roleName2>,acs:ram:<userBID>:role/<roleName3>},...'. Vous pouvez utiliser les chaînes de rôles pour appeler des keysets encapsulés entre différents comptes Alibaba Cloud.

    • Valeur renvoyée

      Un jeu de clés encapsulé de type BINARY est renvoyé. Vous pouvez utiliser la fonction HEX pour convertir le jeu de clés encapsulé de type BINARY en un jeu de clés de type STRING, selon vos besoins métier. Pour plus d'informations sur la fonction HEX, consultez HEX.

    • Exemples

      Remarque

      Vous pouvez exécuter l'exemple de code suivant contenant des variables dans l'éditeur de code, ou intégrer les variables directement dans l'instruction SQL. MaxCompute ne prend pas en charge les portées de variables entre plusieurs instructions SQL.

      • Rechiffrer un jeu de clés encapsulé.

        @kms_resource_keyId := 'acs:kms:${<RegionId>}:${<UserId>}:key/${<CmkId>}';
@role_arn := 'acs:ram:${<UserId>}:role/${<roleName>}';
@origin_key := unhex('<wrapped_keyset>');
select hex(ROTATE_WRAPPED_KEYSET(@kms_resource_keyId, @role_arn, @origin_key, 'AES-GCM-256', 'hello world'));

      • Rechiffrer un jeu de clés encapsulé et autoriser d'autres rôles à appeler ce jeu de clés.

        @kms_resource_keyId := 'acs:kms:${<RegionId>}:${<UserId>}:key/${<CmkId>}';
@role_arn := 'acs:ram:${<UserId>}:role/${<roleName>}';
@origin_key := unhex('<wrapped_keyset>');
@role_chain := 'acs:ram:${<UserAId>}:role/${<roleName2>},acs:ram:${<UserBId>}:role/${<roleName3>}';
select hex(ROTATE_WRAPPED_KEYSET(@kms_resource_keyId, @role_arn, @origin_key, 'AES-GCM-256', 'hello world', @role_chain));

    USE_WRAPPED_KEYSET

    • Syntaxe

      binary USE_WRAPPED_KEYSET(string <kms_cmk_arn> , string <role-arn>, string <wrapped_keyset> [,string <role_chain>])

    • Description

      Vous pouvez utiliser MaxCompute avec KMS pour gérer les clés. Il est possible de générer un jeu de clés encapsulé en chiffrant un jeu de clés existant à l'aide d'une clé KMS. La fonction USE_WRAPPED_KEYSET convertit un jeu de clés encapsulé généré par la fonction NEW_WRAPPED_KEYSET en un jeu de clés de base. Ce jeu de clés de base sert de paramètre dans les fonctions de chiffrement ou de déchiffrement pour traiter les données. Vous pouvez également utiliser la fonction USE_WRAPPED_KEYSET pour obtenir des informations sur un jeu de clés encapsulé et les enregistrer en vue d'une maintenance ultérieure.

      Avant d'utiliser la fonction USE_WRAPPED_KEYSET , assurez-vous que les conditions préalables suivantes sont remplies :

      • Un jeu de clés encapsulé a été généré à l'aide de la fonction NEW_WRAPPED_KEYSET . Pour plus d'informations, consultez NEW_WRAPPED_KEYSET.

      • Une clé KMS a été créée et son nom de ressource Alibaba Cloud (ARN) a été obtenu. L'ARN de la clé est spécifié par kms_cmk_arn. Un rôle RAM disposant des autorisations nécessaires pour utiliser la nouvelle clé a été configuré.

    • Paramètres

      • kms_cmk_arn : obligatoire. Ce paramètre spécifie l'ARN de la clé maître cliente (CMK) KMS du jeu de clés que vous souhaitez chiffrer. La valeur du paramètre doit respecter le format 'acs:kms:<RegionId>:<UserId>:key/<CmkId>'. RegionId correspond à l'ID de la région, UserId à l'ID de l'utilisateur et CmkId à l'ID de la CMK. Vous pouvez obtenir l'ARN depuis la page Key Details dans la console KMS.

      • role_arn : obligatoire. Ce paramètre spécifie l'ARN du rôle RAM disposant des autorisations sur KMS. Le rôle doit être assumé par MaxCompute. La valeur du paramètre doit respecter le format 'acs:ram:${<userAID>}:role/${<roleName>}'. userAID correspond à l'ID de l'utilisateur et roleName au nom du rôle.

      • wrapped_keyset : obligatoire. Ce paramètre spécifie un jeu de clés encapsulé existant.

      • role_chain : facultatif. Ce paramètre spécifie la chaîne de rôles pour l'autorisation des utilisateurs. La valeur du paramètre doit respecter le format 'acs:ram:<userAID>:role/<roleName2>,acs:ram:<userBID>:role/<roleName3>},...'. Les chaînes de rôles permettent d'appeler des jeux de clés encapsulés entre différents comptes Alibaba Cloud.

    • Valeur renvoyée

      Un jeu de clés anonymisé de type STRUCT est renvoyé. Vous pouvez utiliser la fonction get_json_object pour extraire les champs liés au jeu de clés selon vos besoins métier.

    • Exemple

      Remarque

      Vous pouvez exécuter l'exemple de code suivant contenant des variables dans l'éditeur de code, ou intégrer les variables directement dans l'instruction SQL. MaxCompute ne prend pas en charge les portées de variables entre plusieurs instructions SQL.

      Obtenir les informations sur l'algorithme de clé d'un jeu de clés encapsulé.

      @kms_resource_keyId := 'acs:kms:${<RegionId>}:${<UserId>}:key/${<CmkId>}';
@role_arn := 'acs:ram:${<UserId>}:role/${<roleName>}';
@origin_key := unhex('<wrapped_keyset>');
@role_chain := 'acs:ram:${<UserAId>}:role/${<roleName2>},acs:ram:${<UserBId>}:role/${<roleName3>}';
@use_keyset_new := USE_WRAPPED_KEYSET(@kms_resource_keyId, @role_arn, @origin_key, @role_chain);

select get_json_object(get_json_object(use_keyset_new.wrapped_keyset_info,'$.masked_keyset'), '$.key[0].key_meta_data.type');

      Le résultat suivant est renvoyé :

      +-----+
| _c0 |
+-----+
| AES-GCM-256 |
+-----+

    ENHANCED_SYM_ENCRYPT

    • Syntaxe

      binary ENHANCED_SYM_ENCRYPT(binary <keyset> , string|binary <plaintext> [,string <additional_data>])

    • Description

      MaxCompute vous permet d'utiliser la fonction ENHANCED_SYM_ENCRYPT pour chiffrer des données à l'aide d'un jeu de clés de base ou encapsulé spécifié. Vous pouvez créer un jeu de clés encapsulé en chiffrant un jeu de clés existant avec une clé Key Management Service (KMS). Par rapport aux jeux de clés de base, les jeux de clés encapsulés offrent une gestion des clés plus sécurisée grâce à KMS.

      Avant d'utiliser la fonction ENHANCED_SYM_ENCRYPT , assurez-vous que les conditions préalables suivantes sont remplies :

      • Un jeu de clés de base ou encapsulé a été généré à l'aide des fonctions NEW_KEYSET ou NEW_WRAPPED_KEYSET . Pour plus d'informations, consultez NEW_KEYSET ou NEW_WRAPPED_KEYSET

      • Un jeu de clés de base a été extrait d'un jeu de clés encapsulé à l'aide de la fonction USE_WRAPPED_KEYSET . Cette condition est requise si vous souhaitez utiliser un jeu de clés encapsulé pour chiffrer des données. Le jeu de clés de base sert de paramètre dans la fonction ENHANCED_SYM_ENCRYPT pour le chiffrement des données. De plus, votre compte doit disposer du rôle ayant les autorisations nécessaires pour utiliser le jeu de clés encapsulé.

    • Paramètres

      • keyset : obligatoire. Ce paramètre spécifie un jeu de clés de base de type BINARY ou un jeu de clés encapsulé de type STRUCT.

      • plaintext : obligatoire. Ce paramètre spécifie le texte clair de type STRING ou BINARY que vous souhaitez chiffrer.

      • additional_data : facultatif. Ce paramètre spécifie les informations de vérification prises en charge par l'algorithme. Ces informations sont de type STRING.

    • Valeur renvoyée

      Un texte chiffré de type BINARY est renvoyé.

    • Données d'exemple

      -- Create a table.
create table mf_user_info(id bigint,
                          name string,
                          gender string,
                          id_card_no string,
                          tel string);
-- Insert data into the table.
insert overwrite table mf_user_info values(1,"bob","male","0001","13900001234"),
                                       (2,"allen","male","0011","13900001111"),
                                     (3,"kate","female","0111","13900002222"),
                                     (4,"annie","female","1111","13900003333");
-- Query data from the table.
select * from mf_user_info;
+------------+------+--------+------------+------------+
| id         | name | gender | id_card_no |    tel     |
+------------+------+--------+------------+------------+
| 1          | bob  | male   | 0001       | 13900001234|
| 2          | allen| male   | 0011       | 13900001111|
| 3          | kate | female | 0111       | 13900002222|
| 4          | annie| female | 1111       | 13900003333|
+------------+------+--------+------------+------------+

    • Exemples

      • Chiffrer la colonne id_card_no de la table mf_user_info à l'aide d'un jeu de clés de base.

        insert overwrite table mf_user_info
select id,
    name,
    gender,
       base64(ENHANCED_SYM_ENCRYPT(unhex ('0A1072384D715A414541385044643351534C12580A330A0B4145532D47434D2D323536122026A8FB1126DF4F5B5DD03C180E6919565D7716CBB291815EFB5BBF30F8BEF9AF1801200210011A1072384D715A414541385044643351534C20022A0B68656C6C6F20776F726C64'), id_card_no ))as id_card_no,
      tel
from mf_user_info;

        L'instruction suivante permet de consulter le résultat du chiffrement :

        select * from mf_user_info;

-- The following result is returned:
+------------+------+--------+------------+-----+
| id         | name | gender | id_card_no | tel |
+------------+------+--------+------------+-----+
| 1          | bob  | male   | nLcdDFdjO2T4aATtirvDMVeBD8oSuu4BfM3t+Y8ny0kwQjJlAQAwkVhYOocPQll8LmdzSwkRf3v2iTow+TAmnQ== | 13900001234 |
| 2          | allen | male   | nLcdDFdjO2T4aATtirvDMVeBD8oSuu4BfM3t+Y8ny0kwQjJlAQBgj1hYOodIPdnyZ0ijZ9RmT+50xbxXh5cwcg== | 13900001111 |
| 3          | kate | female | nLcdDFdjO2T4aATtirvDMVeBD8oSuu4BfM3t+Y8ny0kwQjJlAQCwp1hYOoentQgkfUqctPbmX96k9eD018xg9Q== | 13900002222 |
| 4          | annie | female | nLcdDFdjO2T4aATtirvDMVeBD8oSuu4BfM3t+Y8ny0kwQjJlAQDQqFhYOodexhRmfh6VieEwePZscC4nUVTJXQ== | 13900003333 |
+------------+------+--------+------------+-----+

      • Chiffrer la colonne tel de la table mf_user_info à l'aide d'un jeu de clés encapsulé.

        1. Générer un jeu de clés encapsulé et l'écrire dans une table.

          -- Create a table.
create table mf_keyset_kms (id string,ks binary);
-- Create a wrapped keyset and write it to the table.
insert into mf_keyset_kms 
      select '1',
             NEW_WRAPPED_KEYSET(
                'acs:kms:cn-hangzhou:1**************7:key/key-hzz****************1t', 
                'acs:ram::1**************7:role/kms', 
                'AES-GCM-256', 
               'description');
-- Query data from the table.
select id,hex(ks) from mf_keyset_kms;

-- The following result is returned:
+----+-----+
| id | _c1 |
+----+-----+
| 1  | 613256354C576836656A59314D6D59344E7A6B7A624452754D6D3434627A49786443317A655859786358426F4E6A4D78447654524C4632635077766E74554654584579715242583953724167446D2F397131786F57456E6F5474516739633853766242674456773565736674714A4D5435524455382F6F6A2B4E61766D774344494C734B6A416B6B675A42496F5568656F566D38564C4F30506D4778767137646956517453447A5467395147775639533161305A464A6D6A45562B6742722F56386653444D6E424D2B71493779784668303866594E6D336578775744423949726B645A3469784F2B532B476E6750523854524A58326E5768666478347034473468687248684A514D615071332F526C342B67427652773D3D |
+----+-----+

        2. Chiffrer la colonne tel à l'aide du jeu de clés encapsulé.

          select /*+ MAPJOIN(a) */ 
       id,
       name,
	   gender,
	   id_card_no, 
       ENHANCED_SYM_ENCRYPT(
           USE_WRAPPED_KEYSET('acs:kms:cn-hangzhou:1**************7:key/key-hzz****************1t', 
                              'acs:ram::1**************7:role/kms', 
                              unhex('613256354C576836656A59314D6D59344E7A6B7A624452754D6D3434627A49786443317A655859786358426F4E6A4D78447654524C4632635077766E74554654584579715242583953724167446D2F397131786F57456E6F5474516739633853766242674456773565736674714A4D5435524455382F6F6A2B4E61766D774344494C734B6A416B6B675A42496F5568656F566D38564C4F30506D4778767137646956517453447A5467395147775639533161305A464A6D6A45562B6742722F56386653444D6E424D2B71493779784668303866594E6D336578775744423949726B645A3469784F2B532B476E6750523854524A58326E5768666478347034473468687248684A514D615071332F526C342B67427652773D3D')
                             ),
           tel
       ) as tel 
 FROM mf_user_info;

          Le résultat suivant est renvoyé :

          +------------+------+--------+------------+------+
| id         | name | gender | id_card_no | tel  |
+------------+------+--------+------------+------+
| 1          | bob  | male   | 0001       | =F1=EEa=13V9=CCsB=90=E7=F3fl=D2=CB=F31=D8=3D=88=B7=F7=0CnG=E3\R=FC)=F2=10=3D2e=01=00=90=86=05=94z;=18=A6j=1CN=E5=9F=AC)=8D=D6=D8=0D=A2Y{kq=EE=F4~=C4=A7=9BS=A1w |
| 2          | allen | male   | 0011       | =F1=EEa=13V9=CCsB=90=E7=F3fl=D2=CB=F31=D8=3D=88=B7=F7=0CnG=E3\R=FC)=F2=10=3D2e=01=00=20=AA=05=94z;=85=D8=08a=A2]=02d=20=B1=C3=AE=AF=1C{=EB=EA=C4=81=B5A=15=1BR=F7g=9B |
| 3          | kate | female | 0111       | =F1=EEa=13V9=CCsB=90=E7=F3fl=D2=CB=F31=D8=3D=88=B7=F7=0CnG=E3\R=FC)=F2=10=3D2e=01=00=20=B6=05=94z;[C=12=81=8B<=C1=9D=E2=CF=CE=BC=AE=A7=84=0F[=7CI=B9=B7=9D=DD=89=A8=FD! |
| 4          | annie | female | 1111       | =F1=EEa=13V9=CCsB=90=E7=F3fl=D2=CB=F31=D8=3D=88=B7=F7=0CnG=E3\R=FC)=F2=10=3D2e=01=00=00=A2=05=94z;E=03A=BC=7C=88=CFJ=14=B9=BD=A1=BF=ED=20=11=A3=A6/+%=0Fe=DD=C7=C8=0A |
+------------+------+--------+------------+------+

    ENHANCED_SYM_DECRYPT

    • Syntaxe

      BINARY ENHANCED_SYM_DECRYPT(BINARY <keyset> , BINARY <ciphertext> [,string <additional_data>])

    • Description

      Vous pouvez utiliser la fonction ENHANCED_SYM_DECRYPT dans MaxCompute pour déchiffrer des données à l'aide d'un jeu de clés de base ou encapsulé spécifié. Le jeu de clés utilisé pour le déchiffrement doit être identique à celui utilisé pour le chiffrement. Un jeu de clés encapsulé est créé en chiffrant un jeu de clés existant avec une clé Key Management Service (KMS). L'utilisation de jeux de clés encapsulés avec KMS permet une gestion des clés plus sécurisée qu'avec des jeux de clés de base.

      Avant d'utiliser la fonction ENHANCED_SYM_DECRYPT , effectuez les opérations suivantes :

      • Générez un jeu de clés de base ou encapsulé à l'aide des fonctions NEW_KEYSET ou NEW_WRAPPED_KEYSET . Pour plus d'informations, consultez NEW_KEYSET et NEW_WRAPPED_KEYSET.

      • Si vous utilisez un jeu de clés encapsulé pour déchiffrer des données, vous devez disposer des autorisations associées au rôle lié à ce jeu de clés. Pour plus d'informations, consultez Activate KMS and complete configurations.

    • Paramètres

      keyset : Obligatoire. Le jeu de clés utilisateur, qui peut être de type BINARY ou STRUCT.

      Important

      Le jeu de clés de base ou encapsulé utilisé pour le déchiffrement doit être identique à celui utilisé pour le chiffrement.

      ciphertext : Obligatoire. Le texte chiffré de type BINARY à déchiffrer. Le texte chiffré doit avoir été chiffré avec le jeu de clés spécifié.

    • additional_data : facultatif. Ce paramètre spécifie les informations de vérification prises en charge par l'algorithme. Ces informations sont de type STRING.

    • Valeur renvoyée

      Renvoie un texte clair de type BINARY.

    • Données d'exemple

      -- Create a table.
create table mf_user_info(id bigint,
                          name string,
                          gender string,
                          id_card_no string,
                          tel string);
-- Insert data into the table.
insert overwrite table mf_user_info values(1,"bob","male","0001","13900001234"),
                                       (2,"allen","male","0011","13900001111"),
                                     (3,"kate","female","0111","13900002222"),
                                     (4,"annie","female","1111","13900003333");
-- Query data from the table.
select * from mf_user_info;
+------------+------+--------+------------+------------+
| id         | name | gender | id_card_no |    tel     |
+------------+------+--------+------------+------------+
| 1          | bob  | male   | 0001       | 13900001234|
| 2          | allen| male   | 0011       | 13900001111|
| 3          | kate | female | 0111       | 13900002222|
| 4          | annie| female | 1111       | 13900003333|
+------------+------+--------+------------+------------+

    • Exemples

      • Déchiffrer la colonne id_card_no de la table mf_user_info à l'aide d'un jeu de clés simple :

        Important

        Avant de déchiffrer les données, assurez-vous qu'elles ont bien été chiffrées. Le jeu de clés de base ou encapsulé utilisé pour le déchiffrement doit être identique à celui utilisé pour le chiffrement. Pour un exemple d'opération de chiffrement, consultez ENHANCED_SYM_ENCRYPT.

        INSERT OVERWRITE TABLE mf_user_info 
SELECT id,
       name,
       gender,
       CAST(ENHANCED_SYM_DECRYPT(unhex('0A1072384D715A414541385044643351534C12580A330A0B4145532D47434D2D323536122026A8FB1126DF4F5B5DD03C180E6919565D7716CBB291815EFB5BBF30F8BEF9AF1801200210011A1072384D715A414541385044643351534C20022A0B68656C6C6F20776F726C64'), UNBASE64(id_card_no)) AS STRING) AS id_card_no,
       tel
FROM mf_user_info;

        Le résultat suivant est renvoyé :

        SELECT * FROM mf_user_info;

-- Sample result
+------------+------+--------+------------+------------+
| id         | name | gender | id_card_no |    tel     |
+------------+------+--------+------------+------------+
| 1          | bob  | male   | 0001       | 13900001234|
| 2          | allen| male   | 0011       | 13900001111|
| 3          | kate | female | 0111       | 13900002222|
| 4          | annie| female | 1111       | 13900003333|
+------------+------+--------+------------+------------+

      • Utiliser un jeu de clés encapsulé pour déchiffrer la colonne mf_user_info chiffrée de la table tel :

         SELECT /*+ MAPJOIN(a) */ 
       id,
       name,
	   gender,
	   id_card_no,
       ENHANCED_SYM_DECRYPT(
         USE_WRAPPED_KEYSET('acs:kms:cn-hangzhou:1**************7:key/key-hzz****************1t', 
                              'acs:ram::1**************7:role/kms', 
                              unhex('613256354C576836656A59314D6D59344E7A6B7A624452754D6D3434627A49786443317A655859786358426F4E6A4D78447654524C4632635077766E74554654584579715242583953724167446D2F397131786F57456E6F5474516739633853766242674456773565736674714A4D5435524455382F6F6A2B4E61766D774344494C734B6A416B6B675A42496F5568656F566D38564C4F30506D4778767137646956517453447A5467395147775639533161305A464A6D6A45562B6742722F56386653444D6E424D2B71493779784668303866594E6D336578775744423949726B645A3469784F2B532B476E6750523854524A58326E5768666478347034473468687248684A514D615071332F526C342B67427652773D3D')
                             ),
       	 ENHANCED_SYM_ENCRYPT(
           USE_WRAPPED_KEYSET('acs:kms:cn-hangzhou:1**************7:key/key-hzz****************1t', 
                              'acs:ram::1**************7:role/kms', 
                              unhex('613256354C576836656A59314D6D59344E7A6B7A624452754D6D3434627A49786443317A655859786358426F4E6A4D78447654524C4632635077766E74554654584579715242583953724167446D2F397131786F57456E6F5474516739633853766242674456773565736674714A4D5435524455382F6F6A2B4E61766D774344494C734B6A416B6B675A42496F5568656F566D38564C4F30506D4778767137646956517453447A5467395147775639533161305A464A6D6A45562B6742722F56386653444D6E424D2B71493779784668303866594E6D336578775744423949726B645A3469784F2B532B476E6750523854524A58326E5768666478347034473468687248684A514D615071332F526C342B67427652773D3D')
                             ),
           tel
       ),
       ''
      )
       AS tel 
 FROM mf_user_info;

        Le résultat suivant est renvoyé :

        +------------+------+--------+------------+------+
| id         | name | gender | id_card_no | tel  |
+------------+------+--------+------------+------+
| 1          | bob  | male   | 0001       | 13900001234 |
| 2          | allen | male   | 0011       | 13900001111 |
| 3          | kate | female | 0111       | 13900002222 |
| 4          | annie | female | 1111       | 13900003333 |
+------------+------+--------+------------+------+

    Rubriques connexes