atomicshop 2.2.9__py3-none-any.whl → 2.3.1__py3-none-any.whl

atomicshop/mitm/statistic_analyzer.py

@@ -0,0 +1,465 @@
+import datetime
+
+from .. import filesystem, domains, datetimes, urls
+from ..basics import dicts
+from ..file_io import tomls, xlsxs
+from ..wrappers.loggingw import reading
+from ..print_api import print_api
+
+
+def get_the_last_day_number(statistics_content: list, stop_after_lines: int = None) -> int:
+    """
+    This function gets the last day number from the statistics content.
+
+    :param statistics_content: list, of lines in the statistics content.
+    :param stop_after_lines: integer, if specified, the function will stop after the specified number of lines.
+    :return: integer, the last day number.
+    """
+
+    last_day_number = None
+    start_time_temp = None
+    for line_index, line in enumerate(statistics_content):
+        try:
+            request_time = datetime.datetime.strptime(line['request_time_sent'], '%Y-%m-%d %H:%M:%S.%f')
+        except ValueError:
+            continue
+
+        if not start_time_temp:
+            start_time_temp = request_time
+
+        if stop_after_lines:
+            if line_index == stop_after_lines:
+                break
+
+        last_day_number = datetimes.get_difference_between_dates_in_days(start_time_temp, request_time)
+    return last_day_number
+
+
+def create_empty_features_dict() -> dict:
+    """
+    This function creates an empty dictionary for the daily stats. This should be initiated for each 'host_type' of:
+        'domain', 'subdomain', 'url_no_parameters'.
+    :return: dict
+    """
+
+    return {
+        'total_count': {}, 'normal_count': {}, 'error_count': {},
+        'request_0_byte_count': {}, 'response_0_byte_count': {},
+        'request_sizes_list': {}, 'response_sizes_list': {},
+        'request_sizes_no_0_bytes_list': {}, 'response_sizes_no_0_bytes_list': {},
+        'average_request_size': {}, 'average_response_size': {},
+        'average_request_size_no_0_bytes': {}, 'average_response_size_no_0_bytes': {}}
+
+
+def add_to_count_to_daily_stats(
+        daily_stats: dict, current_day: int, last_day: int, host_type: str, feature: str, host_name: str) -> None:
+    """
+    This function adds 1 to the 'count' feature of the current day in the daily stats.
+
+    :param daily_stats: dict, the daily statistics dict.
+    :param current_day: integer, the current day number.
+    :param last_day: integer, the last day number.
+    :param host_type: string, the type of the host. Can be: 'domain', 'subdomain', 'url_no_parameters'.
+    :param feature: string, the feature to add the count to. Can be: 'total_count', 'normal_count', 'error_count',
+        'request_0_byte_count', 'response_0_byte_count'.
+    :param host_name: string, the name of the host.
+
+    :return: None.
+    """
+
+    # Aggregate daily domain hits.
+    if host_name not in daily_stats[host_type][feature].keys():
+        daily_stats[host_type][feature][host_name] = {}
+        # Iterate from first day to the last day.
+        for day in range(0, last_day + 1):
+            daily_stats[host_type][feature][host_name][day] = 0
+
+    # Add count to current day.
+    daily_stats[host_type][feature][host_name][current_day] += 1
+
+
+def add_to_list_to_daily_stats(
+        daily_stats: dict, current_day: int, last_day: int, host_type: str, feature: str, host_name: str,
+        size: float) -> None:
+    """
+    This function adds the 'size' to the 'feature' list of the current day in the daily stats.
+
+    :param daily_stats: dict, the daily statistics dict.
+    :param current_day: integer, the current day number.
+    :param last_day: integer, the last day number.
+    :param host_type: string, the type of the host. Can be: 'domain', 'subdomain', 'url_no_parameters'.
+    :param feature: string, the feature to add the count to. Can be: 'request_sizes_list', 'response_sizes_list',
+        'request_sizes_no_0_bytes_list', 'response_sizes_no_0_bytes_list'.
+    :param host_name: string, the name of the host.
+    :param size: float, the size in bytes to add to the list.
+
+    :return: None.
+    """
+
+    # Aggregate daily domain hits.
+    if host_name not in daily_stats[host_type][feature].keys():
+        daily_stats[host_type][feature][host_name] = {}
+        # Iterate from first day to the last day.
+        for day in range(0, last_day + 1):
+            daily_stats[host_type][feature][host_name][day] = []
+
+    # Add count to current day.
+    daily_stats[host_type][feature][host_name][current_day].append(size)
+
+
+def add_to_average_to_daily_stats(
+        daily_stats: dict, current_day: int, last_day: int, host_type: str, feature: str, host_name: str,
+        list_of_sizes: list) -> None:
+    """
+    This function adds the average size in bytes calculated from the 'list_of_sizes' to the 'feature' of the current
+        day in the daily stats.
+
+    :param daily_stats: dict, the daily statistics dict.
+    :param current_day: integer, the current day number.
+    :param last_day: integer, the last day number.
+    :param host_type: string, the type of the host. Can be: 'domain', 'subdomain', 'url_no_parameters'.
+    :param feature: string, the feature to add the count to. Can be: 'average_request_size', 'average_response_size',
+        'average_request_size_no_0_bytes', 'average_response_size_no_0_bytes'.
+    :param host_name: string, the name of the host.
+    :param list_of_sizes: list, the list of sizes to calculate the average from.
+
+    :return: None.
+    """
+
+    # Aggregate daily domain hits.
+    if host_name not in daily_stats[host_type][feature].keys():
+        daily_stats[host_type][feature][host_name] = {}
+        # Iterate from first day to the last day.
+        for day in range(0, last_day + 1):
+            daily_stats[host_type][feature][host_name][day] = 0
+
+    # If the list of size is empty, add 0 to the average, since we cannot divide by 0.
+    if len(list_of_sizes) == 0:
+        daily_stats[host_type][feature][host_name][current_day] = 0
+    else:
+        daily_stats[host_type][feature][host_name][current_day] = sum(list_of_sizes) / len(list_of_sizes)
+
+
+def analyze(main_file_path: str):
+    """
+    This function is the main function for the statistic analyzer.
+    :param main_file_path: Path to the main file that is calling this function (__file__).
+    :return:
+    """
+
+    # Get the config and set variables.
+    script_directory: str = filesystem.get_file_directory(main_file_path)
+    config_path: str = filesystem.add_object_to_path(script_directory, 'config_stats.toml')
+    config: dict = tomls.read_toml_file(config_path)
+    summary_path: str = filesystem.check_absolute_path___add_full(config['report_file_path'], script_directory)
+
+    # Get the content from statistics files.
+    statistics_content: list = reading.get_logs(
+        config['statistic_files_path'], pattern='statistics*.csv', log_type='csv',
+    )
+
+    # Initialize loop.
+    line_total_count: int = len(statistics_content)
+    start_time = None
+    last_day_number = None
+    overall_stats: dict = {
+        'domain': {'total_count': {}, 'normal_count': {}, 'error_count': {}},
+        'subdomain': {'total_count': {}, 'normal_count': {}, 'error_count': {}}
+    }
+    daily_stats: dict = {
+        'domain': create_empty_features_dict(),
+        'subdomain': create_empty_features_dict(),
+        'url_no_parameters': create_empty_features_dict()
+    }
+
+    # Start the main loop.
+    for line_index, line in enumerate(statistics_content):
+        # Converting time string to object.
+        # If the time string is not of the specific format, continue to the next line.
+        try:
+            request_time = datetime.datetime.strptime(line['request_time_sent'], '%Y-%m-%d %H:%M:%S.%f')
+        except ValueError:
+            continue
+
+        if not start_time:
+            start_time = request_time
+
+        # For testing, you can set the 'break_after_lines' to an integer, which symbolizes the number of the line
+        # of the 'statistics_content' to stop the loop after.
+        break_after_lines = None
+
+        # Find the last day number. If 'break_after_lines' is specified, the loop will stop after the specified line.
+        if not last_day_number:
+            last_day_number = get_the_last_day_number(statistics_content, break_after_lines)
+
+        if break_after_lines:
+            if line_index == break_after_lines:
+                break
+
+        if config['strings_to_include_in_subdomain'] and config['strings_to_include_in_subdomain'] != ['']:
+            # Checking that 'strings_to_include_in_subdomain' are in the subdomain, if not, continue to the next line.
+            if not any(string in line['host'] for string in config['strings_to_include_in_subdomain']):
+                continue
+
+        if config['strings_to_exclude_from_subdomain'] and config['strings_to_exclude_from_subdomain'] != ['']:
+            # Checking that 'strings_to_exclude_from_subdomain' are not in the subdomain, if they are, continue.
+            if any(string in line['host'] for string in config['strings_to_exclude_from_subdomain']):
+                continue
+
+        # Get the subdomain with the main domain from the 'host' column of current line.
+        subdomain = line['host']
+        # Get the main domain from the subdomain.
+        # Check if suffix of the 'host' is '.com'.
+        if line['host'].endswith('.com'):
+            # Get only the main domain.
+            main_domain = line['host'].split('.')[-2] + '.com'
+        # If the suffix is not '.com', use the 'domains' library to get the main domain.
+        else:
+            # This is the slowest part of the whole loop.
+            main_domain = domains.get_registered_domain(line['host'])
+
+        # If the domain is empty, continue to the next line.
+        if not main_domain:
+            continue
+
+        # If the domain is already in the dict, add 1 to the counter, else add the key to the dict.
+        if main_domain in overall_stats['domain']['total_count'].keys():
+            overall_stats['domain']['total_count'][main_domain] = (
+                    overall_stats['domain']['total_count'][main_domain] + 1)
+        else:
+            overall_stats['domain']['total_count'][main_domain] = 1
+
+        # If the subdomain is already in the dict, add 1 to the counter, else add the key to the dict.
+        if subdomain in overall_stats['subdomain']['total_count'].keys():
+            overall_stats['subdomain']['total_count'][subdomain] = (
+                    overall_stats['subdomain']['total_count'][subdomain] + 1)
+        else:
+            # overall_stats['subdomain']['total_count'] = {}
+            overall_stats['subdomain']['total_count'][subdomain] = 1
+
+        # Check if there is an error in the line and count the domain under 'error_count' key.
+        if line['error'] != '':
+            # If the domain is already in the dict, add 1 to the counter, else add the key to the dict.
+            if main_domain in overall_stats['domain']['error_count'].keys():
+                overall_stats['domain']['error_count'][main_domain] = (
+                        overall_stats['domain']['error_count'][main_domain] + 1)
+            else:
+                # overall_stats['domain']['total_count'] = {}
+                overall_stats['domain']['error_count'][main_domain] = 1
+
+            # If the subdomain is already in the dict, add 1 to the counter, else add the key to the dict.
+            if subdomain in overall_stats['subdomain']['error_count'].keys():
+                overall_stats['subdomain']['error_count'][subdomain] = (
+                        overall_stats['subdomain']['error_count'][subdomain] + 1)
+            else:
+                # overall_stats['subdomain']['total_count'] = {}
+                overall_stats['subdomain']['error_count'][subdomain] = 1
+        else:
+            # If the domain is already in the dict, add 1 to the counter, else add the key to the dict.
+            if main_domain in overall_stats['domain']['normal_count'].keys():
+                overall_stats['domain']['normal_count'][main_domain] = (
+                        overall_stats['domain']['normal_count'][main_domain] + 1)
+            else:
+                # overall_stats['domain']['total_count'] = {}
+                overall_stats['domain']['normal_count'][main_domain] = 1
+
+            # If the subdomain is already in the dict, add 1 to the counter, else add the key to the dict.
+            if subdomain in overall_stats['subdomain']['normal_count'].keys():
+                overall_stats['subdomain']['normal_count'][subdomain] = (
+                        overall_stats['subdomain']['normal_count'][subdomain] + 1)
+            else:
+                # overall_stats['subdomain']['total_count'] = {}
+                overall_stats['subdomain']['normal_count'][subdomain] = 1
+
+        # Get the URL without parameters.
+        url = line['host'] + line['path']
+        url_no_parameters = urls.url_parser(url)['path']
+
+        # Get the request and response sizes.
+        # If the size is not numeric that can be converted to integer, set it to None.
+        # Since, probably there was an SSL 'error' in the line.
+        try:
+            request_size = int(line['request_size_bytes'])
+            response_size = int(line['response_size_bytes'])
+        except ValueError:
+            request_size = None
+            response_size = None
+
+        # Start Day aggregation ========================================================================================
+        # Daily stats.
+        day_number = datetimes.get_difference_between_dates_in_days(start_time, request_time)
+
+        # Add 1 to the total count of the current day.
+        add_to_count_to_daily_stats(
+            daily_stats, day_number, last_day_number, 'domain', 'total_count', main_domain)
+        add_to_count_to_daily_stats(
+            daily_stats, day_number, last_day_number, 'subdomain', 'total_count', subdomain)
+        add_to_count_to_daily_stats(
+            daily_stats, day_number, last_day_number, 'url_no_parameters', 'total_count', url_no_parameters)
+
+        # Handle line if it has error.
+        if line['error'] != '':
+            add_to_count_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'domain', 'error_count', main_domain)
+            add_to_count_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'subdomain', 'error_count', subdomain)
+            add_to_count_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'url_no_parameters', 'error_count', url_no_parameters)
+        else:
+            add_to_count_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'domain', 'normal_count', main_domain)
+            add_to_count_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'subdomain', 'normal_count', subdomain)
+            add_to_count_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'url_no_parameters', 'normal_count', url_no_parameters)
+
+        if request_size == 0:
+            add_to_count_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'domain', 'request_0_byte_count',
+                main_domain)
+            add_to_count_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'subdomain', 'request_0_byte_count',
+                subdomain)
+            add_to_count_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'url_no_parameters', 'request_0_byte_count',
+                url_no_parameters)
+
+        if response_size == 0:
+            add_to_count_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'domain', 'response_0_byte_count',
+                main_domain)
+            add_to_count_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'subdomain', 'response_0_byte_count',
+                subdomain)
+            add_to_count_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'url_no_parameters', 'response_0_byte_count',
+                url_no_parameters)
+
+        if request_size is not None and response_size is not None:
+            add_to_list_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'domain', 'request_sizes_list', main_domain, request_size)
+            add_to_list_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'subdomain', 'request_sizes_list', subdomain, request_size)
+            add_to_list_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'url_no_parameters', 'request_sizes_list', url_no_parameters,
+                request_size)
+
+            add_to_list_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'domain', 'response_sizes_list', main_domain, response_size)
+            add_to_list_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'subdomain', 'response_sizes_list', subdomain, response_size)
+            add_to_list_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'url_no_parameters', 'response_sizes_list', url_no_parameters,
+                response_size)
+
+        if request_size != 0 and request_size is not None:
+            add_to_list_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'domain', 'request_sizes_no_0_bytes_list',
+                main_domain, request_size)
+            add_to_list_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'subdomain', 'request_sizes_no_0_bytes_list',
+                subdomain, request_size)
+            add_to_list_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'url_no_parameters', 'request_sizes_no_0_bytes_list',
+                url_no_parameters, request_size)
+
+        if response_size != 0 and response_size is not None:
+            add_to_list_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'domain', 'response_sizes_no_0_bytes_list',
+                main_domain, response_size)
+            add_to_list_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'subdomain', 'response_sizes_no_0_bytes_list',
+                subdomain, response_size)
+            add_to_list_to_daily_stats(
+                daily_stats, day_number, last_day_number, 'url_no_parameters', 'response_sizes_no_0_bytes_list',
+                url_no_parameters, response_size)
+
+        print_api(f'Processing line: {line_index+1}/{line_total_count}', print_end='\r')
+
+    # Calculate daily average request and response sizes.
+    for host_type, features in daily_stats.items():
+        for feature, hosts in features.items():
+            if feature == 'request_sizes_list':
+                feature_name = 'average_request_size'
+            elif feature == 'response_sizes_list':
+                feature_name = 'average_response_size'
+            elif feature == 'request_sizes_no_0_bytes_list':
+                feature_name = 'average_request_size_no_0_bytes'
+            elif feature == 'response_sizes_no_0_bytes_list':
+                feature_name = 'average_response_size_no_0_bytes'
+            else:
+                continue
+
+            for host_name, days in hosts.items():
+                for day, sizes in days.items():
+                    add_to_average_to_daily_stats(
+                        daily_stats, day, last_day_number, host_type, feature_name, host_name, sizes)
+
+    # Sorting overall stats.
+    sorted_overall_stats: dict = {
+        'domain': {'total_count': {}, 'normal_count': {}, 'error_count': {}},
+        'subdomain': {'total_count': {}, 'normal_count': {}, 'error_count': {}}
+    }
+    for feature_dict, feature_dict_value in overall_stats.items():
+        for feature, feature_value in feature_dict_value.items():
+            sorted_overall_stats[feature_dict][feature] = (
+                dicts.sort_by_values(feature_value, reverse=True))
+
+    # Create combined dictionary of the sorted statistics to export to XLSX file.
+    combined_sorted_stats = {}
+    # Add overall stats.
+    for feature_dict, feature_dict_value in sorted_overall_stats.items():
+        for feature, feature_value in feature_dict_value.items():
+            for feature_index, (host_name, counter) in enumerate(feature_value.items()):
+                if feature_index == 0:
+                    try:
+                        combined_sorted_stats[f'overall_stats']['host_name'].append('')
+                        combined_sorted_stats[f'overall_stats']['counter'].append('')
+                        combined_sorted_stats[f'overall_stats']['host_name'].append(f'{feature_dict}_{feature}')
+                        combined_sorted_stats[f'overall_stats']['counter'].append('counter')
+                    except KeyError:
+                        combined_sorted_stats[f'overall_stats'] = \
+                            {f'host_name': [f'{feature_dict}_{feature}'], 'counter': ['counter']}
+
+                combined_sorted_stats[f'overall_stats']['host_name'].append(host_name)
+                combined_sorted_stats[f'overall_stats']['counter'].append(counter)
+
+    feature_name = ''
+    # Add daily stats to combined dict. Each day will be a column.
+    for host_type, features in daily_stats.items():
+        for feature, hosts in features.items():
+            if 'count' in feature:
+                feature_name = 'counts'
+            elif 'list' in feature:
+                feature_name = 'lists'
+            elif 'average' in feature:
+                feature_name = 'averages'
+
+            for feature_index, (host_name, days) in enumerate(hosts.items()):
+                if feature_index == 0:
+                    try:
+                        combined_sorted_stats[f'daily_{feature_name}']['host_name'].append('')
+                        for day in days.keys():
+                            combined_sorted_stats[f'daily_{feature_name}']['Day' + str(day)].append('')
+                        combined_sorted_stats[f'daily_{feature_name}']['host_name'].append(f'{host_type}_{feature}')
+                        for day in days.keys():
+                            (combined_sorted_stats[f'daily_{feature_name}']['Day' + str(day)].
+                             append('Day' + str(day)))
+                    except KeyError:
+                        combined_sorted_stats[f'daily_{feature_name}'] = {f'host_name': [f'{host_type}_{feature}']}
+                        for day in days.keys():
+                            combined_sorted_stats[f'daily_{feature_name}']['Day' + str(day)] = ['Day' + str(day)]
+
+                combined_sorted_stats[f'daily_{feature_name}']['host_name'].append(host_name)
+                for day_number, counter in days.items():
+                    combined_sorted_stats[f'daily_{feature_name}']['Day' + str(day_number)].append(counter)
+
+    try:
+        xlsxs.write_xlsx(combined_sorted_stats, file_path=summary_path)
+    except FileNotFoundError:
+        directory_path = filesystem.get_file_directory(summary_path)
+        print_api(f'Directory does not exist, creating it: {directory_path}')
+        filesystem.create_directory(directory_path)
+        xlsxs.write_xlsx(combined_sorted_stats, file_path=summary_path)
+
+    return

