Encripte datos del usuario

La API de Data Manager admite la encriptación de datos con los siguientes servicios de administración de claves:

La compatibilidad con algunos casos de uso varía según el servicio de administración de claves (KMS):

Categoría Caso de uso Google Cloud KMS AWS KMS
Públicos Enviar miembros del público
Eventos Conversiones sin conexión o conversiones avanzadas de clientes potenciales
Eventos Conversiones de ventas en la tienda de Google Ads
Eventos Eventos enviados como una fuente de datos adicional a un destino de Google Ads destino
Eventos Eventos enviados como una fuente de datos adicional a un destino de Google Analytics destino

Configura Google Cloud KMS

Estos son los pasos para configurar los recursos de Google Cloud KMS para la encriptación.

Configura la interfaz de línea de comandos de Google Cloud

  1. Instala y, luego, inicializa la interfaz de línea de comandos de Google Cloud.

  2. Para seleccionar o crear un proyecto nuevo de Google Cloud y habilitar el Cloud Key Management Service, haz clic en Habilitar Cloud KMS.

    Habilitar Cloud KMS

  3. Para configurar tu proyecto en tu entorno, usa el gcloud config set comando. Para verificar si el proyecto ya está configurado en tu entorno, ejecuta gcloud config list.

    Si no se configuró ningún project o quieres usar otro proyecto para tu clave, ejecuta gcloud config set:

    gcloud config set project PROJECT_ID

Crea una clave

Para obtener más información, consulta la descripción general de Cloud Key Management Service.

  1. Crea un llavero de claves.

    gcloud kms keyrings create KEY_RING_NAME \
    --location KEY_RING_LOCATION

    Para obtener más información, consulta Crea un llavero de claves.

  2. Crea una clave en el llavero de claves. El ROTATION_PERIOD indica el intervalo para rotar la clave, y el NEXT_ROTATION_TIME indica la fecha y la hora en que debe ocurrir la primera rotación.

    Por ejemplo, para rotar la clave cada 30 días y realizar la primera rotación en 1 semana, establece ROTATION_PERIOD en 30d y NEXT_ROTATION_TIME en $(date --utc --date="next week" --iso-8601=seconds).

    gcloud kms keys create KEY_NAME \
    --keyring KEY_RING_NAME \
    --location KEY_RING_LOCATION \
    --purpose "encryption" \
    --rotation-period ROTATION_PERIOD \
    --next-rotation-time "NEXT_ROTATION_TIME"

    Para obtener más información, consulta Crea una clave.

Crea un proveedor de grupos de identidades para cargas de trabajo

En esta sección, se incluye una breve descripción general de la federación de identidades para cargas de trabajo. Para obtener más información, consulta Federación de identidades para cargas de trabajo.

  1. Crea un grupo de identidades para cargas de trabajo (WIP). La location del grupo debe ser global.

    gcloud iam workload-identity-pools create WIP_ID \
   --location=global \
   --display-name="WIP_DISPLAY_NAME" \
   --description="WIP_DESCRIPTION"

    Para obtener más información, consulta Administra proveedores y grupos de Workload Identity.

  2. Crea un proveedor de grupos de identidades para cargas de trabajo. El argumento --attribute-condition verifica que el llamador sea una cuenta de servicio de correlación confidencial.

    gcloud iam workload-identity-pools providers create-oidc PROVIDER_ID \
   --location=global \
   --workload-identity-pool=WIP_ID \
   --display-name="PROVIDER_DISPLAY_NAME" \
   --description="PROVIDER_DESCRIPTION" \
   --attribute-mapping="google.subject=assertion.sub,google.groups=[\"PROVIDER_ID\"]" \
   --attribute-condition="assertion.swname == 'CONFIDENTIAL_SPACE' &&
     'STABLE' in assertion.submods.confidential_space.support_attributes &&
     ['cfm-services@admcloud-cfm-services.iam.gserviceaccount.com'].exists(
         a, a in assertion.google_service_accounts) &&
     'ECDSA_P256_SHA256:6b1f357b59e9407fb017ca0e3e783b2bd5acbfea6c83dd82971a4150df5b25f9'
     in assertion.submods.container.image_signatures.map(sig, sig.signature_algorithm+':'+sig.key_id)" \
   --issuer-uri="https://confidentialcomputing.googleapis.com" \
   --allowed-audiences="https://sts.googleapis.com"

  3. Otorga el rol de desencriptador de claves al proveedor de WIP.

    # Grants the role to the WIP provider.
