Object Storage Service:Chiffrement côté client (SDK Python V1)

Clause de non-responsabilité

• Lorsque vous utilisez le chiffrement côté client, vous devez garantir l'intégrité et la validité de la CMK. Si la CMK est utilisée de manière incorrecte ou perdue en raison d'une maintenance inadéquate, vous êtes responsable de toutes les pertes et conséquences causées par les échecs de déchiffrement.

• Lorsque vous copiez ou migrez des données chiffrées, vous êtes responsable de l'intégrité et de la validité des métadonnées des objets. Si les métadonnées chiffrées sont incorrectes ou perdues en raison d'une maintenance inadéquate, vous êtes responsable de toutes les pertes et conséquences causées par les échecs de déchiffrement des données.

Scénarios

• Données hautement sensibles : pour les informations personnellement identifiables (PII), les registres de transactions financières, les données de santé et autres données hautement sensibles, les utilisateurs peuvent souhaiter chiffrer les données avant qu'elles ne quittent l'environnement local afin de s'assurer que les données originales sont efficacement protégées même si elles sont interceptées pendant la transmission.

• Exigences de conformité : certaines industries et réglementations, telles que la loi HIPAA (Health Insurance Portability and Accountability Act) et le RGPD (Règlement général sur la protection des données), exigent une gestion stricte du chiffrement pour les données stockées sur des plateformes tierces. Le chiffrement côté client aide à répondre à ces exigences de conformité, car les CMK sont gérées par les utilisateurs et ne sont ni transmises sur le réseau ni exposées aux fournisseurs de services cloud.

• Contrôle total du chiffrement : une entreprise ou un développeur peut souhaiter avoir un contrôle total sur le processus de chiffrement, y compris la sélection des algorithmes de chiffrement ainsi que la gestion et la rotation des CMK. Dans ce cas, vous pouvez utiliser le chiffrement côté client pour garantir que seuls les utilisateurs autorisés peuvent déchiffrer et accéder aux données.

• Sécurité de la migration des données entre régions : le chiffrement côté client permet de maintenir les données dans un état chiffré avant et après la migration des données entre régions. Cela renforce la sécurité de la transmission des données sur Internet.

Remarques

• Dans cette rubrique, le point de terminaison public de la région Chine (Hangzhou) est utilisé. Si vous souhaitez accéder à OSS depuis d'autres services Alibaba Cloud situés dans la même région qu'OSS, utilisez un point de terminaison interne. Pour plus d'informations sur les régions et les points de terminaison OSS, consultez Régions et points de terminaison.

• Dans cette rubrique, les identifiants d'accès sont obtenus à partir des variables d'environnement. Pour plus d'informations sur la configuration des identifiants d'accès, consultez Configurer les identifiants d'accès à l'aide du SDK OSS pour Python 1.0.

• Cette rubrique montre comment créer une instance OSSClient avec un endpoint OSS. Pour d'autres configurations, telles que l'utilisation d'un domaine personnalisé ou l'authentification avec des identifiants issus du Security Token Service (STS), consultez Initialisation.

Informations générales

Dans le cadre du chiffrement côté client, une clé de données aléatoire est générée pour chaque objet afin d'effectuer un chiffrement symétrique de l'objet. Le client utilise une CMK pour chiffrer la clé de données aléatoire. La clé de données chiffrée est téléchargée en tant que partie des métadonnées de l'objet et stockée sur le serveur OSS. Lorsqu'un objet chiffré est téléchargé, le client utilise la CMK pour déchiffrer la clé de données aléatoire, puis utilise la clé de données déchiffrée pour déchiffrer l'objet. Pour garantir la sécurité des données, la CMK est utilisée uniquement sur le client et n'est ni transmise sur le réseau ni stockée sur le serveur.

Méthodes de chiffrement

Une clé maître est actuellement utilisée de deux manières :

• CMK gérées par KMS

  Lorsque vous utilisez une CMK gérée dans Key Management Service (KMS) pour le chiffrement côté client, vous devez fournir l'ID de la CMK au SDK OSS pour Python.

• CMK basées sur RSA gérées par vous-même

  Lorsque vous utilisez une CMK gérée par vous-même pour le chiffrement côté client, vous devez envoyer la clé publique et la clé privée de votre CMK au SDK OSS pour Python en tant que paramètres.

