Datasets:

---

semeru

/

code-text-python

like 11

Follow

Semeru Lab 8

[ "def", "_encrypted_data_keys_hash", "(", "hasher", ",", "encrypted_data_keys", ")", ":", "hashed_keys", "=", "[", "]", "for", "edk", "in", "encrypted_data_keys", ":", "serialized_edk", "=", "serialize_encrypted_data_key", "(", "edk", ")", "_hasher", "=", "hasher", ".", "copy", "(", ")", "_hasher", ".", "update", "(", "serialized_edk", ")", "hashed_keys", ".", "append", "(", "_hasher", ".", "finalize", "(", ")", ")", "return", "b\"\"", ".", "join", "(", "sorted", "(", "hashed_keys", ")", ")" ]

[ "Generates", "the", "expected", "hash", "for", "the", "provided", "encrypted", "data", "keys", "." ]

[ "def", "build_decryption_materials_cache_key", "(", "partition", ",", "request", ")", ":", "hasher", "=", "_new_cache_key_hasher", "(", ")", "_partition_hash", "=", "_partition_name_hash", "(", "hasher", "=", "hasher", ".", "copy", "(", ")", ",", "partition_name", "=", "partition", ")", "_algorithm_info", "=", "request", ".", "algorithm", ".", "id_as_bytes", "(", ")", "_edks_hash", "=", "_encrypted_data_keys_hash", "(", "hasher", "=", "hasher", ".", "copy", "(", ")", ",", "encrypted_data_keys", "=", "request", ".", "encrypted_data_keys", ")", "_ec_hash", "=", "_encryption_context_hash", "(", "hasher", "=", "hasher", ".", "copy", "(", ")", ",", "encryption_context", "=", "request", ".", "encryption_context", ")", "hasher", ".", "update", "(", "_partition_hash", ")", "hasher", ".", "update", "(", "_algorithm_info", ")", "hasher", ".", "update", "(", "_edks_hash", ")", "hasher", ".", "update", "(", "_512_BIT_PAD", ")", "hasher", ".", "update", "(", "_ec_hash", ")", "return", "hasher", ".", "finalize", "(", ")" ]

[ "Generates", "a", "cache", "key", "for", "a", "decrypt", "request", "." ]

[ "def", "cycle_file", "(", "source_plaintext_filename", ")", ":", "# Create a static random master key provider", "key_id", "=", "os", ".", "urandom", "(", "8", ")", "master_key_provider", "=", "StaticRandomMasterKeyProvider", "(", ")", "master_key_provider", ".", "add_master_key", "(", "key_id", ")", "ciphertext_filename", "=", "source_plaintext_filename", "+", "\".encrypted\"", "cycled_plaintext_filename", "=", "source_plaintext_filename", "+", "\".decrypted\"", "# Encrypt the plaintext source data", "with", "open", "(", "source_plaintext_filename", ",", "\"rb\"", ")", "as", "plaintext", ",", "open", "(", "ciphertext_filename", ",", "\"wb\"", ")", "as", "ciphertext", ":", "with", "aws_encryption_sdk", ".", "stream", "(", "mode", "=", "\"e\"", ",", "source", "=", "plaintext", ",", "key_provider", "=", "master_key_provider", ")", "as", "encryptor", ":", "for", "chunk", "in", "encryptor", ":", "ciphertext", ".", "write", "(", "chunk", ")", "# Decrypt the ciphertext", "with", "open", "(", "ciphertext_filename", ",", "\"rb\"", ")", "as", "ciphertext", ",", "open", "(", "cycled_plaintext_filename", ",", "\"wb\"", ")", "as", "plaintext", ":", "with", "aws_encryption_sdk", ".", "stream", "(", "mode", "=", "\"d\"", ",", "source", "=", "ciphertext", ",", "key_provider", "=", "master_key_provider", ")", "as", "decryptor", ":", "for", "chunk", "in", "decryptor", ":", "plaintext", ".", "write", "(", "chunk", ")", "# Verify that the \"cycled\" (encrypted, then decrypted) plaintext is identical to the source", "# plaintext", "assert", "filecmp", ".", "cmp", "(", "source_plaintext_filename", ",", "cycled_plaintext_filename", ")", "# Verify that the encryption context used in the decrypt operation includes all key pairs from", "# the encrypt operation", "#", "# In production, always use a meaningful encryption context. In this sample, we omit the", "# encryption context (no key pairs).", "assert", "all", "(", "pair", "in", "decryptor", ".", "header", ".", "encryption_context", ".", "items", "(", ")", "for", "pair", "in", "encryptor", ".", "header", ".", "encryption_context", ".", "items", "(", ")", ")", "return", "ciphertext_filename", ",", "cycled_plaintext_filename" ]

[ "Encrypts", "and", "then", "decrypts", "a", "file", "under", "a", "custom", "static", "master", "key", "provider", "." ]

[ "def", "_get_raw_key", "(", "self", ",", "key_id", ")", ":", "try", ":", "static_key", "=", "self", ".", "_static_keys", "[", "key_id", "]", "except", "KeyError", ":", "static_key", "=", "os", ".", "urandom", "(", "32", ")", "self", ".", "_static_keys", "[", "key_id", "]", "=", "static_key", "return", "WrappingKey", "(", "wrapping_algorithm", "=", "WrappingAlgorithm", ".", "AES_256_GCM_IV12_TAG16_NO_PADDING", ",", "wrapping_key", "=", "static_key", ",", "wrapping_key_type", "=", "EncryptionKeyType", ".", "SYMMETRIC", ",", ")" ]

[ "Returns", "a", "static", "randomly", "-", "generated", "symmetric", "key", "for", "the", "specified", "key", "ID", "." ]

[ "def", "stream_length", "(", "self", ")", ":", "if", "self", ".", "_stream_length", "is", "None", ":", "try", ":", "current_position", "=", "self", ".", "source_stream", ".", "tell", "(", ")", "self", ".", "source_stream", ".", "seek", "(", "0", ",", "2", ")", "self", ".", "_stream_length", "=", "self", ".", "source_stream", ".", "tell", "(", ")", "self", ".", "source_stream", ".", "seek", "(", "current_position", ",", "0", ")", "except", "Exception", "as", "error", ":", "# Catch-all for unknown issues encountered trying to seek for stream length", "raise", "NotSupportedError", "(", "error", ")", "return", "self", ".", "_stream_length" ]

[ "Returns", "the", "length", "of", "the", "source", "stream", "determining", "it", "if", "not", "already", "known", "." ]

[ "def", "read", "(", "self", ",", "b", "=", "-", "1", ")", ":", "# Any negative value for b is interpreted as a full read", "# None is also accepted for legacy compatibility", "if", "b", "is", "None", "or", "b", "<", "0", ":", "b", "=", "-", "1", "_LOGGER", ".", "debug", "(", "\"Stream read called, requesting %d bytes\"", ",", "b", ")", "output", "=", "io", ".", "BytesIO", "(", ")", "if", "not", "self", ".", "_message_prepped", ":", "self", ".", "_prep_message", "(", ")", "if", "self", ".", "closed", ":", "raise", "ValueError", "(", "\"I/O operation on closed file\"", ")", "if", "b", ">=", "0", ":", "self", ".", "_read_bytes", "(", "b", ")", "output", ".", "write", "(", "self", ".", "output_buffer", "[", ":", "b", "]", ")", "self", ".", "output_buffer", "=", "self", ".", "output_buffer", "[", "b", ":", "]", "else", ":", "while", "True", ":", "line", "=", "self", ".", "readline", "(", ")", "if", "not", "line", ":", "break", "output", ".", "write", "(", "line", ")", "self", ".", "bytes_read", "+=", "output", ".", "tell", "(", ")", "_LOGGER", ".", "debug", "(", "\"Returning %d bytes of %d bytes requested\"", ",", "output", ".", "tell", "(", ")", ",", "b", ")", "return", "output", ".", "getvalue", "(", ")" ]

[ "Returns", "either", "the", "requested", "number", "of", "bytes", "or", "the", "entire", "stream", "." ]

[ "def", "readline", "(", "self", ")", ":", "_LOGGER", ".", "info", "(", "\"reading line\"", ")", "line", "=", "self", ".", "read", "(", "self", ".", "line_length", ")", "if", "len", "(", "line", ")", "<", "self", ".", "line_length", ":", "_LOGGER", ".", "info", "(", "\"all lines read\"", ")", "return", "line" ]

[ "Read", "a", "chunk", "of", "the", "output" ]

[ "def", "next", "(", "self", ")", ":", "_LOGGER", ".", "debug", "(", "\"reading next\"", ")", "if", "self", ".", "closed", ":", "_LOGGER", ".", "debug", "(", "\"stream is closed\"", ")", "raise", "StopIteration", "(", ")", "line", "=", "self", ".", "readline", "(", ")", "if", "not", "line", ":", "_LOGGER", ".", "debug", "(", "\"nothing more to read\"", ")", "raise", "StopIteration", "(", ")", "return", "line" ]

[ "Provides", "hook", "for", "Python2", "iterator", "functionality", "." ]

[ "def", "ciphertext_length", "(", "self", ")", ":", "return", "aws_encryption_sdk", ".", "internal", ".", "formatting", ".", "ciphertext_length", "(", "header", "=", "self", ".", "header", ",", "plaintext_length", "=", "self", ".", "stream_length", ")" ]

[ "Returns", "the", "length", "of", "the", "resulting", "ciphertext", "message", "in", "bytes", "." ]

[ "def", "_write_header", "(", "self", ")", ":", "self", ".", "output_buffer", "+=", "serialize_header", "(", "header", "=", "self", ".", "_header", ",", "signer", "=", "self", ".", "signer", ")", "self", ".", "output_buffer", "+=", "serialize_header_auth", "(", "algorithm", "=", "self", ".", "_encryption_materials", ".", "algorithm", ",", "header", "=", "self", ".", "output_buffer", ",", "data_encryption_key", "=", "self", ".", "_derived_data_key", ",", "signer", "=", "self", ".", "signer", ",", ")" ]

[ "Builds", "the", "message", "header", "and", "writes", "it", "to", "the", "output", "stream", "." ]

[ "def", "_read_bytes_to_non_framed_body", "(", "self", ",", "b", ")", ":", "_LOGGER", ".", "debug", "(", "\"Reading %d bytes\"", ",", "b", ")", "plaintext", "=", "self", ".", "__unframed_plaintext_cache", ".", "read", "(", "b", ")", "plaintext_length", "=", "len", "(", "plaintext", ")", "if", "self", ".", "tell", "(", ")", "+", "len", "(", "plaintext", ")", ">", "MAX_NON_FRAMED_SIZE", ":", "raise", "SerializationError", "(", "\"Source too large for non-framed message\"", ")", "ciphertext", "=", "self", ".", "encryptor", ".", "update", "(", "plaintext", ")", "self", ".", "_bytes_encrypted", "+=", "plaintext_length", "if", "self", ".", "signer", "is", "not", "None", ":", "self", ".", "signer", ".", "update", "(", "ciphertext", ")", "if", "len", "(", "plaintext", ")", "<", "b", ":", "_LOGGER", ".", "debug", "(", "\"Closing encryptor after receiving only %d bytes of %d bytes requested\"", ",", "plaintext_length", ",", "b", ")", "closing", "=", "self", ".", "encryptor", ".", "finalize", "(", ")", "if", "self", ".", "signer", "is", "not", "None", ":", "self", ".", "signer", ".", "update", "(", "closing", ")", "closing", "+=", "serialize_non_framed_close", "(", "tag", "=", "self", ".", "encryptor", ".", "tag", ",", "signer", "=", "self", ".", "signer", ")", "if", "self", ".", "signer", "is", "not", "None", ":", "closing", "+=", "serialize_footer", "(", "self", ".", "signer", ")", "self", ".", "__message_complete", "=", "True", "return", "ciphertext", "+", "closing", "return", "ciphertext" ]

[ "Reads", "the", "requested", "number", "of", "bytes", "from", "source", "to", "a", "streaming", "non", "-", "framed", "message", "body", "." ]

[ "def", "_read_bytes_to_framed_body", "(", "self", ",", "b", ")", ":", "_LOGGER", ".", "debug", "(", "\"collecting %d bytes\"", ",", "b", ")", "_b", "=", "b", "if", "b", ">", "0", ":", "_frames_to_read", "=", "math", ".", "ceil", "(", "b", "/", "float", "(", "self", ".", "config", ".", "frame_length", ")", ")", "b", "=", "int", "(", "_frames_to_read", "*", "self", ".", "config", ".", "frame_length", ")", "_LOGGER", ".", "debug", "(", "\"%d bytes requested; reading %d bytes after normalizing to frame length\"", ",", "_b", ",", "b", ")", "plaintext", "=", "self", ".", "source_stream", ".", "read", "(", "b", ")", "plaintext_length", "=", "len", "(", "plaintext", ")", "_LOGGER", ".", "debug", "(", "\"%d bytes read from source\"", ",", "plaintext_length", ")", "finalize", "=", "False", "if", "b", "<", "0", "or", "plaintext_length", "<", "b", ":", "_LOGGER", ".", "debug", "(", "\"Final plaintext read from source\"", ")", "finalize", "=", "True", "output", "=", "b\"\"", "final_frame_written", "=", "False", "while", "(", "# If not finalizing on this pass, exit when plaintext is exhausted", "(", "not", "finalize", "and", "plaintext", ")", "# If finalizing on this pass, wait until final frame is written", "or", "(", "finalize", "and", "not", "final_frame_written", ")", ")", ":", "current_plaintext_length", "=", "len", "(", "plaintext", ")", "is_final_frame", "=", "finalize", "and", "current_plaintext_length", "<", "self", ".", "config", ".", "frame_length", "bytes_in_frame", "=", "min", "(", "current_plaintext_length", ",", "self", ".", "config", ".", "frame_length", ")", "_LOGGER", ".", "debug", "(", "\"Writing %d bytes into%s frame %d\"", ",", "bytes_in_frame", ",", "\" final\"", "if", "is_final_frame", "else", "\"\"", ",", "self", ".", "sequence_number", ",", ")", "self", ".", "_bytes_encrypted", "+=", "bytes_in_frame", "ciphertext", ",", "plaintext", "=", "serialize_frame", "(", "algorithm", "=", "self", ".", "_encryption_materials", ".", "algorithm", ",", "plaintext", "=", "plaintext", ",", "message_id", "=", "self", ".", "_header", ".", "message_id", ",", "data_encryption_key", "=", "self", ".", "_derived_data_key", ",", "frame_length", "=", "self", ".", "config", ".", "frame_length", ",", "sequence_number", "=", "self", ".", "sequence_number", ",", "is_final_frame", "=", "is_final_frame", ",", "signer", "=", "self", ".", "signer", ",", ")", "final_frame_written", "=", "is_final_frame", "output", "+=", "ciphertext", "self", ".", "sequence_number", "+=", "1", "if", "finalize", ":", "_LOGGER", ".", "debug", "(", "\"Writing footer\"", ")", "if", "self", ".", "signer", "is", "not", "None", ":", "output", "+=", "serialize_footer", "(", "self", ".", "signer", ")", "self", ".", "__message_complete", "=", "True", "return", "output" ]

