removed classes for keyrings / mkps

Author: RitvikKapila

examples/src/migration/migration_aws_kms_key_example.py

@@ -4,7 +4,7 @@
 This is a migration example for moving to the AWS KMS Keyring from AWS KMS master key provider (MKP)
 
 The AWS KMS keyring uses symmetric encryption KMS keys to generate, encrypt and
-decrypt data keys. This example creates the KMS Keyring and KMS MKP and
+decrypt data keys. This example creates a KMS Keyring and KMS MKP and
 then encrypts a custom input EXAMPLE_DATA with an encryption context using both
 the keyring and MKP. The example then decrypts the ciphertext using both keyring and MKPs.
 This example also includes some sanity checks for demonstration:
@@ -202,9 +202,9 @@ def decrypt_using_key_provider(
 def migration_aws_kms_key(
     kms_key_id: str
 ):
-    """Demonstrate a migration example for moving from an AWS KMS keyring to AWS KMS MKP.
+    """Demonstrate a migration example for moving to an AWS KMS keyring from AWS KMS MKP.
 
-    Usage: migration_to_aws_kms_keyring_from_aws_kms_master_key_provider(kms_key_id)
+    Usage: migration_aws_kms_key(kms_key_id)
     :param kms_key_id: KMS Key identifier for the KMS key you want to use for encryption and
     decryption of your data keys.
     :type kms_key_id: string

examples/src/migration/migration_raw_aes_key_example.py

@@ -8,7 +8,7 @@
 preferably in a hardware security module (HSM) or key management system. Use a Raw AES keyring
 when you need to provide the wrapping key and encrypt the data keys locally or offline.
 
-This example defines classes for Raw AES Keyring and Raw AES MKP and
+This example creates a Raw AES Keyring and Raw AES MKP and
 then encrypts a custom input EXAMPLE_DATA with an encryption context using both
 the keyring and MKP. The example then decrypts the ciphertext using both keyring and MKPs.
 This example also includes some sanity checks for demonstration:
@@ -54,79 +54,75 @@
 DEFAULT_KEY_NAME = "My 256-bit AES wrapping key"
 
 
-class RawAesKeyring():
-    """Class for creating a Raw AES Keyring and using it for encryption and decryption"""
+def create_keyring():
+    """Demonstrate how to create a Raw AES keyring.
 
-    @staticmethod
-    def create_keyring():
-        """Demonstrate how to create a Raw AES keyring.
+    Usage: create_keyring()
+    """
+    # We fix the static key in order to make the test deterministic
+    static_key = DEFAULT_AES_256_STATIC_KEY
 
-        Usage: create_keyring()
-        """
-        # We fix the static key in order to make the test deterministic
-        static_key = DEFAULT_AES_256_STATIC_KEY
+    mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
+        config=MaterialProvidersConfig()
+    )
 
-        mat_prov: AwsCryptographicMaterialProviders = AwsCryptographicMaterialProviders(
-            config=MaterialProvidersConfig()
-        )
+    keyring_input: CreateRawAesKeyringInput = CreateRawAesKeyringInput(
+        key_namespace=DEFAULT_KEY_NAME_SPACE,
+        key_name=DEFAULT_KEY_NAME,
+        wrapping_key=static_key,
+        wrapping_alg=AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16
+    )
 
-        keyring_input: CreateRawAesKeyringInput = CreateRawAesKeyringInput(
-            key_namespace=DEFAULT_KEY_NAME_SPACE,
-            key_name=DEFAULT_KEY_NAME,
-            wrapping_key=static_key,
-            wrapping_alg=AesWrappingAlg.ALG_AES256_GCM_IV12_TAG16
-        )
+    keyring: IKeyring = mat_prov.create_raw_aes_keyring(
+        input=keyring_input
+    )
 
-        keyring: IKeyring = mat_prov.create_raw_aes_keyring(
-            input=keyring_input
-        )
+    return keyring
 
-        return keyring
 
-    @staticmethod
-    def encrypt_using_keyring(
-        plaintext_data: bytes,
-        keyring: IKeyring
-    ):
-        """Demonstrate how to encrypt plaintext data using a Raw AES keyring.
+def encrypt_using_keyring(
+    plaintext_data: bytes,
+    keyring: IKeyring
+):
+    """Demonstrate how to encrypt plaintext data using a Raw AES keyring.
 
-        Usage: encrypt_using_keyring(plaintext_data, keyring)
-        :param plaintext_data: plaintext data you want to encrypt
-        :type: bytes
-        :param keyring: Keyring to use for encryption.
-        :type keyring: IKeyring
-        """
-        client = aws_encryption_sdk.EncryptionSDKClient()
+    Usage: encrypt_using_keyring(plaintext_data, keyring)
+    :param plaintext_data: plaintext data you want to encrypt
+    :type: bytes
+    :param keyring: Keyring to use for encryption.
+    :type keyring: IKeyring
+    """
+    client = aws_encryption_sdk.EncryptionSDKClient()
 
