Usar claves de encriptación proporcionadas por el cliente

En esta página, se describe cómo usar tu propia clave de encriptación, conocida como clave de encriptación proporcionada por el cliente, con Cloud Storage. Para obtener detalles sobre esta característica, incluidos los países en los que está disponible, consulta Claves de encriptación proporcionadas por el cliente. Para conocer otras opciones de encriptación en Cloud Storage, consulta Opciones de encriptación de datos.

Generar tu propia clave de encriptación

Hay muchas formas de generar una clave de encriptación AES-256 codificada en Base64. A continuación, se incluyen algunos ejemplos:

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C++.

// Create a pseudo-random number generator (PRNG), this is included for
// demonstration purposes only. You should consult your security team about
// best practices to initialize PRNG. In particular, you should verify that
// the C++ library and operating system provide enough entropy to meet the
// security policies in your organization.

// Use the Mersenne-Twister Engine in this example:
//   https://en.cppreference.com/w/cpp/numeric/random/mersenne_twister_engine
// Any C++ PRNG can be used below, the choice is arbitrary.
using GeneratorType = std::mt19937_64;

// Create the default random device to fetch entropy.
std::random_device rd;

// Compute how much entropy we need to initialize the GeneratorType:
constexpr auto kRequiredEntropyWords =
    GeneratorType::state_size *
    (GeneratorType::word_size / std::numeric_limits<unsigned int>::digits);

// Capture the entropy bits into a vector.
std::vector<unsigned long> entropy(kRequiredEntropyWords);
std::generate(entropy.begin(), entropy.end(), [&rd] { return rd(); });

// Create the PRNG with the fetched entropy.
std::seed_seq seed(entropy.begin(), entropy.end());

// initialized with enough entropy such that the encryption keys are not
// predictable. Note that the default constructor for all the generators in
// the C++ standard library produce predictable keys.
std::mt19937_64 gen(seed);

namespace gcs = google::cloud::storage;
gcs::EncryptionKeyData data = gcs::CreateKeyFromGenerator(gen);

std::cout << "Base64 encoded key = " << data.key << "\n"
          << "Base64 encoded SHA256 of key = " << data.sha256 << "\n";

C#

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C#.

void GenerateEncryptionKey()
{
    Console.Write(EncryptionKey.Generate().Base64Key);
}

Node.js

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Node.js.

const crypto = require('crypto');

/**
 * Generates a 256 bit (32 byte) AES encryption key and prints the base64
 * representation.
 *
 * This is included for demonstration purposes. You should generate your own
 * key. Please remember that encryption keys should be handled with a
 * comprehensive security policy.
 *
 * @returns {string} The encryption key.
 */
function generateEncryptionKey() {
  const buffer = crypto.randomBytes(32);
  const encodedKey = buffer.toString('base64');

  console.log(`Base 64 encoded encryption key: ${encodedKey}`);

  return encodedKey;
}

PHP

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para PHP.


/**
 * Generate a base64 encoded encryption key for Google Cloud Storage.
 *
 * @return void
 */
function generate_encryption_key()
{
    $key = random_bytes(32);
    $encodedKey = base64_encode($key);
    printf('Your encryption key: %s' . PHP_EOL, $encodedKey);
}

Python

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Python.

def generate_encryption_key():
    """Generates a 256 bit (32 byte) AES encryption key and prints the
    base64 representation.

    This is included for demonstration purposes. You should generate your own
    key. Please remember that encryption keys should be handled with a
    comprehensive security policy.
    """
    key = os.urandom(32)
    encoded_key = base64.b64encode(key).decode('utf-8')
    print('Base 64 encoded encryption key: {}'.format(encoded_key))

Ruby

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Ruby.

require "base64"
require "openssl"

encryption_key  = OpenSSL::Cipher.new("aes-256-cfb").encrypt.random_key
encoded_enc_key = Base64.encode64 encryption_key

puts "Sample encryption key: #{encoded_enc_key}"

Subir con tu clave de encriptación

