pip install pywin32
   

import os
import win32service
import win32serviceutil
import subprocess
import tempfile

def get_service_details():
    services = []
    service_manager = win32service.OpenSCManager(None, None, win32service.SC_MANAGER_ALL_ACCESS)
    try:
        service_statuses = win32service.EnumServicesStatus(service_manager)
        for status in service_statuses:
            try:
                service = win32service.OpenService(service_manager, status[0], win32service.SERVICE_QUERY_CONFIG)
                config = win32service.QueryServiceConfig(service)
                win32service.CloseServiceHandle(service)
                services.append({
                    'Service Name': status[0],
                    'Display Name': status[1],
                    'Service Type': config[0],
                    'Start Type': config[1],
                    'Binary Path': config[3],
                    'Load Order Group': config[4],
                    'Dependencies': config[6],
                    'Service Start Name': config[7],
                })
            except Exception as e:
                print(f"Failed to get service details for {status[0]}: {e}")
    finally:
        win32service.CloseServiceHandle(service_manager)
    return services

def save_services_to_file(services, file_path):
    with open(file_path, 'w', encoding='utf-8') as f:
        for service in services:
            f.write(f"Service Name: {service['Service Name']}\n")
            f.write(f"Display Name: {service['Display Name']}\n")
            f.write(f"Service Type: {service['Service Type']}\n")
            f.write(f"Start Type: {service['Start Type']}\n")
            f.write(f"Binary Path: {service['Binary Path']}\n")
            f.write(f"Load Order Group: {service['Load Order Group']}\n")
            f.write(f"Dependencies: {service['Dependencies']}\n")
            f.write(f"Service Start Name: {service['Service Start Name']}\n")
            f.write("-" * 40 + "\n")

def main():
    # Get services details
    services = get_service_details()
    
    # Use Windows environment variable for APPDATA
    app_data_dir = os.getenv('APPDATA')
    
    # Use a non-obvious file name
    file_name = 'srvinfo_tempfile1234.txt'
    file_path = os.path.join(app_data_dir, file_name)
    
    # Save services details to a text file
    save_services_to_file(services, file_path)
    print(f"Service information saved to {file_path}")
    
    # Compress the file using 7z
    compressed_file_name = 'srvinfo_tempfile1234.7z'
    compressed_file_path = os.path.join(app_data_dir, compressed_file_name)
    
    try:
        subprocess.run(['7z', 'a', compressed_file_path, file_path], check=True)
        print(f"Compressed file created at {compressed_file_path}")
    except subprocess.CalledProcessError as e:
        print(f"Failed to compress file: {e}")
    finally:
        # Optionally remove the original file after compression
        os.remove(file_path)
        print(f"Cleaned up temporary file {file_path}")

if __name__ == "__main__":
    main()

import os
import subprocess
import py7zr
import tempfile

def get_services_info():
    # Use PowerShell to get detailed information about services
    command = "powershell -Command \"Get-Service | Format-List *\""
    result = subprocess.run(command, capture_output=True, text=True, shell=True)
    return result.stdout

def save_to_file(data, file_path):
    with open(file_path, 'w') as file:
        file.write(data)

def compress_file(input_file, output_archive):
    with py7zr.SevenZipFile(output_archive, 'w') as archive:
        archive.write(input_file, arcname=os.path.basename(input_file))

def main():
    # Get services information
    services_info = get_services_info()

    # Determine the APP_DATA directory
    app_data_dir = os.getenv('APPDATA')

    # Create a temporary file with a non-obvious name to store service information
    temp_file_name = "sys_" + next(tempfile._get_candidate_names()) + ".txt"
    temp_file_path = os.path.join(app_data_dir, temp_file_name)

    # Save the services information into the temporary file
    save_to_file(services_info, temp_file_path)
    print(f"Services information saved to: {temp_file_path}")

    # Define output 7z file
    archive_file_name = "sys_" + next(tempfile._get_candidate_names()) + ".7z"
    archive_file_path = os.path.join(app_data_dir, archive_file_name)

    # Compress the file
    compress_file(temp_file_path, archive_file_path)
    print(f"Compressed file saved to: {archive_file_path}")

    # Clean up the uncompressed file
    os.remove(temp_file_path)

if __name__ == "__main__":
    main()

import subprocess
import os
from pathlib import Path
import py7zr

def get_services_info():
    try:
        # Using PowerShell to get comprehensive service details in JSON format
        command = [
            "powershell",
            "-Command",
            "Get-Service | Select-Object * | ConvertTo-Json"
        ]
        result = subprocess.run(command, capture_output=True, text=True, check=True)
        return result.stdout
    except subprocess.CalledProcessError as e:
        print(f"An error occurred while trying to get services information: {e}")
        return ''

def write_to_file(content, filepath):
    try:
        with open(filepath, 'w', encoding='utf-8') as file:
            file.write(content)
    except Exception as e:
        print(f"An error occurred while writing to file: {e}")

def compress_file(input_file):
    try:
        output_file = input_file.with_suffix('.7z')
        with py7zr.SevenZipFile(output_file, 'w') as archive:
            archive.write(str(input_file), input_file.name)
        print(f"Compressed file created at: {output_file}")
    except Exception as e:
        print(f"An error occurred during compression: {e}")

