atomicshop 2.10.8__py3-none-any.whl → 2.11.1__py3-none-any.whl

atomicshop/wrappers/ctyping/msi_windows_installer/tables.py

@@ -0,0 +1,419 @@
+import os
+import csv
+import ctypes
+from ctypes import wintypes
+
+from . import base
+from .base import msi
+
+
+def get_column_names(db_handle, table_name):
+    """Fetch column names for a specific table."""
+    column_names = []
+    query = f"SELECT `Name` FROM `_Columns` WHERE `Table`='{table_name}' ORDER BY `Number`"
+    view_handle = base.create_open_execute_view_handle(db_handle, query)
+
+    while True:
+        record_handle = base.create_fetch_record_from_view_handle(view_handle)
+        if not record_handle:
+            break
+
+        column_name = base.get_table_field_data_from_record(record_handle, field_index=1, data_type='stringw')
+        if column_name:
+            column_names.append(column_name)
+
+    msi.MsiCloseHandle(record_handle)
+    msi.MsiCloseHandle(view_handle)
+    return column_names
+
+
+def list_all_table_names(db_handle) -> list:
+    """List all tables in the MSI database."""
+    query = "SELECT `Name` FROM `_Tables`"
+    view_handle = base.create_open_execute_view_handle(db_handle, query)
+
+    tables: list = []
+    while True:
+        record_handle = base.create_fetch_record_from_view_handle(view_handle)
+
+        # If record handle is empty then there is nothing more in the buffer, and we can stop the loop.
+        if not record_handle:
+            break
+
+        tables.append(base.get_table_field_data_from_record(record_handle, field_index=1, data_type='stringw'))
+
+    msi.MsiCloseHandle(record_handle)
+    msi.MsiViewClose(view_handle)
+
+    return tables
+
+
+def get_table_contents(db_handle, table_name):
+    """Fetch all contents of a specific table using ctypes."""
+    view_handle = base.create_open_execute_view_handle(db_handle, f"SELECT * FROM `{table_name}`")
+    contents = []
+
+    # Fetch column names
+    column_names = get_column_names(db_handle, table_name)
+    contents.append(column_names)
+
+    while True:
+        record_handle = base.create_fetch_record_from_view_handle(view_handle)
+        if not record_handle:
+            break
+
+        row = []
+        field_count = msi.MsiRecordGetFieldCount(record_handle)
+
+        for i in range(1, field_count + 1):
+            # Try to fetch as a string
+            buf_size = wintypes.DWORD(1024)
+            buf = ctypes.create_unicode_buffer(buf_size.value)
+            result = msi.MsiRecordGetStringW(record_handle, i, buf, ctypes.byref(buf_size))
+
+            if result == 0:
+                row.append(buf.value)
+            elif result == 234:  # ERROR_MORE_DATA
+                # Increase buffer size and try again
+                buf_size = wintypes.DWORD(buf_size.value + 1)
+                buf = ctypes.create_unicode_buffer(buf_size.value)
+                result = msi.MsiRecordGetStringW(record_handle, i, buf, ctypes.byref(buf_size))
+                if result == 0:
+                    row.append(buf.value)
+                else:
+                    row.append(None)
+            else:
+                # Try to fetch as an integer
+                int_value = ctypes.c_int()
+                result = msi.MsiRecordGetInteger(record_handle, i, ctypes.byref(int_value))
+                if result == 0:
+                    row.append(int_value.value)
+                else:
+                    # Try to fetch as a stream
+                    stream_size = wintypes.DWORD()
+                    result = msi.MsiRecordReadStream(record_handle, i, None, ctypes.byref(stream_size))
+                    if result == 0:
+                        stream_data = ctypes.create_string_buffer(stream_size.value)
+                        msi.MsiRecordReadStream(record_handle, i, stream_data, ctypes.byref(stream_size))
+                        row.append(stream_data.raw)
+                    else:
+                        row.append(None)
+
+        contents.append(row)
+        msi.MsiCloseHandle(record_handle)
+
+    msi.MsiCloseHandle(view_handle)
+    return contents
+
+
+def extract_table_contents_to_csv(db_handle, output_directory):
+    """Extracts all table contents to separate CSV files."""
+
+    os.makedirs(output_directory, exist_ok=True)
+
+    # Get all the table names.
+    table_names: list = list_all_table_names(db_handle)
+    # Get all the table contents by fetching each table.
+    table_contents = {table: get_table_contents(db_handle, table) for table in table_names}
+    print(f"Tables and their contents have been fetched.")
+
+    # Save each table to a separate CSV file
+    for table, contents in table_contents.items():
+        csv_file_path = os.path.join(output_directory, f"{table}.csv")
+        with open(csv_file_path, "w", newline='') as csv_file:
+            writer = csv.writer(csv_file)
+            writer.writerows(contents)
+        print(f"Table {table} contents saved to {csv_file_path}")
+
+    print("All table contents saved to separate CSV files in the 'tables' directory.")
+
+
+def extract_binary_table_entries(db_handle, output_directory: str):
+    os.makedirs(output_directory, exist_ok=True)
+
+    # Create and execute a view to query the Binary table
+    query = "SELECT Name, Data FROM Binary"
+    view_handle = base.create_open_execute_view_handle(db_handle, query)
+
+    while True:
+        # Fetch a record from the view
+        record_handle = base.create_fetch_record_from_view_handle(view_handle)
+        if not record_handle:
+            break
+
+        # Get the binary name
+        name = base.get_table_field_data_from_record(record_handle, field_index=1, data_type='stringw')
+
+        # Get the size of the binary data
+        data_size = msi.MsiRecordDataSize(record_handle, 2)
+        if data_size == 0:
+            continue
+
+        # Read the binary data
+        binary_data = base.get_table_field_data_from_record(
+            record_handle, field_index=2, data_type='stream', buffer_size=data_size)
+
+        # Save the binary data to a file
+        output_filepath = os.path.join(output_directory, name)
+        print(f"Extracting binary file [{name}] to {output_filepath}")
+        with open(output_filepath, 'wb') as f:
+            f.write(binary_data)
+
+    msi.MsiCloseHandle(record_handle)
+    msi.MsiCloseHandle(view_handle)
+
+
+def extract_icon_table_entries(db_handle, output_directory: str):
+    """Extracts icons from the Icon table in the specified MSI file."""
+    os.makedirs(output_directory, exist_ok=True)
+
+    query = "SELECT Name, Data FROM Icon"
+    view_handle = base.create_open_execute_view_handle(db_handle, query)
+
+    while True:
+        # Fetch a record from the view
+        record_handle = base.create_fetch_record_from_view_handle(view_handle)
+        if not record_handle:
+            break
+
+        # Read the Name (field 1) and Data (field 2) from the record
+        icon_filename = base.get_table_field_data_from_record(record_handle, 1, 'stringw')
+        icon_data = base.get_table_field_data_from_record(record_handle, 2, 'stream')
+
+        # Define the output file path
+        output_file_path = os.path.join(output_directory, f"{icon_filename}")
+
+        # Write the icon data to a file
+        with open(output_file_path, 'wb') as icon_file:
+            icon_file.write(icon_data)
+
+        print(f"Extracted icon: {output_file_path}")
+
+    # Close handles.
+    msi.MsiCloseHandle(record_handle)
+    msi.MsiCloseHandle(view_handle)
+
+
+def extract_issetupfiles_table_entries(db_handle, output_directory: str):
+    """Extracts icons from the Icon table in the specified MSI file."""
+    os.makedirs(output_directory, exist_ok=True)
+
+    query = "SELECT FileName, Stream FROM ISSetupFile"
+    view_handle = base.create_open_execute_view_handle(db_handle, query)
+
+    while True:
+        # Fetch a record from the view
+        record_handle = base.create_fetch_record_from_view_handle(view_handle)
+        if not record_handle:
+            break
+
+        # Read the Name (field 1) and Data (field 2) from the record
+        file_name = base.get_table_field_data_from_record(record_handle, 1, 'stringw')
+        file_data = base.get_table_field_data_from_record(record_handle, 2, 'stream')
+
+        # Define the output file path
+        output_file_path = os.path.join(output_directory, f"{file_name}")
+
+        # Write the icon data to a file
+        with open(output_file_path, 'wb') as icon_file:
+            icon_file.write(file_data)
+
+        print(f"Extracted IsSetupFile: {output_file_path}")
+
+    # Close handles.
+    msi.MsiCloseHandle(record_handle)
+    msi.MsiCloseHandle(view_handle)
+
+
+def extract_registry_changes(db_handle, output_directory: str):
+    """Extracts registry changes from the MSI file and writes them to a .reg file."""
+
+    os.makedirs(output_directory, exist_ok=True)
+    registry_file_path: str = os.path.join(output_directory, "registry_changes.reg")
+
+    # Create and execute a view for the Registry table
+    query = "SELECT `Root`, `Key`, `Name`, `Value` FROM `Registry`"
+    view_handle = base.create_open_execute_view_handle(db_handle, query)
+
+    with open(registry_file_path, 'w') as reg_file:
+        # Write the .reg file header
+        reg_file.write("Windows Registry Editor Version 5.00\n\n")
+
+        while True:
+            # Fetch a record from the view
+            record_handle = base.create_fetch_record_from_view_handle(view_handle)
+            if not record_handle:
+                break
+
+            # Read the Root (field 1), Key (field 2), Name (field 3), and Value (field 4) from the record
+            root = int(base.get_table_field_data_from_record(record_handle, 1, 'stringw'))
+            key = base.get_table_field_data_from_record(record_handle, 2, 'stringw')
+            name = base.get_table_field_data_from_record(record_handle, 3, 'stringw')
+            value = base.get_table_field_data_from_record(record_handle, 4, 'stringw')
+
+            # Determine the root key name
+            root_key = {
+                0: "HKEY_CLASSES_ROOT",
+                1: "HKEY_CURRENT_USER",
+                2: "HKEY_LOCAL_MACHINE",
+                3: "HKEY_USERS"
+            }.get(root, "UNKNOWN_ROOT")
+
+            # Format the registry entry
+            if name:
+                reg_entry = f'[{root_key}\\{key}]\n"{name}"="{value}"\n\n'
+            else:
+                reg_entry = f'[{root_key}\\{key}]\n@="{value}"\n\n'
+
+            # Write the registry entry to the .reg file
+            reg_file.write(reg_entry)
+
+    msi.MsiCloseHandle(record_handle)
+    msi.MsiCloseHandle(view_handle)
+
+
+def list_media_table_entries(db_handle):
+    """List all CAB files from the Media table."""
+    query = "SELECT `Cabinet` FROM `Media`"
+    media_view = base.create_open_execute_view_handle(db_handle, query)
+
+    cab_files = []
+    while True:
+        record_handle = base.create_fetch_record_from_view_handle(media_view)
+        if not record_handle:
+            break
+
+        # The CAB file names are prefixed with #
+        cab_name = base.get_table_field_data_from_record(record_handle, field_index=1, data_type='stringw')
+        cab_files.append(cab_name.strip("#"))
+
+    msi.MsiCloseHandle(record_handle)
+    msi.MsiCloseHandle(media_view)
+    return cab_files
+
+
+def extract_cab_files_from_media(db_handle, output_directory: str):
+    """Extract all CAB files from the list."""
+    os.makedirs(output_directory, exist_ok=True)
+
+    query = "SELECT `Cabinet` FROM `Media` WHERE `Cabinet` IS NOT NULL"
+    # Query to fetch CAB files from the Media table
+    view_handle = base.create_open_execute_view_handle(db_handle, query)
+
+    cabinet_name_list: list = []
+    while True:
+        record_handle = base.create_fetch_record_from_view_handle(view_handle)
+        if not record_handle:
+            break
+
+        cabinet_name = base.get_table_field_data_from_record(record_handle, field_index=1, data_type='stringw')
+        cabinet_name_list.append(cabinet_name)
+    msi.MsiCloseHandle(record_handle)
+    msi.MsiCloseHandle(view_handle)
+
+    cab_file_paths: list = []
+    for cabinet_name in cabinet_name_list:
+        if cabinet_name.startswith("#"):
+            cabinet_name = cabinet_name[1:]  # Remove the leading #
+
+            cab_file_path = os.path.join(output_directory, cabinet_name)
+            with open(cab_file_path, 'wb') as f:
+                # Read the binary stream from the MSI package
+                stream_query = f"SELECT `Data` FROM `_Streams` WHERE `Name`='{cabinet_name}'"
+                stream_view = base.create_open_execute_view_handle(db_handle, stream_query)
+
+                while True:
+                    stream_record = base.create_fetch_record_from_view_handle(stream_view)
+                    if not stream_record:
+                        break
+
+                    data = base.get_table_field_data_from_record(stream_record, field_index=1, data_type='stream')
+
+                f.write(data)
+
+                msi.MsiCloseHandle(stream_record)
+                msi.MsiViewClose(stream_view)
+                msi.MsiCloseHandle(stream_view)
+
+            print(f"Extracted: {cabinet_name}")
+            cab_file_paths.append(cab_file_path)
+
+    print(f"CAB files extraction completed. Files are saved to {output_directory}")
+    return cab_file_paths
+
+
+def get_file_table_info(db_handle):
+    query = "SELECT `File`, `FileName`, `Component_` FROM `File`"
+    view_handle = base.create_open_execute_view_handle(db_handle, query)
+
+    file_info = {}
+
+    # Fetch the records
+    while True:
+        record_handle = base.create_fetch_record_from_view_handle(view_handle)
+        if not record_handle:
+            break
+
+        file_key = base.get_table_field_data_from_record(record_handle, field_index=1, data_type='stringw')
+        # Handle cases with multiple file names
+        file_name = base.get_table_field_data_from_record(record_handle, field_index=2, data_type='stringw')
+        file_name = file_name.split('|')[-1]
+        component = base.get_table_field_data_from_record(record_handle, field_index=3, data_type='stringw')
+
+        file_info[file_key] = {'file_name': file_name, 'component': component}
+
+    msi.MsiCloseHandle(record_handle)
+    msi.MsiCloseHandle(view_handle)
+
+    return file_info
+
+
+def get_component_table_info(db_handle):
+    component_info = {}
+
+    query = "SELECT `Component`, `Directory_` FROM `Component`"
+    view_handle = base.create_open_execute_view_handle(db_handle, query)
+
+    # Fetch the records
+    while True:
+        record_handle = base.create_fetch_record_from_view_handle(view_handle)
+        if not record_handle:
+            break
+
+        component_key = base.get_table_field_data_from_record(record_handle, field_index=1, data_type='stringw')
+        directory = base.get_table_field_data_from_record(record_handle, field_index=2, data_type='stringw')
+
+        component_info[component_key] = {'directory': directory}
+
+    msi.MsiCloseHandle(record_handle)
+    msi.MsiCloseHandle(view_handle)
+
+    return component_info
+
+
+def get_directory_table_info(db_handle):
+    directory_info = {}
+
+    # Open a view to the Directory table
+    query = "SELECT `Directory`, `Directory_Parent`, `DefaultDir` FROM `Directory`"
+    view_handle = base.create_open_execute_view_handle(db_handle, query)
+
+    # Fetch the records
+    while True:
+        record_handle = base.create_fetch_record_from_view_handle(view_handle)
+        if not record_handle:
+            break
+
+        directory_key = base.get_table_field_data_from_record(record_handle, field_index=1, data_type='stringw')
+        parent_key = base.get_table_field_data_from_record(record_handle, field_index=2, data_type='stringw')
+
+        # Handle cases with multiple directory names with '|' character.
+        default_dir_buffer = base.get_table_field_data_from_record(record_handle, field_index=3, data_type='stringw')
+        default_dir = default_dir_buffer.split('|')[-1]
+
+        directory_info[directory_key] = {'parent': parent_key, 'default_dir': default_dir}
+
+    msi.MsiCloseHandle(record_handle)
+    msi.MsiCloseHandle(view_handle)
+
+    return directory_info