[ "Reads", "the", "requested", "number", "of", "bytes", "from", "source", "to", "a", "streaming", "framed", "message", "body", "." ]

[ "def", "_read_header", "(", "self", ")", ":", "header", ",", "raw_header", "=", "deserialize_header", "(", "self", ".", "source_stream", ")", "self", ".", "__unframed_bytes_read", "+=", "len", "(", "raw_header", ")", "if", "(", "self", ".", "config", ".", "max_body_length", "is", "not", "None", "and", "header", ".", "content_type", "==", "ContentType", ".", "FRAMED_DATA", "and", "header", ".", "frame_length", ">", "self", ".", "config", ".", "max_body_length", ")", ":", "raise", "CustomMaximumValueExceeded", "(", "\"Frame Size in header found larger than custom value: {found:d} > {custom:d}\"", ".", "format", "(", "found", "=", "header", ".", "frame_length", ",", "custom", "=", "self", ".", "config", ".", "max_body_length", ")", ")", "decrypt_materials_request", "=", "DecryptionMaterialsRequest", "(", "encrypted_data_keys", "=", "header", ".", "encrypted_data_keys", ",", "algorithm", "=", "header", ".", "algorithm", ",", "encryption_context", "=", "header", ".", "encryption_context", ",", ")", "decryption_materials", "=", "self", ".", "config", ".", "materials_manager", ".", "decrypt_materials", "(", "request", "=", "decrypt_materials_request", ")", "if", "decryption_materials", ".", "verification_key", "is", "None", ":", "self", ".", "verifier", "=", "None", "else", ":", "self", ".", "verifier", "=", "Verifier", ".", "from_key_bytes", "(", "algorithm", "=", "header", ".", "algorithm", ",", "key_bytes", "=", "decryption_materials", ".", "verification_key", ")", "if", "self", ".", "verifier", "is", "not", "None", ":", "self", ".", "verifier", ".", "update", "(", "raw_header", ")", "header_auth", "=", "deserialize_header_auth", "(", "stream", "=", "self", ".", "source_stream", ",", "algorithm", "=", "header", ".", "algorithm", ",", "verifier", "=", "self", ".", "verifier", ")", "self", ".", "_derived_data_key", "=", "derive_data_encryption_key", "(", "source_key", "=", "decryption_materials", ".", "data_key", ".", "data_key", ",", "algorithm", "=", "header", ".", "algorithm", ",", "message_id", "=", "header", ".", "message_id", ")", "validate_header", "(", "header", "=", "header", ",", "header_auth", "=", "header_auth", ",", "raw_header", "=", "raw_header", ",", "data_key", "=", "self", ".", "_derived_data_key", ")", "return", "header", ",", "header_auth" ]

[ "Reads", "the", "message", "header", "from", "the", "input", "stream", "." ]

[ "def", "_read_bytes_from_non_framed_body", "(", "self", ",", "b", ")", ":", "_LOGGER", ".", "debug", "(", "\"starting non-framed body read\"", ")", "# Always read the entire message for non-framed message bodies.", "bytes_to_read", "=", "self", ".", "body_length", "_LOGGER", ".", "debug", "(", "\"%d bytes requested; reading %d bytes\"", ",", "b", ",", "bytes_to_read", ")", "ciphertext", "=", "self", ".", "source_stream", ".", "read", "(", "bytes_to_read", ")", "if", "len", "(", "self", ".", "output_buffer", ")", "+", "len", "(", "ciphertext", ")", "<", "self", ".", "body_length", ":", "raise", "SerializationError", "(", "\"Total message body contents less than specified in body description\"", ")", "if", "self", ".", "verifier", "is", "not", "None", ":", "self", ".", "verifier", ".", "update", "(", "ciphertext", ")", "tag", "=", "deserialize_tag", "(", "stream", "=", "self", ".", "source_stream", ",", "header", "=", "self", ".", "_header", ",", "verifier", "=", "self", ".", "verifier", ")", "aad_content_string", "=", "aws_encryption_sdk", ".", "internal", ".", "utils", ".", "get_aad_content_string", "(", "content_type", "=", "self", ".", "_header", ".", "content_type", ",", "is_final_frame", "=", "True", ")", "associated_data", "=", "assemble_content_aad", "(", "message_id", "=", "self", ".", "_header", ".", "message_id", ",", "aad_content_string", "=", "aad_content_string", ",", "seq_num", "=", "1", ",", "length", "=", "self", ".", "body_length", ",", ")", "self", ".", "decryptor", "=", "Decryptor", "(", "algorithm", "=", "self", ".", "_header", ".", "algorithm", ",", "key", "=", "self", ".", "_derived_data_key", ",", "associated_data", "=", "associated_data", ",", "iv", "=", "self", ".", "_unframed_body_iv", ",", "tag", "=", "tag", ",", ")", "plaintext", "=", "self", ".", "decryptor", ".", "update", "(", "ciphertext", ")", "plaintext", "+=", "self", ".", "decryptor", ".", "finalize", "(", ")", "self", ".", "footer", "=", "deserialize_footer", "(", "stream", "=", "self", ".", "source_stream", ",", "verifier", "=", "self", ".", "verifier", ")", "return", "plaintext" ]

[ "Reads", "the", "requested", "number", "of", "bytes", "from", "a", "streaming", "non", "-", "framed", "message", "body", "." ]

[ "def", "_read_bytes_from_framed_body", "(", "self", ",", "b", ")", ":", "plaintext", "=", "b\"\"", "final_frame", "=", "False", "_LOGGER", ".", "debug", "(", "\"collecting %d bytes\"", ",", "b", ")", "while", "len", "(", "plaintext", ")", "<", "b", "and", "not", "final_frame", ":", "_LOGGER", ".", "debug", "(", "\"Reading frame\"", ")", "frame_data", ",", "final_frame", "=", "deserialize_frame", "(", "stream", "=", "self", ".", "source_stream", ",", "header", "=", "self", ".", "_header", ",", "verifier", "=", "self", ".", "verifier", ")", "_LOGGER", ".", "debug", "(", "\"Read complete for frame %d\"", ",", "frame_data", ".", "sequence_number", ")", "if", "frame_data", ".", "sequence_number", "!=", "self", ".", "last_sequence_number", "+", "1", ":", "raise", "SerializationError", "(", "\"Malformed message: frames out of order\"", ")", "self", ".", "last_sequence_number", "+=", "1", "aad_content_string", "=", "aws_encryption_sdk", ".", "internal", ".", "utils", ".", "get_aad_content_string", "(", "content_type", "=", "self", ".", "_header", ".", "content_type", ",", "is_final_frame", "=", "frame_data", ".", "final_frame", ")", "associated_data", "=", "assemble_content_aad", "(", "message_id", "=", "self", ".", "_header", ".", "message_id", ",", "aad_content_string", "=", "aad_content_string", ",", "seq_num", "=", "frame_data", ".", "sequence_number", ",", "length", "=", "len", "(", "frame_data", ".", "ciphertext", ")", ",", ")", "plaintext", "+=", "decrypt", "(", "algorithm", "=", "self", ".", "_header", ".", "algorithm", ",", "key", "=", "self", ".", "_derived_data_key", ",", "encrypted_data", "=", "frame_data", ",", "associated_data", "=", "associated_data", ",", ")", "plaintext_length", "=", "len", "(", "plaintext", ")", "_LOGGER", ".", "debug", "(", "\"bytes collected: %d\"", ",", "plaintext_length", ")", "if", "final_frame", ":", "_LOGGER", ".", "debug", "(", "\"Reading footer\"", ")", "self", ".", "footer", "=", "deserialize_footer", "(", "stream", "=", "self", ".", "source_stream", ",", "verifier", "=", "self", ".", "verifier", ")", "return", "plaintext" ]

[ "Reads", "the", "requested", "number", "of", "bytes", "from", "a", "streaming", "framed", "message", "body", "." ]

[ "def", "close", "(", "self", ")", ":", "_LOGGER", ".", "debug", "(", "\"Closing stream\"", ")", "if", "not", "hasattr", "(", "self", ",", "\"footer\"", ")", ":", "raise", "SerializationError", "(", "\"Footer not read\"", ")", "super", "(", "StreamDecryptor", ",", "self", ")", ".", "close", "(", ")" ]

[ "Closes", "out", "the", "stream", "." ]

[ "def", "_region_from_key_id", "(", "key_id", ",", "default_region", "=", "None", ")", ":", "try", ":", "region_name", "=", "key_id", ".", "split", "(", "\":\"", ",", "4", ")", "[", "3", "]", "except", "IndexError", ":", "if", "default_region", "is", "None", ":", "raise", "UnknownRegionError", "(", "\"No default region found and no region determinable from key id: {}\"", ".", "format", "(", "key_id", ")", ")", "region_name", "=", "default_region", "return", "region_name" ]

[ "Determine", "the", "target", "region", "from", "a", "key", "ID", "falling", "back", "to", "a", "default", "region", "if", "provided", "." ]

[ "def", "_process_config", "(", "self", ")", ":", "self", ".", "_user_agent_adding_config", "=", "botocore", ".", "config", ".", "Config", "(", "user_agent_extra", "=", "USER_AGENT_SUFFIX", ")", "if", "self", ".", "config", ".", "region_names", ":", "self", ".", "add_regional_clients_from_list", "(", "self", ".", "config", ".", "region_names", ")", "self", ".", "default_region", "=", "self", ".", "config", ".", "region_names", "[", "0", "]", "else", ":", "self", ".", "default_region", "=", "self", ".", "config", ".", "botocore_session", ".", "get_config_variable", "(", "\"region\"", ")", "if", "self", ".", "default_region", "is", "not", "None", ":", "self", ".", "add_regional_client", "(", "self", ".", "default_region", ")", "if", "self", ".", "config", ".", "key_ids", ":", "self", ".", "add_master_keys_from_list", "(", "self", ".", "config", ".", "key_ids", ")" ]

[ "Traverses", "the", "config", "and", "adds", "master", "keys", "and", "regional", "clients", "as", "needed", "." ]

[ "def", "_wrap_client", "(", "self", ",", "region_name", ",", "method", ",", "*", "args", ",", "*", "*", "kwargs", ")", ":", "try", ":", "return", "method", "(", "*", "args", ",", "*", "*", "kwargs", ")", "except", "botocore", ".", "exceptions", ".", "BotoCoreError", ":", "self", ".", "_regional_clients", ".", "pop", "(", "region_name", ")", "_LOGGER", ".", "error", "(", "'Removing regional client \"%s\" from cache due to BotoCoreError on %s call'", ",", "region_name", ",", "method", ".", "__name__", ")", "raise" ]

[ "Proxies", "all", "calls", "to", "a", "kms", "clients", "methods", "and", "removes", "misbehaving", "clients" ]

[ "def", "_register_client", "(", "self", ",", "client", ",", "region_name", ")", ":", "for", "item", "in", "client", ".", "meta", ".", "method_to_api_mapping", ":", "method", "=", "getattr", "(", "client", ",", "item", ")", "wrapped_method", "=", "functools", ".", "partial", "(", "self", ".", "_wrap_client", ",", "region_name", ",", "method", ")", "setattr", "(", "client", ",", "item", ",", "wrapped_method", ")" ]

[ "Uses", "functools", ".", "partial", "to", "wrap", "all", "methods", "on", "a", "client", "with", "the", "self", ".", "_wrap_client", "method" ]

[ "def", "add_regional_client", "(", "self", ",", "region_name", ")", ":", "if", "region_name", "not", "in", "self", ".", "_regional_clients", ":", "session", "=", "boto3", ".", "session", ".", "Session", "(", "region_name", "=", "region_name", ",", "botocore_session", "=", "self", ".", "config", ".", "botocore_session", ")", "client", "=", "session", ".", "client", "(", "\"kms\"", ",", "config", "=", "self", ".", "_user_agent_adding_config", ")", "self", ".", "_register_client", "(", "client", ",", "region_name", ")", "self", ".", "_regional_clients", "[", "region_name", "]", "=", "client" ]

[ "Adds", "a", "regional", "client", "for", "the", "specified", "region", "if", "it", "does", "not", "already", "exist", "." ]

[ "def", "_client", "(", "self", ",", "key_id", ")", ":", "region_name", "=", "_region_from_key_id", "(", "key_id", ",", "self", ".", "default_region", ")", "self", ".", "add_regional_client", "(", "region_name", ")", "return", "self", ".", "_regional_clients", "[", "region_name", "]" ]