Si quieres usar las claves de encriptación proporcionadas por el cliente para subir un objeto, haz lo siguiente:

gsutil

  1. Agrega la siguiente opción a la sección [GSUtil] de tu archivo de configuración de boto:

    encryption_key = [YOUR_ENCRYPTION_KEY]

    en el que [YOUR_ENCRYPTION_KEY] es la clave de encriptación AES-256 que se usó para encriptar tu objeto.

  2. Usa el comando gsutil cp:

    gsutil cp [LOCAL_OBJECT_LOCATION] gs://[DESTINATION_BUCKET_NAME]/

    En el que:

    • [LOCAL_OBJECT_LOCATION] es la ruta al objeto que deseas subir. Por ejemplo, Desktop/dogs.png.
    • [DESTINATION_BUCKET_NAME] es el nombre del depósito en el que deseas subir el objeto. Por ejemplo, my-bucket.

Ejemplos de código

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C++.

namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string bucket_name, std::string object_name,
   std::string base64_aes256_key) {
  StatusOr<gcs::ObjectMetadata> object_metadata = client.InsertObject(
      bucket_name, object_name, "top secret",
      gcs::EncryptionKey::FromBase64Key(base64_aes256_key));

  if (!object_metadata) {
    throw std::runtime_error(object_metadata.status().message());
  }

  std::cout << "The object " << object_metadata->name()
            << " was created in bucket " << object_metadata->bucket()
            << "\nFull metadata: " << *object_metadata << "\n";
}

C#

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C#.

private void UploadEncryptedFile(string key, string bucketName,
    string localPath, string objectName = null)
{
    var storage = StorageClient.Create();
    using (var f = File.OpenRead(localPath))
    {
        objectName = objectName ?? Path.GetFileName(localPath);
        storage.UploadObject(bucketName, objectName, null, f,
            new UploadObjectOptions()
            {
                EncryptionKey = EncryptionKey.Create(
                Convert.FromBase64String(key))
            });
        Console.WriteLine($"Uploaded {objectName}.");
    }
}

Go

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Go.

obj := client.Bucket(bucket).Object(object)
// Encrypt the object's contents.
wc := obj.Key(secretKey).NewWriter(ctx)
if _, err := wc.Write([]byte("top secret")); err != nil {
	return err
}
if err := wc.Close(); err != nil {
	return err
}

Java

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Java.

byte[] data = "Hello, World!".getBytes(UTF_8);

BlobId blobId = BlobId.of(bucketName, blobName);
BlobInfo blobInfo = BlobInfo.newBuilder(blobId).setContentType("text/plain").build();
Blob blob = storage.create(blobInfo, data, BlobTargetOption.encryptionKey(encryptionKey));

Node.js

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Node.js.

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const srcFilename = 'Local file to upload, e.g. ./local/path/to/file.txt';
// const destFilename = 'Remote destination for file, e.g. file_encrypted.txt';

// See the "Generating your own encryption key" section above.
// const key = 'A base64 encoded customer-supplied key';

const options = {
  // The path to which the file should be uploaded, e.g. "file_encrypted.txt"
  destination: destFilename,
  // Encrypt the file with a customer-supplied key.
  // See the "Generating your own encryption key" section above.
  encryptionKey: Buffer.from(key, 'base64'),
};

// Encrypts and uploads a local file, e.g. "./local/path/to/file.txt".
// The file will only be retrievable using the key used to upload it.
await storage.bucket(bucketName).upload(srcFilename, options);

console.log(
  `File ${srcFilename} uploaded to gs://${bucketName}/${destFilename}.`
);

PHP

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para PHP.

use Google\Cloud\Storage\StorageClient;

/**
 * Upload an encrypted file.
 *
 * @param string $bucketName the name of your Google Cloud bucket.
 * @param string $objectName the name of your Google Cloud object.
 * @param resource $source the path to the file to upload.
 * @param string $base64EncryptionKey the base64 encoded encryption key.
 *
 * @return void
 */