atomicshop/ssh_scripts/process_from_port.py

@@ -17,6 +17,11 @@ for connection in psutil.net_connections():
         command_line = psutil.Process(connection.pid).cmdline()
         # Command line object is returned as list of parameters. We need 'shlex.join' to join the iterables
         # to regular, readable string.
-        print(shlex.join(command_line))
+        result = shlex.join(command_line)
+        # If the result is still a PID, we'll try to get process name.
+        if result.isnumeric():
+            # Get the process name from the connection PID.
+            result = psutil.Process(connection.pid).name()
+        print(result)
         # Break the loop, when first match is found.
         break

atomicshop/wrappers/factw/fact_config.py

@@ -0,0 +1,2 @@
+FACT_ADDRESS: str = 'http://localhost:5000'
+FIRMWARE_ENDPOINT: str = '/rest/firmware'

atomicshop/wrappers/factw/upload_firmware.py

@@ -0,0 +1,80 @@
+import requests
+import base64
+
+from . import fact_config
+from ... print_api import print_api
+from ... file_io import file_io
+
+
+def upload_firmware(firmware_file_path: str, params: dict, use_all_analysis_systems: bool = False):
+    """
+    Upload firmware binary file to the server.
+
+    :param firmware_file_path: Path to firmware file.
+    :param use_all_analysis_systems: Use all analysis systems.
+    :param params: Parameters:
+        {
+            "device_name": <string>,
+            "device_part": <string>,           # new in FACT 2.5
+            "device_class": <string>,
+            "file_name": <string>,
+            "version": <string>,               # supersedes firmware_version field
+            "vendor": <string>,
+            "release_date": <string>,
+            "tags": <string>,
+            "requested_analysis_systems": <list>,
+            "binary": <string(base64)>
+        }
+
+        'device_name' and 'tags' aren't required.
+        'binary' and 'file_name' is filled by this function from the firmware file.
+        'requested_analysis_systems' is filled by this function if 'use_all_analysis_systems' is True.
+
+        Example from https://github.com/fkie-cad/FACT_core/wiki/Rest-API#restfirmwareuid:
+        {
+            "device_name": "rest_test",
+            "device_part": <string>,
+            "device_class": "Router",
+            "file_name": "firmware.bin",
+            "version": "1.1",
+            "vendor": "AVM",
+            "release_date": "2011-01-01",
+            "tags": "tag1,tag2",
+            "requested_analysis_systems": ["file_type", "file_hashes"],
+            "binary": "dGVzdDEyMzQgdBzb21lIHRlc3QgZQ=="
+        }
+
+    :return: None.
+    """
+
+    url: str = f'{fact_config.FACT_ADDRESS}/{fact_config.FIRMWARE_ENDPOINT}'
+
+    # Add all analysis systems to the list.
+    if use_all_analysis_systems:
+        params['requested_analysis_systems'] = [
+            'binwalk', 'cpu_architecture', 'crypto_hints', 'crypto_material', 'cve_lookup', 'cwe_checker',
+            'device_tree', 'elf_analysis', 'exploit_mitigations', 'file_hashes', 'file_system_metadata',
+            'file_type', 'hardware_analysis', 'hashlookup', 'information_leaks', 'init_systems', 'input_vectors',
+            'interesting_uris', 'ip_and_uri_finder', 'ipc_analyzer', 'kernel_config', 'known_vulnerabilities',
+            'printable_strings', 'qemu_exec', 'software_components', 'source_code_analysis', 'string_evaluator',
+            'tlsh', 'unpacker', 'users_and_passwords'
+        ]
+
+    # Open firmware file.
+    firmware_binary_content = file_io.read_file(firmware_file_path, file_mode='rb')
+    # Encode firmware file to base64.
+    params['binary'] = base64.b64encode(firmware_binary_content)
+
+    # Send firmware file to the server.
+    response = requests.put(
+        url,
+        params=params,
+    )
+
+    # Check response status code.
+    if response.status_code == 200:
+        # Print response.
+        print_api(response.json())
+    else:
+        # Print error.
+        print_api('Error: ' + str(response.status_code), error_type=True, logger_method='critical')

