def __registry_value_dict_from_object(cls, registry_value_obj):
registry_value_dict = {}
if registry_value_obj.get_Name() is not None: registry_value_dict['name'] = Base_Object_Attribute.dict_from_object(registry_value_obj.get_Name())
if registry_value_obj.get_Data() is not None: registry_value_dict['data'] = Base_Object_Attribute.dict_from_object(registry_value_obj.get_Data())
if registry_value_obj.get_Datatype() is not None: registry_value_dict['datatype'] = Base_Object_Attribute.dict_from_object(registry_value_obj.get_Datatype())
if registry_value_obj.get_Byte_Runs() is not None: registry_value_dict['byte_runs'] = ByteRuns.dict_from_object(registry_value_obj.get_Byte_Runs())
return registry_value_dict
def dict_from_object(cls, defined_object):
"""Parse and return a dictionary for a Network Connection Object object"""
defined_object_dict = {}
if defined_object.get_tls_used() is not None:
defined_object_dict["tls_used"] = {"value": defined_object.get_tls_used()}
if defined_object.get_Layer3_Protocol() is not None:
defined_object_dict["layer3_protocol"] = Base_Object_Attribute.dict_from_object(
defined_object.get_Layer3_Protocol()
)
if defined_object.get_Layer4_Protocol() is not None:
defined_object_dict["layer4_protocol"] = Base_Object_Attribute.dict_from_object(
defined_object.get_Layer4_Protocol()
)
if defined_object.get_Layer7_Protocol() is not None:
defined_object_dict["layer7_protocol"] = Base_Object_Attribute.dict_from_object(
defined_object.get_Layer7_Protocol()
)
if defined_object.get_Local_IP_Address() is not None:
defined_object_dict["local_ip_address"] = Address.dict_from_object(defined_object.get_Local_IP_Address())
if defined_object.get_Local_Port() is not None:
defined_object_dict["local_port"] = Port.dict_from_object(defined_object.get_Local_Port())
if defined_object.get_Remote_IP_Address() is not None:
defined_object_dict["remote_ip_address"] = Address.dict_from_object(defined_object.get_Remote_IP_Address())
if defined_object.get_Remote_Port() is not None:
defined_object_dict["remote_port"] = Port.dict_from_object(defined_object.get_Remote_Port())
if defined_object.get_Layer7_Connections() is not None:
layer7_conn = defined_object.get_Layer7_Connections()
layer7_conn_dict = {}
if layer7_conn.get_HTTP_Session() is not None:
layer7_conn_dict["http_session"] = HTTP_Session.dict_from_object(layer7_conn.get_HTTP_Session())
defined_object_dict["layer7_connections"] = layer7_conn_dict
return defined_object_dict
def dict_from_object(cls, win_event_obj):
"""Parse and return a dictionary for a Win Event Object object"""
win_event_dict = {}
if win_event_obj.get_Name() is not None: win_mutex_dict['name'] = Base_Object_Attribute.dict_from_object(win_event_obj.get_Name())
if win_event_obj.get_Handle() is not None: win_mutex_dict['handle'] = Win_Handle.dict_from_object(win_mutex_obj.get_Handle())
if win_event_obj.get_Type() is not None: win_mutex_dict['type'] = Base_Object_Attribute.dict_from_object(win_event_obj.get_Type())
return win_event_dict
def dict_from_object(cls, port_obj):
"""Parse and return a dictionary for an Port Object object"""
port_dict = {}
if port_obj.get_Port_Value() is not None:
port_dict['port_value'] = Base_Object_Attribute.dict_from_object(port_obj.get_Port_Value())
if port_obj.get_Layer4_Protocol() is not None:
port_dict['layer4_protocol'] = Base_Object_Attribute.dict_from_object(port_obj.get_Layer4_Protocol())
return port_dict
def dict_from_object(cls, object):
"""Parse and return a dictionary for a Library Object object"""
object_dictionary = {}
if object.get_Name() is not None: object_dictionary['name'] = Base_Object_Attribute.dict_from_object(object.get_Name())
if object.get_Path() is not None: object_dictionary['path'] = Base_Object_Attribute.dict_from_object(object.get_Path())
if object.get_Size() is not None: object_dictionary['size'] = Base_Object_Attribute.dict_from_object(object.get_Size())
if object.get_Type() is not None: object_dictionary['type'] = Base_Object_Attribute.dict_from_object(object.get_Type())
if object.get_Version() is not None: object_dictionary['version'] = Base_Object_Attribute.dict_from_object(object.get_Version())
if object.get_Base_Address() is not None: object_dictionary['base_address'] = Base_Object_Attribute.dict_from_object(object.get_Base_Address())
return object_dictionary
def dict_from_object(cls, byterun_obj):
"""Parse and return a dictionary for a ByteRun object"""
byterun_dict = {}
if byterun_obj.get_Offset() is not None: byterun_dict['offset'] = Base_Object_Attribute.dict_from_object(byterun_obj.get_Offset())
if byterun_obj.get_File_System_Offset() is not None: byterun_dict['file_system_offset'] = Base_Object_Attribute.dict_from_object(byterun_obj.get_File_System_Offset())
if byterun_obj.get_Image_Offset() is not None: byterun_dict['image_offset'] = Base_Object_Attribute.dict_from_object(byterun_obj.get_Image_Offset())
if byterun_obj.get_Length() is not None: byterun_dict['length'] = Base_Object_Attribute.dict_from_object(byterun_obj.get_Length())
if byterun_obj.get_Hashes() is not None: byterun_dict['hashes'] = HashList.dict_from_object(byterun_obj.get_Hashes())
if byterun_obj.get_Byte_Run_Data() is not None: byterun_dict['byte_run_data'] = {'value' : byterun_obj.get_Byte_Run_Data()}
return byterun_dict
def dict_from_object(cls, win_pipe_obj):
"""Parse and return a dictionary for a Win Pipe Object object"""
win_pipe_dict = Pipe.dict_from_object(win_pipe_obj)
if win_pipe_obj.get_Default_Time_Out() is not None: win_pipe_dict['default_time_out'] = Base_Object_Attribute.dict_from_object(win_pipe_obj.get_Default_Time_Out())
if win_pipe_obj.get_Handle() is not None: win_pipe_dict['handle'] = Win_Handle.dict_from_object(win_pipe_obj.get_Handle())
if win_pipe_obj.get_In_Buffer_Size() is not None: win_pipe_dict['in_buffer_size'] = Base_Object_Attribute.dict_from_object(win_pipe_obj.get_In_Buffer_Size())
if win_pipe_obj.get_Max_Instances() is not None: win_pipe_dict['max_instances'] = Base_Object_Attribute.dict_from_object(win_pipe_obj.get_Max_Instances())
if win_pipe_obj.get_Open_Mode() is not None: win_pipe_dict['open_mode'] = Base_Object_Attribute.dict_from_object(win_pipe_obj.get_Open_Mode())
if win_pipe_obj.get_Out_Buffer_Size() is not None: win_pipe_dict['out_buffer_size'] = Base_Object_Attribute.dict_from_object(win_pipe_obj.get_Out_Buffer_Size())
if win_pipe_obj.get_Pipe_Mode() is not None: win_pipe_dict['pipe_mode'] = Base_Object_Attribute.dict_from_object(win_pipe_obj.get_Pipe_Mode())
if win_pipe_obj.get_Security_Attributes() is not None: win_pipe_dict['security_attributes'] = Base_Object_Attribute.dict_from_object(win_pipe_obj.get_Security_Attributes())
return win_pipe_dict
def dict_from_object(cls, process_obj):
process_dict = {}
if process_obj.get_is_hidden() is not None: process_dict['is_hidden'] = {'value' : process_obj.get_is_hidden()}
if process_obj.get_PID() is not None: process_dict['pid'] = Base_Object_Attribute.dict_from_object(process_obj.get_PID())
if process_obj.get_Creation_Time() is not None: process_dict['creation_time'] = Base_Object_Attribute.dict_from_object(process_obj.get_Creation_Time())
if process_obj.get_Parent_PID() is not None: process_dict['parent_pid'] = Base_Object_Attribute.dict_from_object(process_obj.get_Parent_PID())
if process_obj.get_Child_PID_List() is not None:
child_pid_list = []
for child_pid in process_obj.get_Child_PID_List().get_Child_PID():
child_pid_list.append(Base_Object_Attribute.dict_from_object(child_pid))
process_dict['child_pid_list'] = child_pid_list
if process_obj.get_Image_Info() is not None:
image_info = process_obj.get_Image_Info()
image_info_dict = {}
if image_info.get_File_Name() is not None: image_info_dict['file_name'] = Base_Object_Attribute.dict_from_object(image_info.get_File_Name())
if image_info.get_Command_Line() is not None: image_info_dict['command_line'] = Base_Object_Attribute.dict_from_object(image_info.get_Command_Line())
if image_info.get_Current_Directory() is not None: image_info_dict['current_directory'] = Base_Object_Attribute.dict_from_object(image_info.get_Current_Directory())
if image_info.get_Path() is not None: image_info_dict['path'] = Base_Object_Attribute.dict_from_object(image_info.get_Path())
process_dict['image_info'] = image_info_dict
if process_obj.get_Argument_List() is not None:
argument_list = []
for argument in process_obj.get_Argument_List().get_Argument():
argument_list.append(Base_Object_Attribute.dict_from_object(argument))
process_dict['argument_list'] = argument_list
if process_obj.get_Environment_Variable_List() is not None: process_dict['Environment_Variable_List'] = Environment_Variable_List.dict_from_object(process_obj.get_Environment_Variable_List())
if process_obj.get_Kernel_Time() is not None: process_dict['kernel_time'] = Base_Object_Attribute.dict_from_object(image_info.get_Kernel_Time())
if process_obj.get_Port_List() is not None:
port_list = []
for port in process_obj.get_Port_List().get_Port():
port_list.append(port.dict_from_object(port))
process_dict['port_list'] = port_list
if process_obj.get_Network_Connection_List() is not None:
network_connection_list = []
for network_connection in process_obj.get_Network_Connection_List().get_Network_Connection():
network_connection_dict = {}
if network_connection.get_Creation_Time() is not None: network_connection_dict['creation_time'] = Base_Object_Attribute.dict_from_object(network_connection.get_Creation_Time())
if network_connection.get_Destination_IP_Address() is not None: network_connection_dict['destination_ip_Address'] = Address.dict_from_object(network_connection.get_Destination_IP_Address())
if network_connection.get_Destination_Port() is not None: network_connection_dict['destination_port'] = port.dict_from_object(network_connection.get_Destination_Port())
if network_connection.get_Source_IP_Address() is not None: network_connection_dict['source_ip_Address'] = Address.dict_from_object(network_connection.get_Source_IP_Address())
if network_connection.get_Destination_Port() is not None: network_connection_dict['source_port'] = port.dict_from_object(network_connection.get_Source_Port())
if network_connection.get_TCP_State() is not None: network_connection_dict['tcp_state'] = Base_Object_Attribute.dict_from_object(network_connection.get_TCP_State())
network_connection_list.append(network_connection_dict)
process_dict['network_connection_list'] = network_connection_list
if process_obj.get_Start_Time() is not None: process_dict['start_time'] = Base_Object_Attribute.dict_from_object(process_obj.get_Start_Time())
if process_obj.get_Status() is not None: process_dict['status'] = Base_Object_Attribute.dict_from_object(process_obj.get_Status())
if process_obj.get_String_List() is not None: process_dict['Extracted_String_List'] = Extracted_String_List.dict_from_object(process_obj.get_String_List())
if process_obj.get_Username() is not None: process_dict['username'] = Base_Object_Attribute.dict_from_object(process_obj.get_Username())
if process_obj.get_User_Time() is not None: process_dict['user_time'] = Base_Object_Attribute.dict_from_object(process_obj.get_User_Time())
return process_dict
def dict_from_object(cls, win_thread_obj):
"""Parse and return a dictionary for a Windows Thread Object object"""
win_thread_dict = {}
if win_thread_obj.get_Thread_ID() is not None: win_thread_dict['thread_id'] = Base_Object_Attribute.dict_from_object(win_thread_obj.get_Thread_ID())
if win_thread_obj.get_Handle() is not None: win_thread_dict['handle'] = Win_Handle.dict_from_object(win_thread_obj.get_Handle())
if win_thread_obj.get_Running_Status() is not None: win_thread_dict['running_status'] = Base_Object_Attribute.dict_from_object(win_thread_obj.get_Running_Status())
if win_thread_obj.get_Context() is not None: win_thread_dict['context'] = Base_Object_Attribute.dict_from_object(win_thread_obj.get_Context())
if win_thread_obj.get_Priority() is not None: win_thread_dict['priority'] = Base_Object_Attribute.dict_from_object(win_thread_obj.get_Priority())
if win_thread_obj.get_Creation_Flags() is not None: win_thread_dict['creation_flags'] = Base_Object_Attribute.dict_from_object(win_thread_obj.get_Creation_Flags())
if win_thread_obj.get_Creation_Time() is not None: win_thread_dict['creation_time'] = Base_Object_Attribute.dict_from_object(win_thread_obj.get_Creation_Time())
if win_thread_obj.get_Start_Address() is not None: win_thread_dict['start_address'] = Base_Object_Attribute.dict_from_object(win_thread_obj.get_Start_Address())
if win_thread_obj.get_Parameter_Address() is not None: win_thread_dict['parameter_address'] = Base_Object_Attribute.dict_from_object(win_thread_obj.get_Parameter_Address())
if win_thread_obj.get_Security_Attributes() is not None: win_thread_dict['security_attributes'] = Base_Object_Attribute.dict_from_object(win_thread_obj.get_Security_Attributes())
if win_thread_obj.get_Stack_Size() is not None: win_thread_dict['stack_size'] = Base_Object_Attribute.dict_from_object(win_thread_obj.get_Stack_Size())
return win_thread_dict
def dict_from_object(cls, mutex_obj):
"""Parse and return a dictionary for a Mutex Object object"""
mutex_dict = {}
if mutex_obj.get_Name() is not None: mutex_dict['name'] = Base_Object_Attribute.dict_from_object(mutex_obj.get_Name())
if mutex_obj.get_named() is not None: mutex_dict['named'] = mutex_obj.get_named()
return mutex_dict
def dict_from_object(cls, pipe_obj):
"""Parse and return a dictionary for a Pipe Object object"""
pipe_dict = {}
if pipe_obj.get_Name() is not None: pipe_dict['name'] = Base_Object_Attribute.dict_from_object(pipe_obj.get_Name())
if pipe_obj.get_named() is not None: pipe_dict['named'] = pipe_obj.get_named()
return pipe_dict
def __pe_attributes_dict_from_obj(cls, pe_attributes_obj):
pe_attributes_dict = {}
if pe_attributes_obj.get_Base_Address() is not None:
pe_attributes_dict["base_address"] = Base_Object_Attribute.dict_from_object(
pe_attributes_obj.get_Base_Address()
)
if pe_attributes_obj.get_Exports() is not None:
pe_attributes_dict["exports"] = cls.__exports_dict_from_obj(pe_attributes_obj.get_Exports())
return pe_attributes_dict
def dict_from_object(cls, win_executable_file_obj):
"""Parse and return a dictionary for a Win Executable File Object object"""
win_executable_file_dict = {}
if win_executable_file_obj.get_Peak_Code_Entropy() is not None:
entropy_obj = win_executable_file_obj.get_Peak_Code_Entropy()
entropy_dict = {}
if entropy_obj.get_Value() is not None:
entropy_dict["value"] = Base_Object_Attribute.dict_from_object(entropy_obj.get_Value())
if entropy_obj.get_Max() is not None:
entropy_dict["max"] = Base_Object_Attribute.dict_from_object(entropy_obj.get_Max())
if entropy_obj.get_Min() is not None:
entropy_dict["min"] = Base_Object_Attribute.dict_from_object(entropy_obj.get_Min())
win_executable_file_dict["peak_code_entropy"] = entropy_dict
if win_executable_file_obj.get_PE_Attributes() is not None:
win_executable_file_dict["pe_attributes"] = cls.__pe_attributes_dict_from_obj(
win_executable_file_obj.get_PE_Attributes()
)
return win_executable_file_dict
def dict_from_object(cls, win_mailslot_obj):
"""Parse and return a dictionary for a Win Mailslot Object object"""
win_mailslot_dict = {}
if win_mailslot_obj.get_Handle() is not None: win_mailslot_dict['handle'] = Win_Handle_List.list_from_object(win_mailslot_obj.get_Handle())
if win_mailslot_obj.get_Max_Message_Size() is not None: win_mailslot_dict['max_message_size'] = Base_Object_Attribute.dict_from_object(win_mailslot_obj.get_Max_Message_Size())
if win_mailslot_obj.get_Name() is not None: win_mailslot_dict['name'] = Base_Object_Attribute.dict_from_object(win_mailslot_obj.get_Name())
if win_mailslot_obj.get_Read_Timeout() is not None: win_mailslot_dict['read_timeout'] = Base_Object_Attribute.dict_from_object(win_mailslot_obj.get_Read_Timeout())
if win_mailslot_obj.get_Security_Attributes() is not None: win_mailslot_dict['security_attributes'] = Base_Object_Attribute.dict_from_object(win_mailslot_obj.get_Security_Attributes())
return win_mailslot_dict
def dict_from_object(cls, registry_key_obj):
"""Parse and return a dictionary for a Win Registry Key Object object"""
registry_key_dict = {}
if registry_key_obj.get_Key() is not None: registry_key_dict['key'] = Base_Object_Attribute.dict_from_object(registry_key_obj.get_Key())
if registry_key_obj.get_Hive() is not None: registry_key_dict['hive'] = Base_Object_Attribute.dict_from_object(registry_key_obj.get_Hive())
if registry_key_obj.get_Number_Values() is not None: registry_key_dict['number_values'] = Base_Object_Attribute.dict_from_object(registry_key_obj.get_Number_Values())
if registry_key_obj.get_Values() is not None: registry_key_dict['values'] = cls.__registry_value_dict_from_object(registry_key_obj.get_Values())
if registry_key_obj.get_Modified_Time() is not None: registry_key_dict['modified_time'] = Base_Object_Attribute.dict_from_object(registry_key_obj.get_Modified_Time())
if registry_key_obj.get_Creator_Username() is not None: registry_key_dict['creator_username'] = Base_Object_Attribute.dict_from_object(registry_key_obj.get_Creator_Username())
if registry_key_obj.get_Handle_List() is not None: registry_key_dict['handle_list'] = Win_Handle_List.dict_from_object(registry_key_obj.get_Handle_List())
if registry_key_obj.get_Number_Subkeys() is not None: registry_key_dict['number_subkeys'] = Base_Object_Attribute.dict_from_object(registry_key_obj.get_Number_Subkeys())
if registry_key_obj.get_Subkeys() is not None:
subkeys_list = []
for subkey_obj in registry_key_obj.get_Subkeys().get_Subkey():
subkey_dict = cls.dict_from_object(subkey_obj)
subkeys_list.append(subkey_dict)
registry_key_dict['subkeys'] = subkeys_list
if registry_key_obj.get_Byte_Runs() is not None: registry_key_dict['byte_runs'] = ByteRuns.dict_from_object(registry_key_obj.get_Byte_Runs())
return registry_key_dict
def dict_from_object(cls, defined_object):
"""Parse and return a dictionary for a Memory Object object"""
defined_object_dict = {}
if defined_object.get_is_injected() is not None: defined_object_dict['is_injected'] = {'value' : defined_object.get_is_injected()}
if defined_object.get_is_mapped() is not None: defined_object_dict['is_mapped'] = {'value' : defined_object.get_is_mapped()}
if defined_object.get_is_protected() is not None: defined_object_dict['is_protected'] = {'value' : defined_object.get_is_protected()}
if defined_object.get_Hashes() is not None: defined_object_dict['hashes'] = HashList.dict_from_object(defined_object.get_Hashes())
if defined_object.get_Name() is not None: defined_object_dict['name'] = Base_Object_Attribute.dict_from_object(defined_object.get_Name())
if defined_object.get_Region_Size() is not None: defined_object_dict['region_size'] = Base_Object_Attribute.dict_from_object(defined_object.get_Region_Size())
if defined_object.get_Region_Start_Address() is not None: defined_object_dict['region_start_address'] = Base_Object_Attribute.dict_from_object(defined_object.get_Region_Start_Address())
return defined_object_dict
def dict_from_object(cls, stream_obj):
"""Parse and return a dictionary for a Stream Object object"""
stream_dict = {}
if stream_obj.get_Hash() is not None:
Hashes = []
for Hash_obj in stream_obj.get_Hash():
Hashes.append(Hash.dict_from_object(Hash_obj))
stream_dict['Hashes'] = Hashes
if stream_obj.get_Name() is not None: stream_dict['name'] = Base_Object_Attribute.dict_from_object(stream_obj.get_Name())
if stream_obj.get_Size_In_Bytes() is not None: stream_dict['size_in_bytes'] = Base_Object_Attribute.dict_from_object(stream_obj.get_Size_In_Bytes())
return stream_dict
def __exports_dict_from_obj(cls, exports_obj):
exports_dict = {}
if exports_obj.get_Exported_Functions() is not None:
exported_functions = []
for exported_function_obj in exports_obj.get_Exported_Functions().get_Exported_Function():
exported_function_dict = {}
if exported_function_obj.get_Function_Name() is not None:
exported_function_dict["function_name"] = Base_Object_Attribute.dict_from_object(
exported_function_obj.get_Function_Name()
)
if exported_function_obj.get_Entry_Point() is not None:
exported_function_dict["entry_point"] = Base_Object_Attribute.dict_from_object(
exported_function_obj.get_Entry_Point()
)
if exported_function_obj.get_Ordinal() is not None:
exported_function_dict["ordinal"] = Base_Object_Attribute.dict_from_object(
exported_function_obj.get_Ordinal()
)
exported_functions.append(exported_function_dict)
exports_dict["exported_functions"] = exported_functions
if exports_obj.get_Exports_Time_Stamp() is not None:
exports_dict["exports_time_stamp"] = Base_Object_Attribute.dict_from_object(
exports_obj.get_Exports_Time_Stamp()
)
if exports_obj.get_Number_Of_Addresses() is not None:
exports_dict["number_of_addresses"] = Base_Object_Attribute.dict_from_object(
exports_obj.get_Number_Of_Addresses()
)
if exports_obj.get_Number_Of_Names() is not None:
exports_dict["number_of_names"] = Base_Object_Attribute.dict_from_object(exports_obj.get_Number_Of_Names())
return exports_dict
def dict_from_object(cls, socket_obj):
"""Parse and return a dictionary for a Socket Object object"""
socket_dict = {}
if socket_obj.get_is_blocking() is not None: socket_dict['is_blocking'] = {'value' : socket_obj.get_is_blocking()}
if socket_obj.get_is_listening() is not None: socket_dict['is_listening'] = {'value' : socket_obj.get_is_listening()}
if socket_obj.get_Address_Family() is not None: socket_dict['address_family'] = Base_Object_Attribute.dict_from_object(socket_obj.get_Address_Family())
if socket_obj.get_Domain() is not None: socket_dict['domain'] = Base_Object_Attribute.dict_from_object(socket_obj.get_Domain())
if socket_obj.get_Local_Address() is not None:
local_address_dict = {}
if socket_obj.get_Local_Address().get_IP_Address() is not None:
local_address_dict['ip_address'] = Address.dict_from_object(socket_obj.get_Local_Address().get_IP_Address())
if socket_obj.get_Local_Address().get_Port() is not None:
local_address_dict['port'] = Port.dict_from_object(socket_obj.get_Local_Address().get_Port())
if socket_obj.get_Options() is not None: socket_dict['options'] = cls.__socket_options_dict_from_object(socket_obj.get_Options())
if socket_obj.get_Protocol() is not None: Base_Object_Attribute.dict_from_object(socket_obj.get_Protocol())
if socket_obj.get_Remote_Address() is not None:
remote_address_dict = {}
if socket_obj.get_Remote_Address().get_IP_Address() is not None:
remote_address_dict['ip_address'] = Address.dict_from_object(socket_obj.get_Local_Address().get_IP_Address())
if socket_obj.get_Remote_Address().get_Port() is not None:
remote_address_dict['port'] = Port.dict_from_object(socket_obj.get_Local_Address().get_Port())
if socket_obj.get_Type() is not None: Base_Object_Attribute.dict_from_object(socket_obj.get_Type())
return socket_dict
def dict_from_object(cls, win_file_obj):
"""Parse and return a dictionary for a Win File Object object"""
win_file_dict = File.dict_from_object(win_file_obj)
if win_file_obj.get_Filename_Accessed_Time() is not None: win_file_dict['filename_accessed_time'] = Base_Object_Attribute.dict_from_object(win_file_obj.get_Filename_Accessed_Time())
if win_file_obj.get_Filename_Created_Time() is not None: win_file_dict['filename_created_time'] = Base_Object_Attribute.dict_from_object(win_file_obj.get_Filename_Created_Time())
if win_file_obj.get_Filename_Modified_Time() is not None: win_file_dict['filename_modified_time'] = Base_Object_Attribute.dict_from_object(win_file_obj.get_Filename_Modified_Time())
if win_file_obj.get_Drive() is not None: win_file_dict['drive'] = Base_Object_Attribute.dict_from_object(win_file_obj.get_Drive())
if win_file_obj.get_Security_ID() is not None: win_file_dict['security_id'] = Base_Object_Attribute.dict_from_object(win_file_obj.get_Security_ID())
if win_file_obj.get_Security_Type() is not None: win_file_dict['security_type'] = Base_Object_Attribute.dict_from_object(win_file_obj.get_Security_Type())
if win_file_obj.get_Stream_List() is not None:
stream_list = []
for stream_obj in win_file_obj.get_Stream_List().get_Stream():
stream_list.append(Stream.dict_from_object(stream_obj))
win_file_dict['stream_list'] = stream_list
return win_file_dict
def dict_from_object(cls, win_handle_obj):
"""Parse and return a dictionary for a Win Handle Object object"""
win_handle_dict = {}
if win_handle_obj.get_ID() is not None:
win_handle_dict["id"] = Base_Object_Attribute.dict_from_object(win_handle_obj.get_ID())
if win_handle_obj.get_Type() is not None:
win_handle_dict["type"] = Base_Object_Attribute.dict_from_object(win_handle_obj.get_Type())
if win_handle_obj.get_Name() is not None:
win_handle_dict["name"] = Base_Object_Attribute.dict_from_object(win_handle_obj.get_Name())
if win_handle_obj.get_Object_Address() is not None:
win_handle_dict["object_address"] = Base_Object_Attribute.dict_from_object(win_handle_obj.get_Object_Address())
if win_handle_obj.get_Access_Mask() is not None:
win_handle_dict["access_mask"] = Base_Object_Attribute.dict_from_object(win_handle_obj.get_Access_Mask())
if win_handle_obj.get_Pointer_Count() is not None:
win_handle_dict["type"] = Base_Object_Attribute.dict_from_object(win_handle_obj.get_Pointer_Count())
return win_handle_dict
def __parse_http_server_response(cls, http_server_response):
http_server_response_dict = {}
if http_server_response.get_HTTP_Status_Line() is not None:
server_status_line = http_server_response.get_HTTP_Status_Line()
server_status_line_dict = {}
if server_status_line_dict.get_Version() is not None:
server_status_line_dict['version'] = Base_Object_Attribute.dict_from_object(server_status_line.get_Version())
if server_status_line_dict.get_Status_Code() is not None:
server_status_line_dict['status_code'] = Base_Object_Attribute.dict_from_object(server_status_line.get_Status_Code())
if server_status_line_dict.get_Reason_Phrase() is not None:
server_status_line_dict['reason_phrase'] = Base_Object_Attribute.dict_from_object(server_status_line.get_Reason_Phrase())
http_server_response_dict['http_status_line'] = server_status_line_dict
if http_server_response.get_HTTP_Response_Header() is not None:
response_header = http_server_response.get_HTTP_Response_Header()
response_header_dict = {}
if response_header.get_Raw_Header() is not None:
response_header_dict['raw_header'] = response_header.get_Raw_Header()
if response_header.get_Parsed_Header() is not None:
parsed_header = response_header.get_Parsed_Header()
parsed_header_dict = {}
if parsed_header.get_Access_Control_Allow_Origin() is not None: parsed_header_dict['access-control-allow-origin'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Access_Control_Allow_Origin())
if parsed_header.get_Accept_Ranges() is not None: parsed_header_dict['accept-ranges'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Accept_Ranges())
if parsed_header.get_Age() is not None: parsed_header_dict['age'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Age())
if parsed_header.get_Cache_Control() is not None: parsed_header_dict['cache-control'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Cache_Control())
if parsed_header.get_Connection() is not None: parsed_header_dict['connection'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Connection())
if parsed_header.get_Content_Encoding() is not None: parsed_header_dict['content-encoding'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Content_Encoding())
if parsed_header.get_Content_Language() is not None: parsed_header_dict['content-language'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Content_Language())
if parsed_header.get_Content_Length() is not None: parsed_header_dict['content-length'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Content_Length())
if parsed_header.get_Content_Location() is not None: parsed_header_dict['content-location'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Content_Location())
if parsed_header.get_Content_MD5() is not None: parsed_header_dict['content-md5'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Content_MD5())
if parsed_header.get_Content_Disposition() is not None: parsed_header_dict['content-disposition'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Content_Disposition())
if parsed_header.get_Content_Range() is not None: parsed_header_dict['content-range'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Content_Range())
if parsed_header.get_Content_Type() is not None: parsed_header_dict['content-type'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Content_Type())
if parsed_header.get_Date() is not None: parsed_header_dict['date'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Date())
if parsed_header.get_ETag() is not None: parsed_header_dict['etag'] = Base_Object_Attribute.dict_from_object(parsed_header.get_ETag())
if parsed_header.get_Expires() is not None: parsed_header_dict['expires'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Expires())
if parsed_header.get_Last_Modified() is not None: parsed_header_dict['last-modified'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Last_Modified())
if parsed_header.get_Link() is not None: parsed_header_dict['link'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Link())
if parsed_header.get_Location() is not None: parsed_header_dict['location'] = URI.object_from_dict(parsed_header.get_Location())
if parsed_header.get_P3P() is not None: parsed_header_dict['p3p'] = Base_Object_Attribute.dict_from_object(parsed_header.get_P3P())
if parsed_header.get_Pragma() is not None: parsed_header_dict['pragma'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Pragma())
if parsed_header.get_Proxy_Authenticate() is not None: parsed_header_dict['proxy-authenticate'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Proxy_Authenticate())
if parsed_header.get_Refresh() is not None: parsed_header_dict['refresh'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Refresh())
if parsed_header.get_Retry_After() is not None: parsed_header_dict['retry-after'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Retry_After())
if parsed_header.get_Server() is not None: parsed_header_dict['server'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Server())
if parsed_header.get_Set_Cookie() is not None: parsed_header_dict['set-cookie'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Set_Cookie())
if parsed_header.get_Strict_Transport_Security() is not None: parsed_header_dict['strict-transport-security'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Strict_Transport_Security())
if parsed_header.get_Trailer() is not None: parsed_header_dict['trailer'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Trailer())
if parsed_header.get_Transfer_Encoding() is not None: parsed_header_dict['transfer-encoding'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Transfer_Encoding())
if parsed_header.get_Vary() is not None: parsed_header_dict['vary'] = URI.dict_from_object(parsed_header.get_Vary(), vary_dict)
if parsed_header.get_Via() is not None: parsed_header_dict['via'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Via())
if parsed_header.get_Warning() is not None: parsed_header_dict['warning'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Warning())
if parsed_header.get_WWW_Authenticate() is not None: parsed_header_dict['www-authenticate'] = Base_Object_Attribute.dict_from_object(parsed_header.get_WWW_Authenticate())
if parsed_header.get_X_Frame_Options() is not None: parsed_header_dict['x-frame-options'] = Base_Object_Attribute.dict_from_object(parsed_header.get_X_Frame_Options())
if parsed_header.get_X_XSS_Protection() is not None: parsed_header_dict['x-xss-protection'] = Base_Object_Attribute.dict_from_object(parsed_header.get_X_XSS_Protection())
if parsed_header.get_X_Content_Type_Options() is not None: parsed_header_dict['x-content-type-options'] = Base_Object_Attribute.dict_from_object(parsed_header.get_X_Content_Type_Options())
if parsed_header.get_X_Forwarded_Proto() is not None: parsed_header_dict['x-forwarded-proto'] = Base_Object_Attribute.dict_from_object(parsed_header.get_X_Forwareded_Proto())
if parsed_header.get_X_Powered_By() is not None: parsed_header_dict['x-powered-by'] = Base_Object_Attribute.dict_from_object(parsed_header.get_X_Powered_By())
if parsed_header.get_X_UA_Compatible() is not None: parsed_header_dict['x-ua-compatible'] = Base_Object_Attribute.dict_from_object(parsed_header.get_X_UA_Compatible())
response_header_dict['parsed_header'] = parsed_header_dict
http_server_response_dict['http_response_header'] = response_header_dict
if http_server_response.get_HTTP_Message_Body() is not None:
message_body = http_server_response.get_HTTP_Message_Body()
message_body_dict = {}
if message_body.get_Length() is not None: message_body_dict['length'] = Base_Object_Attribute.dict_from_object(message_body.get_Length())
if message_body.get_Message_Body() is not None: message_body_dict['message_body'] = Base_Object_Attribute.dict_from_object(message_body.get_Message_Body())
http_server_response_dict['http_message_body'] = message_body_dict
return http_server_response_dict
def dict_from_object(cls, extracted_string_obj):
"""Parse and return a dictionary for an Extracted String object"""
extracted_string_dict = {}
if extracted_string_obj.get_encoding() is not None: extracted_string_dict['encoding'] = {'value' : element.get_encoding()}
if extracted_string_obj.get_String_Value() is not None: extracted_string_dict['string_value'] = Base_Object_Attribute.dict_from_object(defined_object.get_String_Value())
if extracted_string_obj.get_Hashes() is not None: extracted_string_dict['hashes'] = HashList.dict_from_object(element.get_Hashes())
if extracted_string_obj.get_Address() is not None: extracted_string_dict['address'] = Base_Object_Attribute.dict_from_object(defined_object.get_Address())
if extracted_string_obj.get_Length() is not None: extracted_string_dict['length'] = Base_Object_Attribute.dict_from_object(defined_object.get_Length())
if extracted_string_obj.get_Language() is not None: extracted_string_dict['language'] = Base_Object_Attribute.dict_from_object(defined_object.get_Language())
if extracted_string_obj.get_English_Translation() is not None: extracted_string_dict['english_translation'] = Base_Object_Attribute.dict_from_object(defined_object.get_English_Translation())
return extracted_string_dict
def dict_from_object(cls, environment_variable_obj):
"""Parse and return a dictionary for an Environment Variable object"""
environment_variable_dict = {}
if environment_variable_obj.get_Name() is not None: environment_variable_dict['name'] = Base_Object_Attribute.dict_from_object(defined_object.get_Name())
if environment_variable_obj.get_Value() is not None: environment_variable_dict['value'] = Base_Object_Attribute.dict_from_object(defined_object.get_Value())
return environment_variable_dict
def __parse_http_client_request(cls, http_client_request):
http_client_request_dict = {}
if http_client_request.get_HTTP_Request_Line() is not None:
client_request_line = http_client_request.get_HTTP_Request_Line()
client_request_line_dict = {}
if client_request_line.get_HTTP_Method() is not None:
client_request_line_dict['http_method'] = Base_Object_Attribute.dict_from_object(client_request_line.get_HTTP_Method())
if client_request_line.get_Value() is not None:
client_request_line_dict['value'] = Base_Object_Attribute.dict_from_object(client_request_line.get_HTTP_Value())
if client_request_line.get_Version() is not None:
client_request_line_dict['version'] = Base_Object_Attribute.dict_from_object(client_request_line.get_Version())
http_client_request_dict['http_request_line'] = client_request_line_dict
if http_client_request.get_HTTP_Request_Header() is not None:
request_header = http_client_request.get_HTTP_Request_Header()
request_header_dict = {}
if request_header.get_Raw_Header() is not None:
request_header_dict['raw_header'] = request_header.get_Raw_Header()
if request_header.get_Parsed_Header() is not None:
parsed_header = request_header.get_Parsed_Header()
parsed_header_dict = {}
if parsed_header.get_Accept() is not None: parsed_header_dict['accept'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Accept())
if parsed_header.get_Accept_Charset() is not None: parsed_header_dict['accept-charset'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Accept_Charset())
if parsed_header.get_Accept_Language() is not None: parsed_header_dict['accept-language'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Accept_Language())
if parsed_header.get_Accept_Datetime() is not None: parsed_header_dict['accept-datetime'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Accept_Datetime())
if parsed_header.get_Accept_Encoding() is not None: parsed_header_dict['accept'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Accept_Encoding())
if parsed_header.get_Authorization() is not None: parsed_header_dict['authorization'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Authorization())
if parsed_header.get_Cache_Control() is not None: parsed_header_dict['cache-control'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Cache_Control())
if parsed_header.get_Connection() is not None: parsed_header_dict['connection'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Connection())
if parsed_header.get_Cookie() is not None: parsed_header_dict['cookie'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Cookie())
if parsed_header.get_Content_Length() is not None: parsed_header_dict['content-length'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Content_Length())
if parsed_header.get_Content_MD5() is not None: parsed_header_dict['content-md5'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Content_MD5())
if parsed_header.get_Content_Type() is not None: parsed_header_dict['content-type'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Content_Type())
if parsed_header.get_Date() is not None: parsed_header_dict['date'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Date())
if parsed_header.get_Expect() is not None: parsed_header_dict['expect'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Expect())
if parsed_header.get_From() is not None: parsed_header_dict['from'] = Address.dict_from_object(parsed_header.get_From())
if parsed_header.get_Host() is not None:
host = parsed_header.get_Host()
host_dict = {}
if host.get_Domain_Name() is not None: host_dict['domain_name'] = URI.dict_from_object(host.get_Domain_Name())
if host.get_Port() is not None: host_dict['port'] = Port.dict_from_object(host.get_Port())
parsed_header_dict['host'] = host_dict
if parsed_header.get_If_Match() is not None: parsed_header_dict['if-match'] = Base_Object_Attribute.dict_from_object(parsed_header.get_If_Match())
if parsed_header.get_If_Modified_Since() is not None: parsed_header_dict['if-modified-since'] = Base_Object_Attribute.dict_from_object(parsed_header.get_If_Modified_Since())
if parsed_header.get_If_None_Match() is not None: parsed_header_dict['if-none-match'] = Base_Object_Attribute.dict_from_object(parsed_header.get_If_None_Match())
if parsed_header.get_If_Range() is not None: parsed_header_dict['if-range'] =Base_Object_Attribute.dict_from_object( parsed_header.get_If_Range())
if parsed_header.get_If_Unmodified_Since() is not None: parsed_header_dict['if-unmodified-since'] = Base_Object_Attribute.dict_from_object(parsed_header.get_If_Unmodified_Since())
if parsed_header.get_Max_Forwards() is not None: parsed_header_dict['max-forwards'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Max_Forwards())
if parsed_header.get_Pragma() is not None: parsed_header_dict['pragma'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Pragma())
if parsed_header.get_Proxy_Authorization() is not None: parsed_header_dict['proxy-authorization'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Proxy_Authorization())
if parsed_header.get_Range() is not None: parsed_header_dict['range'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Range())
if parsed_header.get_Referer() is not None: parsed_header_dict['referer'] = URI.dict_from_object(parsed_header.get_Referer())
if parsed_header.get_TE() is not None: parsed_header_dict['te'] = Base_Object_Attribute.dict_from_object(parsed_header.get_TE())
if parsed_header.get_User_Agent() is not None: parsed_header_dict['user-agent'] = Base_Object_Attribute.dict_from_object(parsed_header.get_User_Agent())
if parsed_header.get_Via() is not None: parsed_header_dict['via'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Via())
if parsed_header.get_Warning() is not None: parsed_header_dict['warning'] = Base_Object_Attribute.dict_from_object(parsed_header.get_Warning())
if parsed_header.get_DNT() is not None: parsed_header_dict['DNT'] = URI.dict_from_object(parsed_header.get_DNT())
if parsed_header.get_X_Requested_With() is not None: parsed_header_dict['x-requested-with'] = Base_Object_Attribute.dict_from_object(parsed_header.get_X_Requested_With())
if parsed_header.get_X_Requested_For() is not None: parsed_header_dict['x-requested-for'] = Base_Object_Attribute.dict_from_object(parsed_header.get_X_Requested_For())
if parsed_header.get_X_ATT_DeviceId() is not None: parsed_header_dict['x-att-deviceid'] = Base_Object_Attribute.dict_from_object(parsed_header.get_X_ATT_DeviceId())
if parsed_header.get_X_Wap_Profile() is not None: parsed_header_dict['x-wap-profile'] = URI.dict_from_object(parsed_header.get_X_Wap_Profile())
request_header_dict['parsed_header'] = parsed_header_dict
http_client_request_dict['http_request_header'] = request_header_dict
if http_client_request.get_HTTP_Message_Body() is not None:
message_body = http_client_request.get_HTTP_Message_Body()
message_body_dict = {}
if message_body.get_Length() is not None: message_body_dict['length'] = Base_Object_Attribute.dict_from_object(message_body.get_Length())
if message_body.get_Message_Body() is not None: message_body_dict['message_body'] = Base_Object_Attribute.dict_from_object(message_body.get_Message_Body())
http_client_request_dict['http_message_body'] = message_body_dict
return http_client_request_dict
def __socket_options_dict_from_object(cls, socket_options_obj):
socket_options_dict = {}
if socket_options_obj.get_IP_MULTICAST_IF() is not None: socket_options_dict['ip_multicast_if'] = {'value' : socket_options_obj.get_IP_MULTICAST_IF()}
if socket_options_obj.get_IP_MULTICAST_IF2() is not None: socket_options_dict['ip_multicast_if2'] = {'value' : socket_options_obj.get_IP_MULTICAST_IF2()}
if socket_options_obj.get_IP_MULTICAST_LOOP() is not None: socket_options_dict['ip_multicast_loop'] = {'value' : socket_options_obj.get_IP_MULTICAST_LOOP()}
if socket_options_obj.get_IP_TOS() is not None: socket_options_dict['ip_tos'] = Base_Object_Attribute.dict_from_object(socket_options_obj.get_IP_TOS())
if socket_options_obj.get_SO_BROADCAST() is not None: socket_options_dict['so_broadcast'] = {'value' : socket_options_obj.get_SO_BROADCAST()}
if socket_options_obj.get_SO_CONDITIONAL_ACCEPT() is not None: socket_options_dict['so_conditional_accept'] = {'value' : socket_options_obj.get_SO_CONDITIONAL_ACCEPT()}
if socket_options_obj.get_SO_KEEPALIVE() is not None: socket_options_dict['so_keepalive'] = {'value' : socket_options_obj.get_SO_KEEPALIVE()}
if socket_options_obj.get_SO_DONTROUTE() is not None: socket_options_dict['so_dontroute'] = {'value' : socket_options_obj.get_SO_DONTROUTE()}
if socket_options_obj.get_SO_LINGER() is not None: socket_options_dict['so_linger'] = Base_Object_Attribute.dict_from_object(socket_options_obj.get_SO_LINGER())
if socket_options_obj.get_SO_DONTLINGER() is not None: socket_options_dict['so_dontlinger'] = {'value' : socket_options_obj.get_SO_DONTLINGER()}
if socket_options_obj.get_SO_OOBINLINE() is not None: socket_options_dict['so_oobinline'] = {'value' : socket_options_obj.get_SO_OOBINLINE()}
if socket_options_obj.get_SO_RCVBUF() is not None: socket_options_dict['so_rcvbuf'] = Base_Object_Attribute.dict_from_object(socket_options_obj.get_SO_RCVBUF())
if socket_options_obj.get_SO_GROUP_PRIORITY() is not None: socket_options_dict['so_group_priority'] = Base_Object_Attribute.dict_from_object(socket_options_obj.get_SO_GROUP_PRIORITY())
if socket_options_obj.get_SO_REUSEADDR() is not None: socket_options_dict['so_reuseaddr'] = {'value' : socket_options_obj.get_SO_REUSEADDR()}
if socket_options_obj.get_SO_DEBUG() is not None: socket_options_dict['so_debug'] = {'value' : socket_options_obj.get_SO_DEBUG()}
if socket_options_obj.get_SO_RCVTIMEO() is not None: socket_options_dict['so_rcvtimeo'] = Base_Object_Attribute.dict_from_object(socket_options_obj.get_SO_RCVTIMEO())
if socket_options_obj.get_SO_SNDBUF() is not None: socket_options_dict['so_sndbuf'] = Base_Object_Attribute.dict_from_object(socket_options_obj.get_SO_SNDBUF())
if socket_options_obj.get_SO_SNDTIMEO() is not None: socket_options_dict['so_sndtimeo'] = Base_Object_Attribute.dict_from_object(socket_options_obj.get_SO_SNDTIMEO())
if socket_options_obj.get_SO_UPDATE_ACCEPT_CONTEXT() is not None: socket_options_dict['so_update_accept_context'] = Base_Object_Attribute.dict_from_object(socket_options_obj.get_SO_UPDATE_ACCEPT_CONTEXT())
if socket_options_obj.get_SO_TIMEOUT() is not None: socket_options_dict['so_timeout'] = Base_Object_Attribute.dict_from_object(socket_options_obj.get_SO_TIMEOUT())
if socket_options_obj.get_TCP_NODELAY() is not None: socket_options_dict['tcp_nodelay'] = Base_Object_Attribute.dict_from_object(socket_options_obj.get_TCP_NODELAY())
return socket_options_dict
def dict_from_object(cls, digital_signature_obj):
"""Parse and return a dictionary for a Digital Signature object"""
digital_signature_dict = {}
if digital_signature_obj.get_signature_exists() is not None: digital_signature_dict['signature_exists'] = {'value' : digital_signature_obj.get_signature_exists()}
if digital_signature_obj.get_signature_verified() is not None: digital_signature_dict['signature_verified'] = {'value' : digital_signature_obj.get_signature_verified()}
if digital_signature_obj.get_Certificate_Issuer() is not None: digital_signature_dict['certificate_issuer'] = Base_Object_Attribute.dict_from_object(digital_signature_obj.get_Certificate_Issuer())
if digital_signature_obj.get_Certificate_Subject() is not None: digital_signature_dict['certificate_subject'] = Base_Object_Attribute.dict_from_object(digital_signature_obj.get_Certificate_Subject())
if digital_signature_obj.get_Signature_Description() is not None: digital_signature_dict['signature_description'] = Base_Object_Attribute.dict_from_object(digital_signature_obj.get_Signature_Description())
return digital_signature_dict
def dict_from_object(cls, win_mutex_obj):
"""Parse and return a dictionary for a Win Mutex Object object"""
win_mutex_dict = Mutex.dict_from_object(defined_object)
if win_mutex_obj.get_Handle() is not None: win_mutex_dict['handle'] = Win_Handle.dict_from_object(win_mutex_obj.get_Handle())
if win_mutex_obj.get_Security_Attributes() is not None: win_mutex_dict['security_attributes'] = Base_Object_Attribute.dict_from_object(win_mutex_obj.get_Security_Attributes())
return win_mutex_dict