[ "Returns", "a", "Boto3", "KMS", "client", "for", "the", "appropriate", "region", "." ]

[ "def", "_new_master_key", "(", "self", ",", "key_id", ")", ":", "_key_id", "=", "to_str", "(", "key_id", ")", "# KMS client requires str, not bytes", "return", "KMSMasterKey", "(", "config", "=", "KMSMasterKeyConfig", "(", "key_id", "=", "key_id", ",", "client", "=", "self", ".", "_client", "(", "_key_id", ")", ")", ")" ]

[ "Returns", "a", "KMSMasterKey", "for", "the", "specified", "key_id", "." ]

[ "def", "_generate_data_key", "(", "self", ",", "algorithm", ",", "encryption_context", "=", "None", ")", ":", "kms_params", "=", "{", "\"KeyId\"", ":", "self", ".", "_key_id", ",", "\"NumberOfBytes\"", ":", "algorithm", ".", "kdf_input_len", "}", "if", "encryption_context", "is", "not", "None", ":", "kms_params", "[", "\"EncryptionContext\"", "]", "=", "encryption_context", "if", "self", ".", "config", ".", "grant_tokens", ":", "kms_params", "[", "\"GrantTokens\"", "]", "=", "self", ".", "config", ".", "grant_tokens", "# Catch any boto3 errors and normalize to expected EncryptKeyError", "try", ":", "response", "=", "self", ".", "config", ".", "client", ".", "generate_data_key", "(", "*", "*", "kms_params", ")", "plaintext", "=", "response", "[", "\"Plaintext\"", "]", "ciphertext", "=", "response", "[", "\"CiphertextBlob\"", "]", "key_id", "=", "response", "[", "\"KeyId\"", "]", "except", "(", "ClientError", ",", "KeyError", ")", ":", "error_message", "=", "\"Master Key {key_id} unable to generate data key\"", ".", "format", "(", "key_id", "=", "self", ".", "_key_id", ")", "_LOGGER", ".", "exception", "(", "error_message", ")", "raise", "GenerateKeyError", "(", "error_message", ")", "return", "DataKey", "(", "key_provider", "=", "MasterKeyInfo", "(", "provider_id", "=", "self", ".", "provider_id", ",", "key_info", "=", "key_id", ")", ",", "data_key", "=", "plaintext", ",", "encrypted_data_key", "=", "ciphertext", ",", ")" ]

[ "Generates", "data", "key", "and", "returns", "plaintext", "and", "ciphertext", "of", "key", "." ]

[ "def", "_encrypt_data_key", "(", "self", ",", "data_key", ",", "algorithm", ",", "encryption_context", "=", "None", ")", ":", "kms_params", "=", "{", "\"KeyId\"", ":", "self", ".", "_key_id", ",", "\"Plaintext\"", ":", "data_key", ".", "data_key", "}", "if", "encryption_context", ":", "kms_params", "[", "\"EncryptionContext\"", "]", "=", "encryption_context", "if", "self", ".", "config", ".", "grant_tokens", ":", "kms_params", "[", "\"GrantTokens\"", "]", "=", "self", ".", "config", ".", "grant_tokens", "# Catch any boto3 errors and normalize to expected EncryptKeyError", "try", ":", "response", "=", "self", ".", "config", ".", "client", ".", "encrypt", "(", "*", "*", "kms_params", ")", "ciphertext", "=", "response", "[", "\"CiphertextBlob\"", "]", "key_id", "=", "response", "[", "\"KeyId\"", "]", "except", "(", "ClientError", ",", "KeyError", ")", ":", "error_message", "=", "\"Master Key {key_id} unable to encrypt data key\"", ".", "format", "(", "key_id", "=", "self", ".", "_key_id", ")", "_LOGGER", ".", "exception", "(", "error_message", ")", "raise", "EncryptKeyError", "(", "error_message", ")", "return", "EncryptedDataKey", "(", "key_provider", "=", "MasterKeyInfo", "(", "provider_id", "=", "self", ".", "provider_id", ",", "key_info", "=", "key_id", ")", ",", "encrypted_data_key", "=", "ciphertext", ")" ]

[ "Encrypts", "a", "data", "key", "and", "returns", "the", "ciphertext", "." ]

[ "def", "serialize_encrypted_data_key", "(", "encrypted_data_key", ")", ":", "encrypted_data_key_format", "=", "(", "\">\"", "# big endian", "\"H\"", "# key provider ID length", "\"{provider_id_len}s\"", "# key provider ID", "\"H\"", "# key info length", "\"{provider_info_len}s\"", "# key info", "\"H\"", "# encrypted data key length", "\"{enc_data_key_len}s\"", "# encrypted data key", ")", "return", "struct", ".", "pack", "(", "encrypted_data_key_format", ".", "format", "(", "provider_id_len", "=", "len", "(", "encrypted_data_key", ".", "key_provider", ".", "provider_id", ")", ",", "provider_info_len", "=", "len", "(", "encrypted_data_key", ".", "key_provider", ".", "key_info", ")", ",", "enc_data_key_len", "=", "len", "(", "encrypted_data_key", ".", "encrypted_data_key", ")", ",", ")", ",", "len", "(", "encrypted_data_key", ".", "key_provider", ".", "provider_id", ")", ",", "to_bytes", "(", "encrypted_data_key", ".", "key_provider", ".", "provider_id", ")", ",", "len", "(", "encrypted_data_key", ".", "key_provider", ".", "key_info", ")", ",", "to_bytes", "(", "encrypted_data_key", ".", "key_provider", ".", "key_info", ")", ",", "len", "(", "encrypted_data_key", ".", "encrypted_data_key", ")", ",", "encrypted_data_key", ".", "encrypted_data_key", ",", ")" ]

[ "Serializes", "an", "encrypted", "data", "key", "." ]

[ "def", "serialize_header", "(", "header", ",", "signer", "=", "None", ")", ":", "ec_serialized", "=", "aws_encryption_sdk", ".", "internal", ".", "formatting", ".", "encryption_context", ".", "serialize_encryption_context", "(", "header", ".", "encryption_context", ")", "header_start_format", "=", "(", "\">\"", "# big endian", "\"B\"", "# version", "\"B\"", "# type", "\"H\"", "# algorithm ID", "\"16s\"", "# message ID", "\"H\"", "# encryption context length", "\"{}s\"", "# serialized encryption context", ")", ".", "format", "(", "len", "(", "ec_serialized", ")", ")", "header_bytes", "=", "bytearray", "(", ")", "header_bytes", ".", "extend", "(", "struct", ".", "pack", "(", "header_start_format", ",", "header", ".", "version", ".", "value", ",", "header", ".", "type", ".", "value", ",", "header", ".", "algorithm", ".", "algorithm_id", ",", "header", ".", "message_id", ",", "len", "(", "ec_serialized", ")", ",", "ec_serialized", ",", ")", ")", "serialized_data_keys", "=", "bytearray", "(", ")", "for", "data_key", "in", "header", ".", "encrypted_data_keys", ":", "serialized_data_keys", ".", "extend", "(", "serialize_encrypted_data_key", "(", "data_key", ")", ")", "header_bytes", ".", "extend", "(", "struct", ".", "pack", "(", "\">H\"", ",", "len", "(", "header", ".", "encrypted_data_keys", ")", ")", ")", "header_bytes", ".", "extend", "(", "serialized_data_keys", ")", "header_close_format", "=", "(", "\">\"", "# big endian", "\"B\"", "# content type (no framing vs framing)", "\"4x\"", "# reserved (formerly content AAD length)", "\"B\"", "# nonce/IV length, this applies to all IVs in this message", "\"I\"", "# frame length", ")", "header_bytes", ".", "extend", "(", "struct", ".", "pack", "(", "header_close_format", ",", "header", ".", "content_type", ".", "value", ",", "header", ".", "algorithm", ".", "iv_len", ",", "header", ".", "frame_length", ")", ")", "output", "=", "bytes", "(", "header_bytes", ")", "if", "signer", "is", "not", "None", ":", "signer", ".", "update", "(", "output", ")", "return", "output" ]

[ "Serializes", "a", "header", "object", "." ]

[ "def", "serialize_header_auth", "(", "algorithm", ",", "header", ",", "data_encryption_key", ",", "signer", "=", "None", ")", ":", "header_auth", "=", "encrypt", "(", "algorithm", "=", "algorithm", ",", "key", "=", "data_encryption_key", ",", "plaintext", "=", "b\"\"", ",", "associated_data", "=", "header", ",", "iv", "=", "header_auth_iv", "(", "algorithm", ")", ",", ")", "output", "=", "struct", ".", "pack", "(", "\">{iv_len}s{tag_len}s\"", ".", "format", "(", "iv_len", "=", "algorithm", ".", "iv_len", ",", "tag_len", "=", "algorithm", ".", "tag_len", ")", ",", "header_auth", ".", "iv", ",", "header_auth", ".", "tag", ",", ")", "if", "signer", "is", "not", "None", ":", "signer", ".", "update", "(", "output", ")", "return", "output" ]

[ "Creates", "serialized", "header", "authentication", "data", "." ]

[ "def", "serialize_non_framed_open", "(", "algorithm", ",", "iv", ",", "plaintext_length", ",", "signer", "=", "None", ")", ":", "body_start_format", "=", "(", "\">\"", "\"{iv_length}s\"", "\"Q\"", ")", ".", "format", "(", "iv_length", "=", "algorithm", ".", "iv_len", ")", "# nonce (IV) # content length", "body_start", "=", "struct", ".", "pack", "(", "body_start_format", ",", "iv", ",", "plaintext_length", ")", "if", "signer", ":", "signer", ".", "update", "(", "body_start", ")", "return", "body_start" ]

[ "Serializes", "the", "opening", "block", "for", "a", "non", "-", "framed", "message", "body", "." ]

[ "def", "serialize_non_framed_close", "(", "tag", ",", "signer", "=", "None", ")", ":", "body_close", "=", "struct", ".", "pack", "(", "\"{auth_len}s\"", ".", "format", "(", "auth_len", "=", "len", "(", "tag", ")", ")", ",", "tag", ")", "if", "signer", ":", "signer", ".", "update", "(", "body_close", ")", "return", "body_close" ]

[ "Serializes", "the", "closing", "block", "for", "a", "non", "-", "framed", "message", "body", "." ]

[ "def", "serialize_frame", "(", "algorithm", ",", "plaintext", ",", "message_id", ",", "data_encryption_key", ",", "frame_length", ",", "sequence_number", ",", "is_final_frame", ",", "signer", "=", "None", ")", ":", "if", "sequence_number", "<", "1", ":", "raise", "SerializationError", "(", "\"Frame sequence number must be greater than 0\"", ")", "if", "sequence_number", ">", "aws_encryption_sdk", ".", "internal", ".", "defaults", ".", "MAX_FRAME_COUNT", ":", "raise", "SerializationError", "(", "\"Max frame count exceeded\"", ")", "if", "is_final_frame", ":", "content_string", "=", "ContentAADString", ".", "FINAL_FRAME_STRING_ID", "else", ":", "content_string", "=", "ContentAADString", ".", "FRAME_STRING_ID", "frame_plaintext", "=", "plaintext", "[", ":", "frame_length", "]", "frame_ciphertext", "=", "encrypt", "(", "algorithm", "=", "algorithm", ",", "key", "=", "data_encryption_key", ",", "plaintext", "=", "frame_plaintext", ",", "associated_data", "=", "aws_encryption_sdk", ".", "internal", ".", "formatting", ".", "encryption_context", ".", "assemble_content_aad", "(", "message_id", "=", "message_id", ",", "aad_content_string", "=", "content_string", ",", "seq_num", "=", "sequence_number", ",", "length", "=", "len", "(", "frame_plaintext", ")", ",", ")", ",", "iv", "=", "frame_iv", "(", "algorithm", ",", "sequence_number", ")", ",", ")", "plaintext", "=", "plaintext", "[", "frame_length", ":", "]", "if", "is_final_frame", ":", "_LOGGER", ".", "debug", "(", "\"Serializing final frame\"", ")", "packed_frame", "=", "struct", ".", "pack", "(", "\">II{iv_len}sI{content_len}s{auth_len}s\"", ".", "format", "(", "iv_len", "=", "algorithm", ".", "iv_len", ",", "content_len", "=", "len", "(", "frame_ciphertext", ".", "ciphertext", ")", ",", "auth_len", "=", "algorithm", ".", "auth_len", ")", ",", "SequenceIdentifier", ".", "SEQUENCE_NUMBER_END", ".", "value", ",", "sequence_number", ",", "frame_ciphertext", ".", "iv", ",", "len", "(", "frame_ciphertext", ".", "ciphertext", ")", ",", "frame_ciphertext", ".", "ciphertext", ",", "frame_ciphertext", ".", "tag", ",", ")", "else", ":", "_LOGGER", ".", "debug", "(", "\"Serializing frame\"", ")", "packed_frame", "=", "struct", ".", "pack", "(", "\">I{iv_len}s{content_len}s{auth_len}s\"", ".", "format", "(", "iv_len", "=", "algorithm", ".", "iv_len", ",", "content_len", "=", "frame_length", ",", "auth_len", "=", "algorithm", ".", "auth_len", ")", ",", "sequence_number", ",", "frame_ciphertext", ".", "iv", ",", "frame_ciphertext", ".", "ciphertext", ",", "frame_ciphertext", ".", "tag", ",", ")", "if", "signer", "is", "not", "None", ":", "signer", ".", "update", "(", "packed_frame", ")", "return", "packed_frame", ",", "plaintext" ]

[ "Receives", "a", "message", "plaintext", "breaks", "off", "a", "frame", "encrypts", "and", "serializes", "the", "frame", "and", "returns", "the", "encrypted", "frame", "and", "the", "remaining", "plaintext", "." ]