-        ciphertext_data, _ = client.encrypt(
-            source=plaintext_data,
-            keyring=keyring,
-            encryption_context=DEFAULT_ENCRYPTION_CONTEXT
-        )
+    ciphertext_data, _ = client.encrypt(
+        source=plaintext_data,
+        keyring=keyring,
+        encryption_context=DEFAULT_ENCRYPTION_CONTEXT
+    )
 
-        return ciphertext_data
+    return ciphertext_data
 
-    @staticmethod
-    def decrypt_using_keyring(
-        ciphertext_data: bytes,
-        keyring: IKeyring
-    ):
-        """Demonstrate how to decrypt ciphertext data using a Raw AES keyring.
 
-        Usage: decrypt_using_keyring(ciphertext_data, keyring)
-        :param ciphertext_data: ciphertext data you want to decrypt
-        :type: bytes
-        :param keyring: Keyring to use for decryption.
-        :type keyring: IKeyring
-        """
-        client = aws_encryption_sdk.EncryptionSDKClient()
+def decrypt_using_keyring(
+    ciphertext_data: bytes,
+    keyring: IKeyring
+):
+    """Demonstrate how to decrypt ciphertext data using a Raw AES keyring.
 
-        decrypted_plaintext_data, _ = client.decrypt(
-            source=ciphertext_data,
-            keyring=keyring
-        )
+    Usage: decrypt_using_keyring(ciphertext_data, keyring)
+    :param ciphertext_data: ciphertext data you want to decrypt
+    :type: bytes
+    :param keyring: Keyring to use for decryption.
+    :type keyring: IKeyring
+    """
+    client = aws_encryption_sdk.EncryptionSDKClient()
 
-        return decrypted_plaintext_data
+    decrypted_plaintext_data, _ = client.decrypt(
+        source=ciphertext_data,
+        keyring=keyring
+    )
+
+    return decrypted_plaintext_data
 
 
 # This is a helper class necessary for the Raw AES master key provider
@@ -162,89 +158,85 @@ def _get_raw_key(self, key_id):
         )
 
 
-class RawAesMasterKeyProvider():
-    """Class for creating a Raw AES MKP and using it for encryption and decryption"""
+def create_key_provider():
+    """Demonstrate how to create a Raw AES master key provider.
 
-    @staticmethod
-    def create_key_provider():
-        """Demonstrate how to create a Raw AES master key provider.
+    Usage: create_key_provider()
+    """
+    # Create a Raw AES master key provider.
 
-        Usage: create_key_provider()
-        """
-        # Create a Raw AES master key provider.
-
-        # The Key ID field in the JceMasterKey and RawMasterKey is equivalent to key name in the Raw keyrings
-        key_id = DEFAULT_KEY_NAME
-        key_provider = StaticRandomMasterKeyProvider()
-        key_provider.add_master_key(key_id)
-
-        return key_provider
-
-    @staticmethod
-    def encrypt_using_key_provider(
-        plaintext_data: bytes,
-        key_provider: aws_encryption_sdk.key_providers.base.MasterKeyProvider
-    ):
-        """Demonstrate how to encrypt plaintext data using a Raw AES master key provider.
-
-        Usage: encrypt_using_key_provider(plaintext_data, key_provider)
-        :param plaintext_data: plaintext data you want to encrypt
-        :type: bytes
-        :param key_provider: Master key provider to use for encryption.
-        :type key_provider: aws_encryption_sdk.key_providers.base.MasterKeyProvider
-        """
-        client = aws_encryption_sdk.EncryptionSDKClient()
+    # The Key ID field in the JceMasterKey and RawMasterKey is equivalent to key name in the Raw keyrings
+    key_id = DEFAULT_KEY_NAME
+    key_provider = StaticRandomMasterKeyProvider()
+    key_provider.add_master_key(key_id)
 
-        ciphertext_data, _ = client.encrypt(
-            source=plaintext_data,
-            key_provider=key_provider,
-            encryption_context=DEFAULT_ENCRYPTION_CONTEXT
-        )
+    return key_provider
 
-        return ciphertext_data
 
-    @staticmethod
-    def decrypt_using_key_provider(
-        ciphertext_data: bytes,
-        key_provider: aws_encryption_sdk.key_providers.base.MasterKeyProvider
-    ):
-        """Demonstrate how to decrypt ciphertext data using a Raw AES master key provider.
+def encrypt_using_key_provider(
+    plaintext_data: bytes,
+    key_provider: aws_encryption_sdk.key_providers.base.MasterKeyProvider
+):
+    """Demonstrate how to encrypt plaintext data using a Raw AES master key provider.
 
-        Usage: decrypt_using_key_provider(ciphertext_data, key_provider)
-        :param ciphertext_data: ciphertext data you want to decrypt
-        :type: bytes
-        :param key_provider: Master key provider to use for decryption.
-        :type key_provider: aws_encryption_sdk.key_providers.base.MasterKeyProvider
-        """
-        client = aws_encryption_sdk.EncryptionSDKClient()
+    Usage: encrypt_using_key_provider(plaintext_data, key_provider)
+    :param plaintext_data: plaintext data you want to encrypt
+    :type: bytes
+    :param key_provider: Master key provider to use for encryption.
+    :type key_provider: aws_encryption_sdk.key_providers.base.MasterKeyProvider
+    """
+    client = aws_encryption_sdk.EncryptionSDKClient()
 
