Configuración del SDK de cifrado AWS de bases de datos - AWS SDK de cifrado de bases de datos
Selección de un lenguaje de programaciónSeleccionar las claves de encapsulamientoCrear un filtro de detecciónTrabajar con bases de datos de varios inquilinosCrear balizas firmadas

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Configuración del SDK de cifrado AWS de bases de datos

Se cambió el nombre de nuestra biblioteca de cifrado del lado del cliente por el de SDK de cifrado de AWS bases de datos. En esta guía para desarrolladores, se sigue proporcionando información sobre el cliente de cifrado de DynamoDB.

El SDK AWS de cifrado de bases de datos está diseñado para ser fácil de usar. Si bien el SDK AWS de cifrado de bases de datos tiene varias opciones de configuración, los valores predeterminados se eligen cuidadosamente para que sean prácticos y seguros para la mayoría de las aplicaciones. Sin embargo, es posible que deba ajustar la configuración para mejorar el rendimiento o incluir una característica personalizada en el diseño.

Selección de un lenguaje de programación

El SDK AWS de cifrado de bases de datos para DynamoDB está disponible en varios lenguajes de programación. Las implementaciones del lenguaje están diseñadas para ser totalmente interoperables y ofrecer las mismas características, aunque pueden implementarse de diferentes maneras. Por lo general, se utiliza la biblioteca que es compatible con su aplicación.

Seleccionar las claves de encapsulamiento

El SDK AWS de cifrado de bases de datos genera una clave de datos simétrica única para cifrar cada campo. No necesita configurar, administrar ni usar las claves de datos. El SDK AWS de cifrado de bases de datos lo hace por usted.

Sin embargo, debe seleccionar una o más claves de encapsulación para cifrar cada clave de datos. El SDK de cifrado de bases de datos de AWS admite claves KMS de cifrado simétrico y claves RSA KMS asimétricas de AWS Key Management Service(AWS KMS). También es compatible con las claves simétricas AES y las claves asimétricas RSA que proporciona en diferentes tamaños. Usted es responsable de la seguridad y durabilidad de sus claves de empaquetado, por lo que le recomendamos que utilice una clave de cifrado en un módulo de seguridad de hardware o en un servicio de infraestructura de claves, como AWS KMS.

Para especificar las claves de encapsulación para el cifrado y el descifrado, utilice un conjunto de claves. Según el tipo de conjunto de claves que utilice, puede especificar una clave de encapsulación o varias claves de empaquetado del mismo tipo o de diferentes tipos. Si utiliza varias claves de encapsulación para encapsular una clave de datos, cada clave de encapsulación cifrará una copia de la misma clave de datos. Las claves de datos cifradas (una por clave de encapsulación) se guardan en la descripción del material que se almacena junto al campo cifrado. Para descifrar los datos, el SDK de cifrado de AWS bases de datos debe utilizar primero una de sus claves de empaquetado para descifrar una clave de datos cifrada.

