Migrazione del client di crittografia Amazon S3 (da V2 a V3) - AWS SDK per C++
Panoramica sulla migrazioneComprensione dei concetti della V3Aggiorna i client esistenti per leggere nuovi formatiMigrazione dei client di crittografia e decrittografia alla V3Esempi aggiuntivi

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à.

Migrazione del client di crittografia Amazon S3 (da V2 a V3)

Nota

Se utilizzi la versione 1 del client di crittografia Amazon S3, devi prima migrare alla V2 prima di migrare alla V3. Per informazioni, consulta Migrazione del client di crittografia Amazon S3 (da V1 a V2).

Questo argomento mostra come migrare le applicazioni dalla versione 2 (V2) alla versione 3 (V3) del client di crittografia Amazon Simple Storage Service (Amazon S3) e garantire la disponibilità delle applicazioni durante tutto il processo di migrazione. V3 introduce l'ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEYalgoritmo e le Commitment Policies per migliorare la sicurezza proteggendo dalla manomissione delle chiavi di dati nei file di istruzioni.

Panoramica sulla migrazione

Questa migrazione avviene in due fasi:

1. Aggiorna i client esistenti per leggere nuovi formati. Innanzitutto, distribuisci una versione aggiornata di nella AWS SDK per C++ tua applicazione. Ciò consente ai client di crittografia V2 esistenti di decrittografare gli oggetti scritti dai nuovi client V3. Se l'applicazione ne utilizza più AWS SDKs, è necessario aggiornare ogni SDK separatamente.

2. Migra i client di crittografia e decrittografia alla V3. Una volta che tutti i client di crittografia V2 saranno in grado di leggere nuovi formati, sarà possibile migrare i client di crittografia e decrittografia esistenti alle rispettive versioni V3.

Comprensione dei concetti della V3

La versione 3 del client di crittografia Amazon S3 introduce nuove funzionalità di sicurezza che migliorano la protezione contro la manomissione delle chiavi dei dati. La comprensione di questi concetti è essenziale per una migrazione di successo.

Politica di impegno

Le politiche di impegno controllano il modo in cui il client di crittografia gestisce l'impegno delle chiavi durante le operazioni di crittografia e decrittografia. V3 offre tre opzioni di policy per supportare diversi scenari di migrazione e requisiti di sicurezza:

FORBID_ENCRYPT_ALLOW_DECRYPT

Comportamento di crittografia: crittografa gli oggetti senza impegno di chiave, utilizzando gli stessi algoritmi della V2.

Comportamento di decrittografia: consente la decrittografia di oggetti crittografati con e senza impegno di chiave.

Implicazioni sulla sicurezza: questa politica non impone l'impegno delle chiavi e può consentire la manomissione della chiave di dati crittografata nei file di istruzioni. Utilizza questa politica solo durante la fase di migrazione iniziale, quando hai bisogno che i client V2 leggano i nuovi oggetti crittografati.

Compatibilità delle versioni: gli oggetti crittografati con questa politica possono essere letti da tutte le implementazioni V2 e V3.

REQUIRE_ENCRYPT_ALLOW_DECRYPT (predefinito)

Comportamento di crittografia: crittografa gli oggetti con impegno chiave utilizzando l'algoritmo. ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY

Comportamento di decrittografia: consente la decrittografia sia degli oggetti crittografati con impegno di chiave che degli oggetti crittografati senza impegno di chiave.

Implicazioni sulla sicurezza: questa politica offre una protezione avanzata per gli oggetti appena crittografati, mantenendo al contempo la compatibilità con le versioni precedenti per la lettura di oggetti più vecchi. Questa è la politica consigliata per la maggior parte degli scenari di migrazione.

Compatibilità delle versioni: gli oggetti crittografati con questa politica possono essere letti solo dalla V3 e dalle implementazioni V2 più recenti. I client V2 non possono decrittografare questi oggetti. Tuttavia, i client V3 che utilizzano questa politica possono comunque decrittografare gli oggetti crittografati dai client V2.

REQUIRE_ENCRYPT_REQUIRE_DECRYPT

Comportamento di crittografia: crittografa gli oggetti con impegno chiave utilizzando l'algoritmo. ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY

Comportamento di decrittografia: consente solo la decrittografia di oggetti crittografati con l'impegno della chiave. Rifiuta gli oggetti crittografati senza l'impegno di una chiave.

Implicazioni sulla sicurezza: questa politica offre il massimo livello di sicurezza imponendo un impegno fondamentale per tutte le operazioni. Utilizzate questa policy solo dopo che tutti gli oggetti sono stati ricrittografati con impegno chiave e non è più necessario leggere gli oggetti crittografati V1 o V2 precedenti.

Compatibilità delle versioni: gli oggetti crittografati con questa policy possono essere letti solo dalla V3 e dalle implementazioni V2 più recenti. Inoltre, i client che utilizzano questa politica non possono decrittografare gli oggetti crittografati dai client V1 o V2.

Considerazioni sulla migrazione: durante la migrazione, inizia con FORBID_ENCRYPT_ALLOW_DECRYPT se hai bisogno che i client V2 leggano nuovi oggetti, quindi procedi con l'aggiornamento di tutti i client alla REQUIRE_ENCRYPT_ALLOW_DECRYPT V3. Infine, considera REQUIRE_ENCRYPT_REQUIRE_DECRYPT solo dopo che tutti gli oggetti legacy sono stati ricrittografati.

Algoritmo ALG_AES_256_GCM_HKDF_ _COMMIT_KEY SHA512

L'ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEYalgoritmo è un nuovo algoritmo di crittografia introdotto nella V3 che offre una maggiore sicurezza per le chiavi di dati crittografate archiviate nei file di istruzioni.

Impatto sui file di istruzioni: l'ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEYalgoritmo influisce solo sui file di istruzioni, che sono oggetti S3 separati che memorizzano i metadati di crittografia, inclusa la chiave dati crittografata. Gli oggetti che memorizzano i metadati di crittografia nei metadati degli oggetti (il metodo di archiviazione predefinito) non sono interessati da questa modifica dell'algoritmo.

Protezione contro la manomissione: l'ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEYalgoritmo protegge dalla manomissione delle chiavi di dati legando crittograficamente la chiave di dati crittografata al contesto di crittografia. Ciò impedisce agli aggressori di sostituire una chiave di dati crittografata diversa nel file di istruzioni, il che potrebbe potenzialmente portare alla decrittografia con una chiave non intenzionale.

Compatibilità delle versioni: gli oggetti crittografati con l'ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEYalgoritmo possono essere decrittografati solo dalle implementazioni V3 e dalle ultime versioni di transizione V2 dell'SDK che includono il supporto per la decrittografia V3.

avvertimento

Importante: prima di abilitare la crittografia con l'ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEYalgoritmo (utilizzando REQUIRE_ENCRYPT_ALLOW_DECRYPT o REQUIRE_ENCRYPT_REQUIRE_DECRYPT impegnando le politiche), è necessario assicurarsi che tutti i client che leggeranno questi oggetti siano stati aggiornati alla V3 o all'ultima versione di transizione V2 che supporta la decrittografia V3. Se non si esegue prima l'aggiornamento di tutti i lettori, si verificheranno errori di decrittografia per i nuovi oggetti crittografati.

Aggiorna i client esistenti per leggere nuovi formati

Devi prima aggiornare i client esistenti all'ultima versione dell'SDK. Dopo aver completato questo passaggio, i client V2 dell'applicazione saranno in grado di decrittografare gli oggetti crittografati dai client di crittografia V3 senza aggiornare la base di codice dell'applicazione.

Compila e installa la versione più recente di AWS SDK per C++

Applicazioni che utilizzano l'SDK dal codice sorgente

Se compili e installi il codice sorgente, scarica o clona il codice sorgente dell'SDK AWS SDK per C++ da on. aws/aws-sdk-cpp GitHub Quindi ripeti i normali passaggi di compilazione e installazione.

Se state effettuando l'aggiornamento AWS SDK per C++ da una versione precedente alla 1.11.x, consultate questo CHANGELOG per conoscere le modifiche introdotte in ogni versione principale. Per ulteriori informazioni su come creare e installare, consulta. AWS SDK per C++ Ottenere AWS SDK per C++ il codice sorgente

Applicazioni che utilizzano l'SDK di Vcpkg