[ "def", "serialize_footer", "(", "signer", ")", ":", "footer", "=", "b\"\"", "if", "signer", "is", "not", "None", ":", "signature", "=", "signer", ".", "finalize", "(", ")", "footer", "=", "struct", ".", "pack", "(", "\">H{sig_len}s\"", ".", "format", "(", "sig_len", "=", "len", "(", "signature", ")", ")", ",", "len", "(", "signature", ")", ",", "signature", ")", "return", "footer" ]

[ "Uses", "the", "signer", "object", "which", "has", "been", "used", "to", "sign", "the", "message", "to", "generate", "the", "signature", "then", "serializes", "that", "signature", "." ]

[ "def", "serialize_raw_master_key_prefix", "(", "raw_master_key", ")", ":", "if", "raw_master_key", ".", "config", ".", "wrapping_key", ".", "wrapping_algorithm", ".", "encryption_type", "is", "EncryptionType", ".", "ASYMMETRIC", ":", "return", "to_bytes", "(", "raw_master_key", ".", "key_id", ")", "return", "struct", ".", "pack", "(", "\">{}sII\"", ".", "format", "(", "len", "(", "raw_master_key", ".", "key_id", ")", ")", ",", "to_bytes", "(", "raw_master_key", ".", "key_id", ")", ",", "# Tag Length is stored in bits, not bytes", "raw_master_key", ".", "config", ".", "wrapping_key", ".", "wrapping_algorithm", ".", "algorithm", ".", "tag_len", "*", "8", ",", "raw_master_key", ".", "config", ".", "wrapping_key", ".", "wrapping_algorithm", ".", "algorithm", ".", "iv_len", ",", ")" ]

[ "Produces", "the", "prefix", "that", "a", "RawMasterKey", "will", "always", "use", "for", "the", "key_info", "value", "of", "keys", "which", "require", "additional", "information", "." ]

[ "def", "serialize_wrapped_key", "(", "key_provider", ",", "wrapping_algorithm", ",", "wrapping_key_id", ",", "encrypted_wrapped_key", ")", ":", "if", "encrypted_wrapped_key", ".", "iv", "is", "None", ":", "key_info", "=", "wrapping_key_id", "key_ciphertext", "=", "encrypted_wrapped_key", ".", "ciphertext", "else", ":", "key_info", "=", "struct", ".", "pack", "(", "\">{key_id_len}sII{iv_len}s\"", ".", "format", "(", "key_id_len", "=", "len", "(", "wrapping_key_id", ")", ",", "iv_len", "=", "wrapping_algorithm", ".", "algorithm", ".", "iv_len", ")", ",", "to_bytes", "(", "wrapping_key_id", ")", ",", "len", "(", "encrypted_wrapped_key", ".", "tag", ")", "*", "8", ",", "# Tag Length is stored in bits, not bytes", "wrapping_algorithm", ".", "algorithm", ".", "iv_len", ",", "encrypted_wrapped_key", ".", "iv", ",", ")", "key_ciphertext", "=", "encrypted_wrapped_key", ".", "ciphertext", "+", "encrypted_wrapped_key", ".", "tag", "return", "EncryptedDataKey", "(", "key_provider", "=", "MasterKeyInfo", "(", "provider_id", "=", "key_provider", ".", "provider_id", ",", "key_info", "=", "key_info", ")", ",", "encrypted_data_key", "=", "key_ciphertext", ",", ")" ]

[ "Serializes", "EncryptedData", "into", "a", "Wrapped", "EncryptedDataKey", "." ]

[ "def", "assemble_content_aad", "(", "message_id", ",", "aad_content_string", ",", "seq_num", ",", "length", ")", ":", "if", "not", "isinstance", "(", "aad_content_string", ",", "aws_encryption_sdk", ".", "identifiers", ".", "ContentAADString", ")", ":", "raise", "SerializationError", "(", "\"Unknown aad_content_string\"", ")", "fmt", "=", "\">16s{}sIQ\"", ".", "format", "(", "len", "(", "aad_content_string", ".", "value", ")", ")", "return", "struct", ".", "pack", "(", "fmt", ",", "message_id", ",", "aad_content_string", ".", "value", ",", "seq_num", ",", "length", ")" ]

[ "Assembles", "the", "Body", "AAD", "string", "for", "a", "message", "body", "structure", "." ]

[ "def", "serialize_encryption_context", "(", "encryption_context", ")", ":", "if", "not", "encryption_context", ":", "return", "bytes", "(", ")", "serialized_context", "=", "bytearray", "(", ")", "dict_size", "=", "len", "(", "encryption_context", ")", "if", "dict_size", ">", "aws_encryption_sdk", ".", "internal", ".", "defaults", ".", "MAX_BYTE_ARRAY_SIZE", ":", "raise", "SerializationError", "(", "\"The encryption context contains too many elements.\"", ")", "serialized_context", ".", "extend", "(", "struct", ".", "pack", "(", "\">H\"", ",", "dict_size", ")", ")", "# Encode strings first to catch bad values.", "encryption_context_list", "=", "[", "]", "for", "key", ",", "value", "in", "encryption_context", ".", "items", "(", ")", ":", "try", ":", "if", "isinstance", "(", "key", ",", "bytes", ")", ":", "key", "=", "codecs", ".", "decode", "(", "key", ")", "if", "isinstance", "(", "value", ",", "bytes", ")", ":", "value", "=", "codecs", ".", "decode", "(", "value", ")", "encryption_context_list", ".", "append", "(", "(", "aws_encryption_sdk", ".", "internal", ".", "str_ops", ".", "to_bytes", "(", "key", ")", ",", "aws_encryption_sdk", ".", "internal", ".", "str_ops", ".", "to_bytes", "(", "value", ")", ")", ")", "except", "Exception", ":", "raise", "SerializationError", "(", "\"Cannot encode dictionary key or value using {}.\"", ".", "format", "(", "aws_encryption_sdk", ".", "internal", ".", "defaults", ".", "ENCODING", ")", ")", "for", "key", ",", "value", "in", "sorted", "(", "encryption_context_list", ",", "key", "=", "lambda", "x", ":", "x", "[", "0", "]", ")", ":", "serialized_context", ".", "extend", "(", "struct", ".", "pack", "(", "\">H{key_size}sH{value_size}s\"", ".", "format", "(", "key_size", "=", "len", "(", "key", ")", ",", "value_size", "=", "len", "(", "value", ")", ")", ",", "len", "(", "key", ")", ",", "key", ",", "len", "(", "value", ")", ",", "value", ",", ")", ")", "if", "len", "(", "serialized_context", ")", ">", "aws_encryption_sdk", ".", "internal", ".", "defaults", ".", "MAX_BYTE_ARRAY_SIZE", ":", "raise", "SerializationError", "(", "\"The serialized context is too large.\"", ")", "return", "bytes", "(", "serialized_context", ")" ]

[ "Serializes", "the", "contents", "of", "a", "dictionary", "into", "a", "byte", "string", "." ]

[ "def", "read_short", "(", "source", ",", "offset", ")", ":", "try", ":", "(", "short", ",", ")", "=", "struct", ".", "unpack_from", "(", "\">H\"", ",", "source", ",", "offset", ")", "return", "short", ",", "offset", "+", "struct", ".", "calcsize", "(", "\">H\"", ")", "except", "struct", ".", "error", ":", "raise", "SerializationError", "(", "\"Bad format of serialized context.\"", ")" ]

[ "Reads", "a", "number", "from", "a", "byte", "array", "." ]

[ "def", "read_string", "(", "source", ",", "offset", ",", "length", ")", ":", "end", "=", "offset", "+", "length", "try", ":", "return", "(", "codecs", ".", "decode", "(", "source", "[", "offset", ":", "end", "]", ",", "aws_encryption_sdk", ".", "internal", ".", "defaults", ".", "ENCODING", ")", ",", "end", ")", "except", "Exception", ":", "raise", "SerializationError", "(", "\"Bad format of serialized context.\"", ")" ]

[ "Reads", "a", "string", "from", "a", "byte", "string", "." ]

[ "def", "deserialize_encryption_context", "(", "serialized_encryption_context", ")", ":", "if", "len", "(", "serialized_encryption_context", ")", ">", "aws_encryption_sdk", ".", "internal", ".", "defaults", ".", "MAX_BYTE_ARRAY_SIZE", ":", "raise", "SerializationError", "(", "\"Serialized context is too long.\"", ")", "if", "serialized_encryption_context", "==", "b\"\"", ":", "_LOGGER", ".", "debug", "(", "\"No encryption context data found\"", ")", "return", "{", "}", "deserialized_size", "=", "0", "encryption_context", "=", "{", "}", "dict_size", ",", "deserialized_size", "=", "read_short", "(", "source", "=", "serialized_encryption_context", ",", "offset", "=", "deserialized_size", ")", "_LOGGER", ".", "debug", "(", "\"Found %d keys\"", ",", "dict_size", ")", "for", "_", "in", "range", "(", "dict_size", ")", ":", "key_size", ",", "deserialized_size", "=", "read_short", "(", "source", "=", "serialized_encryption_context", ",", "offset", "=", "deserialized_size", ")", "key", ",", "deserialized_size", "=", "read_string", "(", "source", "=", "serialized_encryption_context", ",", "offset", "=", "deserialized_size", ",", "length", "=", "key_size", ")", "value_size", ",", "deserialized_size", "=", "read_short", "(", "source", "=", "serialized_encryption_context", ",", "offset", "=", "deserialized_size", ")", "value", ",", "deserialized_size", "=", "read_string", "(", "source", "=", "serialized_encryption_context", ",", "offset", "=", "deserialized_size", ",", "length", "=", "value_size", ")", "if", "key", "in", "encryption_context", ":", "raise", "SerializationError", "(", "\"Duplicate key in serialized context.\"", ")", "encryption_context", "[", "key", "]", "=", "value", "if", "deserialized_size", "!=", "len", "(", "serialized_encryption_context", ")", ":", "raise", "SerializationError", "(", "\"Formatting error: Extra data in serialized context.\"", ")", "return", "encryption_context" ]

[ "Deserializes", "the", "contents", "of", "a", "byte", "string", "into", "a", "dictionary", "." ]

[ "def", "owns_data_key", "(", "self", ",", "data_key", ":", "DataKey", ")", "->", "bool", ":", "return", "data_key", ".", "key_provider", ".", "provider_id", "in", "self", ".", "_allowed_provider_ids" ]

[ "Determine", "whether", "the", "data", "key", "is", "owned", "by", "a", "null", "or", "zero", "provider", "." ]

[ "def", "frame_iv", "(", "algorithm", ",", "sequence_number", ")", ":", "if", "sequence_number", "<", "1", "or", "sequence_number", ">", "MAX_FRAME_COUNT", ":", "raise", "ActionNotAllowedError", "(", "\"Invalid frame sequence number: {actual}\\nMust be between 1 and {max}\"", ".", "format", "(", "actual", "=", "sequence_number", ",", "max", "=", "MAX_FRAME_COUNT", ")", ")", "prefix_len", "=", "algorithm", ".", "iv_len", "-", "4", "prefix", "=", "b\"\\x00\"", "*", "prefix_len", "return", "prefix", "+", "struct", ".", "pack", "(", "\">I\"", ",", "sequence_number", ")" ]

[ "Builds", "the", "deterministic", "IV", "for", "a", "body", "frame", "." ]

[ "def", "valid_kdf", "(", "self", ",", "kdf", ")", ":", "if", "kdf", ".", "input_length", "is", "None", ":", "return", "True", "if", "self", ".", "data_key_length", ">", "kdf", ".", "input_length", "(", "self", ")", ":", "raise", "InvalidAlgorithmError", "(", "\"Invalid Algorithm definition: data_key_len must not be greater than kdf_input_len\"", ")", "return", "True" ]

[ "Determine", "whether", "a", "KDFSuite", "can", "be", "used", "with", "this", "EncryptionSuite", "." ]

[ "def", "header_length", "(", "header", ")", ":", "# Because encrypted data key lengths may not be knowable until the ciphertext", "# is received from the providers, just serialize the header directly.", "header_length", "=", "len", "(", "serialize_header", "(", "header", ")", ")", "header_length", "+=", "header", ".", "algorithm", ".", "iv_len", "# Header Authentication IV", "header_length", "+=", "header", ".", "algorithm", ".", "auth_len", "# Header Authentication Tag", "return", "header_length" ]

[ "Calculates", "the", "ciphertext", "message", "header", "length", "given", "a", "complete", "header", "." ]

[ "def", "_non_framed_body_length", "(", "header", ",", "plaintext_length", ")", ":", "body_length", "=", "header", ".", "algorithm", ".", "iv_len", "# IV", "body_length", "+=", "8", "# Encrypted Content Length", "body_length", "+=", "plaintext_length", "# Encrypted Content", "body_length", "+=", "header", ".", "algorithm", ".", "auth_len", "# Authentication Tag", "return", "body_length" ]

[ "Calculates", "the", "length", "of", "a", "non", "-", "framed", "message", "body", "given", "a", "complete", "header", "." ]

[ "def", "_standard_frame_length", "(", "header", ")", ":", "frame_length", "=", "4", "# Sequence Number", "frame_length", "+=", "header", ".", "algorithm", ".", "iv_len", "# IV", "frame_length", "+=", "header", ".", "frame_length", "# Encrypted Content", "frame_length", "+=", "header", ".", "algorithm", ".", "auth_len", "# Authentication Tag", "return", "frame_length" ]

[ "Calculates", "the", "length", "of", "a", "standard", "ciphertext", "frame", "given", "a", "complete", "header", "." ]