atomicshop/wrappers/dockerw/install_docker.py

@@ -1,8 +1,10 @@
+import os
 import subprocess
 import getpass
 
 from ... import process, filesystem, permissions
 from ...print_api import print_api
+from .. import ubuntu_terminal
 
 
 def is_docker_installed():
@@ -59,14 +61,21 @@ def add_current_user_to_docker_group(print_kwargs: dict = None):
         return False
 
 
-def install_docker_ubuntu(rootless: bool = True, add_current_user_to_docker_group_bool: bool = False):
+def install_docker_ubuntu(
+        use_docker_installer: bool = True,
+        rootless: bool = False,
+        add_current_user_to_docker_group_bool: bool = False
+):
     """
     The function will install docker on ubuntu.
     :param rootless: bool, if True, the rootless installation will be performed.
         Meaning, you will be able to run the 'docker' command without sudo and you will not need to add the
         current user to the docker group.
+    :param use_docker_installer: bool, if True, the docker installer will be used.
+        If False, the docker will be installed using the apt package manager, custom repo and keyring.
     :param add_current_user_to_docker_group_bool: bool, if True, the current user will be added to the docker group.
-        So the user will be able to run the 'docker' command without sudo.
+        So the user will be able to run the 'docker' command without sudo. If you install docker in rootless mode
+        this is not needed.
 
     Usage in main.py (run with sudo):
         from atomicshop.wrappers.dockerw import install_docker
@@ -80,41 +89,66 @@ def install_docker_ubuntu(rootless: bool = True, add_current_user_to_docker_grou
             main()
     """
 