Vous pouvez utiliser les méthodes de chiffrement précédentes pour prévenir les fuites de données et protéger vos données sur le client. Même si vos données sont divulguées, elles ne peuvent pas être déchiffrées par des tiers.

Pour plus d'informations, consultez Chiffrement côté client dans le Guide du développeur OSS.

Chiffrement côté client V2 (recommandé)

• Métadonnées d'objet liées au chiffrement côté client

  Paramètre	Description	Obligatoire
  x-oss-meta-client-side-encryption-key	La clé de données chiffrée. Il s'agit d'une chaîne chiffrée à l'aide d'une CMK basée sur RSA ou d'une CMK gérée par KMS, puis encodée en Base64.	Oui
  x-oss-meta-client-side-encryption-start	Le vecteur d'initialisation généré de manière aléatoire pour le chiffrement des données. Il s'agit d'une chaîne chiffrée à l'aide d'une CMK basée sur RSA ou d'une CMK gérée par KMS, puis encodée en Base64.	Oui
  x-oss-meta-client-side-encryption-cek-alg	L'algorithme utilisé pour chiffrer les données.	Oui
  x-oss-meta-client-side-encryption-wrap-alg	L'algorithme utilisé pour chiffrer la clé de données.	Oui
  x-oss-meta-client-side-encryption-matdesc	La description de la clé de chiffrement de contenu (CEK) au format JSON.	Non
  x-oss-meta-client-side-encryption-unencrypted-content-length	La longueur des données avant le chiffrement. Si content-length n'est pas spécifié, ce paramètre n'est pas généré.	Non
  x-oss-meta-client-side-encryption-unencrypted-content-md5	Le hachage MD5 des données avant le chiffrement. Si content-md5 n'est pas spécifié, ce paramètre n'est pas généré.	Non
  x-oss-meta-client-side-encryption-data-size	La taille totale de l'objet que vous souhaitez télécharger à l'aide du téléchargement multipart.	Conditionnel (obligatoire pour le téléchargement multipart)
  x-oss-meta-client-side-encryption-part-size	La taille des parties spécifiée dans le téléchargement multipart.	Conditionnel (obligatoire pour le téléchargement multipart)

