Tous les produits
Search

Ce produit

    MaxCompute:Fonctions de chiffrement

    Centre de documentation

    MaxCompute:Fonctions de chiffrement

    Dernière mise à jour :Aug 20, 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 ensemble de clés (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 ensemble de clés, 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 ensemble de clés basé sur un type d'algorithme spécifié.

      ADD_KEY_TO_KEYSET

      Ajoute une nouvelle clé à un ensemble de clés et la définit comme clé principale.

      KEYSET_TO_JSON

      Convertit un ensemble de clés 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 d'ensemble de clés du format JSON au 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 ensemble de clés de base et le chiffre à l'aide d'une clé maître cliente (CMK) provenant de KMS pour créer un ensemble de clés encapsulé (wrapped keyset). Vous êtes responsable du stockage de cet ensemble de clés encapsulé. Pour déchiffrer les données, vous devez fournir l'ensemble de clés encapsulé. MaxCompute utilise ensuite la CMK KMS pour déchiffrer l'ensemble de clés encapsulé en un ensemble de clés 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 intégrées à KMS dans MaxCompute SQL.

      Fonction

      Description

      NEW_WRAPPED_KEYSET

      Crée un nouvel ensemble de clés encapsulé. Cette opération nécessite un rôle (spécifié par role_arn) disposant de l'autorisation d'utiliser une clé maître cliente (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 l'ensemble de clés.

      REWRAP_KEYSET

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

      ROTATE_WRAPPED_KEYSET

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

      USE_WRAPPED_KEYSET

      Déchiffre un ensemble de clés encapsulé en un ensemble de clés 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 de l'ensemble de clés encapsulé à des fins de maintenance.

      ENHANCED_SYM_ENCRYPT

      Chiffre les données à l'aide d'un ensemble de clés spécifié.

      ENHANCED_SYM_DECRYPT

      Déchiffre les données à l'aide d'un ensemble de clés 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 d'un 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 ensemble de clés 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 ensemble de clés 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 ensemble de clés et configure la clé comme clé principale.

    • Paramètres

      • keyset : obligatoire. Ce paramètre spécifie un ensemble de clés 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 ensemble de clés 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 de keyset au format JSON en type BINARY.

    • Paramètres

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

    • Valeur renvoyée

      Renvoie le keyset sous forme de valeur BINARY.

      Remarque

      Pour convertir des valeurs entre les types 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 de chiffrement et de déchiffrement ultérieures 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. Cette approche permet de chiffrer ou de déchiffrer les données de manière plus sécurisée. La fonction NEW_WRAPPED_KEYSET suppose le nom de ressource Alibaba Cloud (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 de la CMK KMS est spécifié par kms_cmk_arn. La fonction sert également à accorder à d'autres comptes Alibaba Cloud les permissions d'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 a été créée.

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

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

    • 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 autorisations 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 la gestion des 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 nom de ressource Alibaba Cloud (ARN) (kms_cmk_arn). Accordez au rôle RAM l'autorisation 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 autorisations 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. 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. Par rapport à 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é 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 l'ARN de clé spécifié par kms_cmk_arn a été obtenu. Un rôle RAM dispose des autorisations nécessaires 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 autorisations 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 de retour

      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

      MaxCompute s'intègre à KMS pour la gestion des clés. Vous pouvez 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 dernier sert de paramètre aux fonctions de chiffrement ou de déchiffrement pour traiter les données. Vous pouvez également utiliser la fonction USE_WRAPPED_KEYSET pour récupérer les informations relatives à un jeu de clés encapsulé et les conserver pour 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 Alibaba Cloud Resource Name (ARN) a été obtenu. L'ARN de la clé est spécifié par le paramètre kms_cmk_arn. Un rôle RAM dispose des autorisations nécessaires pour utiliser la nouvelle clé.

    • Paramètres

      • kms_cmk_arn : obligatoire. Ce paramètre indique l'ARN de la Customer Master Key (CMK) KMS du jeu de clés à chiffrer. La valeur du paramètre suit 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 indique l'ARN du rôle RAM disposant des autorisations sur KMS. Ce rôle doit être assumé par MaxCompute. La valeur du paramètre suit 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 indique un jeu de clés encapsulé existant.

      • role_chain : facultatif. Ce paramètre indique la chaîne de rôles pour l'autorisation des utilisateurs. La valeur du paramètre suit 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 de retour

      Un jeu de clés masqué de type STRUCT est renvoyé. Vous pouvez utiliser la fonction get_json_object pour extraire les champs relatifs 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.

      Récupérer 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 via 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 à la fonction ENHANCED_SYM_ENCRYPT pour le chiffrement des données. De plus, votre compte doit disposer du rôle autorisé à utiliser le jeu de clés encapsulé.

    • Paramètres

      • keyset : obligatoire. Ce paramètre indique 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 indique le texte clair de type STRING ou BINARY à chiffrer.

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

    • Valeur de retour

      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 interroge 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

      La fonction ENHANCED_SYM_DECRYPT de MaxCompute permet de 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 offre une gestion des clés plus sécurisée que celle 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. Jeu de clés utilisateur, 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. Texte chiffré de type BINARY à déchiffrer. Il doit avoir été chiffré avec le jeu de clés spécifié.

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

    • Valeur de retour

      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