Recomendamos utilizar uno de los AWS KMS llaveros siempre que sea posible. El SDK AWS de cifrado de bases de datos proporciona el AWS KMS anillo de claves y el anillo de claves AWS KMS jerárquico, lo que reduce la cantidad de llamadas realizadas. AWS KMS Para especificar una AWS KMS key en un conjunto de claves, utilice un identificador de clave compatible. AWS KMS Si utiliza el conjunto de claves AWS KMS jerárquico, debe especificar el ARN de clave. Para obtener más información sobre los identificadores clave de una AWS KMS clave, consulte los identificadores clave en la Guía para desarrolladores.AWS Key Management Service

  • Al cifrar con un AWS KMS anillo de claves, puede especificar cualquier identificador de clave válido (ARN de clave, nombre de alias, ARN de alias o ID de clave) para una clave KMS de cifrado simétrico. Si usa una clave de RSA KMS asimétrica, debe especificar la clave ARN.

    Si especifica un nombre de alias o un ARN de alias para una clave de KMS al cifrar, el SDK de cifrado de bases de datos de AWS guarda el ARN de clave actualmente asociado a ese alias; no lo guarda. Los cambios en el alias no afectan a la clave KMS utilizada para descifrar las claves de datos.

  • De forma predeterminada, el conjunto de AWS KMS claves descifra los registros en modo estricto (en el que se especifican determinadas claves de KMS). Debe usar el ARN de una clave para identificar AWS KMS keys para descifrar.

    Al cifrar con un AWS KMS anillo de claves, el SDK de cifrado de AWS bases de datos almacena la clave ARN de la descripción del material junto con AWS KMS key la clave de datos cifrados. Al descifrar en modo estricto, el SDK de cifrado de AWS bases de datos comprueba que aparezca la misma clave ARN en el anillo de claves antes de intentar utilizar la clave de empaquetado para descifrar la clave de datos cifrados. Si utiliza un identificador de clave diferente, el SDK de cifrado de AWS bases de datos no lo reconocerá ni utilizará AWS KMS key, aunque los identificadores hagan referencia a la misma clave.

  • Al descifrar en modo de descubrimiento, no especifique ninguna clave de encapsulación. En primer lugar, el SDK de cifrado de AWS bases de datos intenta descifrar el registro con la clave ARN almacenada en la descripción del material. Si eso no funciona, el SDK de cifrado de AWS bases de datos solicita AWS KMS descifrar el registro con la clave de KMS que lo cifró, independientemente de quién sea el propietario de esa clave de KMS o de quién tenga acceso a ella.

Para especificar una clave AES sin procesar o un par de claves RSA sin procesar como clave de encapsulación en un conjunto de claves, debe especificar un espacio de nombres y un nombre. Al descifrar, debe utilizar exactamente el mismo espacio de nombres y el mismo nombre para cada clave de encapsulación sin procesar que utilizó al cifrar. Si utiliza un nombre o espacio de nombres diferente, el SDK de cifrado de AWS bases de datos no reconocerá ni utilizará la clave de empaquetado, aunque el material de la clave sea el mismo.

Crear un filtro de detección

Al descifrar datos cifrados con claves KMS, se recomienda descifrarlos en modo estricto, es decir, limitar las claves de encapsulamiento utilizadas solo a las que especifique. Sin embargo, si es necesario, también puede descifrar en el modo de detección, en el que no se especifica ninguna clave de encapsulamiento. En este modo, AWS KMS puede descifrar la clave de datos cifrada con la clave de KMS que la cifró, independientemente de quién sea el propietario o el que tenga acceso a esa clave de KMS.

Si debe descifrar en modo de descubrimiento, le recomendamos que utilice siempre un filtro de descubrimiento, que limite las claves de KMS que se pueden usar a las de una partición Cuenta de AWS AND específica. El filtro de detección es opcional, pero es una práctica recomendada.

Utilice la siguiente tabla para determinar el valor de partición de su filtro de detección.

Región Partición
Regiones de AWS aws
Regiones de China aws-cn
AWS GovCloud (US) Regions aws-us-gov

El siguiente ejemplo muestra cómo crear un filtro de detección. Antes de usar el código, sustituya los valores de ejemplo por valores válidos para su partición Cuenta de AWS y.

Java
// Create the discovery filter
DiscoveryFilter discoveryFilter = DiscoveryFilter.builder()
        .partition("aws")
        .accountIds(111122223333)
        .build();
C# / .NET
var discoveryFilter = new DiscoveryFilter
{
    Partition = "aws",
    AccountIds = 111122223333
};

Trabajar con bases de datos de varios inquilinos

Con el SDK AWS de cifrado de bases de datos, puede configurar el cifrado del lado del cliente para las bases de datos con un esquema compartido aislando cada inquilino con materiales de cifrado distintos. Al considerar una base de datos de multitenencia, tómese un tiempo para revisar sus requisitos de seguridad y cómo podría afectarlos la multitenencia. Por ejemplo, el uso de una base de datos multiusuario podría afectar a su capacidad de combinar el SDK de cifrado de AWS bases de datos con otra solución de cifrado del lado del servidor.