function upload_encrypted_object($bucketName, $objectName, $source, $base64EncryptionKey)
{
    $storage = new StorageClient();
    $file = fopen($source, 'r');
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->upload($file, [
        'name' => $objectName,
        'encryptionKey' => $base64EncryptionKey,
    ]);
    printf('Uploaded encrypted %s to gs://%s/%s' . PHP_EOL,
        basename($source), $bucketName, $objectName);
}

Python

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Python.

def upload_encrypted_blob(bucket_name, source_file_name,
                          destination_blob_name, base64_encryption_key):
    """Uploads a file to a Google Cloud Storage bucket using a custom
    encryption key.

    The file will be encrypted by Google Cloud Storage and only
    retrievable using the provided encryption key.
    """
    storage_client = storage.Client()
    bucket = storage_client.get_bucket(bucket_name)
    # Encryption key must be an AES256 key represented as a bytestring with
    # 32 bytes. Since it's passed in as a base64 encoded string, it needs
    # to be decoded.
    encryption_key = base64.b64decode(base64_encryption_key)
    blob = Blob(destination_blob_name, bucket, encryption_key=encryption_key)

    blob.upload_from_filename(source_file_name)

    print('File {} uploaded to {}.'.format(
        source_file_name,
        destination_blob_name))

Ruby

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Ruby.

# project_id        = "Your Google Cloud project ID"
# bucket_name       = "Your Google Cloud Storage bucket name"
# local_file_path   = "Path to local file to upload"
# storage_file_path = "Path to store the file in Google Cloud Storage"
# encryption_key    = "AES-256 encryption key"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new project_id: project_id

bucket = storage.bucket bucket_name

file = bucket.create_file local_file_path, storage_file_path,
                          encryption_key: encryption_key

puts "Uploaded #{file.name} with encryption key"

API de REST

API de JSON

  1. Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus propias credenciales de OAuth.
  2. Usa cURL para llamar a la API de JSON con una solicitud de objeto POST:

    curl -X POST --data-binary @[OBJECT] \
      -H "Authorization: Bearer [OAUTH2_TOKEN]" \
      -H "Content-Type: [OBJECT_CONTENT_TYPE]" \
      -H "x-goog-encryption-algorithm: AES256" \
      -H "x-goog-encryption-key: [YOUR_ENCRYPTION_KEY]" \
      -H "x-goog-encryption-key-sha256: [HASH_OF_YOUR_KEY]" \
      "https://www.googleapis.com/upload/storage/v1/b/[BUCKET_NAME]/o?uploadType=media&name=[OBJECT_NAME]"

    En la que:

    • [OBJECT] es la ruta al objeto que deseas subir. Por ejemplo, Desktop/dogs.png.
    • [OAUTH2_TOKEN] es el token de acceso que generaste en el Paso 1.
    • [OBJECT_CONTENT_TYPE] es el tipo de contenido del objeto. Por ejemplo, image/png.
    • [YOUR_ENCRYPTION_KEY] es la clave AES-256 que se usó para encriptar el objeto subido.
    • [HASH_OF_YOUR_KEY] es el hash SHA-256 para tu clave AES-256.
    • [BUCKET_NAME] es el nombre del depósito en el que deseas subir el objeto. Por ejemplo, my-bucket.
    • [OBJECT_NAME] es el nombre del objeto que deseas subir. Por ejemplo, pets/dogs.png.

Consulta la sección sobre encabezados de solicitud de encriptación para obtener más información sobre los encabezados específicos de encriptación.