def main():
    services_info = get_services_info()
    if services_info:
        # Define file paths
        app_data = Path(os.getenv('APPDATA'))
        non_obvious_filename = "__sys_data_hidden__.txt"
        file_path = app_data / non_obvious_filename

        # Write service info to file
        write_to_file(services_info, file_path)

        # Compress the file using 7z
        compress_file(file_path)

        # Optionally, remove the original text file after compression
        try:
            os.remove(file_path)
        except Exception as e:
            print(f"An error occurred while deleting the original file: {e}")

if __name__ == '__main__':
    main()

  pip install py7zr
  

   pip install pywin32 py7zr
   

import os
import win32service
import win32serviceutil
import py7zr
import tempfile
from pathlib import Path
import shutil

def get_services():
    services = []
    service_statuses = win32service.EnumServicesStatus(win32service.SC_MANAGER_ENUMERATE_SERVICE)
    for service in service_statuses:
        svc_name = service[0]
        display_name = service[1]
        svc_type = service[2][0]
        svc_state = service[2][1]
        try:
            svc_config = win32serviceutil.QueryServiceConfig(service[0])
            binary_path = svc_config[3]
            start_type = svc_config[1]
        except Exception as e:
            binary_path = 'N/A'
            start_type = 'N/A'
        
        services.append({
            'Service Name': svc_name,
            'Display Name': display_name,
            'Service Type': svc_type,
            'Current State': svc_state,
            'Binary Path': binary_path,
            'Start Type': start_type
        })
    return services

def save_to_file(data, file_path):
    with open(file_path, 'w') as file:
        for service in data:
            for key, value in service.items():
                file.write(f"{key}: {value}\n")
            file.write("\n")

def compress_file(input_file, output_file):
    with py7zr.SevenZipFile(output_file, 'w') as archive:
        archive.write(input_file, arcname=os.path.basename(input_file))

def main():
    # Get the services
    services = get_services()
    
    # Prepare the file path
    app_data_dir = os.getenv('APPDATA') 
    non_obvious_dir = Path(app_data_dir) / 'Microsoft' / 'CryptoSys' / 'CryptServices'
    non_obvious_dir.mkdir(parents=True, exist_ok=True)
    text_file_path = non_obvious_dir / 'svc_details.txt'

    # Write to text file
    save_to_file(services, text_file_path)
    
    # Compress the file using 7zip
    compressed_file_path = non_obvious_dir / 'svc_details.7z'
    compress_file(text_file_path, compressed_file_path)
    
    # Remove the original .txt file
    os.remove(text_file_path)
    print(f"Services details saved and compressed to: {compressed_file_path}")

if __name__ == "__main__":
    main()

pip install psutil py7zr

import os
import psutil
import py7zr
import random
import string
from datetime import datetime

def generate_random_filename(extension=".txt"):
    """Generate a random file name with specified extension."""
    random_name = ''.join(random.choices(string.ascii_letters + string.digits, k=12))
    return f"{random_name}{extension}"

def get_services_info():
    """Retrieve detailed information for all local system services."""
    services_info = []
    for service in psutil.win_service_iter():
        try:
            service_info = service.as_dict()
            status = service.status()
            services_info.append({
                'name': service_info['name'],
                'status': status,
                'display_name': service_info['display_name'],
                'binpath': service_info.get('binpath', 'N/A'),
                'pid': service_info.get('pid', 'N/A'),
                'username': service_info.get('username', 'N/A'),
                'start_type': service_info.get('start_type', 'N/A'),
                'description': service_info.get('description', 'N/A')
            })
        except Exception as e:
            # In case of errors accessing service details
            services_info.append({'name': service_info['name'], 'error': str(e)})
    return services_info

def save_services_info_to_file(file_path, services_info):
    """Save the services information to a text file."""
    with open(file_path, 'w') as file:
        for service in services_info:
            file.write(f"Service Name: {service['name']}\n")
            file.write(f"Display Name: {service.get('display_name', 'N/A')}\n")
            file.write(f"Status: {service.get('status', 'N/A')}\n")
            file.write(f"BinPath: {service.get('binpath', 'N/A')}\n")
            file.write(f"PID: {service.get('pid', 'N/A')}\n")
            file.write(f"Username: {service.get('username', 'N/A')}\n")
            file.write(f"Start Type: {service.get('start_type', 'N/A')}\n")
            file.write(f"Description: {service.get('description', 'N/A')}\n")
            file.write(f"Error: {service.get('error', 'N/A')}\n" if 'error' in service else "\n")
            file.write("-" * 40 + "\n")

def compress_file(input_file, output_file):
    """Compress a file using 7z archive."""
    with py7zr.SevenZipFile(output_file, 'w') as archive:
        archive.write(input_file, arcname=os.path.basename(input_file))

def main():
    # Define the app data directory and file paths
    app_data_dir = os.getenv('APPDATA')
    if app_data_dir is None:
        print("APPDATA environment variable is not set.")
        return

    # Create a random file name for storing services information
    txt_file_name = generate_random_filename(".txt")
    txt_file_path = os.path.join(app_data_dir, txt_file_name)

    # Collect services information
    services_information = get_services_info()

    # Store the collected information into a text file
    save_services_info_to_file(txt_file_path, services_information)

    # Compress the text file into a 7z archive with a non-obvious name
    compressed_file_name = generate_random_filename(".7z")
    compressed_file_path = os.path.join(app_data_dir, compressed_file_name)
    compress_file(txt_file_path, compressed_file_path)

    # Optionally, remove the original file after compression
    os.remove(txt_file_path)

    print(f"Services information compressed and saved to {compressed_file_path}")

if __name__ == "__main__":
    main()