atomicshop/wrappers/loggingw/reading.py

@@ -2,6 +2,7 @@ import os
 from typing import Literal
 
 from ... import filesystem, datetimes
+from ...basics import list_of_dicts
 from ...file_io import csvs
 
 
@@ -26,6 +27,7 @@ def get_logs(
         'all' - Each CSV file has a header. Get the header from each file.
     :param remove_logs: Boolean, if True, the logs will be removed after getting them.
     :param move_to_path: Path to move the logs to.
+
     :param print_kwargs: Keyword arguments dict for 'print_api' function.
     """
 
@@ -35,13 +37,9 @@ def get_logs(
     if remove_logs and move_to_path:
         raise ValueError('Both "remove_logs" and "move_to_path" cannot be True/specified at the same time.')
 
-    logs_files: list = filesystem.get_files_and_folders(
-        path, string_contains=pattern)
-
-    # If there's more than 1 file, it means that the latest file is 'statistics.csv' and it is the first in
-    # The found list, so we need to move it to the last place.
-    if len(logs_files) > 1:
-        logs_files = list(logs_files[1:] + [logs_files[0]])
+    logs_files: list = filesystem.get_file_paths_and_relative_directories(
+        path, file_name_check_pattern=pattern,
+        add_last_modified_time=True, sort_by_last_modified_time=True)
 
     # Read all the logs.
     logs_content: list = list()
@@ -49,12 +47,12 @@ def get_logs(
     for single_file in logs_files:
         if log_type == 'csv':
             if header_type_of_files == 'all':
-                csv_content, _ = csvs.read_csv_to_list(single_file, **print_kwargs)
+                csv_content, _ = csvs.read_csv_to_list(single_file['path'], **print_kwargs)
                 logs_content.extend(csv_content)
             elif header_type_of_files == 'first':
                 # The function gets empty header to read it from the CSV file, the returns the header that it read.
                 # Then each time the header is fed once again to the function.
-                csv_content, header = csvs.read_csv_to_list(single_file, header=header, **print_kwargs)
+                csv_content, header = csvs.read_csv_to_list(single_file['path'], header=header, **print_kwargs)
                 # Any way the first file will be read with header.
                 logs_content.extend(csv_content)
 
@@ -65,7 +63,7 @@ def get_logs(
     if remove_logs:
         # Remove the statistics files.
         for single_file in logs_files:
-            filesystem.remove_file(single_file)
+            filesystem.remove_file(single_file['path'])
 
     if move_to_path:
         # Get formatted time stamp for file name.
@@ -78,8 +76,8 @@ def get_logs(
         filesystem.create_directory(move_to_path_with_timestamp)
         # Move the statistics files.
         for single_file in logs_files:
-            single_file_name = filesystem.get_file_name(single_file)
+            single_file_name = filesystem.get_file_name(single_file['path'])
             move_to_path_with_file = f'{move_to_path_with_timestamp}{os.sep}{single_file_name}'
-            filesystem.move_file(single_file, move_to_path_with_file)
+            filesystem.move_file(single_file['path'], move_to_path_with_file)
 
     return logs_content

atomicshop/wrappers/socketw/socket_server_tester.py

@@ -57,14 +57,14 @@ def execute_test(config_static):
     loggingw.get_logger_with_stream_handler("network")
 
     # Get all the files in requests folder recursively.
-    request_file_list, _ = get_file_paths_and_relative_directories(config['requests_directory'])
+    request_file_list = get_file_paths_and_relative_directories(config['requests_directory'])
     print(f"Found request files: {len(request_file_list)}")
 
     # Get contents of all request files to list of contents.
     requests_bytes_list: list = list()
     for request_file_path in request_file_list:
         if config['request_type'] == 'json':
-            request_file_content = jsons.read_json_file(request_file_path)
+            request_file_content = jsons.read_json_file(request_file_path['path'])
 
             # If imported json is regular and not combined json.
             if isinstance(request_file_content, dict):
@@ -79,13 +79,13 @@ def execute_test(config_static):
                     requests_bytes_list.extend(
                         get_key_values_from_json(json_dict, config['request_json_hex_key_list']))
         elif config['request_type'] == 'string':
-            request_file_content = file_io.read_file(request_file_path)
+            request_file_content = file_io.read_file(request_file_path['path'])
             # Convert string content to bytes and append to list.
             requests_bytes_list.append(request_file_content.encode())
             print(f"Extracted 1 request.")
         elif config['request_type'] == 'binary':
             # The content is already in bytes, so just appending.
-            requests_bytes_list.append(file_io.read_file(request_file_path, 'rb'))
+            requests_bytes_list.append(file_io.read_file(request_file_path['path'], 'rb'))
             print(f"Extracted 1 request.")
 
     print(f"Finished parsing. Parsed requests: {len(requests_bytes_list)}")