[ "def", "_final_frame_length", "(", "header", ",", "final_frame_bytes", ")", ":", "final_frame_length", "=", "4", "# Sequence Number End", "final_frame_length", "+=", "4", "# Sequence Number", "final_frame_length", "+=", "header", ".", "algorithm", ".", "iv_len", "# IV", "final_frame_length", "+=", "4", "# Encrypted Content Length", "final_frame_length", "+=", "final_frame_bytes", "# Encrypted Content", "final_frame_length", "+=", "header", ".", "algorithm", ".", "auth_len", "# Authentication Tag", "return", "final_frame_length" ]

[ "Calculates", "the", "length", "of", "a", "final", "ciphertext", "frame", "given", "a", "complete", "header", "and", "the", "number", "of", "bytes", "of", "ciphertext", "in", "the", "final", "frame", "." ]

[ "def", "body_length", "(", "header", ",", "plaintext_length", ")", ":", "body_length", "=", "0", "if", "header", ".", "frame_length", "==", "0", ":", "# Non-framed", "body_length", "+=", "_non_framed_body_length", "(", "header", ",", "plaintext_length", ")", "else", ":", "# Framed", "frames", ",", "final_frame_bytes", "=", "divmod", "(", "plaintext_length", ",", "header", ".", "frame_length", ")", "body_length", "+=", "frames", "*", "_standard_frame_length", "(", "header", ")", "body_length", "+=", "_final_frame_length", "(", "header", ",", "final_frame_bytes", ")", "# Final frame is always written", "return", "body_length" ]

[ "Calculates", "the", "ciphertext", "message", "body", "length", "given", "a", "complete", "header", "." ]

[ "def", "footer_length", "(", "header", ")", ":", "footer_length", "=", "0", "if", "header", ".", "algorithm", ".", "signing_algorithm_info", "is", "not", "None", ":", "footer_length", "+=", "2", "# Signature Length", "footer_length", "+=", "header", ".", "algorithm", ".", "signature_len", "# Signature", "return", "footer_length" ]

[ "Calculates", "the", "ciphertext", "message", "footer", "length", "given", "a", "complete", "header", "." ]

[ "def", "ciphertext_length", "(", "header", ",", "plaintext_length", ")", ":", "ciphertext_length", "=", "header_length", "(", "header", ")", "ciphertext_length", "+=", "body_length", "(", "header", ",", "plaintext_length", ")", "ciphertext_length", "+=", "footer_length", "(", "header", ")", "return", "ciphertext_length" ]

[ "Calculates", "the", "complete", "ciphertext", "message", "length", "given", "a", "complete", "header", "." ]

[ "def", "owns_data_key", "(", "self", ",", "data_key", ")", ":", "expected_key_info_len", "=", "-", "1", "if", "(", "self", ".", "config", ".", "wrapping_key", ".", "wrapping_algorithm", ".", "encryption_type", "is", "EncryptionType", ".", "ASYMMETRIC", "and", "data_key", ".", "key_provider", "==", "self", ".", "key_provider", ")", ":", "return", "True", "elif", "self", ".", "config", ".", "wrapping_key", ".", "wrapping_algorithm", ".", "encryption_type", "is", "EncryptionType", ".", "SYMMETRIC", ":", "expected_key_info_len", "=", "(", "len", "(", "self", ".", "_key_info_prefix", ")", "+", "self", ".", "config", ".", "wrapping_key", ".", "wrapping_algorithm", ".", "algorithm", ".", "iv_len", ")", "if", "(", "data_key", ".", "key_provider", ".", "provider_id", "==", "self", ".", "provider_id", "and", "len", "(", "data_key", ".", "key_provider", ".", "key_info", ")", "==", "expected_key_info_len", "and", "data_key", ".", "key_provider", ".", "key_info", ".", "startswith", "(", "self", ".", "_key_info_prefix", ")", ")", ":", "return", "True", "_LOGGER", ".", "debug", "(", "(", "\"RawMasterKey does not own data_key: %s\\n\"", "\"Expected provider_id: %s\\n\"", "\"Expected key_info len: %s\\n\"", "\"Expected key_info prefix: %s\"", ")", ",", "data_key", ",", "self", ".", "provider_id", ",", "expected_key_info_len", ",", "self", ".", "_key_info_prefix", ",", ")", "return", "False" ]

[ "Determines", "if", "data_key", "object", "is", "owned", "by", "this", "RawMasterKey", "." ]

[ "def", "_encrypt_data_key", "(", "self", ",", "data_key", ",", "algorithm", ",", "encryption_context", ")", ":", "# Raw key string to EncryptedData", "encrypted_wrapped_key", "=", "self", ".", "config", ".", "wrapping_key", ".", "encrypt", "(", "plaintext_data_key", "=", "data_key", ".", "data_key", ",", "encryption_context", "=", "encryption_context", ")", "# EncryptedData to EncryptedDataKey", "return", "aws_encryption_sdk", ".", "internal", ".", "formatting", ".", "serialize", ".", "serialize_wrapped_key", "(", "key_provider", "=", "self", ".", "key_provider", ",", "wrapping_algorithm", "=", "self", ".", "config", ".", "wrapping_key", ".", "wrapping_algorithm", ",", "wrapping_key_id", "=", "self", ".", "key_id", ",", "encrypted_wrapped_key", "=", "encrypted_wrapped_key", ",", ")" ]

[ "Performs", "the", "provider", "-", "specific", "key", "encryption", "actions", "." ]

[ "def", "put_encryption_materials", "(", "self", ",", "cache_key", ",", "encryption_materials", ",", "plaintext_length", ",", "entry_hints", "=", "None", ")", ":", "return", "CryptoMaterialsCacheEntry", "(", "cache_key", "=", "cache_key", ",", "value", "=", "encryption_materials", ")" ]

[ "Does", "not", "add", "encryption", "materials", "to", "the", "cache", "since", "there", "is", "no", "cache", "to", "which", "to", "add", "them", "." ]

[ "def", "_set_signature_type", "(", "self", ")", ":", "try", ":", "verify_interface", "(", "ec", ".", "EllipticCurve", ",", "self", ".", "algorithm", ".", "signing_algorithm_info", ")", "return", "ec", ".", "EllipticCurve", "except", "InterfaceNotImplemented", ":", "raise", "NotSupportedError", "(", "\"Unsupported signing algorithm info\"", ")" ]

[ "Ensures", "that", "the", "algorithm", "signature", "type", "is", "a", "known", "type", "and", "sets", "a", "reference", "value", "." ]

[ "def", "from_key_bytes", "(", "cls", ",", "algorithm", ",", "key_bytes", ")", ":", "key", "=", "serialization", ".", "load_der_private_key", "(", "data", "=", "key_bytes", ",", "password", "=", "None", ",", "backend", "=", "default_backend", "(", ")", ")", "return", "cls", "(", "algorithm", ",", "key", ")" ]

[ "Builds", "a", "Signer", "from", "an", "algorithm", "suite", "and", "a", "raw", "signing", "key", "." ]

[ "def", "key_bytes", "(", "self", ")", ":", "return", "self", ".", "key", ".", "private_bytes", "(", "encoding", "=", "serialization", ".", "Encoding", ".", "DER", ",", "format", "=", "serialization", ".", "PrivateFormat", ".", "PKCS8", ",", "encryption_algorithm", "=", "serialization", ".", "NoEncryption", "(", ")", ",", ")" ]

[ "Returns", "the", "raw", "signing", "key", "." ]

[ "def", "finalize", "(", "self", ")", ":", "prehashed_digest", "=", "self", ".", "_hasher", ".", "finalize", "(", ")", "return", "_ecc_static_length_signature", "(", "key", "=", "self", ".", "key", ",", "algorithm", "=", "self", ".", "algorithm", ",", "digest", "=", "prehashed_digest", ")" ]

[ "Finalizes", "the", "signer", "and", "returns", "the", "signature", "." ]

[ "def", "from_encoded_point", "(", "cls", ",", "algorithm", ",", "encoded_point", ")", ":", "return", "cls", "(", "algorithm", "=", "algorithm", ",", "key", "=", "_ecc_public_numbers_from_compressed_point", "(", "curve", "=", "algorithm", ".", "signing_algorithm_info", "(", ")", ",", "compressed_point", "=", "base64", ".", "b64decode", "(", "encoded_point", ")", ")", ".", "public_key", "(", "default_backend", "(", ")", ")", ",", ")" ]

[ "Creates", "a", "Verifier", "object", "based", "on", "the", "supplied", "algorithm", "and", "encoded", "compressed", "ECC", "curve", "point", "." ]

[ "def", "from_key_bytes", "(", "cls", ",", "algorithm", ",", "key_bytes", ")", ":", "return", "cls", "(", "algorithm", "=", "algorithm", ",", "key", "=", "serialization", ".", "load_der_public_key", "(", "data", "=", "key_bytes", ",", "backend", "=", "default_backend", "(", ")", ")", ")" ]

[ "Creates", "a", "Verifier", "object", "based", "on", "the", "supplied", "algorithm", "and", "raw", "verification", "key", "." ]

[ "def", "key_bytes", "(", "self", ")", ":", "return", "self", ".", "key", ".", "public_bytes", "(", "encoding", "=", "serialization", ".", "Encoding", ".", "DER", ",", "format", "=", "serialization", ".", "PublicFormat", ".", "SubjectPublicKeyInfo", ")" ]

[ "Returns", "the", "raw", "verification", "key", "." ]

[ "def", "verify", "(", "self", ",", "signature", ")", ":", "prehashed_digest", "=", "self", ".", "_hasher", ".", "finalize", "(", ")", "self", ".", "key", ".", "verify", "(", "signature", "=", "signature", ",", "data", "=", "prehashed_digest", ",", "signature_algorithm", "=", "ec", ".", "ECDSA", "(", "Prehashed", "(", "self", ".", "algorithm", ".", "signing_hash_type", "(", ")", ")", ")", ",", ")" ]

[ "Verifies", "the", "signature", "against", "the", "current", "cryptographic", "verifier", "state", "." ]

[ "def", "encrypt", "(", "self", ",", "plaintext_data_key", ",", "encryption_context", ")", ":", "if", "self", ".", "wrapping_algorithm", ".", "encryption_type", "is", "EncryptionType", ".", "ASYMMETRIC", ":", "if", "self", ".", "wrapping_key_type", "is", "EncryptionKeyType", ".", "PRIVATE", ":", "encrypted_key", "=", "self", ".", "_wrapping_key", ".", "public_key", "(", ")", ".", "encrypt", "(", "plaintext", "=", "plaintext_data_key", ",", "padding", "=", "self", ".", "wrapping_algorithm", ".", "padding", ")", "else", ":", "encrypted_key", "=", "self", ".", "_wrapping_key", ".", "encrypt", "(", "plaintext", "=", "plaintext_data_key", ",", "padding", "=", "self", ".", "wrapping_algorithm", ".", "padding", ")", "return", "EncryptedData", "(", "iv", "=", "None", ",", "ciphertext", "=", "encrypted_key", ",", "tag", "=", "None", ")", "serialized_encryption_context", "=", "serialize_encryption_context", "(", "encryption_context", "=", "encryption_context", ")", "iv", "=", "os", ".", "urandom", "(", "self", ".", "wrapping_algorithm", ".", "algorithm", ".", "iv_len", ")", "return", "encrypt", "(", "algorithm", "=", "self", ".", "wrapping_algorithm", ".", "algorithm", ",", "key", "=", "self", ".", "_derived_wrapping_key", ",", "plaintext", "=", "plaintext_data_key", ",", "associated_data", "=", "serialized_encryption_context", ",", "iv", "=", "iv", ",", ")" ]

[ "Encrypts", "a", "data", "key", "using", "a", "direct", "wrapping", "key", "." ]

[ "def", "decrypt", "(", "self", ",", "encrypted_wrapped_data_key", ",", "encryption_context", ")", ":", "if", "self", ".", "wrapping_key_type", "is", "EncryptionKeyType", ".", "PUBLIC", ":", "raise", "IncorrectMasterKeyError", "(", "\"Public key cannot decrypt\"", ")", "if", "self", ".", "wrapping_key_type", "is", "EncryptionKeyType", ".", "PRIVATE", ":", "return", "self", ".", "_wrapping_key", ".", "decrypt", "(", "ciphertext", "=", "encrypted_wrapped_data_key", ".", "ciphertext", ",", "padding", "=", "self", ".", "wrapping_algorithm", ".", "padding", ")", "serialized_encryption_context", "=", "serialize_encryption_context", "(", "encryption_context", "=", "encryption_context", ")", "return", "decrypt", "(", "algorithm", "=", "self", ".", "wrapping_algorithm", ".", "algorithm", ",", "key", "=", "self", ".", "_derived_wrapping_key", ",", "encrypted_data", "=", "encrypted_wrapped_data_key", ",", "associated_data", "=", "serialized_encryption_context", ",", ")" ]

[ "Decrypts", "a", "wrapped", "encrypted", "data", "key", "." ]

[ "def", "_generate_data_key", "(", "self", ",", "algorithm", ":", "AlgorithmSuite", ",", "encryption_context", ":", "Dict", "[", "Text", ",", "Text", "]", ")", "->", "DataKey", ":", "data_key", "=", "b\"\"", ".", "join", "(", "[", "chr", "(", "i", ")", ".", "encode", "(", "\"utf-8\"", ")", "for", "i", "in", "range", "(", "1", ",", "algorithm", ".", "data_key_len", "+", "1", ")", "]", ")", "return", "DataKey", "(", "key_provider", "=", "self", ".", "key_provider", ",", "data_key", "=", "data_key", ",", "encrypted_data_key", "=", "self", ".", "_encrypted_data_key", ")" ]

[ "Perform", "the", "provider", "-", "specific", "data", "key", "generation", "task", "." ]