Se l'applicazione utilizza Vcpkg per tenere traccia degli aggiornamenti SDK, è sufficiente utilizzare il metodo di aggiornamento Vcpkg esistente per aggiornare l'SDK alla versione più recente. Tieni presente che c'è un ritardo tra il rilascio di una versione e il momento in cui è disponibile tramite un gestore di pacchetti. La versione più recente è sempre disponibile tramite l'installazione dal codice sorgente.

È possibile eseguire il seguente comando per aggiornare il pacchettoaws-sdk-cpp:

vcpkg upgrade aws-sdk-cpp

E verifica la versione del pacchettoaws-sdk-cpp:

vcpkg list aws-sdk-cpp

La versione deve essere almeno la 1.11.x per supportare la decrittografia degli oggetti crittografati con V3.

Per ulteriori informazioni sull'utilizzo di Vcpkg con, vedere. AWS SDK per C++ Ottenere il AWS SDK per C++ file da un gestore di pacchetti

Crea, installa e distribuisci le tue applicazioni

Se l'applicazione si collega staticamente a AWS SDK per C++, non sono necessarie modifiche al codice nell'applicazione, ma è necessario creare nuovamente l'applicazione per utilizzare le ultime modifiche dell'SDK. Questo passaggio non è necessario per il collegamento dinamico.

Dopo aver aggiornato la versione dipendente dell'applicazione e verificato la funzionalità dell'applicazione, procedi con la distribuzione dell'applicazione nel tuo parco macchine. Una volta completata la distribuzione dell'applicazione, è possibile procedere con la fase successiva di migrazione dell'applicazione per utilizzare i client di crittografia e decrittografia V3.

Migrazione dei client di crittografia e decrittografia alla V3

I passaggi seguenti mostrano come migrare correttamente il codice dalla V2 alla V3 del client di crittografia Amazon S3. Poiché sono necessarie modifiche al codice, dovrai ricostruire l'applicazione indipendentemente dal fatto che si colleghi staticamente o dinamicamente a. AWS SDK per C++

Utilizzo dei client di crittografia V3

V3 introduce la S3EncryptionClientV3 classe e sostituisce gli CryptoConfigurationV3 equivalenti V2. Le differenze principali in V3 sono:

  • V3 utilizza KMSWithContextEncryptionMaterials (come V2) ma richiede una configurazione esplicita in. CryptoConfigurationV3

  • Tutte le PutObject operazioni richiedono una mappa del contesto di crittografia (può essere vuota).

  • V3 introduce Commitment Policies per controllare il comportamento di crittografia e decrittografia.

  • Per impostazione predefinita, V3 crittografa con impegno chiave utilizzando l'algoritmo. ALG_AES_256_GCM_HKDF_SHA512_COMMIT_KEY

  • L'API di configurazione della decrittografia degli algoritmi legacy cambia da a. config.SetSecurityProfile(SecurityProfile::V2_AND_LEGACY); config.AllowLegacy();

Esempio: migrazione dalla V2 alla V3 con KMS Encryption

Premigrazione (V2) 

// Create encryption materials
auto materials = Aws::MakeShared<KMSWithContextEncryptionMaterials>("s3EncryptionV2", CUSTOMER_MASTER_KEY_ID);

// Create V2 crypto configuration
CryptoConfigurationV2 cryptoConfig(materials);

// Create V2 encryption client
S3EncryptionClientV2 encryptionClient(cryptoConfig);

// Put object with encryption context
Aws::Map<Aws::String, Aws::String> encryptionContext;
encryptionContext.emplace("client", "aws-sdk-cpp");
encryptionContext.emplace("version", "1.11.0");

PutObjectRequest putObjectRequest;
putObjectRequest.SetBucket(BUCKET_NAME);
putObjectRequest.SetKey(OBJECT_KEY);
// Set object body...

auto putOutcome = encryptionClient.PutObject(putObjectRequest, encryptionContext);

// Get object with encryption context
GetObjectRequest getObjectRequest;
getObjectRequest.SetBucket(BUCKET_NAME);
getObjectRequest.SetKey(OBJECT_KEY);

auto getOutcome = encryptionClient.GetObject(getObjectRequest, encryptionContext);