API de XML

  1. Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus propias credenciales de OAuth.
  2. Usa cURL para llamar a la API de XML con una solicitud de objeto PUT:

    curl -X -i PUT --data-binary @[OBJECT] \
      -H "Authorization: Bearer [OAUTH2_TOKEN]" \
      -H "Content-Type: [OBJECT_CONTENT_TYPE]" \
      -H "x-goog-encryption-algorithm: AES256" \
      -H "x-goog-encryption-key: [YOUR_ENCRYPTION_KEY]" \
      -H "x-goog-encryption-key-sha256: [HASH_OF_YOUR_KEY]" \
      "https://storage.googleapis.com/[BUCKET_NAME]/[OBJECT_NAME]"

    En la que:

    • [OBJECT] es la ruta al objeto que deseas subir. Por ejemplo, Desktop/dogs.png.
    • [OAUTH2_TOKEN] es el token de acceso que generaste en el Paso 1.
    • [OBJECT_CONTENT_TYPE] es el tipo de contenido del objeto. Por ejemplo, image/png.
    • [YOUR_ENCRYPTION_KEY] es la clave AES-256 que se usó para encriptar el objeto subido.
    • [HASH_OF_YOUR_KEY] es el hash SHA-256 para tu clave AES-256.
    • [BUCKET_NAME] es el nombre del depósito en el que deseas subir el objeto. Por ejemplo, my-bucket.
    • [OBJECT_NAME] es el nombre del objeto que deseas subir. Por ejemplo, pets/dogs.png.

Consulta la sección sobre encabezados de solicitud de encriptación para obtener más información sobre los encabezados específicos de encriptación.

Descargar objetos encriptados

Para descargar un objeto almacenado en Cloud Storage que está encriptado con una clave de encriptación proporcionada por el cliente, haz lo siguiente:

gsutil

  1. Agrega la siguiente opción a la sección [GSUtil] de tu archivo de configuración de boto:

    decryption_key1 = [YOUR_ENCRYPTION_KEY]

    en el que [YOUR_ENCRYPTION_KEY] es la clave que se usó para encriptar el objeto cuando se subió.

  2. Usa el comando gsutil cp:

    gsutil cp gs://[BUCKET_NAME]/[OBJECT_NAME] [OBJECT_DESTINATION]

    En el que:

    • [BUCKET_NAME] es el nombre del depósito que contiene el objeto que deseas descargar. Por ejemplo, my-bucket.
    • [OBJECT_NAME] es el nombre del objeto que deseas descargar. Por ejemplo, pets/dog.png.
    • [OBJECT_DESTINATION] es la ubicación en la que deseas guardar tu objeto. Por ejemplo, Desktop.

Ejemplos de código

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C++.

namespace gcs = google::cloud::storage;
[](gcs::Client client, std::string bucket_name, std::string object_name,
   std::string base64_aes256_key) {
  gcs::ObjectReadStream stream =
      client.ReadObject(bucket_name, object_name,
                        gcs::EncryptionKey::FromBase64Key(base64_aes256_key));

  std::string data(std::istreambuf_iterator<char>{stream}, {});
  std::cout << "The object contents are: " << data << "\n";
}

C#

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C#.

private void DownloadEncryptedObject(string key, string bucketName,
    string objectName, string localPath = null)
{
    var storage = StorageClient.Create();
    localPath = localPath ?? Path.GetFileName(objectName);
    using (var outputFile = File.OpenWrite(localPath))
    {
        storage.DownloadObject(bucketName, objectName, outputFile,
            new DownloadObjectOptions()
            {
                EncryptionKey = EncryptionKey.Create(
                    Convert.FromBase64String(key))
            });
    }
    Console.WriteLine($"downloaded {objectName} to {localPath}.");
}

Go

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Go.

obj := client.Bucket(bucket).Object(object)
rc, err := obj.Key(secretKey).NewReader(ctx)
if err != nil {
	return nil, err
}
defer rc.Close()

data, err := ioutil.ReadAll(rc)
if err != nil {
	return nil, err
}

Java

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Java.

byte[] content =
    storage.readAllBytes(bucketName, blobName, BlobSourceOption.decryptionKey(decryptionKey));

Node.js

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Node.js.

// Imports the Google Cloud client library
const {Storage} = require('@google-cloud/storage');

// Creates a client
const storage = new Storage();