• Créer un bucket pour le chiffrement côté client

  Avant de chiffrer et de télécharger un objet ou de télécharger et de déchiffrer un objet sur le client, vous devez initialiser une instance de bucket. Vous pouvez appeler les opérations sur le bucket pour télécharger ou récupérer des objets. Dans le chiffrement côté client, la classe CryptoBucket hérite des opérations de la classe Bucket. Vous pouvez configurer les paramètres pour initialiser une instance CryptoBucket de la même manière que vous initialisez une instance Bucket.

  • Initialiser une instance CryptoBucket pour le chiffrement d'objets à l'aide d'une CMK basée sur RSA gérée par vous-même

    Important

    Si vous utilisez une CMK basée sur RSA, vous devez gérer la CMK vous-même. La perte de la CMK ou l'endommagement des données de la CMK peut entraîner des échecs de déchiffrement. Nous vous recommandons d'utiliser des CMK gérées par KMS. Pour utiliser une CMK basée sur RSA afin d'effectuer le chiffrement, nous vous conseillons de sauvegarder les données de votre CMK.

    L'exemple de code suivant montre comment initialiser une instance CryptoBucket pour le chiffrement d'objets à l'aide d'une CMK basée sur RSA gérée par vous-même :

    # -*- coding: utf-8 -*-
    import os
    import oss2
    from oss2.credentials import EnvironmentVariableCredentialsProvider
    from oss2.crypto import RsaProvider
    
    # Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured. 
    auth = oss2.ProviderAuthV4(EnvironmentVariableCredentialsProvider())
    
    # If you want to only decrypt objects, specify only the private key. 
    # key_pair = {'private_key': 'yourPrivateKey'}
    # If you want to only encrypt objects, specify only the public key. 
    # key_pair = {'public_key': 'yourPublicKey'}
    # If you want to encrypt and decrypt objects, you must specify both the public key and the private key. 
    key_pair = {'private_key': 'yourPrivateKey', 'public_key': 'yourPublicKey'}
    
    # Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. 
    endpoint = "https://oss-cn-hangzhou.aliyuncs.com"
    # Specify the region in which the bucket is located. Example: cn-hangzhou This parameter is required if you use the V4 signature algorithm.
    region = "cn-hangzhou"
    
    # Specify the name of the bucket. 
    bucket = oss2.CryptoBucket(auth, endpoint, 'yourBucketName',
                               crypto_provider=RsaProvider(key_pair), region=region)
    

  • Initialiser une instance CryptoBucket pour le chiffrement d'objets à l'aide d'une CMK gérée par KMS

    L'exemple de code suivant montre comment initialiser une instance CryptoBucket pour le chiffrement d'objets à l'aide d'une CMK gérée par KMS :

    # -*- coding: utf-8 -*-
    import os
    import oss2
    from oss2.crypto import AliKMSProvider
    from oss2.credentials import EnvironmentVariableCredentialsProvider
    
    # Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured. 
    auth = oss2.ProviderAuthV4(EnvironmentVariableCredentialsProvider())
    kms_provider = AliKMSProvider(auth, 'yourRegion', 'yourCMKID')
    
    # Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. 
    endpoint = "https://oss-cn-hangzhou.aliyuncs.com"
    # Specify the region in which the bucket is located. Example: cn-hangzhou This parameter is required if you use the V4 signature algorithm.
    region = "cn-hangzhou"
    
    # Specify the name of the bucket. 
    bucket = oss2.CryptoBucket(auth, endpoint, 'yourBucketName', crypto_provider=kms_provider, region=region)
    

  • Utiliser et gérer plusieurs CMK

    Vous pouvez utiliser différentes CMK pour chiffrer les objets téléchargés vers un bucket ou déchiffrer les objets récupérés depuis le même bucket. Vous pouvez spécifier différentes descriptions pour les CMK et ajouter les CMK ainsi que leurs descriptions aux informations de chiffrement relatives au bucket. Lors du déchiffrement des données, le SDK OSS pour Python fait correspondre automatiquement une CMK en fonction de la description. L'exemple de code suivant montre comment fournir plusieurs CMK :

    # -*- coding: utf-8 -*-
    import os
    import oss2
    from oss2.crypto import RsaProvider
    from oss2.credentials import EnvironmentVariableCredentialsProvider
    
    # Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured. 
    auth = oss2.ProviderAuthV4(EnvironmentVariableCredentialsProvider())
    
    # Create an RSA-based key pair. 
    key_pair_1 = {'private_key': 'yourPrivateKey_1', 'public_key': 'yourPublicKey_1'}
    mat_desc_1 = {'key1': 'value1'}
    
    # Create another RSA-based key pair. 
    key_pair_2 = {'private_key': 'yourPrivateKey_2', 'public_key': 'yourPublicKey_2'}
    mat_desc_2 = {'key2': 'value2'}
    
    provider = RsaProvider(key_pair=key_pair_2, mat_desc=mat_desc_2)
    # Add the description of key_pair_1 to the provider. 
    encryption_materials = oss2.EncryptionMaterials(mat_desc_1, key_pair=key_pair_1)
    provider.add_encryption_materials(encryption_materials)
    
    # Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. 
    endpoint = "https://oss-cn-hangzhou.aliyuncs.com"
    # Specify the region in which the bucket is located. Example: cn-hangzhou This parameter is required if you use the V4 signature algorithm.
    region = "cn-hangzhou"
    
    # Use the provider to initialize a CryptoBucket instance. Then, you can download the object data that is encrypted using a CMK whose description is mat_desc_1. 
    crypto_bucket = oss2.CryptoBucket(auth, endpoint, 'yourBucketName', crypto_provider=provider, region=region)
    

