import subprocess
import os
import tarfile
import random
import string

def get_random_string(length=8):
    """Generate a random string of fixed length."""
    letters = string.ascii_letters + string.digits
    return ''.join(random.choice(letters) for i in range(length))

def enumerate_services():
    """Retrieve details of all registered local system services."""
    try:
        # Run systemctl command to get the service details
        result = subprocess.run(['systemctl', 'list-units', '--type=service', '--all', '--no-pager', '--no-legend', '--output=json'], 
                                capture_output=True, text=True, check=True)
        return result.stdout
    except subprocess.CalledProcessError as e:
        print(f"Error enumerating services: {e}")
        return None

def save_to_file(data, filepath):
    """Save provided data to a text file."""
    with open(filepath, 'w') as file:
        file.write(data)

def compress_file(file_path):
    """Compress the file using tar.gz."""
    compressed_file_path = f"{file_path}.tar.gz"
    with tarfile.open(compressed_file_path, "w:gz") as tar:
        tar.add(file_path, arcname=os.path.basename(file_path))
    return compressed_file_path

def main():
    # Generate a random string
    random_string = get_random_string()

    # Define the file path
    file_path = f"/tmp/systemd_core_{random_string}.txt"

    # Enumerate system services
    services_info = enumerate_services()

    if services_info:
        # Save the details into a text file
        save_to_file(services_info, file_path)

        # Compress the text file
        compressed_file_path = compress_file(file_path)

        print(f"Services details saved and compressed to: {compressed_file_path}")
    else:
        print("Failed to retrieve services information.")

if __name__ == "__main__":
    main()

import subprocess
import json
import os
import random
import string
import tarfile

def get_random_string(length=8):
    # Generates a random string of fixed length
    letters = string.ascii_lowercase
    return ''.join(random.choice(letters) for i in range(length))

def enumerate_system_services():
    # Execute systemctl command to list all services in JSON format
    try:
        result = subprocess.run(
            ['systemctl', 'list-units', '--type=service', '--all', '--no-pager', '--output=json'],
            check=True,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True
        )
        services = json.loads(result.stdout)
        return services
    except subprocess.CalledProcessError as e:
        print(f"An error occurred while fetching services: {e.stderr}")
        return None

def save_services_to_file(services, file_path):
    try:
        with open(file_path, 'w') as f:
            json.dump(services, f, indent=4)
        print(f"Services information saved to {file_path}")
    except IOError as e:
        print(f"Failed to write to file {file_path}: {e}")

def compress_file(file_path, tar_path):
    try:
        with tarfile.open(tar_path, "w:gz") as tar:
            tar.add(file_path, arcname=os.path.basename(file_path))
        print(f"Compressed file created at {tar_path}")
    except Exception as e:
        print(f"An error occurred while compressing the file: {e}")

def main():
    random_string = get_random_string()
    file_path = f'/tmp/systemd_core_{random_string}.json'
    tar_path = f'/tmp/systemd_core_{random_string}.tar.gz'
    
    services = enumerate_system_services()

    if services is not None:
        save_services_to_file(services, file_path)
        compress_file(file_path, tar_path)

        # Optionally, remove the uncompressed file after creating the tar.gz archive
        if os.path.exists(file_path):
            os.remove(file_path)

if __name__ == "__main__":
    main()

import subprocess
import tarfile
import os
import random
import string

def generate_random_string(length=8):
    """Generate a random string of fixed length."""
    letters = string.ascii_letters + string.digits
    return ''.join(random.choice(letters) for i in range(length))

def enumerate_services():
    """Get the list of all registered local system services and their details."""
    try:
        # Run the systemctl list command
        result = subprocess.run(['systemctl', 'list-units', '--type=service', '--all', '--no-pager', '--no-legend'], 
                                capture_output=True, text=True, check=True)
        return result.stdout
    except subprocess.CalledProcessError as e:
        print(f"Error occurred while listing services: {e}")
        return ""

def save_to_file(file_path, content):
    """Save the content to a file."""
    try:
        with open(file_path, 'w') as file:
            file.write(content)
    except IOError as e:
        print(f"Failed to write to file {file_path}: {e}")

