AWS KMS Hierarchische Schlüsselanhänger - AWS Encryption SDK
FunktionsweiseVoraussetzungenErforderliche BerechtigungenWählen Sie einen CacheErstellen Sie einen hierarchischen Schlüsselbund

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

AWS KMS Hierarchische Schlüsselanhänger

Mit dem AWS KMS hierarchischen Schlüsselbund können Sie Ihre kryptografischen Materialien mit einem symmetrischen KMS Verschlüsselungsschlüssel schützen, ohne AWS KMS jedes Mal anrufen zu müssen, wenn Sie Daten ver- oder entschlüsseln. Es ist eine gute Wahl für Anwendungen, bei denen die Anzahl der Aufrufe minimiert werden muss AWS KMS, und für Anwendungen, die kryptografisches Material wiederverwenden können, ohne ihre Sicherheitsanforderungen zu verletzen.

Der hierarchische Schlüsselbund ist eine Caching-Lösung für kryptografisches Material, die die Anzahl der AWS KMS Aufrufe reduziert, indem AWS KMS geschützte Branch-Schlüssel verwendet werden, die in einer Amazon DynamoDB-Tabelle gespeichert sind, und anschließend das für Ver- und Entschlüsselungsvorgänge verwendete Zweigschlüsselmaterial lokal zwischenspeichert. Die DynamoDB-Tabelle dient als Schlüsselspeicher, der Zweigschlüssel verwaltet und schützt. Sie speichert den aktiven Branch-Schlüssel und alle vorherigen Versionen des Branch-Schlüssels. Der aktive Zweigschlüssel ist die neueste Version des Zweigschlüssels. Der hierarchische Schlüsselbund verwendet einen eindeutigen Datenschlüssel, um jede Nachricht zu verschlüsseln, verschlüsselt jeden Datenverschlüsselungsschlüssel für jede Verschlüsselungsanforderung und verschlüsselt jeden Datenverschlüsselungsschlüssel mit einem eindeutigen Umschließungsschlüssel, der vom aktiven Branch-Schlüssel abgeleitet wird. Der hierarchische Schlüsselbund hängt von der Hierarchie ab, die zwischen aktiven Zweigschlüsseln und ihren abgeleiteten Umschließungsschlüsseln eingerichtet wurde.

Der hierarchische Schlüsselbund verwendet in der Regel jede Version des Zweigschlüssels, um mehrere Anfragen zu erfüllen. Sie kontrollieren jedoch, in welchem Umfang aktive Zweigschlüssel wiederverwendet werden, und bestimmen, wie oft der aktive Zweigschlüssel rotiert wird. Die aktive Version des Abzweigschlüssels bleibt aktiv, bis Sie ihn drehen. Frühere Versionen des aktiven Zweigschlüssels werden nicht zur Ausführung von Verschlüsselungsvorgängen verwendet, sie können jedoch weiterhin abgefragt und bei Entschlüsselungsvorgängen verwendet werden.

Wenn Sie den hierarchischen Schlüsselbund instanziieren, erstellt er einen lokalen Cache. Sie geben ein Cache-Limit an, das die maximale Zeitspanne definiert, für die die Branch-Schlüsselmaterialien im lokalen Cache gespeichert werden, bevor sie ablaufen und aus dem Cache entfernt werden. Der hierarchische Schlüsselbund führt einen AWS KMS Aufruf durch, um den Zweigschlüssel zu entschlüsseln und die Zweigschlüsselmaterialien zusammenzustellen, wenn a zum ersten Mal in einem Vorgang angegeben branch-key-id wird. Anschließend werden die Materialien der Verzweigungsschlüssel im lokalen Cache gespeichert und für alle Verschlüsselungs- und Entschlüsselungsvorgänge, die dies spezifizieren, wiederverwendet, bis das Cache-Limit abläuft. branch-key-id Das Speichern von Zweigschlüsselmaterialien im lokalen Cache reduziert die Anzahl der Aufrufe. AWS KMS Stellen Sie sich beispielsweise ein Cache-Limit von 15 Minuten vor. Wenn Sie 10.000 Verschlüsselungsvorgänge innerhalb dieses Cache-Limits ausführen, müsste der herkömmliche AWS KMS Schlüsselbund 10.000 AWS KMS Aufrufe tätigen, um 10.000 Verschlüsselungsvorgänge zu erfüllen. Wenn Sie einen aktiven Schlüsselbund habenbranch-key-id, muss der hierarchische Schlüsselbund nur einen AWS KMS Aufruf tätigen, um 10.000 Verschlüsselungsvorgänge abzuwickeln.

Der lokale Cache trennt Verschlüsselungsmaterialien von Entschlüsselungsmaterialien. Die Verschlüsselungsmaterialien werden aus dem aktiven Zweigschlüssel zusammengesetzt und für alle Verschlüsselungsvorgänge wiederverwendet, bis das Cache-Limit abgelaufen ist. Die Entschlüsselungsmaterialien werden aus der Zweigschlüssel-ID und der Version zusammengestellt, die in den Metadaten des verschlüsselten Felds identifiziert wurden, und sie werden für alle Entschlüsselungsvorgänge im Zusammenhang mit der Branch-Schlüssel-ID und -version wiederverwendet, bis das Cache-Limit abläuft. Im lokalen Cache können mehrere Versionen desselben Zweigschlüssels gleichzeitig gespeichert werden. Wenn der lokale Cache für die Verwendung von konfiguriert istbranch key ID supplier, kann er auch Zweigschlüsselmaterial von mehreren aktiven Branch-Schlüsseln gleichzeitig speichern.