[ "def", "_encrypt_data_key", "(", "self", ",", "data_key", ":", "DataKey", ",", "algorithm", ":", "AlgorithmSuite", ",", "encryption_context", ":", "Dict", "[", "Text", ",", "Text", "]", ")", "->", "NoReturn", ":", "raise", "NotImplementedError", "(", "\"CountingMasterKey does not support encrypt_data_key\"", ")" ]

[ "Encrypt", "a", "data", "key", "and", "return", "the", "ciphertext", "." ]

[ "def", "validate_header", "(", "header", ",", "header_auth", ",", "raw_header", ",", "data_key", ")", ":", "_LOGGER", ".", "debug", "(", "\"Starting header validation\"", ")", "try", ":", "decrypt", "(", "algorithm", "=", "header", ".", "algorithm", ",", "key", "=", "data_key", ",", "encrypted_data", "=", "EncryptedData", "(", "header_auth", ".", "iv", ",", "b\"\"", ",", "header_auth", ".", "tag", ")", ",", "associated_data", "=", "raw_header", ",", ")", "except", "InvalidTag", ":", "raise", "SerializationError", "(", "\"Header authorization failed\"", ")" ]

[ "Validates", "the", "header", "using", "the", "header", "authentication", "data", "." ]

[ "def", "_deserialize_encrypted_data_keys", "(", "stream", ")", ":", "# type: (IO) -> Set[EncryptedDataKey]", "(", "encrypted_data_key_count", ",", ")", "=", "unpack_values", "(", "\">H\"", ",", "stream", ")", "encrypted_data_keys", "=", "set", "(", "[", "]", ")", "for", "_", "in", "range", "(", "encrypted_data_key_count", ")", ":", "(", "key_provider_length", ",", ")", "=", "unpack_values", "(", "\">H\"", ",", "stream", ")", "(", "key_provider_identifier", ",", ")", "=", "unpack_values", "(", "\">{}s\"", ".", "format", "(", "key_provider_length", ")", ",", "stream", ")", "(", "key_provider_information_length", ",", ")", "=", "unpack_values", "(", "\">H\"", ",", "stream", ")", "(", "key_provider_information", ",", ")", "=", "unpack_values", "(", "\">{}s\"", ".", "format", "(", "key_provider_information_length", ")", ",", "stream", ")", "(", "encrypted_data_key_length", ",", ")", "=", "unpack_values", "(", "\">H\"", ",", "stream", ")", "encrypted_data_key", "=", "stream", ".", "read", "(", "encrypted_data_key_length", ")", "encrypted_data_keys", ".", "add", "(", "EncryptedDataKey", "(", "key_provider", "=", "MasterKeyInfo", "(", "provider_id", "=", "to_str", "(", "key_provider_identifier", ")", ",", "key_info", "=", "key_provider_information", ")", ",", "encrypted_data_key", "=", "encrypted_data_key", ",", ")", ")", "return", "encrypted_data_keys" ]

[ "Deserialize", "some", "encrypted", "data", "keys", "from", "a", "stream", "." ]

[ "def", "_verified_iv_length", "(", "iv_length", ",", "algorithm_suite", ")", ":", "# type: (int, AlgorithmSuite) -> int", "if", "iv_length", "!=", "algorithm_suite", ".", "iv_len", ":", "raise", "SerializationError", "(", "\"Specified IV length ({length}) does not match algorithm IV length ({algorithm})\"", ".", "format", "(", "length", "=", "iv_length", ",", "algorithm", "=", "algorithm_suite", ")", ")", "return", "iv_length" ]

[ "Verify", "an", "IV", "length", "for", "an", "algorithm", "suite", "." ]

[ "def", "_verified_frame_length", "(", "frame_length", ",", "content_type", ")", ":", "# type: (int, ContentType) -> int", "if", "content_type", "==", "ContentType", ".", "FRAMED_DATA", "and", "frame_length", ">", "MAX_FRAME_SIZE", ":", "raise", "SerializationError", "(", "\"Specified frame length larger than allowed maximum: {found} > {max}\"", ".", "format", "(", "found", "=", "frame_length", ",", "max", "=", "MAX_FRAME_SIZE", ")", ")", "if", "content_type", "==", "ContentType", ".", "NO_FRAMING", "and", "frame_length", "!=", "0", ":", "raise", "SerializationError", "(", "\"Non-zero frame length found for non-framed message\"", ")", "return", "frame_length" ]

[ "Verify", "a", "frame", "length", "value", "for", "a", "message", "content", "type", "." ]

[ "def", "deserialize_header", "(", "stream", ")", ":", "# type: (IO) -> MessageHeader", "_LOGGER", ".", "debug", "(", "\"Starting header deserialization\"", ")", "tee", "=", "io", ".", "BytesIO", "(", ")", "tee_stream", "=", "TeeStream", "(", "stream", ",", "tee", ")", "version_id", ",", "message_type_id", "=", "unpack_values", "(", "\">BB\"", ",", "tee_stream", ")", "header", "=", "dict", "(", ")", "header", "[", "\"version\"", "]", "=", "_verified_version_from_id", "(", "version_id", ")", "header", "[", "\"type\"", "]", "=", "_verified_message_type_from_id", "(", "message_type_id", ")", "algorithm_id", ",", "message_id", ",", "ser_encryption_context_length", "=", "unpack_values", "(", "\">H16sH\"", ",", "tee_stream", ")", "header", "[", "\"algorithm\"", "]", "=", "_verified_algorithm_from_id", "(", "algorithm_id", ")", "header", "[", "\"message_id\"", "]", "=", "message_id", "header", "[", "\"encryption_context\"", "]", "=", "deserialize_encryption_context", "(", "tee_stream", ".", "read", "(", "ser_encryption_context_length", ")", ")", "header", "[", "\"encrypted_data_keys\"", "]", "=", "_deserialize_encrypted_data_keys", "(", "tee_stream", ")", "(", "content_type_id", ",", ")", "=", "unpack_values", "(", "\">B\"", ",", "tee_stream", ")", "header", "[", "\"content_type\"", "]", "=", "_verified_content_type_from_id", "(", "content_type_id", ")", "(", "content_aad_length", ",", ")", "=", "unpack_values", "(", "\">I\"", ",", "tee_stream", ")", "header", "[", "\"content_aad_length\"", "]", "=", "_verified_content_aad_length", "(", "content_aad_length", ")", "(", "iv_length", ",", ")", "=", "unpack_values", "(", "\">B\"", ",", "tee_stream", ")", "header", "[", "\"header_iv_length\"", "]", "=", "_verified_iv_length", "(", "iv_length", ",", "header", "[", "\"algorithm\"", "]", ")", "(", "frame_length", ",", ")", "=", "unpack_values", "(", "\">I\"", ",", "tee_stream", ")", "header", "[", "\"frame_length\"", "]", "=", "_verified_frame_length", "(", "frame_length", ",", "header", "[", "\"content_type\"", "]", ")", "return", "MessageHeader", "(", "*", "*", "header", ")", ",", "tee", ".", "getvalue", "(", ")" ]

[ "Deserializes", "the", "header", "from", "a", "source", "stream" ]

[ "def", "deserialize_header_auth", "(", "stream", ",", "algorithm", ",", "verifier", "=", "None", ")", ":", "_LOGGER", ".", "debug", "(", "\"Starting header auth deserialization\"", ")", "format_string", "=", "\">{iv_len}s{tag_len}s\"", ".", "format", "(", "iv_len", "=", "algorithm", ".", "iv_len", ",", "tag_len", "=", "algorithm", ".", "tag_len", ")", "return", "MessageHeaderAuthentication", "(", "*", "unpack_values", "(", "format_string", ",", "stream", ",", "verifier", ")", ")" ]

[ "Deserializes", "a", "MessageHeaderAuthentication", "object", "from", "a", "source", "stream", "." ]

[ "def", "deserialize_non_framed_values", "(", "stream", ",", "header", ",", "verifier", "=", "None", ")", ":", "_LOGGER", ".", "debug", "(", "\"Starting non-framed body iv/tag deserialization\"", ")", "(", "data_iv", ",", "data_length", ")", "=", "unpack_values", "(", "\">{}sQ\"", ".", "format", "(", "header", ".", "algorithm", ".", "iv_len", ")", ",", "stream", ",", "verifier", ")", "return", "data_iv", ",", "data_length" ]

[ "Deserializes", "the", "IV", "and", "body", "length", "from", "a", "non", "-", "framed", "stream", "." ]

[ "def", "deserialize_tag", "(", "stream", ",", "header", ",", "verifier", "=", "None", ")", ":", "(", "data_tag", ",", ")", "=", "unpack_values", "(", "format_string", "=", "\">{auth_len}s\"", ".", "format", "(", "auth_len", "=", "header", ".", "algorithm", ".", "auth_len", ")", ",", "stream", "=", "stream", ",", "verifier", "=", "verifier", ")", "return", "data_tag" ]

[ "Deserialize", "the", "Tag", "value", "from", "a", "non", "-", "framed", "stream", "." ]

[ "def", "deserialize_frame", "(", "stream", ",", "header", ",", "verifier", "=", "None", ")", ":", "_LOGGER", ".", "debug", "(", "\"Starting frame deserialization\"", ")", "frame_data", "=", "{", "}", "final_frame", "=", "False", "(", "sequence_number", ",", ")", "=", "unpack_values", "(", "\">I\"", ",", "stream", ",", "verifier", ")", "if", "sequence_number", "==", "SequenceIdentifier", ".", "SEQUENCE_NUMBER_END", ".", "value", ":", "_LOGGER", ".", "debug", "(", "\"Deserializing final frame\"", ")", "(", "sequence_number", ",", ")", "=", "unpack_values", "(", "\">I\"", ",", "stream", ",", "verifier", ")", "final_frame", "=", "True", "else", ":", "_LOGGER", ".", "debug", "(", "\"Deserializing frame sequence number %d\"", ",", "int", "(", "sequence_number", ")", ")", "frame_data", "[", "\"final_frame\"", "]", "=", "final_frame", "frame_data", "[", "\"sequence_number\"", "]", "=", "sequence_number", "(", "frame_iv", ",", ")", "=", "unpack_values", "(", "\">{iv_len}s\"", ".", "format", "(", "iv_len", "=", "header", ".", "algorithm", ".", "iv_len", ")", ",", "stream", ",", "verifier", ")", "frame_data", "[", "\"iv\"", "]", "=", "frame_iv", "if", "final_frame", "is", "True", ":", "(", "content_length", ",", ")", "=", "unpack_values", "(", "\">I\"", ",", "stream", ",", "verifier", ")", "if", "content_length", ">=", "header", ".", "frame_length", ":", "raise", "SerializationError", "(", "\"Invalid final frame length: {final} >= {normal}\"", ".", "format", "(", "final", "=", "content_length", ",", "normal", "=", "header", ".", "frame_length", ")", ")", "else", ":", "content_length", "=", "header", ".", "frame_length", "(", "frame_content", ",", "frame_tag", ")", "=", "unpack_values", "(", "\">{content_len}s{auth_len}s\"", ".", "format", "(", "content_len", "=", "content_length", ",", "auth_len", "=", "header", ".", "algorithm", ".", "auth_len", ")", ",", "stream", ",", "verifier", ",", ")", "frame_data", "[", "\"ciphertext\"", "]", "=", "frame_content", "frame_data", "[", "\"tag\"", "]", "=", "frame_tag", "return", "MessageFrameBody", "(", "*", "*", "frame_data", ")", ",", "final_frame" ]

[ "Deserializes", "a", "frame", "from", "a", "body", "." ]

[ "def", "deserialize_footer", "(", "stream", ",", "verifier", "=", "None", ")", ":", "_LOGGER", ".", "debug", "(", "\"Starting footer deserialization\"", ")", "signature", "=", "b\"\"", "if", "verifier", "is", "None", ":", "return", "MessageFooter", "(", "signature", "=", "signature", ")", "try", ":", "(", "sig_len", ",", ")", "=", "unpack_values", "(", "\">H\"", ",", "stream", ")", "(", "signature", ",", ")", "=", "unpack_values", "(", "\">{sig_len}s\"", ".", "format", "(", "sig_len", "=", "sig_len", ")", ",", "stream", ")", "except", "SerializationError", ":", "raise", "SerializationError", "(", "\"No signature found in message\"", ")", "if", "verifier", ":", "verifier", ".", "verify", "(", "signature", ")", "return", "MessageFooter", "(", "signature", "=", "signature", ")" ]

[ "Deserializes", "a", "footer", "." ]

[ "def", "deserialize_wrapped_key", "(", "wrapping_algorithm", ",", "wrapping_key_id", ",", "wrapped_encrypted_key", ")", ":", "if", "wrapping_key_id", "==", "wrapped_encrypted_key", ".", "key_provider", ".", "key_info", ":", "encrypted_wrapped_key", "=", "EncryptedData", "(", "iv", "=", "None", ",", "ciphertext", "=", "wrapped_encrypted_key", ".", "encrypted_data_key", ",", "tag", "=", "None", ")", "else", ":", "if", "not", "wrapped_encrypted_key", ".", "key_provider", ".", "key_info", ".", "startswith", "(", "wrapping_key_id", ")", ":", "raise", "SerializationError", "(", "\"Master Key mismatch for wrapped data key\"", ")", "_key_info", "=", "wrapped_encrypted_key", ".", "key_provider", ".", "key_info", "[", "len", "(", "wrapping_key_id", ")", ":", "]", "try", ":", "tag_len", ",", "iv_len", "=", "struct", ".", "unpack", "(", "\">II\"", ",", "_key_info", "[", ":", "8", "]", ")", "except", "struct", ".", "error", ":", "raise", "SerializationError", "(", "\"Malformed key info: key info missing data\"", ")", "tag_len", "//=", "8", "# Tag Length is stored in bits, not bytes", "if", "iv_len", "!=", "wrapping_algorithm", ".", "algorithm", ".", "iv_len", ":", "raise", "SerializationError", "(", "\"Wrapping AlgorithmSuite mismatch for wrapped data key\"", ")", "iv", "=", "_key_info", "[", "8", ":", "]", "if", "len", "(", "iv", ")", "!=", "iv_len", ":", "raise", "SerializationError", "(", "\"Malformed key info: incomplete iv\"", ")", "ciphertext", "=", "wrapped_encrypted_key", ".", "encrypted_data_key", "[", ":", "-", "1", "*", "tag_len", "]", "tag", "=", "wrapped_encrypted_key", ".", "encrypted_data_key", "[", "-", "1", "*", "tag_len", ":", "]", "if", "not", "ciphertext", "or", "len", "(", "tag", ")", "!=", "tag_len", ":", "raise", "SerializationError", "(", "\"Malformed key info: incomplete ciphertext or tag\"", ")", "encrypted_wrapped_key", "=", "EncryptedData", "(", "iv", "=", "iv", ",", "ciphertext", "=", "ciphertext", ",", "tag", "=", "tag", ")", "return", "encrypted_wrapped_key" ]