Si tiene varios usuarios que realizan operaciones de cifrado en su base de datos, puede usar uno de los AWS KMS anillos de claves para proporcionar a cada usuario una clave distinta para utilizarla en sus operaciones criptográficas. Administrar las claves de datos de una solución de cifrado del cliente multitenencia puede resultar complicado. Recomendamos organizar los datos por inquilino siempre que sea posible. Si el inquilino se identifica mediante los valores de la clave principal (por ejemplo, la clave de partición de una tabla de Amazon DynamoDB), la administración de las claves resulta más sencilla.

Puede usar el anillo de AWS KMS claves para aislar a cada inquilino con un anillo de claves distinto y. AWS KMS AWS KMS keys Según el volumen de AWS KMS llamadas realizadas por inquilino, es posible que desee utilizar el anillo de claves AWS KMS jerárquico para minimizar las llamadas a. AWS KMS El anillo de claves AWS KMS jerárquico es una solución de almacenamiento en caché de materiales criptográficos que reduce el número de AWS KMS llamadas mediante el uso de claves de rama AWS KMS protegidas que se conservan en una tabla de Amazon DynamoDB y, a continuación, el almacenamiento en caché local de los materiales de clave de rama utilizados en las operaciones de cifrado y descifrado. Debe utilizar el conjunto de claves jerárquico para implementar un cifrado con capacidad de búsqueda en su base de datos AWS KMS .

Crear balizas firmadas

El SDK AWS de cifrado de bases de datos utiliza balizas estándar y balizas compuestas para proporcionar soluciones de cifrado con capacidad de búsqueda que le permiten buscar registros cifrados sin descifrar toda la base de datos consultada. Sin embargo, el SDK de cifrado AWS de bases de datos también admite balizas firmadas que se pueden configurar completamente a partir de campos firmados de texto simple. Las balizas firmadas son un tipo de baliza compuesta que indexan y realizan consultas complejas en SIGN_ONLY los campos y campos. SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT

Por ejemplo, si tiene una base de datos de multitenencia, puede que desee crear una baliza firmada que le permita consultar en la base de datos los registros cifrados por la clave de un inquilino específico. Para obtener más información, consulte Consulta de balizas en una base de datos de multitenencia.

Debe utilizar el conjunto de claves AWS KMS jerárquico para crear balizas firmadas.

Para configurar una baliza firmada, proporcione los siguientes valores.

Java

Configuración de baliza compuesta

El siguiente ejemplo define las listas de piezas firmadas localmente dentro de la configuración de baliza firmada.

List<CompoundBeacon> compoundBeaconList = new ArrayList<>();
CompoundBeacon exampleCompoundBeacon = CompoundBeacon.builder()
    .name("compoundBeaconName")
    .split(".") 
    .signed(signedPartList)                       
    .constructors(constructorList) 
    .build();
compoundBeaconList.add(exampleCompoundBeacon);

Definición de la versión de baliza

El siguiente ejemplo define las listas de piezas firmadas de forma global en la versión de baliza. Para obtener más información sobre cómo definir la versión de baliza, consulte Uso de balizas.

 List<BeaconVersion> beaconVersions = new ArrayList<>();
beaconVersions.add(
    BeaconVersion.builder()
        .standardBeacons(standardBeaconList)
        .compoundBeacons(compoundBeaconList)
        .signedParts(signedPartList)
        .version(1) // MUST be 1
        .keyStore(keyStore)
        .keySource(BeaconKeySource.builder()
            .single(SingleKeyStore.builder()
                .keyId(branchKeyId)
                .cacheTTL(6000)
                .build())
            .build())
        .build()
);
C# / .NET

Consulte el ejemplo de código completo: .cs BeaconConfig

Configuración de baliza firmada

El siguiente ejemplo define las listas de piezas firmadas localmente dentro de la configuración de baliza firmada.

var compoundBeaconList = new List<CompoundBeacon>();       
var exampleCompoundBeacon = new CompoundBeacon
 {
    Name = "compoundBeaconName",
    Split = ".",
    Signed = signedPartList,                        
    Constructors = constructorList 
 };
compoundBeaconList.Add(exampleCompoundBeacon);

Definición de la versión de baliza