-        decrypted_plaintext_data, _ = client.decrypt(
-            source=ciphertext_data,
-            key_provider=key_provider
-        )
+    ciphertext_data, _ = client.encrypt(
+        source=plaintext_data,
+        key_provider=key_provider,
+        encryption_context=DEFAULT_ENCRYPTION_CONTEXT
+    )
+
+    return ciphertext_data
+
+
+def decrypt_using_key_provider(
+    ciphertext_data: bytes,
+    key_provider: aws_encryption_sdk.key_providers.base.MasterKeyProvider
+):
+    """Demonstrate how to decrypt ciphertext data using a Raw AES master key provider.
+
+    Usage: decrypt_using_key_provider(ciphertext_data, key_provider)
+    :param ciphertext_data: ciphertext data you want to decrypt
+    :type: bytes
+    :param key_provider: Master key provider to use for decryption.
+    :type key_provider: aws_encryption_sdk.key_providers.base.MasterKeyProvider
+    """
+    client = aws_encryption_sdk.EncryptionSDKClient()
+
+    decrypted_plaintext_data, _ = client.decrypt(
+        source=ciphertext_data,
+        key_provider=key_provider
+    )
 
-        return decrypted_plaintext_data
+    return decrypted_plaintext_data
 
 
-def migration_to_raw_aes_keyring_from_raw_aes_master_key_provider():
-    """Demonstrate a migration example for moving from a Raw AES keyring to Raw AES MKP.
+def migration_raw_aes_key():
+    """Demonstrate a migration example for moving to a Raw AES keyring from Raw AES MKP.
 
-    Usage: migration_to_raw_aes_keyring_from_raw_aes_master_key_provider()
+    Usage: migration_raw_aes_key()
     """
     # 1a. Create a Raw AES Keyring
-    raw_aes_keyring = RawAesKeyring.create_keyring()
+    raw_aes_keyring = create_keyring()
 
     # 1b. Create a Raw AES Master Key Provider
-    raw_aes_master_key_provider = RawAesMasterKeyProvider.create_key_provider()
+    raw_aes_master_key_provider = create_key_provider()
 
     # 2a. Encrypt EXAMPLE_DATA using Raw AES Keyring
-    ciphertext_keyring = RawAesKeyring.encrypt_using_keyring(
+    ciphertext_keyring = encrypt_using_keyring(
         plaintext_data=EXAMPLE_DATA,
         keyring=raw_aes_keyring
     )
 
     # 2b. Encrypt EXAMPLE_DATA using Raw AES Master Key Provider
-    ciphertext_mkp = RawAesMasterKeyProvider.encrypt_using_key_provider(
+    ciphertext_mkp = encrypt_using_key_provider(
         plaintext_data=EXAMPLE_DATA,
         key_provider=raw_aes_master_key_provider
     )
@@ -256,12 +248,12 @@ def migration_to_raw_aes_keyring_from_raw_aes_master_key_provider():
 
     # 3. Decrypt the ciphertext_keyring using both the keyring and MKP and ensure the
     # resulting plaintext is the same and also equal to EXAMPLE_DATA
-    decrypted_ciphertext_keyring_using_keyring = RawAesKeyring.decrypt_using_keyring(
+    decrypted_ciphertext_keyring_using_keyring = decrypt_using_keyring(
         ciphertext_data=ciphertext_keyring,
         keyring=raw_aes_keyring
     )
 
-    decrypted_ciphertext_keyring_using_mkp = RawAesMasterKeyProvider.decrypt_using_key_provider(
+    decrypted_ciphertext_keyring_using_mkp = decrypt_using_key_provider(
         ciphertext_data=ciphertext_keyring,
         key_provider=raw_aes_master_key_provider
     )
@@ -272,12 +264,12 @@ def migration_to_raw_aes_keyring_from_raw_aes_master_key_provider():
 
     # 4. Decrypt the ciphertext_mkp using both the keyring and MKP and ensure the
     # resulting plaintext is the same and also equal to EXAMPLE_DATA
-    decrypted_ciphertext_mkp_using_keyring = RawAesKeyring.decrypt_using_keyring(
+    decrypted_ciphertext_mkp_using_keyring = decrypt_using_keyring(
         ciphertext_data=ciphertext_mkp,
         keyring=raw_aes_keyring
     )
 
-    decrypted_ciphertext_mkp_using_mkp = RawAesMasterKeyProvider.decrypt_using_key_provider(
+    decrypted_ciphertext_mkp_using_mkp = decrypt_using_key_provider(
         ciphertext_data=ciphertext_mkp,
         key_provider=raw_aes_master_key_provider
     )