Durante la migrazione (V3 con compatibilità con le versioni precedenti) 

// Create encryption materials
auto materials = Aws::MakeShared<KMSWithContextEncryptionMaterials>("s3EncryptionV3", CUSTOMER_MASTER_KEY_ID);

// Create V3 crypto configuration with materials
CryptoConfigurationV3 cryptoConfig(materials);

// Set commitment policy to maintain compatibility with V2 encrypted objects
// This allows V3 clients to decrypt objects encrypted by the V2 client
cryptoConfig.SetCommitmentPolicy(CommitmentPolicy::REQUIRE_ENCRYPT_ALLOW_DECRYPT);

// Create V3 encryption client
S3EncryptionClientV3 encryptionClient(cryptoConfig);

// Put object with encryption context
Aws::Map<Aws::String, Aws::String> encryptionContext;
encryptionContext.emplace("client", "aws-sdk-cpp");
encryptionContext.emplace("version", "1.11.0");

PutObjectRequest putObjectRequest;
putObjectRequest.SetBucket(BUCKET_NAME);
putObjectRequest.SetKey(OBJECT_KEY);
// Set object body...

auto putOutcome = encryptionClient.PutObject(putObjectRequest, encryptionContext);

// Get object with encryption context
GetObjectRequest getObjectRequest;
getObjectRequest.SetBucket(BUCKET_NAME);
getObjectRequest.SetKey(OBJECT_KEY);

auto getOutcome = encryptionClient.GetObject(getObjectRequest, encryptionContext);

Dopo la migrazione (V3 con impegno chiave) 

// Create encryption materials
auto materials = Aws::MakeShared<KMSWithContextEncryptionMaterials>("s3EncryptionV3", CUSTOMER_MASTER_KEY_ID);

// Create V3 crypto configuration with materials
CryptoConfigurationV3 cryptoConfig(materials);

// Use the default commitment policy (REQUIRE_ENCRYPT_REQUIRE_DECRYPT)
// This encrypts with key commitment and does not decrypt V2 objects
// cryptoConfig.SetCommitmentPolicy(CommitmentPolicy::REQUIRE_ENCRYPT_ALLOW_DECRYPT);

// Create V3 encryption client
S3EncryptionClientV3 encryptionClient(cryptoConfig);

// Put object with encryption context
Aws::Map<Aws::String, Aws::String> encryptionContext;
encryptionContext.emplace("client", "aws-sdk-cpp");
encryptionContext.emplace("version", "1.11.0");

PutObjectRequest putObjectRequest;
putObjectRequest.SetBucket(BUCKET_NAME);
putObjectRequest.SetKey(OBJECT_KEY);
// Set object body...

auto putOutcome = encryptionClient.PutObject(putObjectRequest, encryptionContext);

// Get object with encryption context
GetObjectRequest getObjectRequest;
getObjectRequest.SetBucket(BUCKET_NAME);
getObjectRequest.SetKey(OBJECT_KEY);

auto getOutcome = encryptionClient.GetObject(getObjectRequest, encryptionContext);

Esempi aggiuntivi

Questa sezione fornisce ulteriori esempi per la configurazione delle opzioni del client di crittografia V3 per supportare vari scenari e requisiti di migrazione.

Attivazione del supporto Legacy

I client V3 possono decrittografare gli oggetti crittografati dai client V2 solo quando utilizzano le REQUIRE_ENCRYPT_ALLOW_DECRYPT policy o commit. FORBID_ENCRYPT_ALLOW_DECRYPT Tuttavia, se è necessario decrittografare oggetti crittografati dai client V1, è necessario abilitare esplicitamente il supporto legacy utilizzando questo metodo. AllowLegacy()

Quando utilizzare il supporto legacy:

  • Hai oggetti in S3 che sono stati crittografati utilizzando la versione 1 di S3 Encryption Client.

  • È necessario leggere questi oggetti crittografati con V1 con il client V3 durante il processo di migrazione.

  • Stai utilizzando la politica di impegno REQUIRE_ENCRYPT_ALLOW_DECRYPT oFORBID_ENCRYPT_ALLOW_DECRYPT.

avvertimento