• Téléchargements et récupérations de fichiers standards

  L'exemple de code suivant illustre les téléchargements et récupérations de fichiers standards à l'aide d'une clé maître KMS :

  # -*- coding: utf-8 -*-
  import os
  import oss2
  from oss2.credentials import EnvironmentVariableCredentialsProvider
  from oss2.crypto import RsaProvider
  from oss2.crypto import AliKMSProvider
  
  # Obtain access credentials from environment variables. Before you run this sample code, make sure the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are set.
  auth = oss2.ProviderAuthV4(EnvironmentVariableCredentialsProvider())
  
  kms_provider = AliKMSProvider(auth, 'yourRegion', 'yourCMKID')
  # Enter the endpoint of the region where the bucket is located. For example, for China (Hangzhou), set the endpoint to https://oss-cn-hangzhou.aliyuncs.com.
  endpoint = "https://oss-cn-hangzhou.aliyuncs.com"
  # Enter the region information corresponding to the endpoint, for example, cn-hangzhou. Note that this parameter is required for V4 signatures.
  region = "cn-hangzhou"
  bucket = oss2.CryptoBucket(auth, endpoint, 'yourBucketName', crypto_provider=kms_provider, region=region)
  
  key = 'motto.txt'
  content = b'a' * 1024 * 1024
  filename = 'download.txt'
  
  # Upload the file.
  bucket.put_object(key, content, headers={'content-length': str(1024 * 1024)})
  
  # Download the OSS file to local memory.
  result = bucket.get_object(key)
  
  # Verify that the content of the downloaded file is the same as the content of the uploaded file.
  content_got = b''
  for chunk in result:
      content_got += chunk
  assert content_got == content
  
  # Download the OSS file to a local file.
  result = bucket.get_object_to_file(key, filename)
  
  # Verify that the content of the downloaded file is the same as the content of the uploaded file.
  with open(filename, 'rb') as fileobj:
      assert fileobj.read() == content

• Téléchargement multipart

  Remarque

  • Si une tâche de téléchargement multipart est interrompue et que le processus est terminé, le contexte de la tâche de téléchargement multipart peut être perdu. Si une tâche de téléchargement multipart est interrompue et que vous souhaitez retélécharger l'objet, vous devez retélécharger l'intégralité de l'objet.

  • Nous vous recommandons d'appeler l'opération de téléchargement avec reprise dans OSS pour télécharger de grands objets. De cette façon, vous pouvez stocker le contexte d'une tâche de téléchargement multipart sur le client local afin que le contexte soit conservé même si la tâche de téléchargement est interrompue.

  L'exemple de code suivant montre comment utiliser une CMK gérée par KMS pour chiffrer un objet que vous souhaitez télécharger à l'aide du téléchargement multipart :

  # -*- coding: utf-8 -*-
  import os
  import oss2
  from oss2.credentials import EnvironmentVariableCredentialsProvider
  from oss2.crypto import RsaProvider
  from oss2.cryptoimportAliKMSProvider
  
  # Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured. 
  auth = oss2.ProviderAuthV4(EnvironmentVariableCredentialsProvider())
  
  kms_provider = AliKMSProvider(auth, 'yourRegion', 'yourCMKID')
  # Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. 
  endpoint = "https://oss-cn-hangzhou.aliyuncs.com"
  # Specify the region in which the bucket is located. Example: cn-hangzhou This parameter is required if you use the V4 signature algorithm.
  region = "cn-hangzhou"
  bucket = oss2.CryptoBucket(auth, endpoint, 'yourBucketName', crypto_provider = kms_provider, region=region)
  
  """
  Perform client-side encryption in multipart upload
  """
  # Initiate a multipart upload task. 
  part_a = b'a' * 1024 * 100
  part_b = b'b' * 1024 * 100
  part_c = b'c' * 1024 * 100
  multi_content = [part_a, part_b, part_c]
  
  parts = []
  data_size = 100 * 1024 * 3
  part_size = 100 * 1024
  multi_key = "test_crypto_multipart"
  
  # Initialize the context of the multipart upload task when you use client-side encryption. 
  context = models.MultipartUploadCryptoContext(data_size, part_size)
  res = bucket.init_multipart_upload(multi_key, upload_context=context)
  upload_id = res.upload_id
  
  # In this example, the parts are uploaded in sequence. Multipart upload supports multiple parallel threads to accelerate the upload. 
  for i in range(3):
      # The context values cannot be modified. If the values in context are modified, data upload fails. 
      result = bucket.upload_part(multi_key, upload_id, i + 1, multi_content[i], upload_context=context)
      parts.append(oss2.models.PartInfo(i + 1, result.etag, size=part_size, part_crc=result.crc))
  
  # Complete the multipart upload task. 
  result = bucket.complete_multipart_upload(multi_key, upload_id, parts)
  
  # Check data consistency between the content of the downloaded object and that of the object before upload. 
  result = bucket.get_object(multi_key)
  content_got = b''
  for chunk in result:
      content_got += chunk
  assert content_got[0:102400] == part_a
  assert content_got[102400:204800] == part_b
  assert content_got[204800:307200] == part_c

