Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# SDK di crittografia AWS per Python
<a name="python"></a>

In questo argomento viene descritto come installare e utilizzare SDK di crittografia AWS per Python. Per dettagli sulla programmazione con SDK di crittografia AWS per Python, consulta il [aws-encryption-sdk-python](https://github.com/aws/aws-encryption-sdk-python/)repository su GitHub. Per la documentazione sulle API, consulta [Leggi i documenti](https://aws-encryption-sdk-python.readthedocs.io/en/latest/).

**Topics**
+ [Prerequisiti](#python-prerequisites)
+ [Installazione](#python-installation)
+ [Esempi](python-example-code.md)

## Prerequisiti
<a name="python-prerequisites"></a>

Prima di installare il SDK di crittografia AWS per Python, assicuratevi di avere i seguenti prerequisiti.

**Una versione supportata di Python**  
Python 3.8 o successivo è richiesto dalle SDK di crittografia AWS per Python versioni 3.2.0 e successive.  
La [AWS Cryptographic Material Providers Library](https://github.com/aws/aws-cryptographic-material-providers-library) (MPL) è una dipendenza opzionale per quella introdotta nella versione 4. SDK di crittografia AWS per Python *x.* Se intendi installare l'MPL, devi usare Python 3.11 o successivo.
Le versioni precedenti di Python AWS Encryption SDK supportano Python 2.7 e Python 3.4 e versioni successive, ma si consiglia di utilizzare la versione più recente di. AWS Encryption SDK  
Per scaricare Python, consulta la pagina relativa ai [download di Python](https://www.python.org/downloads/).

**Lo strumento di installazione pip per Python**  
`pip`è incluso in Python 3.6 e versioni successive, anche se potresti volerlo aggiornare. Per ulteriori informazioni sull'aggiornamento o l'installazione`pip`, consulta [Installazione](https://pip.pypa.io/en/latest/installation/) nella documentazione. `pip`

## Installazione
<a name="python-installation"></a>

Installazione della versione più recente della SDK di crittografia AWS per Python.

**Nota**  
[Tutte le versioni SDK di crittografia AWS per Python precedenti alla 3.0.0 sono in fase di sviluppo. end-of-support](https://docs.aws.amazon.com/sdkref/latest/guide/maint-policy.html#version-life-cycle)  
È possibile eseguire l'aggiornamento in tutta sicurezza dalla versione 2.0. *x* e versioni successive alla versione più recente di AWS Encryption SDK senza modifiche al codice o ai dati. Tuttavia, nella versione 2.0 sono state introdotte [nuove funzionalità di sicurezza](about-versions.md#version-2). *x* non sono retrocompatibili. Per eseguire l'aggiornamento da versioni precedenti alla 1.7. *x* alla versione 2.0. *x* e versioni successive, è necessario prima eseguire l'aggiornamento alla versione più recente 1. versione *x* di AWS Encryption SDK. Per informazioni dettagliate, vedi [Migrazione del tuo AWS Encryption SDK](migration.md).

Utilizzare `pip` per installare SDK di crittografia AWS per Python, come illustrato negli esempi seguenti.

**Per installare la versione più recente**  

```
pip install "aws-encryption-sdk[MPL]"
```
Il `[MPL]` suffisso installa la [AWS Cryptographic Material Providers Library](https://github.com/aws/aws-cryptographic-material-providers-library) (MPL). L'MPL contiene costrutti per crittografare e decrittografare i dati. L'MPL è una dipendenza opzionale per quella introdotta nella versione 4. SDK di crittografia AWS per Python *x.* Consigliamo vivamente di installare l'MPL. Tuttavia, se non intendete utilizzare l'MPL, potete omettere il suffisso. `[MPL]`

Per ulteriori dettagli sull'utilizzo di pip per installare e aggiornare pacchetti, consulta la sezione relativa all'[installazione dei pacchetti](https://packaging.python.org/tutorials/installing-packages/).

 SDK di crittografia AWS per Python Richiede la [libreria di crittografia (pyca/cryptography](https://cryptography.io/en/latest/)) su tutte le piattaforme. Tutte le versioni di installano e creano `pip` automaticamente la libreria su Windows. `cryptography` `pip`8.1 e versioni successive vengono installate e create automaticamente `cryptography` su Linux. Se si utilizza una versione precedente di `pip` e l'ambiente Linux non dispone degli strumenti necessari per creare la `cryptography` libreria, è necessario installarli. Per ulteriori informazioni, consulta la sezione relativa alla [creazione di una crittografia in Linux](https://cryptography.io/en/latest/installation.html#building-cryptography-on-linux).

Le versioni 1.10.0 e 2.5.0 inseriscono la dipendenza dalla SDK di crittografia AWS per Python [crittografia](https://cryptography.io/en/latest/) tra 2.5.0 e 3.3.2. Le altre versioni installano la versione più recente della crittografia. SDK di crittografia AWS per Python Se è necessaria una versione di crittografia successiva alla 3.3.2, si consiglia di utilizzare la versione principale più recente di. SDK di crittografia AWS per Python

Per la versione di sviluppo più recente di SDK di crittografia AWS per Python, vai al [aws-encryption-sdk-python](https://github.com/aws/aws-encryption-sdk-python/)repository in. GitHub

Dopo aver installato SDK di crittografia AWS per Python, inizia a guardare il [codice di esempio di Python](python-example-code.md) in questa guida.

# SDK di crittografia AWS per Python codice di esempio
<a name="python-example-code"></a>

I seguenti esempi mostrano come utilizzare il per SDK di crittografia AWS per Python crittografare e decrittografare i dati.

Gli esempi in questa sezione mostrano come utilizzare la versione 4. *x* del SDK di crittografia AWS per Python con la dipendenza opzionale [Cryptographic Material Providers Library](https://github.com/aws/aws-cryptographic-material-providers-library) ()`aws-cryptographic-material-providers`. Per visualizzare esempi che utilizzano versioni precedenti o installazioni senza la libreria dei provider di materiali (MPL), trovate la vostra versione nell'elenco delle [release](https://github.com/aws/aws-encryption-sdk-python/releases) del [aws-encryption-sdk-python](https://github.com/aws/aws-encryption-sdk-python/)repository su. GitHub

Quando usi la versione 4. *x* della SDK di crittografia AWS per Python MPL, utilizza i [portachiavi](choose-keyring.md) per eseguire la crittografia delle [buste](concepts.md#envelope-encryption). AWS Encryption SDK Fornisce portachiavi compatibili con i provider di chiavi principali utilizzati nelle versioni precedenti. Per ulteriori informazioni, consulta [Compatibilità dei keyring](choose-keyring.md#keyring-compatibility). Per esempi sulla migrazione dai fornitori di chiavi master ai portachiavi, consulta [Esempi di migrazione nell'`aws-encryption-sdk-python`archivio](https://github.com/aws/aws-encryption-sdk-python/tree/master/examples/src/migration) su; GitHub

**Topics**
+ [Stringhe](#python-example-strings)
+ [Flussi di byte](#python-example-streams)

## Crittografia e decrittazione di stringhe
<a name="python-example-strings"></a>

L'esempio seguente mostra come utilizzare le stringhe per crittografare e AWS Encryption SDK decrittografare. Questo esempio utilizza un [AWS KMS portachiavi con una chiave KMS](use-kms-keyring.md) di crittografia simmetrica.

[Questo esempio crea un'istanza del AWS Encryption SDK client con la politica di impegno predefinita,.](migrate-commitment-policy.md) `REQUIRE_ENCRYPT_REQUIRE_DECRYPT` Per ulteriori informazioni, consulta [Impostazione della politica di impegno](migrate-commitment-policy.md).

```
# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
This example sets up the KMS Keyring

The AWS KMS keyring uses symmetric encryption KMS keys to generate, encrypt and
decrypt data keys. This example creates a KMS Keyring and then encrypts a custom input EXAMPLE_DATA
with an encryption context. This example also includes some sanity checks for demonstration:
1. Ciphertext and plaintext data are not the same
2. Encryption context is correct in the decrypted message header
3. Decrypted plaintext value matches EXAMPLE_DATA
These sanity checks are for demonstration in the example only. You do not need these in your code.

AWS KMS keyrings can be used independently or in a multi-keyring with other keyrings
of the same or a different type.

"""

import boto3
from aws_cryptographic_material_providers.mpl import AwsCryptographicMaterialProviders
from aws_cryptographic_material_providers.mpl.config import MaterialProvidersConfig
from aws_cryptographic_material_providers.mpl.models import CreateAwsKmsKeyringInput
from aws_cryptographic_material_providers.mpl.references import IKeyring
from typing import Dict  # noqa pylint: disable=wrong-import-order

import aws_encryption_sdk
from aws_encryption_sdk import CommitmentPolicy

EXAMPLE_DATA: bytes = b"Hello World"


def encrypt_and_decrypt_with_keyring(
    kms_key_id: str
):
    """Demonstrate an encrypt/decrypt cycle using an AWS KMS keyring.

    Usage: encrypt_and_decrypt_with_keyring(kms_key_id)
    :param kms_key_id: KMS Key identifier for the KMS key you want to use for encryption and
    decryption of your data keys.
    :type kms_key_id: string
    
    """
    # 1. Instantiate the encryption SDK client.
    # This builds the client with the REQUIRE_ENCRYPT_REQUIRE_DECRYPT commitment policy,
    # which enforces that this client only encrypts using committing algorithm suites and enforces
    # that this client will only decrypt encrypted messages that were created with a committing
    # algorithm suite.
    # This is the default commitment policy if you were to build the client as
    # `client = aws_encryption_sdk.EncryptionSDKClient()`.
    client = aws_encryption_sdk.EncryptionSDKClient(
        commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
    )

    # 2. Create a boto3 client for KMS.
    kms_client = boto3.client('kms', region_name="us-west-2")

    # 3. Optional: create encryption context.
    # Remember that your encryption context is NOT SECRET.
    encryption_context: Dict[str, str] = {
        "encryption": "context",
        "is not": "secret",
        "but adds": "useful metadata",
        "that can help you": "be confident that",
        "the data you are handling": "is what you think it is",
    }

    # 4. Create your keyring
    mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
        config=MaterialProvidersConfig()
    )

    keyring_input: CreateAwsKmsKeyringInput = CreateAwsKmsKeyringInput(
        kms_key_id=kms_key_id,
        kms_client=kms_client
    )

    kms_keyring: IKeyring = mat_prov.create_aws_kms_keyring(
        input=keyring_input
    )

    # 5. Encrypt the data with the encryptionContext.
    ciphertext, _ = client.encrypt(
        source=EXAMPLE_DATA,
        keyring=kms_keyring,
        encryption_context=encryption_context
    )

    # 6. Demonstrate that the ciphertext and plaintext are different.
    # (This is an example for demonstration; you do not need to do this in your own code.)
    assert ciphertext != EXAMPLE_DATA, \
        "Ciphertext and plaintext data are the same. Invalid encryption"

    # 7. Decrypt your encrypted data using the same keyring you used on encrypt.
    plaintext_bytes, _ = client.decrypt(
        source=ciphertext,
        keyring=kms_keyring,
        # Provide the encryption context that was supplied to the encrypt method
        encryption_context=encryption_context,
    )

    # 8. Demonstrate that the decrypted plaintext is identical to the original plaintext.
    # (This is an example for demonstration; you do not need to do this in your own code.)
    assert plaintext_bytes == EXAMPLE_DATA, \
        "Decrypted plaintext should be identical to the original plaintext. Invalid decryption"
```

## Crittografia e decrittazione di flussi di byte
<a name="python-example-streams"></a>

L'esempio seguente mostra come utilizzare per crittografare e AWS Encryption SDK decrittografare i flussi di byte. [Questo esempio utilizza un portachiavi Raw AES.](use-raw-aes-keyring.md)

Questo esempio crea un'istanza del AWS Encryption SDK client con la politica di [impegno predefinita](migrate-commitment-policy.md),. `REQUIRE_ENCRYPT_REQUIRE_DECRYPT` Per ulteriori informazioni, consulta [Impostazione della politica di impegno](migrate-commitment-policy.md).

```
# Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: Apache-2.0
"""
This example demonstrates file streaming for encryption and decryption.

File streaming is useful when the plaintext or ciphertext file/data is too large to load into
memory. Therefore, the AWS Encryption SDK allows users to stream the data, instead of loading it
all at once in memory. In this example, we demonstrate file streaming for encryption and decryption
using a Raw AES keyring. However, you can use any keyring with streaming.

This example creates a Raw AES Keyring and then encrypts an input stream from the file
`plaintext_filename` with an encryption context to an output (encrypted) file `ciphertext_filename`.
It then decrypts the ciphertext from `ciphertext_filename` to a new file `decrypted_filename`.
This example also includes some sanity checks for demonstration:
1. Ciphertext and plaintext data are not the same
2. Encryption context is correct in the decrypted message header
3. Decrypted plaintext value matches EXAMPLE_DATA
These sanity checks are for demonstration in the example only. You do not need these in your code.

See raw_aes_keyring_example.py in the same directory for another raw AES keyring example
in the AWS Encryption SDK for Python.
"""
import filecmp
import secrets

from aws_cryptographic_material_providers.mpl import AwsCryptographicMaterialProviders
from aws_cryptographic_material_providers.mpl.config import MaterialProvidersConfig
from aws_cryptographic_material_providers.mpl.models import AesWrappingAlg, CreateRawAesKeyringInput
from aws_cryptographic_material_providers.mpl.references import IKeyring
from typing import Dict  # noqa pylint: disable=wrong-import-order

import aws_encryption_sdk
from aws_encryption_sdk import CommitmentPolicy


def encrypt_and_decrypt_with_keyring(
    plaintext_filename: str,
    ciphertext_filename: str,
    decrypted_filename: str
):
    """Demonstrate a streaming encrypt/decrypt cycle.

    Usage: encrypt_and_decrypt_with_keyring(plaintext_filename
                                            ciphertext_filename
                                            decrypted_filename)
    :param plaintext_filename: filename of the plaintext data
    :type plaintext_filename: string
    :param ciphertext_filename: filename of the ciphertext data
    :type ciphertext_filename: string
    :param decrypted_filename: filename of the decrypted data
    :type decrypted_filename: string
    """
    # 1. Instantiate the encryption SDK client.
    # This builds the client with the REQUIRE_ENCRYPT_REQUIRE_DECRYPT commitment policy,
    # which enforces that this client only encrypts using committing algorithm suites and enforces
    # that this client will only decrypt encrypted messages that were created with a committing
    # algorithm suite.
    # This is the default commitment policy if you were to build the client as
    # `client = aws_encryption_sdk.EncryptionSDKClient()`.
    client = aws_encryption_sdk.EncryptionSDKClient(
        commitment_policy=CommitmentPolicy.REQUIRE_ENCRYPT_REQUIRE_DECRYPT
    )

    # 2. The key namespace and key name are defined by you.
    # and are used by the Raw AES keyring to determine
    # whether it should attempt to decrypt an encrypted data key.
    key_name_space = "Some managed raw keys"
    key_name = "My 256-bit AES wrapping key"

    # 3. Optional: create encryption context.
    # Remember that your encryption context is NOT SECRET.
    encryption_context: Dict[str, str] = {
        "encryption": "context",
        "is not": "secret",
        "but adds": "useful metadata",
        "that can help you": "be confident that",
        "the data you are handling": "is what you think it is",
    }

    # 4. Generate a 256-bit AES key to use with your keyring.
    # In practice, you should get this key from a secure key management system such as an HSM.

    # Here, the input to secrets.token_bytes() = 32 bytes = 256 bits
    static_key = secrets.token_bytes(32)

    # 5. Create a Raw AES keyring
    # We choose to use a raw AES keyring, but any keyring can be used with streaming.
    mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
        config=MaterialProvidersConfig()
    )

    keyring_input: CreateRawAesKeyringInput = CreateRawAesKeyringInput(
        key_namespace=key_name_space,
        key_name=key_name,
        wrapping_key=static_key,
        wrapping_alg=AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16
    )

    raw_aes_keyring: IKeyring = mat_prov.create_raw_aes_keyring(
        input=keyring_input
    )

    # 6. Encrypt the data stream with the encryptionContext
    with open(plaintext_filename, 'rb') as pt_file, open(ciphertext_filename, 'wb') as ct_file:
        with client.stream(
            mode='e',
            source=pt_file,
            keyring=raw_aes_keyring,
            encryption_context=encryption_context
        ) as encryptor:
            for chunk in encryptor:
                ct_file.write(chunk)

    # 7. Demonstrate that the ciphertext and plaintext are different.
    # (This is an example for demonstration; you do not need to do this in your own code.)
    assert not filecmp.cmp(plaintext_filename, ciphertext_filename), \
        "Ciphertext and plaintext data are the same. Invalid encryption"

    # 8. Decrypt your encrypted data stream using the same keyring you used on encrypt.
    with open(ciphertext_filename, 'rb') as ct_file, open(decrypted_filename, 'wb') as pt_file:
        with client.stream(
            mode='d',
            source=ct_file,
            keyring=raw_aes_keyring,
            encryption_context=encryption_context
        ) as decryptor:
            for chunk in decryptor:
                pt_file.write(chunk)

    # 10. Demonstrate that the decrypted plaintext is identical to the original plaintext.
    # (This is an example for demonstration; you do not need to do this in your own code.)
    assert filecmp.cmp(plaintext_filename, decrypted_filename), \
        "Decrypted plaintext should be identical to the original plaintext. Invalid decryption"
```