Il supporto legacy deve essere abilitato solo temporaneamente durante la migrazione. Una volta che tutti gli oggetti V1 sono stati ricrittografati con V2 o V3, disabilita il supporto legacy per garantire la massima sicurezza.

Esempio: attivazione del supporto Legacy

// Create encryption materials
auto materials = Aws::MakeShared<KMSWithContextEncryptionMaterials>("s3EncryptionV3", CUSTOMER_MASTER_KEY_ID);

// Create V3 crypto configuration
CryptoConfigurationV3 cryptoConfig(materials);

// Enable legacy support to read V1 encrypted objects
cryptoConfig.AllowLegacy();

// Set commitment policy (default is REQUIRE_ENCRYPT_REQUIRE_DECRYPT but we need to allow decryption)
cryptoConfig.SetCommitmentPolicy(CommitmentPolicy::REQUIRE_ENCRYPT_ALLOW_DECRYPT);

// Create V3 encryption client with legacy support enabled
S3EncryptionClientV3 encryptionClient(cryptoConfig);

// Now you can decrypt objects encrypted by V1, V2, and V3 clients
GetObjectRequest getObjectRequest;
getObjectRequest.SetBucket(BUCKET_NAME);
getObjectRequest.SetKey(LEGACY_OBJECT_KEY);

Aws::Map<Aws::String, Aws::String> encryptionContext;
auto getOutcome = encryptionClient.GetObject(getObjectRequest, encryptionContext);

Configurazione del metodo di archiviazione

Il client di crittografia S3 può archiviare i metadati di crittografia in due modi: come metadati di oggetti (impostazione predefinita) o in un file di istruzioni separato. È possibile configurare il metodo di archiviazione utilizzando il SetStorageMethod() metodo on. CryptoConfigurationV3

Opzioni del metodo di archiviazione:

METADATA (predefinito)

I metadati di crittografia vengono archiviati nelle intestazioni dei metadati dell'oggetto. Questo è il metodo più comune e conveniente in quanto tutte le informazioni di crittografia vengono archiviate con l'oggetto stesso.

Quando utilizzarlo: utilizzate questo metodo per la maggior parte degli scenari. Semplifica la gestione degli oggetti poiché i metadati di crittografia viaggiano con l'oggetto.

INSTRUCTION_FILE

I metadati di crittografia vengono archiviati in un oggetto S3 separato (il file di istruzioni) con il suffisso. .instruction

Quando utilizzarlo: utilizza questo metodo quando la dimensione dei metadati degli oggetti è un problema o quando è necessario separare i metadati di crittografia dall'oggetto crittografato. Nota che l'utilizzo dei file di istruzioni richiede la gestione di due oggetti S3 (l'oggetto crittografato e il relativo file di istruzioni) anziché uno.

Esempio: configurazione del metodo di archiviazione

// Create encryption materials
auto materials = Aws::MakeShared<KMSWithContextEncryptionMaterials>("s3EncryptionV3", CUSTOMER_MASTER_KEY_ID);

// Create V3 crypto configuration
CryptoConfigurationV3 cryptoConfig(materials);

// Option 1: Use metadata storage (default, can be omitted)
cryptoConfig.SetStorageMethod(StorageMethod::METADATA);

// Option 2: Use instruction file storage
cryptoConfig.SetStorageMethod(StorageMethod::INSTRUCTION_FILE);

// Create V3 encryption client with the configured storage method
S3EncryptionClientV3 encryptionClient(cryptoConfig);

// Put object - encryption metadata will be stored according to the configured method
Aws::Map<Aws::String, Aws::String> encryptionContext;
encryptionContext.emplace("client", "aws-sdk-cpp");

PutObjectRequest putObjectRequest;
putObjectRequest.SetBucket(BUCKET_NAME);
putObjectRequest.SetKey(OBJECT_KEY);
// Set object body...

auto putOutcome = encryptionClient.PutObject(putObjectRequest, encryptionContext);

// If using INSTRUCTION_FILE, a separate object with key "OBJECT_KEY.instruction" will be created
Nota

Quando utilizzate il metodo INSTRUCTION_FILE di archiviazione, ricordate che l'eliminazione dell'oggetto crittografato non elimina automaticamente il file di istruzioni. È necessario gestire entrambi gli oggetti separatamente.