[ "Extracts", "and", "deserializes", "EncryptedData", "from", "a", "Wrapped", "EncryptedDataKey", "." ]

[ "def", "validate_frame_length", "(", "frame_length", ",", "algorithm", ")", ":", "if", "frame_length", "<", "0", "or", "frame_length", "%", "algorithm", ".", "encryption_algorithm", ".", "block_size", "!=", "0", ":", "raise", "SerializationError", "(", "\"Frame size must be a non-negative multiple of the block size of the crypto algorithm: {block_size}\"", ".", "format", "(", "block_size", "=", "algorithm", ".", "encryption_algorithm", ".", "block_size", ")", ")", "if", "frame_length", ">", "aws_encryption_sdk", ".", "internal", ".", "defaults", ".", "MAX_FRAME_SIZE", ":", "raise", "SerializationError", "(", "\"Frame size too large: {frame} > {max}\"", ".", "format", "(", "frame", "=", "frame_length", ",", "max", "=", "aws_encryption_sdk", ".", "internal", ".", "defaults", ".", "MAX_FRAME_SIZE", ")", ")" ]

[ "Validates", "that", "frame", "length", "is", "within", "the", "defined", "limits", "and", "is", "compatible", "with", "the", "selected", "algorithm", "." ]

[ "def", "get_aad_content_string", "(", "content_type", ",", "is_final_frame", ")", ":", "if", "content_type", "==", "ContentType", ".", "NO_FRAMING", ":", "aad_content_string", "=", "ContentAADString", ".", "NON_FRAMED_STRING_ID", "elif", "content_type", "==", "ContentType", ".", "FRAMED_DATA", ":", "if", "is_final_frame", ":", "aad_content_string", "=", "ContentAADString", ".", "FINAL_FRAME_STRING_ID", "else", ":", "aad_content_string", "=", "ContentAADString", ".", "FRAME_STRING_ID", "else", ":", "raise", "UnknownIdentityError", "(", "\"Unhandled content type\"", ")", "return", "aad_content_string" ]

[ "Prepares", "the", "appropriate", "Body", "AAD", "Value", "for", "a", "message", "body", "." ]

[ "def", "prepare_data_keys", "(", "primary_master_key", ",", "master_keys", ",", "algorithm", ",", "encryption_context", ")", ":", "encrypted_data_keys", "=", "set", "(", ")", "encrypted_data_encryption_key", "=", "None", "data_encryption_key", "=", "primary_master_key", ".", "generate_data_key", "(", "algorithm", ",", "encryption_context", ")", "_LOGGER", ".", "debug", "(", "\"encryption data generated with master key: %s\"", ",", "data_encryption_key", ".", "key_provider", ")", "for", "master_key", "in", "master_keys", ":", "# Don't re-encrypt the encryption data key; we already have the ciphertext", "if", "master_key", "is", "primary_master_key", ":", "encrypted_data_encryption_key", "=", "EncryptedDataKey", "(", "key_provider", "=", "data_encryption_key", ".", "key_provider", ",", "encrypted_data_key", "=", "data_encryption_key", ".", "encrypted_data_key", ")", "encrypted_data_keys", ".", "add", "(", "encrypted_data_encryption_key", ")", "continue", "encrypted_key", "=", "master_key", ".", "encrypt_data_key", "(", "data_key", "=", "data_encryption_key", ",", "algorithm", "=", "algorithm", ",", "encryption_context", "=", "encryption_context", ")", "encrypted_data_keys", ".", "add", "(", "encrypted_key", ")", "_LOGGER", ".", "debug", "(", "\"encryption key encrypted with master key: %s\"", ",", "master_key", ".", "key_provider", ")", "return", "data_encryption_key", ",", "encrypted_data_keys" ]

[ "Prepares", "a", "DataKey", "to", "be", "used", "for", "encrypting", "message", "and", "list", "of", "EncryptedDataKey", "objects", "to", "be", "serialized", "into", "header", "." ]

[ "def", "prep_stream_data", "(", "data", ")", ":", "if", "isinstance", "(", "data", ",", "(", "six", ".", "string_types", ",", "six", ".", "binary_type", ")", ")", ":", "stream", "=", "io", ".", "BytesIO", "(", "to_bytes", "(", "data", ")", ")", "else", ":", "stream", "=", "data", "return", "InsistentReaderBytesIO", "(", "stream", ")" ]

[ "Take", "an", "input", "and", "prepare", "it", "for", "use", "as", "a", "stream", "." ]

[ "def", "source_data_key_length_check", "(", "source_data_key", ",", "algorithm", ")", ":", "if", "len", "(", "source_data_key", ".", "data_key", ")", "!=", "algorithm", ".", "kdf_input_len", ":", "raise", "InvalidDataKeyError", "(", "\"Invalid Source Data Key length {actual} for algorithm required: {required}\"", ".", "format", "(", "actual", "=", "len", "(", "source_data_key", ".", "data_key", ")", ",", "required", "=", "algorithm", ".", "kdf_input_len", ")", ")" ]

[ "Validates", "that", "the", "supplied", "source_data_key", "s", "data_key", "is", "the", "correct", "length", "for", "the", "supplied", "algorithm", "s", "kdf_input_len", "value", "." ]

[ "def", "encrypt", "(", "algorithm", ",", "key", ",", "plaintext", ",", "associated_data", ",", "iv", ")", ":", "encryptor", "=", "Encryptor", "(", "algorithm", ",", "key", ",", "associated_data", ",", "iv", ")", "ciphertext", "=", "encryptor", ".", "update", "(", "plaintext", ")", "+", "encryptor", ".", "finalize", "(", ")", "return", "EncryptedData", "(", "encryptor", ".", "iv", ",", "ciphertext", ",", "encryptor", ".", "tag", ")" ]

[ "Encrypts", "a", "frame", "body", "." ]

[ "def", "decrypt", "(", "algorithm", ",", "key", ",", "encrypted_data", ",", "associated_data", ")", ":", "decryptor", "=", "Decryptor", "(", "algorithm", ",", "key", ",", "associated_data", ",", "encrypted_data", ".", "iv", ",", "encrypted_data", ".", "tag", ")", "return", "decryptor", ".", "update", "(", "encrypted_data", ".", "ciphertext", ")", "+", "decryptor", ".", "finalize", "(", ")" ]

[ "Decrypts", "a", "frame", "body", "." ]

[ "def", "_master_key_provider", "(", ")", "->", "KMSMasterKeyProvider", ":", "master_key_provider", "=", "KMSMasterKeyProvider", "(", ")", "master_key_provider", ".", "add_master_key_provider", "(", "NullMasterKey", "(", ")", ")", "master_key_provider", ".", "add_master_key_provider", "(", "CountingMasterKey", "(", ")", ")", "return", "master_key_provider" ]

[ "Build", "the", "V0", "master", "key", "provider", "." ]

[ "def", "basic_decrypt", "(", ")", "->", "Response", ":", "APP", ".", "log", ".", "debug", "(", "\"Request:\"", ")", "APP", ".", "log", ".", "debug", "(", "json", ".", "dumps", "(", "APP", ".", "current_request", ".", "to_dict", "(", ")", ")", ")", "APP", ".", "log", ".", "debug", "(", "\"Ciphertext:\"", ")", "APP", ".", "log", ".", "debug", "(", "APP", ".", "current_request", ".", "raw_body", ")", "try", ":", "ciphertext", "=", "APP", ".", "current_request", ".", "raw_body", "plaintext", ",", "_header", "=", "aws_encryption_sdk", ".", "decrypt", "(", "source", "=", "ciphertext", ",", "key_provider", "=", "_master_key_provider", "(", ")", ")", "APP", ".", "log", ".", "debug", "(", "\"Plaintext:\"", ")", "APP", ".", "log", ".", "debug", "(", "plaintext", ")", "response", "=", "Response", "(", "body", "=", "plaintext", ",", "headers", "=", "{", "\"Content-Type\"", ":", "\"application/octet-stream\"", "}", ",", "status_code", "=", "200", ")", "except", "Exception", "as", "error", ":", "# pylint: disable=broad-except", "response", "=", "Response", "(", "body", "=", "str", "(", "error", ")", ",", "status_code", "=", "400", ")", "APP", ".", "log", ".", "debug", "(", "\"Response:\"", ")", "APP", ".", "log", ".", "debug", "(", "json", ".", "dumps", "(", "response", ".", "to_dict", "(", "binary_types", "=", "[", "\"application/octet-stream\"", "]", ")", ")", ")", "return", "response" ]

[ "Basic", "decrypt", "handler", "for", "decrypt", "oracle", "v0", "." ]

[ "def", "read", "(", "self", ",", "b", "=", "None", ")", ":", "data", "=", "self", ".", "__wrapped__", ".", "read", "(", "b", ")", "self", ".", "__tee", ".", "write", "(", "data", ")", "return", "data" ]

[ "Reads", "data", "from", "source", "copying", "it", "into", "tee", "before", "returning", "." ]

[ "def", "read", "(", "self", ",", "b", "=", "-", "1", ")", ":", "remaining_bytes", "=", "b", "data", "=", "io", ".", "BytesIO", "(", ")", "while", "True", ":", "try", ":", "chunk", "=", "to_bytes", "(", "self", ".", "__wrapped__", ".", "read", "(", "remaining_bytes", ")", ")", "except", "ValueError", ":", "if", "self", ".", "__wrapped__", ".", "closed", ":", "break", "raise", "if", "not", "chunk", ":", "break", "data", ".", "write", "(", "chunk", ")", "remaining_bytes", "-=", "len", "(", "chunk", ")", "if", "remaining_bytes", "<=", "0", ":", "break", "return", "data", ".", "getvalue", "(", ")" ]

[ "Keep", "reading", "from", "source", "stream", "until", "either", "the", "source", "stream", "is", "done", "or", "the", "requested", "number", "of", "bytes", "have", "been", "obtained", "." ]

[ "def", "_ecc_static_length_signature", "(", "key", ",", "algorithm", ",", "digest", ")", ":", "pre_hashed_algorithm", "=", "ec", ".", "ECDSA", "(", "Prehashed", "(", "algorithm", ".", "signing_hash_type", "(", ")", ")", ")", "signature", "=", "b\"\"", "while", "len", "(", "signature", ")", "!=", "algorithm", ".", "signature_len", ":", "_LOGGER", ".", "debug", "(", "\"Signature length %d is not desired length %d. Recalculating.\"", ",", "len", "(", "signature", ")", ",", "algorithm", ".", "signature_len", ")", "signature", "=", "key", ".", "sign", "(", "digest", ",", "pre_hashed_algorithm", ")", "if", "len", "(", "signature", ")", "!=", "algorithm", ".", "signature_len", ":", "# Most of the time, a signature of the wrong length can be fixed", "# by negating s in the signature relative to the group order.", "_LOGGER", ".", "debug", "(", "\"Signature length %d is not desired length %d. Negating s.\"", ",", "len", "(", "signature", ")", ",", "algorithm", ".", "signature_len", ")", "r", ",", "s", "=", "decode_dss_signature", "(", "signature", ")", "s", "=", "_ECC_CURVE_PARAMETERS", "[", "algorithm", ".", "signing_algorithm_info", ".", "name", "]", ".", "order", "-", "s", "signature", "=", "encode_dss_signature", "(", "r", ",", "s", ")", "return", "signature" ]

[ "Calculates", "an", "elliptic", "curve", "signature", "with", "a", "static", "length", "using", "pre", "-", "calculated", "hash", "." ]

[ "def", "generate_ecc_signing_key", "(", "algorithm", ")", ":", "try", ":", "verify_interface", "(", "ec", ".", "EllipticCurve", ",", "algorithm", ".", "signing_algorithm_info", ")", "return", "ec", ".", "generate_private_key", "(", "curve", "=", "algorithm", ".", "signing_algorithm_info", "(", ")", ",", "backend", "=", "default_backend", "(", ")", ")", "except", "InterfaceNotImplemented", ":", "raise", "NotSupportedError", "(", "\"Unsupported signing algorithm info\"", ")" ]

[ "Returns", "an", "ECC", "signing", "key", "." ]

[ "def", "derive_data_encryption_key", "(", "source_key", ",", "algorithm", ",", "message_id", ")", ":", "key", "=", "source_key", "if", "algorithm", ".", "kdf_type", "is", "not", "None", ":", "key", "=", "algorithm", ".", "kdf_type", "(", "algorithm", "=", "algorithm", ".", "kdf_hash_type", "(", ")", ",", "length", "=", "algorithm", ".", "data_key_len", ",", "salt", "=", "None", ",", "info", "=", "struct", ".", "pack", "(", "\">H16s\"", ",", "algorithm", ".", "algorithm_id", ",", "message_id", ")", ",", "backend", "=", "default_backend", "(", ")", ",", ")", ".", "derive", "(", "source_key", ")", "return", "key" ]