Anmerkung

Alle Erwähnungen des Begriffs „Hierarchischer Schlüsselbund“ in der AWS Encryption SDK beziehen sich auf den AWS KMS hierarchischen Schlüsselbund.

Kompatibilität mit Programmiersprachen

Der hierarchische Schlüsselbund wird von den folgenden Programmiersprachen und Versionen unterstützt:

  • Version 3. x der AWS-Verschlüsselungs-SDK for Java

  • Ausführung 4. x der AWS Encryption SDK Form. NET

  • Ausführung 4. x von AWS-Verschlüsselungs-SDK for Python, wenn es mit der optionalen MPL Abhängigkeit verwendet wird.

Funktionsweise

In den folgenden exemplarischen Vorgehensweisen wird beschrieben, wie der hierarchische Schlüsselbund Verschlüsselungs- und Entschlüsselungsmaterialien zusammenstellt und welche verschiedenen Aufrufe der Schlüsselbund für Verschlüsselungs- und Entschlüsselungsvorgänge vornimmt. Technische Einzelheiten zur Ableitung von Schlüsseln und zur Verschlüsselung von Klartext-Datenschlüsseln finden Sie unter Technische Details zum hierarchischen Schlüsselbund.AWS KMS

Verschlüsseln und signieren

In der folgenden exemplarischen Vorgehensweise wird beschrieben, wie der hierarchische Schlüsselbund Verschlüsselungsmaterialien zusammenstellt und daraus einen eindeutigen Umschließungsschlüssel ableitet.

  1. Die Verschlüsselungsmethode fragt den hierarchischen Schlüsselbund nach Verschlüsselungsmaterialien. Der Schlüsselbund generiert einen Klartext-Datenschlüssel und überprüft dann, ob sich im lokalen Cache gültiges Verzweigungsmaterial für die Generierung des Wrapping-Schlüssels befindet. Wenn gültiges Schlüsselmaterial für die Zweige vorhanden ist, fährt der Schlüsselbund mit Schritt 4 fort.

  2. Wenn kein gültiges Material für Zweigschlüssel vorhanden ist, fragt der hierarchische Schlüsselbund den Schlüsselspeicher nach dem aktiven Zweigschlüssel ab.

    1. Der Schlüsselspeicher ruft AWS KMS zur Entschlüsselung des aktiven Zweigschlüssels auf und gibt den aktiven Zweigschlüssel im Klartext zurück. Daten, die den aktiven Zweigschlüssel identifizieren, werden serialisiert, um zusätzliche authentifizierte Daten (AAD) beim Entschlüsselungsaufruf von bereitzustellen. AWS KMS

    2. Der Schlüsselspeicher gibt den Klartext-Zweigschlüssel und Daten, die ihn identifizieren, wie z. B. die Version des Zweigschlüssels, zurück.

  3. Der hierarchische Schlüsselbund stellt die Schlüsselmaterialien der Zweige zusammen (die Version mit dem Zweigschlüssel im Klartext und der Zweigschlüsselversion) und speichert eine Kopie davon im lokalen Cache.

  4. Der hierarchische Schlüsselbund leitet aus dem Klartext-Verzweigungsschlüssel und einem 16-Byte-Zufallssalz einen eindeutigen Umbruchschlüssel ab. Er verwendet den abgeleiteten Umschließungsschlüssel, um eine Kopie des Klartext-Datenschlüssels zu verschlüsseln.

Die Verschlüsselungsmethode verwendet die Verschlüsselungsmaterialien, um die Daten zu verschlüsseln. Weitere Informationen finden Sie unter So werden AWS Encryption SDK Daten verschlüsselt.

Mehr anzeigenWeniger anzeigen
Entschlüsseln und verifizieren