gcloud kms keys add-iam-policy-binding KEY_NAME \
    --keyring KEY_RING_NAME \
    --location KEY_RING_LOCATION \
    --member "principalSet://iam.googleapis.com/projects/PROJECT_ID/locations/global/workloadIdentityPools/WIP_ID/group/PROVIDER_ID" \
    --role "roles/cloudkms.cryptoKeyDecrypter"

  4. Si deseas encriptar los datos de eventos para las conversiones sin conexión y las conversiones avanzadas de leads, otorga el rol de desencriptador de claves a la cuenta de servicio de Google datamanager-api@datamanager-ga.iam.gserviceaccount.com.

    # Grants the role to the Google service account.
gcloud kms keys add-iam-policy-binding KEY_NAME \
    --keyring KEY_RING_NAME \
    --location KEY_RING_LOCATION \
    --member "serviceAccount:datamanager-api@datamanager-ga.iam.gserviceaccount.com" \
    --role "roles/cloudkms.cryptoKeyDecrypter"

Continúa con la sección Encripta datos.

Configura AWS KMS

Estos son los pasos para configurar los recursos de AWS KMS para la encriptación.

Configura la interfaz de línea de comandos de AWS

  1. Instala la interfaz de línea de comandos de AWS.

  2. Ejecuta el siguiente comando para verificar la instalación:

    aws --version

    Este es un fragmento del resultado de una instalación correcta:

    aws-cli/2.31.12 Python/3.13.7 ...

Configura un usuario de AWS y accede

  1. Completa los requisitos previos para usar la interfaz de línea de comandos de AWS.
  2. Accede a una sesión de IAM Identity Center.

Crea una clave

  1. Crea una clave de KMS simétrica (KEK).

    aws kms create-key \
  --key-usage ENCRYPT_DECRYPT \
  --key-spec SYMMETRIC_DEFAULT \
  --description "KEK for Confidential Matching Data Encryption"

    Toma nota del Arn en KeyMetadata en el resultado. Necesitarás este Amazon Resource Name (ARN) en otros pasos.

    AWS_KEY_ARN

  2. Opcional: Crea un alias de clave con el nombre de alias que elijas.

    aws kms create-alias \
  --alias-name "alias/AWS_KEY_ALIAS" \
  --target-key-id AWS_KEY_ARN

    No se requiere un alias, pero es útil para crear comandos de la interfaz de línea de comandos de AWS. Por ejemplo, puedes recuperar el ARN de la clave con el alias:

    aws kms describe-key --key-id "alias/AWS_KEY_ALIAS" \
  --query 'KeyMetadata.Arn' \
  --output text

Crea un proveedor de identidad de OpenID Connect

Crea un proveedor de identidad de OpenID Connect (OIDC). Solo debes realizar este paso una vez por cada cuenta de AWS.

aws iam create-open-id-connect-provider \
  --url https://confidentialcomputing.googleapis.com \
  --client-id-list AUDIENCE \
  --thumbprint-list "08745487e891c19e3078c1f2a07e452950ef36f6"

Toma nota del ARN del proveedor de OIDC del resultado. Necesitarás este ARN en otros pasos.

AWS_OIDC_PROVIDER_ARN

Crea una política de IAM

  1. Crea un archivo JSON llamado kms-decrypt-policy.json con el siguiente contenido:

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": "kms:Decrypt",
      "Resource": "AWS_KEY_ARN"
    }
  ]
}

  2. Crea una política de IAM con el archivo JSON y el nombre de política que elijas.

    aws iam create-policy \
  --policy-name "AWS_POLICY_NAME" \
  --policy-document file://kms-decrypt-policy.json

    Toma nota del ARN de la política de IAM en el resultado. Necesitarás este ARN en otros pasos.

    AWS_IAM_POLICY_ARN