-    # Remove the existing keyrings, so we will not be asked to overwrite it if it exists.
-    docker_keyring_file_path: str = "/etc/apt/keyrings/docker.gpg"
-    filesystem.remove_file(docker_keyring_file_path)
-
-    script = f"""
-    # Step 1: Set up Docker's apt repository
-    sudo apt-get update
-    sudo apt-get install -y ca-certificates curl gnupg
-    sudo install -m 0755 -d /etc/apt/keyrings
-    curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
-    sudo chmod a+r /etc/apt/keyrings/docker.gpg
-    
-    # Add the repository to Apt sources
-    echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
-    sudo apt-get update
-    
-    # Step 2: Install the Docker packages
-    sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
-    
-    # Step 3: Verify the installation
-    # sudo docker run hello-world
-    
-    # Add Privileges to run docker without sudo. Add current user to Docker superuser group.
-    # sudo usermod -aG docker $USER
-    """
-
-    process.execute_script(script, shell=True)
+    if use_docker_installer:
+        # Use the docker installer script.
+        # The script will install docker and add the current user to the docker group.
+        # The script will also install docker-compose and docker-buildx.
+        process.execute_script('curl -fsSL https://get.docker.com -o get-docker.sh && sh get-docker.sh', shell=True)
+    else:
+        # Remove the existing keyrings, so we will not be asked to overwrite it if it exists.
+        docker_keyring_file_path: str = "/etc/apt/keyrings/docker.gpg"
+        filesystem.remove_file(docker_keyring_file_path)
+
+        script = f"""
+        # Step 1: Set up Docker's apt repository
+        sudo apt-get update
+        sudo apt-get install -y ca-certificates curl gnupg
+        sudo install -m 0755 -d /etc/apt/keyrings
+        curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
+        sudo chmod a+r /etc/apt/keyrings/docker.gpg
+        
+        # Add the repository to Apt sources
+        echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
+        sudo apt-get update
+        
+        # Step 2: Install the Docker packages
+        sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
+        
+        # Step 3: Verify the installation
+        # sudo docker run hello-world
+        
+        # Add Privileges to run docker without sudo. Add current user to Docker superuser group.
+        # sudo usermod -aG docker $USER
+        """
+
+        process.execute_script(script, shell=True)
+
+    if rootless:
+        # Install uidmap package.
+        ubuntu_terminal.update_system_packages()
+        ubuntu_terminal.install_packages(['uidmap'])
+
+        # After 'get-docker.sh' execution, we will install docker in rootless mode.
+        subprocess.run(['dockerd-rootless-setuptool.sh', 'install'], shell=True)
+
+        # Start and enable the docker service in user mode.
+        ubuntu_terminal.start_enable_service_check_availability('docker.service', user_mode=True, sudo=False)
+
+        # Enable lingering so Docker runs when the user is not logged in
+        subprocess.run(['sudo', 'loginctl', 'enable-linger', os.getlogin()], shell=True)
+
+        # Add $HOME/bin to your PATH if it's not already there.
+        ubuntu_terminal.add_path_to_bashrc()
 
     if add_current_user_to_docker_group_bool:
         # Check if current user that executed the script is a sudo user. If not, use the current user.
         # Add the current user to the docker group.
         add_current_user_to_docker_group()
 