In der folgenden exemplarischen Vorgehensweise wird beschrieben, wie der hierarchische Schlüsselbund Entschlüsselungsmaterialien zusammenstellt und den verschlüsselten Datenschlüssel entschlüsselt.

  1. Die Entschlüsselungsmethode identifiziert den verschlüsselten Datenschlüssel aus der verschlüsselten Nachricht und leitet ihn an den hierarchischen Schlüsselbund weiter.

  2. Der hierarchische Schlüsselbund deserialisiert Daten, die den verschlüsselten Datenschlüssel identifizieren, einschließlich der Version des Zweigschlüssels, des 16-Byte-Salts und anderer Informationen, die beschreiben, wie der Datenschlüssel verschlüsselt wurde.

    Weitere Informationen finden Sie unter AWS KMS Technische Details zum hierarchischen Schlüsselbund.

  3. Mit dem hierarchischen Schlüsselbund wird geprüft, ob sich im lokalen Cache gültiges Zweigschlüsselmaterial befindet, das mit der in Schritt 2 identifizierten Version des Zweigschlüssels übereinstimmt. Wenn gültiges Schlüsselmaterial für die Zweige vorhanden ist, fährt der Schlüsselbund mit Schritt 6 fort.

  4. Wenn kein gültiges Material für Zweigschlüssel vorhanden ist, fragt der hierarchische Schlüsselbund den Schlüsselspeicher nach dem Zweigschlüssel ab, der mit der in Schritt 2 identifizierten Version des Zweigschlüssels übereinstimmt.

    1. Der Schlüsselspeicher ruft AWS KMS zur Entschlüsselung des Zweigschlüssels auf und gibt den aktiven Zweigschlüssel im Klartext zurück. Daten, die den aktiven Zweigschlüssel identifizieren, werden serialisiert, um zusätzliche authentifizierte Daten (AAD) beim Entschlüsselungsaufruf von bereitzustellen. AWS KMS

    2. Der Schlüsselspeicher gibt den Klartext-Zweigschlüssel und Daten, die ihn identifizieren, wie z. B. die Version des Zweigschlüssels, zurück.

  5. Der hierarchische Schlüsselbund stellt die Schlüsselmaterialien der Zweige zusammen (die Version mit dem Zweigschlüssel im Klartext und der Zweigschlüsselversion) und speichert eine Kopie davon im lokalen Cache.

  6. Der hierarchische Schlüsselbund verwendet die zusammengestellten Zweigschlüsselmaterialien und das in Schritt 2 identifizierte 16-Byte-Salt, um den eindeutigen Wrapping-Schlüssel zu reproduzieren, mit dem der Datenschlüssel verschlüsselt wurde.

  7. Der hierarchische Schlüsselbund verwendet den reproduzierten Wrapping-Schlüssel, um den Datenschlüssel zu entschlüsseln, und gibt den Klartext-Datenschlüssel zurück.

Die Entschlüsselungsmethode verwendet die Entschlüsselungsmaterialien und den Klartext-Datenschlüssel, um die verschlüsselte Nachricht zu entschlüsseln. Weitere Informationen finden Sie unter So AWS Encryption SDK entschlüsselt der eine verschlüsselte Nachricht.

Mehr anzeigenWeniger anzeigen

Voraussetzungen

Bevor Sie einen hierarchischen Schlüsselbund erstellen und verwenden, stellen Sie sicher, dass die folgenden Voraussetzungen erfüllt sind.

Erforderliche Berechtigungen

Der benötigt AWS Encryption SDK keinen AWS-Konto und hängt auch nicht von einem ab AWS-Service. Um einen hierarchischen Schlüsselbund verwenden zu können, benötigen Sie jedoch mindestens die folgenden Mindestberechtigungen für die symmetrische (n) Verschlüsselung AWS KMS key(en) in Ihrem Schlüsselspeicher. AWS-Konto

Weitere Informationen zur Steuerung des Zugriffs auf Ihre Filialschlüssel und Ihren Schlüsselspeicher finden Sie unterImplementieren der geringsten Berechtigungen.

Wählen Sie einen Cache

Der hierarchische Schlüsselbund reduziert die Anzahl der Aufrufe, AWS KMS indem er die bei den Verschlüsselungs- und Entschlüsselungsvorgängen verwendeten Zweigschlüsselmaterialien lokal zwischenspeichert. Bevor Sie Ihren hierarchischen Schlüsselbund erstellen, müssen Sie entscheiden, welche Art von Cache Sie verwenden möchten. Sie können den Standard-Cache verwenden oder den Cache so anpassen, dass er Ihren Bedürfnissen am besten entspricht.

Der hierarchische Schlüsselbund unterstützt die folgenden Cachetypen:

Wichtig

Alle unterstützten Cachetypen sind für die Unterstützung von Multithread-Umgebungen konzipiert.

In Kombination mit dem unterstützt der AWS-Verschlüsselungs-SDK for Python hierarchische Schlüsselbund jedoch keine Multithread-Umgebungen. Weitere Informationen finden Sie in der READMEPython-.rst-Datei im aws-cryptographic-material-providers-library-Repository unter. GitHub

Standard-Cache

Für die meisten Benutzer erfüllt der Standard-Cache ihre Threading-Anforderungen. Der Standard-Cache ist so konzipiert, dass er Umgebungen mit hohem Multithreading-Anteil unterstützt. Wenn ein Eintrag für Branch-Schlüssel-Materialien abläuft, verhindert der Standard-Cache den Aufruf mehrerer Threads, AWS KMS indem ein Thread 10 Sekunden im Voraus darüber informiert wird, dass der Eintrag für Branch-Schlüssel-Materialien abläuft. Dadurch wird sichergestellt, dass nur ein Thread eine Anfrage AWS KMS zur Aktualisierung des Caches sendet.

Standard und StormTracking Caches unterstützen dasselbe Threading-Modell, aber Sie müssen nur die Eingangskapazität angeben, um den Standard-Cache verwenden zu können. Für detailliertere Cache-Anpassungen verwenden Sie den. StormTracking Zwischenspeicher

Sofern Sie nicht die Anzahl der Materialeinträge für Branch Key anpassen möchten, die im lokalen Cache gespeichert werden können, müssen Sie bei der Erstellung des hierarchischen Schlüsselbunds keinen Cachetyp angeben. Wenn Sie keinen Cachetyp angeben, verwendet der hierarchische Schlüsselbund den Standard-Cachetyp und legt die Eintragskapazität auf 1000 fest.