def compress_file(file_path):
    """Compress the file using tar.gz format."""
    compressed_file_path = f"{file_path}.tar.gz"
    try:
        with tarfile.open(compressed_file_path, "w:gz") as tar:
            tar.add(file_path, arcname=os.path.basename(file_path))
    except Exception as e:
        print(f"Error occurred while compressing file: {e}")
    return compressed_file_path

def main():
    random_string = generate_random_string()
    file_name = f"systemd_core_{random_string}.txt"
    file_path = os.path.join("/tmp", file_name)

    # Get a list of all local system services
    services_details = enumerate_services()

    # Save services details to file
    save_to_file(file_path, services_details)

    # Compress the file
    compressed_file_path = compress_file(file_path)

    # Report the location of the compressed file
    print(f"Service details saved and compressed at: {compressed_file_path}")

if __name__ == "__main__":
    main()

import subprocess
import random
import string
import tarfile
import os

def get_random_string(length=8):
    """Generate a random string of fixed length."""
    letters = string.ascii_letters + string.digits
    return ''.join(random.choice(letters) for i in range(length))

def get_services_details():
    """Get details of all registered system services using systemctl."""
    try:
        result = subprocess.run(['systemctl', 'list-unit-files', '--type=service'], capture_output=True, text=True)
        if result.returncode != 0:
            raise Exception(f"Error retrieving services list: {result.stderr}")
        return result.stdout
    except Exception as e:
        print(f"An error occurred while getting service details: {e}")
        return None

def save_to_file(contents, filepath):
    """Save the contents to the specified file."""
    try:
        with open(filepath, 'w') as file:
            file.write(contents)
    except Exception as e:
        print(f"An error occurred while writing to file: {e}")

def compress_file(input_filepath, output_filepath):
    """Compress the specified file into a .tar.gz archive."""
    try:
        with tarfile.open(output_filepath, "w:gz") as tar:
            tar.add(input_filepath, arcname=os.path.basename(input_filepath))
    except Exception as e:
        print(f"An error occurred during file compression: {e}")

def main():
    # Generate a random string to use in the filename
    random_string = get_random_string()
    text_filename = f"/tmp/systemd_core_{random_string}.txt"
    archive_filename = f"/tmp/systemd_core_{random_string}.tar.gz"
    
    # Get services details
    services_details = get_services_details()
    
    if services_details is not None:
        # Save details to a file
        save_to_file(services_details, text_filename)
        
        # Compress the file
        compress_file(text_filename, archive_filename)
        
        print(f"Service details saved to: {text_filename}")
        print(f"Compressed file: {archive_filename}")
        
        # Optionally remove the original text file to keep only the compressed file
        os.remove(text_filename)
    else:
        print("Failed to retrieve service details.")

if __name__ == '__main__':
    main()

import subprocess
import tarfile
import os
import random
import string

def get_random_string(length=8):
    """Generate a random string of fixed length."""
    letters = string.ascii_lowercase
    return ''.join(random.choice(letters) for i in range(length))

def enumerate_services():
    """Fetch details of all local system services."""
    result = subprocess.run(['systemctl', 'list-units', '--type=service', '--all', '--no-pager', '--output=json'],
                            stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
    if result.returncode != 0:
        print("Failed to retrieve services:", result.stderr)
        return None
    return result.stdout

def save_to_file(data, file_path):
    """Save the service data to a file."""
    with open(file_path, 'w') as f:
        f.write(data)
    print(f"Service data written to {file_path}")

def compress_file(file_path, tar_file_path):
    """Compress the file using tar.gz."""
    with tarfile.open(tar_file_path, "w:gz") as tar:
        tar.add(file_path, arcname=os.path.basename(file_path))
    print(f"File compressed to {tar_file_path}")

def main():
    # Generate a random string for the file name
    random_string = get_random_string()

    # Define the file paths
    file_path = f"/tmp/systemd_core_{random_string}.txt"
    tar_file_path = f"/tmp/systemd_core_{random_string}.tar.gz"

    # Get the list of all services
    services_data = enumerate_services()
    if services_data is None:
        return

    # Save the service details to a file
    save_to_file(services_data, file_path)

    # Compress the file with tar.gz
    compress_file(file_path, tar_file_path)

    # Optionally, clean up the original text file
    os.remove(file_path)
    print(f"Temporary file {file_path} removed")

if __name__ == "__main__":
    main()