/**
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const bucketName = 'Name of a bucket, e.g. my-bucket';
// const srcFilename = 'File to download, e.g. file_encrypted.txt';
// const destFilename = 'Local destination for file, e.g. ./file.txt';

// See the "Generating your own encryption key" section above.
// const key = 'A base64 encoded customer-supplied key';

const options = {
  // The path to which the file should be downloaded, e.g. "./file.txt"
  destination: destFilename,
};

// Descrypts and downloads the file. This can only be done with the key used
// to encrypt and upload the file.
await storage
  .bucket(bucketName)
  .file(srcFilename)
  .setEncryptionKey(Buffer.from(key, 'base64'))
  .download(options);

console.log(`File ${srcFilename} downloaded to ${destFilename}.`);

PHP

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para PHP.

use Google\Cloud\Storage\StorageClient;

/**
 * Download an encrypted file
 *
 * @param string $bucketName the name of your Google Cloud bucket.
 * @param string $objectName the name of your Google Cloud object.
 * @param string $destination the local destination to save the encrypted file.
 * @param string $base64EncryptionKey the base64 encoded encryption key.
 *
 * @return void
 */
function download_encrypted_object($bucketName, $objectName, $destination, $base64EncryptionKey)
{
    $storage = new StorageClient();
    $bucket = $storage->bucket($bucketName);
    $object = $bucket->object($objectName);
    $object->downloadToFile($destination, [
        'encryptionKey' => $base64EncryptionKey,
    ]);
    printf('Encrypted object gs://%s/%s downloaded to %s' . PHP_EOL,
        $bucketName, $objectName, basename($destination));
}

Python

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Python.

def download_encrypted_blob(bucket_name, source_blob_name,
                            destination_file_name, base64_encryption_key):
    """Downloads a previously-encrypted blob from Google Cloud Storage.

    The encryption key provided must be the same key provided when uploading
    the blob.
    """
    storage_client = storage.Client()
    bucket = storage_client.get_bucket(bucket_name)
    # Encryption key must be an AES256 key represented as a bytestring with
    # 32 bytes. Since it's passed in as a base64 encoded string, it needs
    # to be decoded.
    encryption_key = base64.b64decode(base64_encryption_key)
    blob = Blob(source_blob_name, bucket, encryption_key=encryption_key)

    blob.download_to_filename(destination_file_name)

    print('Blob {} downloaded to {}.'.format(
        source_blob_name,
        destination_file_name))

Ruby

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Ruby.

# project_id     = "Your Google Cloud project ID"
# bucket_name    = "Your Google Cloud Storage bucket name"
# file_name      = "Name of file in Google Cloud Storage to download locally"
# local_path     = "Destination path for downloaded file"
# encryption_key = "AES-256 encryption key"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new project_id: project_id

bucket = storage.bucket bucket_name

file = bucket.file storage_file_path, encryption_key: encryption_key
file.download local_file_path, encryption_key: encryption_key

puts "Downloaded encrypted #{file.name}"

API de REST

API de JSON

  1. Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus propias credenciales de OAuth.
  2. Usa cURL para llamar a la API de JSON con una solicitud de objeto GET:

    curl -X GET \
      -H "Authorization: Bearer [OAUTH2_TOKEN]" \
      -H "x-goog-encryption-algorithm: AES256" \
      -H "x-goog-encryption-key: [YOUR_ENCRYPTION_KEY]" \
      -H "x-goog-encryption-key-sha256: [HASH_OF_YOUR_KEY]" \
      -o "[SAVE_TO_LOCATION]" \
      "https://www.googleapis.com/storage/v1/b/[BUCKET_NAME]/o/[OBJECT_NAME]?alt=media"

    En la que:

    • [OAUTH2_TOKEN] es el token de acceso que generaste en el Paso 1.
    • [YOUR_ENCRYPTION_KEY] es la clave AES-256 que usaste para encriptar el objeto.
    • [HASH_OF_YOUR_KEY] es el hash SHA-256 para tu clave AES-256.
    • [SAVE_TO_LOCATION] es la ubicación en la que deseas guardar tu objeto. Por ejemplo, Desktop/dog.png.
    • [BUCKET_NAME] es el nombre del depósito desde el que descargas el objeto. Por ejemplo, my-bucket.
    • [OBJECT_NAME] es el nombre del objeto que deseas descargar. Por ejemplo, pets/dogs.png.