-    # Verify the installation.
-    result: list = process.execute_with_live_output('sudo docker run hello-world')
+        # Verify the installation.
+        result: list = process.execute_with_live_output('sudo docker run hello-world')
+    else:
+        result: list = process.execute_with_live_output('docker run hello-world')
 
     print_api('\n'.join(result))
 

atomicshop/wrappers/factw/install/pre_install_and_install_before_restart.py

@@ -37,12 +37,16 @@ def install_before_restart(
         print_api("This script requires root privileges...", color='red')
         sys.exit(1)
 
-    docker_keyring_file_path: str = "/etc/apt/keyrings/docker.gpg"
+    # Install docker in rootless mode.
+    install_docker.install_docker_ubuntu(
+        use_docker_installer=True, rootless=True, add_current_user_to_docker_group_bool=False)
+
+    # docker_keyring_file_path: str = "/etc/apt/keyrings/docker.gpg"
     nodesource_keyring_file_path: str = "/etc/apt/keyrings/nodesource.gpg"
     fact_core_pre_install_file_path = str(Path(installation_directory, config_install.PRE_INSTALL_FILE_PATH))
 
     # Remove the existing keyrings, so we will not be asked to overwrite it if it exists.
-    filesystem.remove_file(docker_keyring_file_path)
+    # filesystem.remove_file(docker_keyring_file_path)
     filesystem.remove_file(nodesource_keyring_file_path)
 
     # Remove the existing installation directory.
@@ -76,9 +80,9 @@ def install_before_restart(
 
     # Install docker. FACT installs the docker, but there can be a problem with permissions, so we need to add
     # the user permissions to the docker group before restart.
-    if not install_docker.add_current_user_to_docker_group():
-        print_api("Docker is installed, but the current user was not added to the docker group.", color='red')
-        sys.exit(1)
+    # if not install_docker.add_current_user_to_docker_group():
+    #     print_api("Docker is installed, but the current user was not added to the docker group.", color='red')
+    #     sys.exit(1)
 
     print_api("FACT_core installation before restart is finished.", color='green')
     print_api("Please restart the computer to continue the installation.", color='red')

atomicshop/wrappers/olefilew.py

@@ -0,0 +1,63 @@
+import os
+import datetime
+import json
+
+import olefile
+
+
+def convert_object_to_string(obj):
+    if isinstance(obj, bytes):
+        # MSI Database uses latin-1 encoding for strings, could be that other ole files too.
+        return obj.decode('latin-1')
+    elif isinstance(obj, datetime.datetime):
+        return obj.strftime('%Y-%m-%d-%H:%M:%S')
+    return obj
+
+
+def extract_ole_metadata(ole_file_path: str, output_directory: str):
+    """
+    Extract metadata from an OLE2 file.
+    :param ole_file_path:
+    :param output_directory:
+    :return:
+    """
+    os.makedirs(output_directory, exist_ok=True)
+    metadata_file_path = os.path.join(output_directory, "metadata.json")
+
+    # Check if the file is ole2 file.
+    if not olefile.isOleFile(ole_file_path):
+        message = f"The file {ole_file_path} is not an OLE2 file."
+        print(message)
+        with open(metadata_file_path, "w") as metadata_file:
+            metadata_file.write(message)
+        return
+
+    # Open the OLE2 file.
+    ole = olefile.OleFileIO(ole_file_path)
+
+    # Get the metadata of the OLE2 file.
+    metadata = ole.get_metadata()
+
+    meta_properties: dict = {
+        'SummaryInformation': {},
+        'DocumentSummaryInformation': {}
+    }
+    # Properties from SummaryInformation stream.
+    for prop in metadata.SUMMARY_ATTRIBS:
+        value = getattr(metadata, prop)
+        value = convert_object_to_string(value)
+        meta_properties['SummaryInformation'][prop] = value
+    # Properties from DocumentSummaryInformation stream.
+    for prop in metadata.DOCSUM_ATTRIBS:
+        value = getattr(metadata, prop)
+        value = convert_object_to_string(value)
+        meta_properties['DocumentSummaryInformation'][prop] = value
+
+    # Save the metadata to a file.
+    with open(metadata_file_path, "w") as metadata_file:
+        json.dump(meta_properties, metadata_file, indent=4)
+
+    print(f"Metadata of the OLE2 file saved to {metadata_file_path}")
+
+    # Close the OLE2 file.
+    ole.close()