El siguiente ejemplo define las listas de piezas firmadas de forma global en la versión de baliza. Para obtener más información sobre cómo definir la versión de baliza, consulte Uso de balizas.

var beaconVersions = new List<BeaconVersion>
{
    new BeaconVersion
    {
        StandardBeacons = standardBeaconList,
        CompoundBeacons = compoundBeaconList,
        SignedParts = signedPartsList,
        Version = 1, // MUST be 1
        KeyStore = keyStore,
        KeySource = new BeaconKeySource
        {
            Single = new SingleKeyStore
            {
                KeyId = branchKeyId,
                CacheTTL = 6000
            }
        }
    }
};

Puede definir las piezas firmadas en listas definidas local o globalmente. Siempre que sea posible, le recomendamos que defina las piezas firmadas en una lista global en la versión de baliza. Al definir las partes firmadas de forma global, puede definir cada parte una vez y, a continuación, reutilizarlas en varias configuraciones de balizas compuestas. Si solo piensa utilizar una parte firmada una vez, puede definirla en una lista local en la configuración de baliza firmada. Puede hacer referencia a partes locales y globales en su lista de constructores.

Si define sus listas de piezas firmadas de forma global, debe proporcionar una lista de piezas de construcción que identifique todas las formas posibles en que la baliza firmada puede ensamblar los campos de la configuración de la baliza.

nota

Para definir listas de piezas firmadas de forma global, debe utilizar la versión 3.2 o posterior del SDK de cifrado de AWS bases de datos. Implemente la nueva versión en todos los lectores antes de definir cualquier pieza nueva a nivel mundial.

No puede actualizar las configuraciones de balizas existentes para definir listas de piezas firmadas a nivel mundial.

Nombre de la baliza

El nombre que utilizas al consultar la baliza.

El nombre de una baliza firmada no puede ser el mismo nombre que el de un campo sin cifrar. No puede haber dos balizas con el mismo nombre de baliza.

Carácter dividido

El personaje que se usa para separar las partes que componen su baliza firmada.

El carácter dividido no puede aparecer en los valores de texto no cifrado de ninguno de los campos a partir de los que se construye la baliza firmada.

Lista de piezas firmadas

Identifica los campos firmados incluidos en la baliza firmada.

Cada parte debe incluir un nombre, una fuente y un prefijo. La fuente es el SIGN_AND_INCLUDE_IN_ENCRYPTION_CONTEXT campo SIGN_ONLY o que identifica la pieza. La fuente debe ser un nombre de campo o un índice que haga referencia al valor de un campo anidado. Si el nombre de la pieza identifica la fuente, puede omitirla y el SDK de cifrado de AWS bases de datos utilizará automáticamente el nombre como fuente. Recomendamos especificar la fuente como nombre de la pieza siempre que sea posible. El prefijo puede ser cualquier cadena, pero debe ser único. Dos partes firmadas de una baliza firmada no pueden tener el mismo prefijo. Recomendamos utilizar un valor corto que distinga la pieza de otras partes servidas por la baliza compuesta.

Recomendamos definir las piezas firmadas de forma global siempre que sea posible. Podría considerar la posibilidad de definir una pieza firmada de forma local si solo tiene intención de utilizarla en una baliza compuesta. Una pieza definida localmente no puede tener el mismo prefijo o nombre que una pieza definida globalmente.

Java
List<SignedPart> signedPartList = new ArrayList<>);
    SignedPart signedPartExample = SignedPart.builder()
        .name("signedFieldName")
        .prefix("S-")
        .build();
    signedPartList.add(signedPartExample);
C# / .NET
var signedPartsList = new List<SignedPart>
{
    new SignedPart { Name = "signedFieldName1", Prefix = "S-" },
    new SignedPart { Name = "signedFieldName2", Prefix = "SF-" }
};
Lista de constructores (opcional)

Identifique los constructores que definen las diferentes formas en que la baliza firmada puede ensamblar las piezas firmadas.

Si no especifica una lista de constructores, el SDK de cifrado de AWS bases de datos agrupa la baliza firmada con el siguiente constructor predeterminado.

  • Todas las piezas firmadas en el orden en que se agregaron a la lista de piezas firmadas

  • Todas las piezas son obligatorias