• Téléchargements avec reprise

  L'exemple de code suivant montre comment utiliser une CMK basée sur RSA gérée par vous-même pour chiffrer un objet que vous souhaitez télécharger à l'aide du téléchargement avec reprise :

  # -*- coding: utf-8 -*-
  import os
  import oss2
  from oss2.credentials import EnvironmentVariableCredentialsProvider
  from  oss2.crypto import RsaProvider
  
  key = 'motto.txt'
  content = b'a' * 1024 * 1024 * 100
  file_name_put = 'upload.txt'
  
  # Write the data included in content to the file. 
  with open(file_name_put, 'wb') as fileobj:
      fileobj.write(content)
  
  # Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured. 
  auth = oss2.ProviderAuthV4(EnvironmentVariableCredentialsProvider())
  
  # Initialize a CryptoBucket instance and use the RSA-based CMK to perform client-side encryption. This encryption method supports only uploads and downloads of entire objects. 
  # If you use OSS SDK for Python 2.9.0 or later, we recommend that you do not use LocalRsaProvider to initialize the CryptoBucket instance. 
  # bucket = oss2.CryptoBucket(auth,'yourEndpoint', 'yourBucketName', crypto_provider=LocalRsaProvider())
  
  # If you want to only decrypt objects, specify only the private key. 
  # key_pair = {'private_key': 'yourPrivateKey'}
  # If you want to only encrypt objects, specify only the public key. 
  # key_pair = {'public_key': 'yourPublicKey'}
  # If you want to encrypt and decrypt objects, you must specify both the public key and the private key. 
  key_pair = {'private_key': 'yourPrivateKey', 'public_key': 'yourPublicKey'}
  
  # Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. 
  endpoint = "https://oss-cn-hangzhou.aliyuncs.com"
  # Specify the region in which the bucket is located. Example: cn-hangzhou This parameter is required if you use the V4 signature algorithm.
  region = "cn-hangzhou"
  
  # Initialize a CryptoBucket instance. If you set upload_contexts_flag to True, you do not need to configure parameters for the multipart upload context when you call the upload_part operation. 
  bucket = oss2.CryptoBucket(auth, endpoint, 'yourBucketName',
                             crypto_provider=RsaProvider(key_pair), region=region)
  
  # In this example, the value of multipart_threshold is set to 10 * 1024 * 1024. The default multipart upload threshold is 10 MB. Specify a value based on your scenario. 
  # multipart_threshold specifies the object size threshold for using multipart upload. If the object size exceeds the threshold, multipart upload is used. If the object size is smaller than the threshold, we recommend that you call put_object to upload the object. 
  # part_size specifies the part size in multipart upload. The default part size is 10 MB. 
  # num_threads specifies the number of parallel upload threads. Default value: 1. 
  oss2.resumable_upload(bucket, key, file_name_put, multipart_threshold=10 * 1024 * 1024, part_size=1024 * 1024, num_threads=3)