Consulta la sección sobre encabezados de solicitud de encriptación para obtener más información sobre los encabezados específicos de encriptación.

API de XML

  1. Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus propias credenciales de OAuth.
  2. Usa cURL para llamar a la API de XML con una solicitud de objeto GET:

    curl -X GET \
      -H "Authorization: Bearer [OAUTH2_TOKEN]" \
      -H "x-goog-encryption-algorithm: AES256" \
      -H "x-goog-encryption-key: [YOUR_ENCRYPTION_KEY]" \
      -H "x-goog-encryption-key-sha256: [HASH_OF_YOUR_KEY]" \
      -o "[SAVE_TO_LOCATION]" \
      "https://storage.googleapis.com/[BUCKET_NAME]/[OBJECT_NAME]"

    En la que:

    • [OAUTH2_TOKEN] es el token de acceso que generaste en el Paso 1.
    • [YOUR_ENCRYPTION_KEY] es la clave AES-256 que usaste para encriptar el objeto.
    • [HASH_OF_YOUR_KEY] es el hash SHA-256 para tu clave AES-256.
    • [SAVE_TO_LOCATION] es la ubicación en la que deseas guardar tu objeto. Por ejemplo, Desktop/dog.png.
    • [BUCKET_NAME] es el nombre del depósito desde el que descargas el objeto. Por ejemplo, my-bucket.
    • [OBJECT_NAME] es el nombre del objeto que deseas descargar. Por ejemplo, pets/dogs.png.

Consulta la sección sobre encabezados de solicitud de encriptación para obtener más información sobre los encabezados específicos de encriptación.

Rotar tus claves de encriptación

Para rotar una clave de encriptación proporcionada por el cliente, sigue estos pasos:

gsutil

  1. Agrega las siguientes opciones a la sección [GSUtil] de tu archivo de configuración de boto:

    encryption_key = [NEW_ENCRYPTION_KEY]
    decryption_key1 = [OLD_ENCRYPTION_KEY]

    En el que:

    • [NEW_ENCRYPTION_KEY] es la clave de encriptación nueva de tu objeto.
    • [OLD_ENCRYPTION_KEY] es la clave de encriptación actual de tu objeto.
  2. Usa el comando gsutil rewrite con la marca -k:

    gsutil rewrite -k gs://[BUCKET_NAME]/[OBJECT_NAME]

    En el que:

    • [BUCKET_NAME] es el nombre del depósito que contiene el objeto pertinente. Por ejemplo, my-bucket.
    • [OBJECT_NAME] es el nombre del objeto pertinente. Por ejemplo, pets/dog.png.

Ejemplos de código

C++

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para C++.

namespace gcs = google::cloud::storage;
using ::google::cloud::StatusOr;
[](gcs::Client client, std::string bucket_name, std::string object_name,
   std::string old_key_base64, std::string new_key_base64) {
  StatusOr<gcs::ObjectMetadata> object_metadata =
      client.RewriteObjectBlocking(
          bucket_name, object_name, bucket_name, object_name,
          gcs::SourceEncryptionKey::FromBase64Key(old_key_base64),
          gcs::EncryptionKey::FromBase64Key(new_key_base64));

  if (!object_metadata) {
    throw std::runtime_error(object_metadata.status().message());
  }

  std::cout << "Rotated key on object " << object_metadata->name()
            << " in bucket " << object_metadata->bucket()
            << "\nFull Metadata: " << *object_metadata << "\n";
}

Go

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Go.

client, err := storage.NewClient(ctx)
if err != nil {
	return err
}
obj := client.Bucket(bucket).Object(object)
// obj is encrypted with key, we are encrypting it with the newKey.
_, err = obj.Key(newKey).CopierFrom(obj.Key(key)).Run(ctx)
if err != nil {
	return err
}