Constructores

Cada constructor es una lista ordenada de piezas del constructor que define una forma de ensamblar la baliza firmada. Las piezas del constructor se unen en el orden en que se agregan a la lista, con cada parte separada por el carácter dividido especificado.

Cada parte del constructor nombra una parte firmada y define si esa parte es obligatoria u opcional dentro del constructor. Por ejemplo, si desea consultar una baliza firmada sobre Field1, Field1.Field2 yField1.Field2.Field3, marcar Field2 y Field3 como opcional y crear un constructor.

Cada constructor debe tener como mínimo una pieza requerida. Recomendamos hacer que la primera parte de cada constructor sea obligatoria para poder usar el operador BEGINS_WITH en las consultas.

Un constructor tiene éxito si todas las piezas requeridas están presentes en el registro. Al escribir un registro nuevo, la baliza firmada utiliza la lista de constructores para determinar si la baliza se puede ensamblar a partir de los valores proporcionados. Intente ensamblar la baliza en el orden en que se agregaron los constructores a la lista de constructores y utilice el primer constructor que lo haga correctamente. Si ningún constructor tiene éxito, la baliza no se graba en el registro.

Todos los lectores y redactores deben especificar el mismo orden de constructores para garantizar que los resultados de sus consultas sean correctos.

Utilice los siguientes procedimientos para especificar su propia lista de constructores.

  1. Cree una pieza constructora para cada pieza firmada para definir si esa pieza es necesaria o no.

    El nombre de la pieza constructora debe ser el nombre del campo firmado.

    El siguiente ejemplo ilustra cómo crear una pieza de construcción para un campo firmado.

    Java
    ConstructorPart field1ConstructorPart = ConstructorPart.builder()
        .name("Field1")
        .required(true)
        .build();
    C# / .NET
    var field1ConstructorPart = new ConstructorPart { Name = "Field1", Required = true };

  2. Cree un constructor para cada una de las formas posibles de ensamblar la baliza firmada utilizando las partes constructoras que creó en el paso 1.

    Por ejemplo, si desea consultar sobre Field1.Field2.Field3 y Field4.Field2.Field3, debe crear dos constructores. Tanto Field1 como Field4 pueden ser necesarios porque están definidos en dos constructores distintos.

    Java
    // Create a list for Field1.Field2.Field3 queries
List<ConstructorPart> field123ConstructorPartList = new ArrayList<>();
field123ConstructorPartList.add(field1ConstructorPart);
field123ConstructorPartList.add(field2ConstructorPart);
field123ConstructorPartList.add(field3ConstructorPart);
Constructor field123Constructor = Constructor.builder()
        .parts(field123ConstructorPartList)
        .build();
// Create a list for Field4.Field2.Field1 queries
List<ConstructorPart> field421ConstructorPartList = new ArrayList<>();
field421ConstructorPartList.add(field4ConstructorPart);
field421ConstructorPartList.add(field2ConstructorPart);
field421ConstructorPartList.add(field1ConstructorPart);
Constructor field421Constructor = Constructor.builder()
        .parts(field421ConstructorPartList)
        .build();
    C# / .NET
    // Create a list for Field1.Field2.Field3 queries
 var field123ConstructorPartList = new Constructor
{
    Parts = new List<ConstructorPart> { field1ConstructorPart, field2ConstructorPart, field3ConstructorPart }
};
// Create a list for Field4.Field2.Field1 queries        
var field421ConstructorPartList = new Constructor
{
    Parts = new List<ConstructorPart> { field4ConstructorPart, field2ConstructorPart, field1ConstructorPart }
};

  3. Cree una lista de constructores que incluya todos los constructores que creó en el Paso 2.

    Java
    List<Constructor> constructorList = new ArrayList<>();
constructorList.add(field123Constructor)
constructorList.add(field421Constructor)
    C# / .NET
    var constructorList = new List<Constructor>
{
    field123Constructor,
    field421Constructor
};

  4. Especifique el constructorList cuando cree su baliza firmada.

Mostrar másMostrar menos