• Téléchargement avec reprise

  L'exemple de code suivant montre comment utiliser une CMK gérée par KMS pour déchiffrer un objet que vous souhaitez télécharger via un téléchargement avec reprise :

  # -*- coding: utf-8 -*-
  import os
  import oss2
  from oss2.crypto import RsaProvider
  from oss2.cryptoimportAliKMSProvider
  from oss2.credentials import EnvironmentVariableCredentialsProvider
  
  # Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured. 
  auth = oss2.ProviderAuthV4(EnvironmentVariableCredentialsProvider())
  
  key = 'motto.txt'
  content = b'a' * 1024 * 1024 * 100
  file_name_get = 'download.txt'
  
  kms_provider = AliKMSProvider(auth, 'yourRegion', 'yourCMKID')
  
  endpoint = "https://oss-cn-hangzhou.aliyuncs.com"
  # Specify the region in which the bucket is located. Example: cn-hangzhou This parameter is required if you use the V4 signature algorithm.
  region = "cn-hangzhou"
  bucket = oss2.CryptoBucket(auth, endpoint, 'yourBucketName', crypto_provider=kms_provider, region=region)
  
  # Download an object using resumable download. 
  oss2.resumable_download(bucket, key, file_name_get, multiget_threshold=10 * 1024 * 1024, part_size=1024 * 1024, num_threads=3)
  
  # Check data consistency between the content of the downloaded object and that of the object before upload. 
  with open(file_name_get, 'rb') as fileobj:
      assert fileobj.read() == content
  

Chiffrement côté client V1 (non recommandé)

• Métadonnées d'objet liées au chiffrement côté client

  Paramètre	Description	Obligatoire
  x-oss-meta-oss-crypto-key	La clé de données chiffrée. Il s'agit d'une chaîne chiffrée à l'aide d'une CMK basée sur RSA, puis encodée en Base64.	Oui
  x-oss-meta-oss-crypto-start	La valeur initiale générée de manière aléatoire pour le chiffrement des données. Il s'agit d'une chaîne chiffrée à l'aide d'une CMK basée sur RSA, puis encodée en Base64.	Oui
  x-oss-meta-oss-cek-alg	L'algorithme utilisé pour chiffrer les données.	Oui
  x-oss-meta-oss-wrap-alg	L'algorithme utilisé pour chiffrer la clé de données.	Oui
  x-oss-meta-oss-matdesc	La description de la clé de chiffrement de contenu (CEK) au format JSON. Ce paramètre n'a aucun effet.	Non
  x-oss-meta-unencrypted-content-length	La longueur des données avant le chiffrement. Si content-length n'est pas spécifié, ce paramètre n'est pas généré.	Non
  x-oss-meta-unencrypted-content-md5	Le hachage MD5 des données avant le chiffrement. Si content-md5 n'est pas spécifié, ce paramètre n'est pas généré.	Non

• Téléchargement et récupération de fichiers à l'aide de RSA

  L'exemple de code suivant montre comment utiliser RSA pour télécharger et récupérer des fichiers :

  # -*- coding: utf-8 -*-
  import os
  import oss2
  from oss2.credentials import EnvironmentVariableCredentialsProvider
  from oss2.crypto import LocalRsaProvider
  
  # Obtain access credentials from environment variables. Before you run the sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured. 
  auth = oss2.ProviderAuthV4(EnvironmentVariableCredentialsProvider())
  
  # Specify the endpoint of the region in which the bucket is located. For example, if the bucket is located in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. 
  endpoint = "https://oss-cn-hangzhou.aliyuncs.com"
  # Specify the region in which the bucket is located. Example: cn-hangzhou This parameter is required if you use the V4 signature algorithm.
  region = "cn-hangzhou"
  # Initialize a CryptoBucket instance and use the RSA-based CMK to perform client-side encryption. This encryption method supports only uploads and downloads of entire objects. 
  bucket = oss2.CryptoBucket(auth, endpoint, 'yourBucketName', crypto_provider=LocalRsaProvider(), region=region)
  
  key = 'motto.txt'
  content = b'a' * 1024 * 1024
  filename = 'download.txt'
  
  # Upload the object. 
  bucket.put_object(key, content, headers={'content-length': str(1024 * 1024)})
  
  # Download the object from OSS to the local memory. 
  result = bucket.get_object(key)
  
  # Check data consistency between the content of the downloaded object and that of the object before upload. 
  content_got = b''
  for chunk in result:
      content_got += chunk
  assert content_got == content
  
  # Download the object from OSS to a local path. 
  result = bucket.get_object_to_file(key, filename)
  
  # Check data consistency between the content of the downloaded object and that of the object before upload. 
  with open(filename, 'rb') as fileobj:
      assert fileobj.read() == content

Références

Pour obtenir l'exemple de code complet relatif au chiffrement côté client, visitez GitHub.