Crea y adjunta un rol de IAM

  1. Crea un archivo JSON llamado role-trust-policy.json con el siguiente contenido y el ARN del proveedor de OIDC del paso anterior:

    {
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Principal": {
                "Federated": "AWS_OIDC_PROVIDER_ARN"
            },
            "Action": [
                "sts:AssumeRoleWithWebIdentity",
                "sts:TagSession"
            ],
            "Condition": {
                "StringEquals": {
                    "confidentialcomputing.googleapis.com:aud": "cfm-awsresource",
                    "aws:RequestTag/swname": "CONFIDENTIAL_SPACE",
                    "aws:RequestTag/container.signatures.key_ids": "6b1f357b59e9407fb017ca0e3e783b2bd5acbfea6c83dd82971a4150df5b25f9"
                },
                "StringLike": {
                    "aws:RequestTag/confidential_space.support_attributes": "*STABLE*"
                }
            }
        }
    ]
}

  2. Crea un rol de IAM con el nombre de rol que elijas.

    aws iam create-role \
  --role-name "AWS_IAM_ROLE_NAME" \
  --assume-role-policy-document file://role-trust-policy.json

  3. Adjunta la política de rol a la política de IAM.

    aws iam attach-role-policy \
  --role-name "AWS_IAM_ROLE_NAME" \
  --policy-arn "AWS_IAM_POLICY_ARN"

Encripta datos

La encriptación en la API de Data Manager requiere una clave de encriptación de datos (DEK). Una DEK es una clave simétrica que usas para encriptar datos. Tu DEK se encripta con tu clave de encriptación de claves (KEK) de Google Cloud o AWS KMS. Envías la DEK encriptada, el URI de KEK y el proveedor de WIP como parte de la solicitud.

Para preparar los datos de la solicitud para la encriptación, sigue los mismos lineamientos de formato y hash que usarías para los datos sin encriptar.

No encriptes valores sin hash. Por ejemplo, el region_code o el postal_code de un AddressInfo.

Una vez que los datos de cada campo estén formateados y tengan hash, encripta el valor con hash siguiendo estos pasos:

  1. Codifica los bytes de hash con la codificación Base64.
  2. Encripta el hash codificado en Base64 con tu DEK.
  3. Codifica el resultado del proceso de encriptación con la codificación hexadecimal o Base64.
  4. Usa el valor codificado para el campo.
  5. Establece encryption_info y encoding en la solicitud.

Para completar el último paso, modifica el IngestAudienceMembersRequest o IngestEventsRequest para indicar que encriptaste tus datos:

  • Establece el campo encryption_info.
  • Establece el campo encoding en la codificación que se usó para codificar los valores de los campos encriptados.

Este es un fragmento de una solicitud que usa una clave de Google Cloud KMS y en la que se establecen los campos de encriptación y codificación:

{
  ...
  "encryptionInfo": {
    "gcpWrappedKeyInfo": {
      "kekUri": "gcp-kms://projects/PROJECT_ID/locations/KEY_RING_LOCATION/keyRings/KEY_RING_NAME/cryptoKeys/KEY_NAME",
      "wipProvider": "projects/PROJECT_ID/locations/global/workloadIdentityPools/WIP_ID/providers/PROVIDER_ID",
      "keyType": "XCHACHA20_POLY1305",
      "encryptedDek": "ENCRYPTED_DEK"
    }
  },
  "encoding": "ENCODING"
}

Para usar la biblioteca y las utilidades de la API de Data Manager para crear y enviar una solicitud, consulta el ejemplo de código IngestAudienceMembers para Java o el ejemplo de código ingest_audience_members para Python.

Verifica el diagnóstico para detectar problemas de encriptación

Después de subir datos encriptados, usa el diagnóstico para verificar si hay advertencias relacionadas con la encriptación, como PROCESSING_WARNING_REASON_KEK_PERMISSION_DENIED o PROCESSING_WARNING_REASON_DEK_DECRYPTION_ERROR. Aborda las advertencias en el diagnóstico, vuelve a enviar las solicitudes y verifica que el diagnóstico ya no muestre advertencias después de los cambios.

Anterior
Da formato a los datos del usuario
Siguiente
Información sobre los errores de la API