Java

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Java.

BlobId blobId = BlobId.of(bucketName, blobName);
CopyRequest request =
    CopyRequest.newBuilder()
        .setSource(blobId)
        .setSourceOptions(BlobSourceOption.decryptionKey(oldEncryptionKey))
        .setTarget(blobId, BlobTargetOption.encryptionKey(newEncryptionKey))
        .build();
Blob blob = storage.copy(request).getResult();

PHP

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para PHP.

use Google\Cloud\Storage\StorageClient;

/**
 * Change the encryption key used to store an existing object.
 *
 * @param string $bucketName the name of your Google Cloud bucket.
 * @param string $objectName the name of your Google Cloud object.
 * @param string $base64EncryptionKey the base64 encoded encryption key.
 * @param string $newBase64EncryptionKey the new base64 encoded encryption key.
 *
 * @return void
 */
function rotate_encryption_key(
    $bucketName,
    $objectName,
    $base64EncryptionKey,
    $newBase64EncryptionKey
) {
    $storage = new StorageClient();
    $object = $storage->bucket($bucketName)->object($objectName);

    $rewrittenObject = $object->rewrite($bucketName, [
        'encryptionKey' => $base64EncryptionKey,
        'destinationEncryptionKey' => $newBase64EncryptionKey,
    ]);

    printf('Rotated encryption key for object gs://%s/%s' . PHP_EOL,
        $bucketName, $objectName);
}

Python

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Python.

def rotate_encryption_key(bucket_name, blob_name, base64_encryption_key,
                          base64_new_encryption_key):
    """Performs a key rotation by re-writing an encrypted blob with a new
    encryption key."""
    storage_client = storage.Client()
    bucket = storage_client.get_bucket(bucket_name)
    current_encryption_key = base64.b64decode(base64_encryption_key)
    new_encryption_key = base64.b64decode(base64_new_encryption_key)

    # Both source_blob and destination_blob refer to the same storage object,
    # but destination_blob has the new encryption key.
    source_blob = Blob(
        blob_name, bucket, encryption_key=current_encryption_key)
    destination_blob = Blob(
        blob_name, bucket, encryption_key=new_encryption_key)

    token = None

    while True:
        token, bytes_rewritten, total_bytes = destination_blob.rewrite(
            source_blob, token=token)
        if token is None:
            break

    print('Key rotation complete for Blob {}'.format(blob_name))

Ruby

Si deseas obtener más información, consulta la documentación de referencia de la API de Cloud Storage para Ruby.

# project_id             = "Your Google Cloud project ID"
# bucket_name            = "Your Google Cloud Storage bucket name"
# file_name              = "Name of a file in the Cloud Storage bucket"
# current_encryption_key = "Encryption key currently being used"
# new_encryption_key     = "New encryption key to use"

require "google/cloud/storage"

storage = Google::Cloud::Storage.new project_id: project_id
bucket  = storage.bucket bucket_name
file    = bucket.file file_name, encryption_key: current_encryption_key

file.rotate encryption_key:     current_encryption_key,
            new_encryption_key: new_encryption_key

puts "The encryption key for #{file.name} in #{bucket.name} was rotated."

API de REST