Um den Standard-Cache anzupassen, geben Sie die folgenden Werte an:

  • Eintragskapazität: Schränkt die Anzahl der Einträge für wichtige Materialien der Branche ein, die im lokalen Cache gespeichert werden können.

Java
.cache(CacheType.builder()
        .Default(DefaultCache.builder()
        .entryCapacity(100)
        .build())
C# / .NET
CacheType defaultCache = new CacheType
{
    Default = new DefaultCache{EntryCapacity = 100}
};
Python
default_cache = CacheTypeDefault(
    value=DefaultCache(
        entry_capacity=100
    )
)

MultiThreaded Cache

Der MultiThreaded Cache kann sicher in Multithread-Umgebungen verwendet werden, bietet jedoch keine Funktionen zur Minimierung AWS KMS von Amazon DynamoDB DynamoDB-Aufrufen. Daher werden alle Threads gleichzeitig benachrichtigt, wenn ein Eintrag für wichtige Materialien in einer Branche abläuft. Dies kann zu mehreren AWS KMS Aufrufen führen, um den Cache zu aktualisieren.

Um den MultiThreaded Cache zu verwenden, geben Sie die folgenden Werte an:

  • Eintragskapazität: Beschränkt die Anzahl der Einträge für Branch-Schlüsselmaterialien, die im lokalen Cache gespeichert werden können.

  • Größe des Endstücks des Eintrags: Definiert die Anzahl der Einträge, die beschnitten werden müssen, wenn die Eingangskapazität erreicht ist.

Java
.cache(CacheType.builder()
        .MultiThreaded(MultiThreadedCache.builder()
        .entryCapacity(100)
        .entryPruningTailSize(1)                                        
        .build())
C# / .NET
CacheType multithreadedCache = new CacheType
{
    MultiThreaded = new MultiThreadedCache
    {
        EntryCapacity = 100,
        EntryPruningTailSize = 1
    }
};
Python
multithreaded_cache = CacheTypeMultiThreaded(
    value=MultiThreadedCache(
        entry_capacity=100,
        entry_pruning_tail_size=1
    )
)

StormTracking Zwischenspeicher

Der StormTracking Cache ist so konzipiert, dass er Umgebungen mit vielen Threads unterstützt. Wenn ein Eintrag für Branch-Schlüssel-Materialien abläuft, verhindert der StormTracking Cache den Aufruf mehrerer Threads, AWS KMS indem ein Thread im Voraus darüber informiert wird, dass der Eintrag für Branch-Schlüssel-Materialien abläuft. Dadurch wird sichergestellt, dass nur ein Thread eine Anfrage AWS KMS zur Aktualisierung des Caches sendet.

Um den StormTracking Cache zu verwenden, geben Sie die folgenden Werte an:

  • Eintragskapazität: Beschränkt die Anzahl der Einträge für Branch-Schlüsselmaterialien, die im lokalen Cache gespeichert werden können.

    Standardwert: 1000 Einträge

  • Größe des Eintrags zum Beschneiden: Definiert die Anzahl der Einträge für wichtige Materialien in der Branche, die gleichzeitig beschnitten werden sollen.

    Standardwert: 1 Eintrag

  • Übergangszeit: Definiert die Anzahl der Sekunden vor Ablauf, nach der versucht wird, die wichtigsten Materialien der Branche zu aktualisieren.

    Standardwert: 10 Sekunden

  • Verlängerungsintervall: Definiert die Anzahl der Sekunden zwischen Versuchen, die Schlüsselmaterialien der Filiale zu aktualisieren.

    Standardwert: 1 Sekunde

  • Fan-out: Definiert die Anzahl der gleichzeitigen Versuche, die wichtigsten Materialien der Filiale zu aktualisieren.

    Standardwert: 20 Versuche

  • In flight time to live (TTL): Definiert die Anzahl der Sekunden, bis beim Versuch, die Schlüsselmaterialien der Filiale zu aktualisieren, eine Zeitüberschreitung eintritt. Jedes Mal, wenn der Cache als Antwort auf eine zurückkehrt NoSuchEntryGetCacheEntry, gilt dieser Verzweigungsschlüssel als aktiv, bis derselbe Schlüssel zusammen mit einem PutCache Eintrag geschrieben wird.

    Standardwert: 20 Sekunden

  • Ruhezustand: Definiert die Anzahl der Sekunden, die ein Thread in den Ruhezustand versetzen soll, wenn der Wert überschritten fanOut wird.

    Standardwert: 20 Millisekunden

Java
.cache(CacheType.builder()
        .StormTracking(StormTrackingCache.builder()
        .entryCapacity(100)
        .entryPruningTailSize(1)
        .gracePeriod(10)
        .graceInterval(1)
        .fanOut(20) 
        .inFlightTTL(20)
        .sleepMilli(20)                                        
        .build())
C# / .NET
CacheType stormTrackingCache = new CacheType
{
    StormTracking = new StormTrackingCache
    {
        EntryCapacity = 100,
        EntryPruningTailSize = 1,
        FanOut = 20,
        GraceInterval = 1,
        GracePeriod = 10,
        InFlightTTL = 20,
        SleepMilli = 20
    }
};
Python
storm_tracking_cache = CacheTypeStormTracking(
    value=StormTrackingCache(
        entry_capacity=100,
        entry_pruning_tail_size=1,
        fan_out=20,
        grace_interval=1,
        grace_period=10,
        in_flight_ttl=20,
        sleep_milli=20
    )
)

Gemeinsamer Cache

Standardmäßig erstellt der hierarchische Schlüsselbund jedes Mal, wenn Sie den Schlüsselbund instanziieren, einen neuen lokalen Cache. Der Shared Cache kann jedoch dabei helfen, Speicherplatz zu sparen, indem er es Ihnen ermöglicht, einen Cache für mehrere hierarchische Schlüsselbunde gemeinsam zu nutzen. Anstatt für jeden hierarchischen Schlüsselbund, den Sie instanziieren, einen neuen Cache für kryptografisches Material zu erstellen, speichert der Shared Cache nur einen Cache im Arbeitsspeicher, der von allen hierarchischen Schlüsselbunden verwendet werden kann, die auf ihn verweisen. Der gemeinsam genutzte Cache trägt zur Optimierung der Speichernutzung bei, indem verhindert wird, dass kryptografisches Material in mehreren Schlüsselbunden doppelt vorhanden ist. Stattdessen können die hierarchischen Schlüsselbunde auf denselben zugrunde liegenden Cache zugreifen, wodurch der Gesamtspeicherbedarf reduziert wird.

Wenn Sie Ihren Shared Cache erstellen, definieren Sie immer noch den Cachetyp. Sie können einen Standard-CacheMultiThreaded Cache, oder StormTracking Zwischenspeicher als Cachetyp angeben oder einen beliebigen kompatiblen benutzerdefinierten Cache ersetzen.

Partitionen

Ein einziger gemeinsam genutzter Cache kann von mehreren hierarchischen Schlüsselbunden verwendet werden. Wenn Sie einen hierarchischen Schlüsselbund mit einem gemeinsam genutzten Cache erstellen, können Sie eine optionale Partitions-ID definieren. Die Partitions-ID unterscheidet, welcher hierarchische Schlüsselbund in den Cache schreibt. Wenn zwei hierarchische Schlüsselbunde auf dieselbe Partitions-ID und dieselbe Zweigschlüssel-ID verweisenlogical key store name, teilen sich die beiden Schlüsselbunde dieselben Cache-Einträge im Cache. Wenn Sie zwei hierarchische Schlüsselbunde mit demselben Shared Cache, aber unterschiedlicher Partition IDs erstellen, greift jeder Schlüsselbund nur auf die Cache-Einträge von der eigenen zugewiesenen Partition innerhalb des Shared Caches zu. Die Partitionen dienen als logische Unterteilungen innerhalb des gemeinsam genutzten Caches, sodass jeder hierarchische Schlüsselbund unabhängig auf seiner eigenen zugewiesenen Partition betrieben werden kann, ohne die in der anderen Partition gespeicherten Daten zu beeinträchtigen.

Wenn Sie beabsichtigen, die Cache-Einträge in einer Partition wiederzuverwenden oder gemeinsam zu nutzen, müssen Sie Ihre eigene Partitions-ID definieren. Wenn Sie die Partitions-ID an Ihren hierarchischen Schlüsselbund übergeben, kann der Schlüsselbund die Cache-Einträge wiederverwenden, die bereits im Shared Cache vorhanden sind, anstatt die Branch-Schlüsselmaterialien erneut abrufen und autorisieren zu müssen. Wenn Sie keine Partitions-ID angeben, wird dem Schlüsselbund bei jeder Instanziierung des hierarchischen Schlüsselbunds automatisch eine eindeutige Partitions-ID zugewiesen.

Die folgenden Verfahren veranschaulichen, wie ein gemeinsam genutzter Cache mit dem Standard-Cachetyp erstellt und an einen hierarchischen Schlüsselbund übergeben wird.

  1. Erstellen Sie einen CryptographicMaterialsCache (CMC) mithilfe der Material Providers Library ()MPL.

    Java
    // Instantiate the MPL
final MaterialProviders matProv =
    MaterialProviders.builder()
        .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
        .build();

// Create a CacheType object for the Default cache
final CacheType cache =
    CacheType.builder() 
        .Default(DefaultCache.builder().entryCapacity(100).build())
        .build();

// Create a CMC using the default cache
final CreateCryptographicMaterialsCacheInput cryptographicMaterialsCacheInput =
    CreateCryptographicMaterialsCacheInput.builder()
        .cache(cache)
        .build();

final ICryptographicMaterialsCache sharedCryptographicMaterialsCache =
    matProv.CreateCryptographicMaterialsCache(cryptographicMaterialsCacheInput);
    C# / .NET
    // Instantiate the MPL
var materialProviders = new MaterialProviders(new MaterialProvidersConfig());

// Create a CacheType object for the Default cache
var cache = new CacheType { Default = new DefaultCache{EntryCapacity = 100} };

// Create a CMC using the default cache
var cryptographicMaterialsCacheInput = new CreateCryptographicMaterialsCacheInput {Cache = cache};

var sharedCryptographicMaterialsCache = materialProviders.CreateCryptographicMaterialsCache(cryptographicMaterialsCacheInput);
    Python
    # Instantiate the MPL
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
    config=MaterialProvidersConfig()
)

# Create a CacheType object for the default cache
cache: CacheType = CacheTypeDefault(
    value=DefaultCache(
        entry_capacity=100,
    )
)

# Create a CMC using the default cache
cryptographic_materials_cache_input = CreateCryptographicMaterialsCacheInput(
    cache=cache,
)

shared_cryptographic_materials_cache = mat_prov.create_cryptographic_materials_cache(
    cryptographic_materials_cache_input
)

  2. Erstellen Sie ein CacheType Objekt für den Shared Cache.

    Übergeben sharedCryptographicMaterialsCache Sie das, was Sie in Schritt 1 erstellt haben, an das neue CacheType Objekt.

    Java
    // Create a CacheType object for the sharedCryptographicMaterialsCache
final CacheType sharedCache =
    CacheType.builder()
        .Shared(sharedCryptographicMaterialsCache)
        .build();
    C# / .NET
    // Create a CacheType object for the sharedCryptographicMaterialsCache
var sharedCache = new CacheType { Shared = sharedCryptographicMaterialsCache };
    Python
    # Create a CacheType object for the shared_cryptographic_materials_cache
shared_cache: CacheType = CacheTypeShared(
    value=shared_cryptographic_materials_cache
)

  3. Übergeben Sie das sharedCache Objekt aus Schritt 2 an Ihren hierarchischen Schlüsselbund.

    Wenn Sie einen hierarchischen Schlüsselbund mit einem gemeinsam genutzten Cache erstellen, können Sie optional a definieren, um Cache-Einträge für mehrere hierarchische Schlüsselbunde gemeinsam partitionID zu nutzen. Wenn Sie keine Partitions-ID angeben, weist der hierarchische Schlüsselbund dem Schlüsselbund automatisch eine eindeutige Partitions-ID zu.

    Anmerkung

    Ihre hierarchischen Schlüsselbunde verwenden dieselben Cacheeinträge in einem gemeinsam genutzten Cache, wenn Sie zwei oder mehr Schlüsselbunde erstellen, die auf dieselbe Partitions-ID und Verzweigungsschlüssel-ID verweisen. logical key store name Wenn Sie nicht möchten, dass sich mehrere Schlüsselbunde dieselben Cache-Einträge teilen, müssen Sie für jeden hierarchischen Schlüsselbund eine eindeutige Partitions-ID verwenden.

    Im folgenden Beispiel wird ein hierarchischer Schlüsselbund mit einem und einem branch key ID supplier Cache-Limit von 600 Sekunden erstellt. Weitere Informationen zu den Werten, die in der folgenden Konfiguration für den hierarchischen Schlüsselbund definiert sind, finden Sie unter. Erstellen Sie einen hierarchischen Schlüsselbund

    Java
    // Create the Hierarchical keyring
final CreateAwsKmsHierarchicalKeyringInput keyringInput =
    CreateAwsKmsHierarchicalKeyringInput.builder()
        .keyStore(keystore)
        .branchKeyIdSupplier(branchKeyIdSupplier)
        .ttlSeconds(600)
        .cache(sharedCache)
        .partitionID(partitionID)
        .build();
final IKeyring hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
    C# / .NET
    // Create the Hierarchical keyring        
var createKeyringInput = new CreateAwsKmsHierarchicalKeyringInput
{
   KeyStore = keystore,
   BranchKeyIdSupplier = branchKeyIdSupplier,
   Cache = sharedCache,
   TtlSeconds = 600,
   PartitionId = partitionID
};
var keyring = materialProviders.CreateAwsKmsHierarchicalKeyring(createKeyringInput);
    Python
    # Create the Hierarchical keyring
keyring_input: CreateAwsKmsHierarchicalKeyringInput = CreateAwsKmsHierarchicalKeyringInput(
    key_store=keystore,
    branch_key_id_supplier=branch_key_id_supplier,
    ttl_seconds=600,
    cache=shared_cache,
    partition_id=partition_id
)

hierarchical_keyring: IKeyring = mat_prov.create_aws_kms_hierarchical_keyring(
    input=keyring_input
)
Mehr anzeigenWeniger anzeigen

Erstellen Sie einen hierarchischen Schlüsselbund

Um einen hierarchischen Schlüsselbund zu erstellen, müssen Sie die folgenden Werte angeben:

  • Ein Name für den Schlüsselspeicher

    Der Name der DynamoDB-Tabelle, die Sie oder Ihr Schlüsselspeicheradministrator als Schlüsselspeicher erstellt haben.

  • Ein Cache-Limit für die Gültigkeitsdauer () TTL

    Die Zeitspanne in Sekunden, in der ein Eintrag für Materialien in einem Branch Key innerhalb des lokalen Caches verwendet werden kann, bevor er abläuft. Das Cache-Limit TTL bestimmt, wie oft der Client anruft AWS KMS , um die Verwendung der Branch-Schlüssel zu autorisieren. Dieser Wert muss größer als null sein. Nach TTL Ablauf des Cache-Limits wird der Eintrag nicht mehr bearbeitet und aus dem lokalen Cache entfernt.

  • Ein Schlüsselbezeichner für einen Zweig

    Sie können den entweder statisch konfigurierenbranch-key-id, der einen einzelnen aktiven Zweigschlüssel in Ihrem Schlüsselspeicher identifiziert, oder einen Lieferanten für die Zweigschlüssel-ID angeben.

    Der Anbieter der Zweigschlüssel-ID bestimmt anhand der im Verschlüsselungskontext gespeicherten Felder, welcher Filialschlüssel zum Entschlüsseln eines Datensatzes erforderlich ist.

    Wir empfehlen dringend, einen Branch-Schlüssel-ID-Anbieter für Mehrmandantendatenbanken zu verwenden, bei denen jeder Mandant seinen eigenen Branch-Schlüssel hat. Sie können den Anbieter für die Branch-Schlüssel-ID verwenden, um einen benutzerfreundlichen Namen für Ihren Branch-Schlüssel IDs zu erstellen, damit Sie die richtige Branch-Schlüssel-ID für einen bestimmten Mandanten leicht erkennen können. Mit dem Anzeigenamen können Sie beispielsweise auf einen Zweigschlüssel als tenant1 statt auf verweisenb3f61619-4d35-48ad-a275-050f87e15122.

    Für Entschlüsselungsvorgänge können Sie entweder einen einzelnen hierarchischen Schlüsselbund statisch konfigurieren, um die Entschlüsselung auf einen einzelnen Mandanten zu beschränken, oder Sie können den Branch-Schlüssel-ID-Anbieter verwenden, um zu ermitteln, welcher Mandant für die Entschlüsselung eines Datensatzes verantwortlich ist.

  • (Optional) Ein Cache

    Wenn Sie Ihren Cachetyp oder die Anzahl der Einträge für Branch-Schlüsselmaterialien, die im lokalen Cache gespeichert werden können, anpassen möchten, geben Sie den Cachetyp und die Eintragskapazität an, wenn Sie den Schlüsselbund initialisieren.

    Der hierarchische Schlüsselbund unterstützt die folgenden Cachetypen: Standard, MultiThreaded, StormTracking und Shared. Weitere Informationen und Beispiele zur Definition der einzelnen Cachetypen finden Sie unter. Wählen Sie einen Cache

    Wenn Sie keinen Cache angeben, verwendet der hierarchische Schlüsselbund automatisch den Standard-Cachetyp und legt die Eintragskapazität auf 1000 fest.

  • (Optional) Eine Partitions-ID

    Wenn Sie die angebenGemeinsamer Cache, können Sie optional eine Partitions-ID definieren. Die Partitions-ID unterscheidet, welcher hierarchische Schlüsselbund in den Cache schreibt. Wenn Sie beabsichtigen, die Cache-Einträge in einer Partition wiederzuverwenden oder gemeinsam zu nutzen, müssen Sie Ihre eigene Partitions-ID definieren. Sie können eine beliebige Zeichenfolge für die Partitions-ID angeben. Wenn Sie keine Partitions-ID angeben, wird dem Schlüsselbund bei der Erstellung automatisch eine eindeutige Partitions-ID zugewiesen.

    Weitere Informationen finden Sie unter Partitions.

    Anmerkung

    Ihre hierarchischen Schlüsselbunde verwenden dieselben Cache-Einträge in einem gemeinsam genutzten Cache, wenn Sie zwei oder mehr Schlüsselbunde erstellen, die auf dieselbe Partitions-ID und Verzweigungsschlüssel-ID verweisen. logical key store name Wenn Sie nicht möchten, dass sich mehrere Schlüsselbunde dieselben Cache-Einträge teilen, müssen Sie für jeden hierarchischen Schlüsselbund eine eindeutige Partitions-ID verwenden.

  • (Optional) Eine Liste von Grant-Tokens

    Wenn Sie den Zugriff auf den KMS Schlüssel in Ihrem hierarchischen Schlüsselbund mit Grants steuern, müssen Sie bei der Initialisierung des Schlüsselbunds alle erforderlichen Grant-Token angeben.

Die folgenden Beispiele zeigen, wie Sie einen hierarchischen Schlüsselbund mit einer statischen Zweigschlüssel-ID, demStandard-Cache, und einem TTL Cache-Limit von 600 Sekunden erstellen.

Java
final MaterialProviders matProv = MaterialProviders.builder()
        .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
        .build();
final CreateAwsKmsHierarchicalKeyringInput keyringInput = CreateAwsKmsHierarchicalKeyringInput.builder()
        .keyStore(branchKeyStoreName)
        .branchKeyId(branch-key-id)
        .ttlSeconds(600)
        .build();
final Keyring hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
C# / .NET
var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsHierarchicalKeyringInput
{
   KeyStore = keystore,
   BranchKeyId = branch-key-id,
   TtlSeconds = 600
};
var hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
Python
mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
    config=MaterialProvidersConfig()
)

keyring_input: CreateAwsKmsHierarchicalKeyringInput = CreateAwsKmsHierarchicalKeyringInput(
    key_store=keystore,
    branch_key_id=branch_key_id,
    ttl_seconds=600
)

hierarchical_keyring: IKeyring = mat_prov.create_aws_kms_hierarchical_keyring(
    input=keyring_input
)

Die folgenden Verfahren zeigen, wie Sie einen hierarchischen Schlüsselbund mit einem Branchenschlüssel-ID-Lieferanten erstellen.

  1. Erstellen Sie einen Lieferanten für die Zweigschlüssel-ID

    Im folgenden Beispiel werden benutzerfreundliche Namen für zwei Branch-Schlüssel und Aufrufe CreateDynamoDbEncryptionBranchKeyIdSupplier zur Erstellung eines Branch-Schlüssel-ID-Lieferanten erstellt.

    Java
    // Create friendly names for each branch-key-id 
class ExampleBranchKeyIdSupplier implements IDynamoDbKeyBranchKeyIdSupplier {
    private static String branchKeyIdForTenant1;
    private static String branchKeyIdForTenant2;

    public ExampleBranchKeyIdSupplier(String tenant1Id, String tenant2Id) {
        this.branchKeyIdForTenant1 = tenant1Id;
        this.branchKeyIdForTenant2 = tenant2Id;
    }
// Create the branch key ID supplier    
final DynamoDbEncryption ddbEnc = DynamoDbEncryption.builder()
        .DynamoDbEncryptionConfig(DynamoDbEncryptionConfig.builder().build())
        .build();
final BranchKeyIdSupplier branchKeyIdSupplier = ddbEnc.CreateDynamoDbEncryptionBranchKeyIdSupplier(
    CreateDynamoDbEncryptionBranchKeyIdSupplierInput.builder()
            .ddbKeyBranchKeyIdSupplier(new ExampleBranchKeyIdSupplier(branch-key-ID-tenant1, branch-key-ID-tenant2))
            .build()).branchKeyIdSupplier();
    C# / .NET
    // Create friendly names for each branch-key-id
 class ExampleBranchKeyIdSupplier : DynamoDbKeyBranchKeyIdSupplierBase {
    private String _branchKeyIdForTenant1;
    private String _branchKeyIdForTenant2;

    public ExampleBranchKeyIdSupplier(String tenant1Id, String tenant2Id) {
        this._branchKeyIdForTenant1 = tenant1Id;
        this._branchKeyIdForTenant2 = tenant2Id;
    }    
// Create the branch key ID supplier
var ddbEnc = new DynamoDbEncryption(new DynamoDbEncryptionConfig());
var branchKeyIdSupplier = ddbEnc.CreateDynamoDbEncryptionBranchKeyIdSupplier(
    new CreateDynamoDbEncryptionBranchKeyIdSupplierInput
    {
        DdbKeyBranchKeyIdSupplier = new ExampleBranchKeyIdSupplier(branch-key-ID-tenant1, branch-key-ID-tenant2)
    }).BranchKeyIdSupplier;
    Python
    # Create branch key ID supplier that maps the branch key ID to a friendly name
branch_key_id_supplier: IBranchKeyIdSupplier = ExampleBranchKeyIdSupplier(
        tenant_1_id=branch_key_id_a,
        tenant_2_id=branch_key_id_b,
)

  2. Erstellen Sie einen hierarchischen Schlüsselbund

    In den folgenden Beispielen wird ein hierarchischer Schlüsselbund mit dem in Schritt 1 erstellten Branch-Schlüssel-ID-Lieferanten, einem Cache-Limit TLL von 600 Sekunden und einer maximalen Cachegröße von 1000 initialisiert.

    Java
    final MaterialProviders matProv = MaterialProviders.builder()
        .MaterialProvidersConfig(MaterialProvidersConfig.builder().build())
        .build();
final CreateAwsKmsHierarchicalKeyringInput keyringInput = CreateAwsKmsHierarchicalKeyringInput.builder()
        .keyStore(keystore)
        .branchKeyIdSupplier(branchKeyIdSupplier)
        .ttlSeconds(600)
        .cache(CacheType.builder() //OPTIONAL
                .Default(DefaultCache.builder()
                .entryCapacity(100)
                .build())
        .build();
final Keyring hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
    C# / .NET
    var matProv = new MaterialProviders(new MaterialProvidersConfig());
var keyringInput = new CreateAwsKmsHierarchicalKeyringInput
{
   KeyStore = keystore,
   BranchKeyIdSupplier = branchKeyIdSupplier,
   TtlSeconds = 600, 
   Cache = new CacheType
   {
        Default = new DefaultCache { EntryCapacity = 100 }
   }
};
var hierarchicalKeyring = matProv.CreateAwsKmsHierarchicalKeyring(keyringInput);
    Python
    mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
    config=MaterialProvidersConfig()
)

keyring_input: CreateAwsKmsHierarchicalKeyringInput = CreateAwsKmsHierarchicalKeyringInput(
    key_store=keystore,
    branch_key_id_supplier=branch_key_id_supplier,
    ttl_seconds=600,
    cache=CacheTypeDefault(
        value=DefaultCache(
            entry_capacity=100
        )
    ),
)

hierarchical_keyring: IKeyring = mat_prov.create_aws_kms_hierarchical_keyring(
    input=keyring_input
)