[ "Derives", "the", "data", "encryption", "key", "using", "the", "defined", "algorithm", "." ]

[ "def", "encrypt", "(", "*", "*", "kwargs", ")", ":", "with", "StreamEncryptor", "(", "*", "*", "kwargs", ")", "as", "encryptor", ":", "ciphertext", "=", "encryptor", ".", "read", "(", ")", "return", "ciphertext", ",", "encryptor", ".", "header" ]

[ "Encrypts", "and", "serializes", "provided", "plaintext", "." ]

[ "def", "decrypt", "(", "*", "*", "kwargs", ")", ":", "with", "StreamDecryptor", "(", "*", "*", "kwargs", ")", "as", "decryptor", ":", "plaintext", "=", "decryptor", ".", "read", "(", ")", "return", "plaintext", ",", "decryptor", ".", "header" ]

[ "Deserializes", "and", "decrypts", "provided", "ciphertext", "." ]

[ "def", "cycle_file", "(", "key_arn", ",", "source_plaintext_filename", ",", "botocore_session", "=", "None", ")", ":", "# \"Cycled\" means encrypted and then decrypted", "ciphertext_filename", "=", "source_plaintext_filename", "+", "\".encrypted\"", "cycled_kms_plaintext_filename", "=", "source_plaintext_filename", "+", "\".kms.decrypted\"", "cycled_static_plaintext_filename", "=", "source_plaintext_filename", "+", "\".static.decrypted\"", "# Create a KMS master key provider", "kms_kwargs", "=", "dict", "(", "key_ids", "=", "[", "key_arn", "]", ")", "if", "botocore_session", "is", "not", "None", ":", "kms_kwargs", "[", "\"botocore_session\"", "]", "=", "botocore_session", "kms_master_key_provider", "=", "aws_encryption_sdk", ".", "KMSMasterKeyProvider", "(", "*", "*", "kms_kwargs", ")", "# Create a static master key provider and add a master key to it", "static_key_id", "=", "os", ".", "urandom", "(", "8", ")", "static_master_key_provider", "=", "StaticRandomMasterKeyProvider", "(", ")", "static_master_key_provider", ".", "add_master_key", "(", "static_key_id", ")", "# Add the static master key provider to the KMS master key provider", "# The resulting master key provider uses KMS master keys to generate (and encrypt)", "# data keys and static master keys to create an additional encrypted copy of each data key.", "kms_master_key_provider", ".", "add_master_key_provider", "(", "static_master_key_provider", ")", "# Encrypt plaintext with both KMS and static master keys", "with", "open", "(", "source_plaintext_filename", ",", "\"rb\"", ")", "as", "plaintext", ",", "open", "(", "ciphertext_filename", ",", "\"wb\"", ")", "as", "ciphertext", ":", "with", "aws_encryption_sdk", ".", "stream", "(", "source", "=", "plaintext", ",", "mode", "=", "\"e\"", ",", "key_provider", "=", "kms_master_key_provider", ")", "as", "encryptor", ":", "for", "chunk", "in", "encryptor", ":", "ciphertext", ".", "write", "(", "chunk", ")", "# Decrypt the ciphertext with only the KMS master key", "with", "open", "(", "ciphertext_filename", ",", "\"rb\"", ")", "as", "ciphertext", ",", "open", "(", "cycled_kms_plaintext_filename", ",", "\"wb\"", ")", "as", "plaintext", ":", "with", "aws_encryption_sdk", ".", "stream", "(", "source", "=", "ciphertext", ",", "mode", "=", "\"d\"", ",", "key_provider", "=", "aws_encryption_sdk", ".", "KMSMasterKeyProvider", "(", "*", "*", "kms_kwargs", ")", ")", "as", "kms_decryptor", ":", "for", "chunk", "in", "kms_decryptor", ":", "plaintext", ".", "write", "(", "chunk", ")", "# Decrypt the ciphertext with only the static master key", "with", "open", "(", "ciphertext_filename", ",", "\"rb\"", ")", "as", "ciphertext", ",", "open", "(", "cycled_static_plaintext_filename", ",", "\"wb\"", ")", "as", "plaintext", ":", "with", "aws_encryption_sdk", ".", "stream", "(", "source", "=", "ciphertext", ",", "mode", "=", "\"d\"", ",", "key_provider", "=", "static_master_key_provider", ")", "as", "static_decryptor", ":", "for", "chunk", "in", "static_decryptor", ":", "plaintext", ".", "write", "(", "chunk", ")", "# Verify that the \"cycled\" (encrypted, then decrypted) plaintext is identical to the source plaintext", "assert", "filecmp", ".", "cmp", "(", "source_plaintext_filename", ",", "cycled_kms_plaintext_filename", ")", "assert", "filecmp", ".", "cmp", "(", "source_plaintext_filename", ",", "cycled_static_plaintext_filename", ")", "# Verify that the encryption context in the decrypt operation includes all key pairs from the", "# encrypt operation.", "#", "# In production, always use a meaningful encryption context. In this sample, we omit the", "# encryption context (no key pairs).", "assert", "all", "(", "pair", "in", "kms_decryptor", ".", "header", ".", "encryption_context", ".", "items", "(", ")", "for", "pair", "in", "encryptor", ".", "header", ".", "encryption_context", ".", "items", "(", ")", ")", "assert", "all", "(", "pair", "in", "static_decryptor", ".", "header", ".", "encryption_context", ".", "items", "(", ")", "for", "pair", "in", "encryptor", ".", "header", ".", "encryption_context", ".", "items", "(", ")", ")", "return", "ciphertext_filename", ",", "cycled_kms_plaintext_filename", ",", "cycled_static_plaintext_filename" ]

[ "Encrypts", "and", "then", "decrypts", "a", "file", "using", "a", "KMS", "master", "key", "provider", "and", "a", "custom", "static", "master", "key", "provider", ".", "Both", "master", "key", "providers", "are", "used", "to", "encrypt", "the", "plaintext", "file", "so", "either", "one", "alone", "can", "decrypt", "it", "." ]

[ "def", "_get_raw_key", "(", "self", ",", "key_id", ")", ":", "try", ":", "static_key", "=", "self", ".", "_static_keys", "[", "key_id", "]", "except", "KeyError", ":", "private_key", "=", "rsa", ".", "generate_private_key", "(", "public_exponent", "=", "65537", ",", "key_size", "=", "4096", ",", "backend", "=", "default_backend", "(", ")", ")", "static_key", "=", "private_key", ".", "private_bytes", "(", "encoding", "=", "serialization", ".", "Encoding", ".", "PEM", ",", "format", "=", "serialization", ".", "PrivateFormat", ".", "PKCS8", ",", "encryption_algorithm", "=", "serialization", ".", "NoEncryption", "(", ")", ",", ")", "self", ".", "_static_keys", "[", "key_id", "]", "=", "static_key", "return", "WrappingKey", "(", "wrapping_algorithm", "=", "WrappingAlgorithm", ".", "RSA_OAEP_SHA1_MGF1", ",", "wrapping_key", "=", "static_key", ",", "wrapping_key_type", "=", "EncryptionKeyType", ".", "PRIVATE", ",", ")" ]

[ "Retrieves", "a", "static", "randomly", "generated", "RSA", "key", "for", "the", "specified", "key", "id", "." ]

[ "def", "month_boundaries", "(", "dt", "=", "None", ")", ":", "dt", "=", "dt", "or", "date", ".", "today", "(", ")", "wkday", ",", "ndays", "=", "calendar", ".", "monthrange", "(", "dt", ".", "year", ",", "dt", ".", "month", ")", "start", "=", "datetime", "(", "dt", ".", "year", ",", "dt", ".", "month", ",", "1", ")", "return", "(", "start", ",", "start", "+", "timedelta", "(", "ndays", "-", "1", ")", ")" ]

[ "Return", "a", "2", "-", "tuple", "containing", "the", "datetime", "instances", "for", "the", "first", "and", "last", "dates", "of", "the", "current", "month", "or", "using", "dt", "as", "a", "reference", "." ]

[ "def", "css_class_cycler", "(", ")", ":", "FMT", "=", "'evt-{0}-{1}'", ".", "format", "return", "defaultdict", "(", "default_css_class_cycler", ",", "(", "(", "e", ".", "abbr", ",", "itertools", ".", "cycle", "(", "(", "FMT", "(", "e", ".", "abbr", ",", "'even'", ")", ",", "FMT", "(", "e", ".", "abbr", ",", "'odd'", ")", ")", ")", ")", "for", "e", "in", "EventType", ".", "objects", ".", "all", "(", ")", ")", ")" ]

[ "Return", "a", "dictionary", "keyed", "by", "EventType", "abbreviations", "whose", "values", "are", "an", "iterable", "or", "cycle", "of", "CSS", "class", "names", "." ]

[ "def", "create_event", "(", "title", ",", "event_type", ",", "description", "=", "''", ",", "start_time", "=", "None", ",", "end_time", "=", "None", ",", "note", "=", "None", ",", "*", "*", "rrule_params", ")", ":", "if", "isinstance", "(", "event_type", ",", "tuple", ")", ":", "event_type", ",", "created", "=", "EventType", ".", "objects", ".", "get_or_create", "(", "abbr", "=", "event_type", "[", "0", "]", ",", "label", "=", "event_type", "[", "1", "]", ")", "event", "=", "Event", ".", "objects", ".", "create", "(", "title", "=", "title", ",", "description", "=", "description", ",", "event_type", "=", "event_type", ")", "if", "note", "is", "not", "None", ":", "event", ".", "notes", ".", "create", "(", "note", "=", "note", ")", "start_time", "=", "start_time", "or", "datetime", ".", "now", "(", ")", ".", "replace", "(", "minute", "=", "0", ",", "second", "=", "0", ",", "microsecond", "=", "0", ")", "end_time", "=", "end_time", "or", "(", "start_time", "+", "swingtime_settings", ".", "DEFAULT_OCCURRENCE_DURATION", ")", "event", ".", "add_occurrences", "(", "start_time", ",", "end_time", ",", "*", "*", "rrule_params", ")", "return", "event" ]

[ "Convenience", "function", "to", "create", "an", "Event", "optionally", "create", "an", "EventType", "and", "associated", "Occurrence", "s", ".", "Occurrence", "creation", "rules", "match", "those", "for", "Event", ".", "add_occurrences", "." ]

[ "def", "add_occurrences", "(", "self", ",", "start_time", ",", "end_time", ",", "*", "*", "rrule_params", ")", ":", "count", "=", "rrule_params", ".", "get", "(", "'count'", ")", "until", "=", "rrule_params", ".", "get", "(", "'until'", ")", "if", "not", "(", "count", "or", "until", ")", ":", "self", ".", "occurrence_set", ".", "create", "(", "start_time", "=", "start_time", ",", "end_time", "=", "end_time", ")", "else", ":", "rrule_params", ".", "setdefault", "(", "'freq'", ",", "rrule", ".", "DAILY", ")", "delta", "=", "end_time", "-", "start_time", "occurrences", "=", "[", "]", "for", "ev", "in", "rrule", ".", "rrule", "(", "dtstart", "=", "start_time", ",", "*", "*", "rrule_params", ")", ":", "occurrences", ".", "append", "(", "Occurrence", "(", "start_time", "=", "ev", ",", "end_time", "=", "ev", "+", "delta", ",", "event", "=", "self", ")", ")", "self", ".", "occurrence_set", ".", "bulk_create", "(", "occurrences", ")" ]

[ "Add", "one", "or", "more", "occurences", "to", "the", "event", "using", "a", "comparable", "API", "to", "dateutil", ".", "rrule", "." ]

[ "def", "daily_occurrences", "(", "self", ",", "dt", "=", "None", ")", ":", "return", "Occurrence", ".", "objects", ".", "daily_occurrences", "(", "dt", "=", "dt", ",", "event", "=", "self", ")" ]

[ "Convenience", "method", "wrapping", "Occurrence", ".", "objects", ".", "daily_occurrences", "." ]

[ "def", "daily_occurrences", "(", "self", ",", "dt", "=", "None", ",", "event", "=", "None", ")", ":", "dt", "=", "dt", "or", "datetime", ".", "now", "(", ")", "start", "=", "datetime", "(", "dt", ".", "year", ",", "dt", ".", "month", ",", "dt", ".", "day", ")", "end", "=", "start", ".", "replace", "(", "hour", "=", "23", ",", "minute", "=", "59", ",", "second", "=", "59", ")", "qs", "=", "self", ".", "filter", "(", "models", ".", "Q", "(", "start_time__gte", "=", "start", ",", "start_time__lte", "=", "end", ",", ")", "|", "models", ".", "Q", "(", "end_time__gte", "=", "start", ",", "end_time__lte", "=", "end", ",", ")", "|", "models", ".", "Q", "(", "start_time__lt", "=", "start", ",", "end_time__gt", "=", "end", ")", ")", "return", "qs", ".", "filter", "(", "event", "=", "event", ")", "if", "event", "else", "qs" ]

[ "Returns", "a", "queryset", "of", "for", "instances", "that", "have", "any", "overlap", "with", "a", "particular", "day", "." ]

[ "def", "event_listing", "(", "request", ",", "template", "=", "'swingtime/event_list.html'", ",", "events", "=", "None", ",", "*", "*", "extra_context", ")", ":", "events", "=", "events", "or", "Event", ".", "objects", ".", "all", "(", ")", "extra_context", "[", "'events'", "]", "=", "events", "return", "render", "(", "request", ",", "template", ",", "extra_context", ")" ]

[ "View", "all", "events", "." ]