API de JSON

  1. Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus propias credenciales de OAuth.
  2. Usa cURL para llamar a la API de JSON con una solicitud de objeto POST:

    curl -X POST --data-binary @[OBJECT] \
      -H "Authorization: Bearer [OAUTH2_TOKEN]" \
      -H "Content-Type: [OBJECT_CONTENT_TYPE]" \
      -H "x-goog-encryption-algorithm: AES256" \
      -H "x-goog-encryption-key: [NEW_ENCRYPTION_KEY]" \
      -H "x-goog-encryption-key-sha256: [HASH_OF_NEW_KEY]" \
      -H "x-goog-copy-source-encryption-algorithm: AES256" \
      -H "x-goog-copy-source-encryption-key: [OLD_ENCRYPTION_KEY]" \
      -H "x-goog-copy-source-encryption-key-sha256: [HASH_OF_OLD_KEY]" \
      "https://www.googleapis.com/storage/v1/b/[BUCKET_NAME]/o/[OBJECT_NAME]/rewriteTo/b/[BUCKET_NAME]/o/[OBJECT_NAME]"

    En la que:

    • [OBJECT] es la ruta al objeto que deseas subir. Por ejemplo, Desktop/dogs.png.
    • [OAUTH2_TOKEN] es el token de acceso que generaste en el Paso 1.
    • [OBJECT_CONTENT_TYPE] es el tipo de contenido del objeto. Por ejemplo, image/png.
    • [NEW_ENCRYPTION_KEY] es la clave AES-256 nueva que se usó para encriptar el objeto.
    • [HASH_OF_NEW_KEY] es el hash SHA-256 para tu clave AES-256 nueva.
    • [OLD_ENCRYPTION_KEY] es la clave AES-256 actual que se usó para encriptar tu objeto.
    • [HASH_OF_OLD_KEY] es el hash SHA-256 actual para tu clave AES-256.
    • [BUCKET_NAME] es el nombre del depósito que contiene el objeto pertinente. Por ejemplo, my-bucket.
    • [OBJECT_NAME] es el nombre del objeto cuyas claves deseas rotar. Por ejemplo, Desktop/dogs.png.

Consulta la sección sobre encabezados de solicitud de encriptación para obtener más información sobre los encabezados específicos de encriptación.

API de XML

  1. Obtén un token de autorización de acceso de OAuth 2.0 Playground. Configura Playground para usar tus propias credenciales de OAuth.
  2. Quita el objeto original de Cloud Storage. Para hacerlo, usa cURL para llamar a la API de XML con una solicitud de objeto DELETE:

    curl -X DELETE \
      -H "Authorization: Bearer [OAUTH2_TOKEN]" \
      "https://storage.googleapis.com/[BUCKET_NAME]/[OBJECT_NAME]"

    En la que:

    • [OAUTH2_TOKEN] es el token de acceso que generaste en el Paso 1.
    • [BUCKET_NAME] es el nombre del depósito del que deseas quitar el objeto. Por ejemplo, my-bucket.
    • [OBJECT_NAME] es el nombre del objeto que deseas quitar. Por ejemplo, Desktop/dogs.png.
  3. Usa cURL para llamar a la API de XML con una solicitud de objeto PUT:

    curl -X -i PUT --data-binary @[OBJECT] \
      -H "Authorization: Bearer [OAUTH2_TOKEN]" \
      -H "Content-Type: [OBJECT_CONTENT_TYPE]" \
      -H "x-goog-encryption-algorithm: AES256" \
      -H "x-goog-encryption-key: [NEW_ENCRYPTION_KEY]" \
      -H "x-goog-encryption-key-sha256: [HASH_OF_NEW_KEY]" \
      "https://storage.googleapis.com/[BUCKET_NAME]/[OBJECT_NAME]"

    En la que:

    • [OBJECT] es la ruta al objeto que deseas subir. Por ejemplo, Desktop/dogs.png.
    • [OAUTH2_TOKEN] es el token de acceso que generaste en el Paso 1.
    • [OBJECT_CONTENT_TYPE] es el tipo de contenido del objeto. Por ejemplo, image/png.
    • [NEW_ENCRYPTION_KEY] es la clave AES-256 nueva que se usó para encriptar tu objeto.
    • [HASH_OF_NEW_KEY] es la clave SHA-256 para tu clave AES-256 nueva.
    • [BUCKET_NAME] es el nombre del depósito en el que deseas subir el objeto. Por ejemplo, my-bucket.
    • [OBJECT_NAME] es el nombre del objeto que deseas subir. Por ejemplo, Desktop/dogs.png.

Consulta la sección sobre encabezados de solicitud de encriptación para obtener más información sobre los encabezados específicos de encriptación.

¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...

Si necesitas ayuda, visita nuestra página de asistencia.