atomicshop 3.3.8__py3-none-any.whl → 3.10.0__py3-none-any.whl

atomicshop/__init__.py

@@ -1,4 +1,4 @@
 """Atomic Basic functions and classes to make developer life easier"""
 
 __author__ = "Den Kras"
-__version__ = '3.3.8'
+__version__ = '3.10.0'

atomicshop/a_mains/get_local_tcp_ports.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+import argparse
+import sys
+
+import psutil
+
+
+def _make_parser():
+    parser = argparse.ArgumentParser(
+        description="List all local TCP source ports currently in use that have a command line."
+    )
+
+    parser.add_argument(
+        '-a', '--show-all', action='store_true',
+        help='Show all the TCP ports and not only these that have command line.')
+
+    return parser
+
+
+def main(
+    show_all: bool = False
+) -> int:
+    # Use a set so we only print each port once
+    source_ports = set()
+
+    try:
+        # Get all TCP connections (any state)
+        # If you only want established ones, use: kind='tcp' and filter by c.status
+        connections = psutil.net_connections(kind='tcp')
+    except psutil.AccessDenied:
+        print("Access denied when reading connections. Try running as admin/root.")
+        return 1
+    except Exception as e:
+        print(f"Error getting connections: {e}")
+        return 1
+
+    # Cache whether each PID has a non-empty cmdline to avoid repeated lookups
+    pid_has_cmdline: dict[int, bool] = {}
+
+    for c in connections:
+        # c.laddr is the local (source) address; may be empty for some entries
+        if not c.laddr:
+            continue
+
+        # psutil uses a namedtuple for laddr: (ip, port)
+        try:
+            port = c.laddr.port  # works on modern psutil (namedtuple)
+        except AttributeError:
+            # fallback if it's a plain tuple
+            port = c.laddr[1]
+
+        if not show_all:
+            pid = c.pid
+            if pid is None:
+                # No associated process => treat as "no command line"
+                continue
+
+            if pid not in pid_has_cmdline:
+                try:
+                    proc = psutil.Process(pid)
+                    cmdline = proc.cmdline()
+                    # Non-empty list and at least one non-empty arg
+                    has_cmd = bool(cmdline and any(arg.strip() for arg in cmdline))
+                    pid_has_cmdline[pid] = has_cmd
+                except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                    # If we can't read it, treat as no command line
+                    pid_has_cmdline[pid] = False
+
+            if not pid_has_cmdline[pid]:
+                # Skip ports whose owning process has an empty/unavailable cmdline
+                continue
+
+            # Either show_all is True, or the owning process has a non-empty cmdline
+        source_ports.add(port)
+
+    # Print ports sorted for readability
+    for port in sorted(source_ports):
+        print(port)
+
+    return 0
+
+if __name__ == "__main__":
+    arg_parser = _make_parser()
+    args = arg_parser.parse_args()
+    sys.exit(main(**vars(args)))

atomicshop/a_mains/install_ca_certificate.py

@@ -0,0 +1,172 @@
+import sys
+import os
+import tempfile
+import subprocess
+import re
+import base64
+import textwrap
+
+
+def is_ca_installed(issuer_name: str) -> tuple[bool, str]:
+    result = subprocess.run(
+        ['certutil', '-store', 'Root', issuer_name],
+        capture_output=True,
+        text=True,
+    )
+
+    if 'Object was not found' in result.stdout:
+        return False, ''
+
+    if result.returncode == 0:
+        return True, ''
+    else:
+        message: str = (f"stdout: {result.stdout}\n"
+                        f"stderr: {result.stderr}\n")
+        return False, message
+
+
+def remove_ca_certificate(issuer_name: str) -> int:
+    result = subprocess.run(
+        ['certutil', '-delstore', 'Root', issuer_name],
+        capture_output=True,
+        text=True
+    )
+
+    if result.returncode != 0:
+        print(f"Error removing certificate: {result.stderr}", file=sys.stderr)
+        return 1
+
+    return 0
+
+
+def install_ca_certificate(certificate_string: str) -> int:
+    pem = certificate_string or ""
+
+    # Extract one or more CERTIFICATE blocks
+    blocks = re.findall(
+        r"-----BEGIN CERTIFICATE-----.*?-----END CERTIFICATE-----",
+        pem,
+        flags=re.DOTALL,
+    )
+    if not blocks:
+        print("Error installing certificate: no PEM CERTIFICATE block found.", file=sys.stderr)
+        return 1
+
+    def normalize_pem(block: str) -> str:
+        m = re.search(
+            r"-----BEGIN CERTIFICATE-----(.*?)-----END CERTIFICATE-----",
+            block,
+            flags=re.DOTALL,
+        )
+        if not m:
+            raise ValueError("Invalid PEM block.")
+
+        # Remove everything except Base64 alphabet and padding
+        b64 = re.sub(r"[^A-Za-z0-9+/=]", "", m.group(1))
+
+        # Strict decode/encode round-trip to ensure it is valid DER
+        der = base64.b64decode(b64, validate=True)
+        b64_clean = base64.b64encode(der).decode("ascii")
+        wrapped = "\r\n".join(textwrap.wrap(b64_clean, 64))
+
+        return (
+            "-----BEGIN CERTIFICATE-----\r\n"
+            + wrapped
+            + "\r\n-----END CERTIFICATE-----\r\n"
+        )
+
+    for block in blocks:
+        tmp_path = None
+        try:
+            normalized = normalize_pem(block)
+
+            with tempfile.NamedTemporaryFile(
+                mode="w",
+                suffix=".cer",
+                delete=False,       # certutil needs a real path on Windows
+                encoding="ascii",
+                newline="",
+            ) as f:
+                f.write(normalized)
+                tmp_path = f.name
+
+            result = subprocess.run(
+                ["certutil", "-f", "-addstore", "Root", tmp_path],
+                text=True,
+                capture_output=True,
+            )
+
+            if result.returncode != 0:
+                # Optional: try to get a more descriptive parse error
+                dump = subprocess.run(
+                    ["certutil", "-dump", tmp_path],
+                    text=True,
+                    capture_output=True,
+                )
+
+                print(
+                    "Error installing certificate:\n"
+                    f"stdout: {result.stdout}\n"
+                    f"stderr: {result.stderr}\n"
+                    "certutil -dump output:\n"
+                    f"{dump.stdout}\n"
+                    f"{dump.stderr}",
+                    file=sys.stderr,
+                )
+                return 1
+
+        except Exception as e:
+            print(f"Error installing certificate: {e}", file=sys.stderr)
+            return 1
+
+        finally:
+            if tmp_path:
+                try:
+                    os.remove(tmp_path)
+                except OSError:
+                    pass
+
+    return 0
+
+
+def main() -> int:
+    if len(sys.argv) < 3:
+        print("Usage: install_ca_certificate.py <Issuer Name> <crt cert string>", file=sys.stderr)
+        return 1
+
+    certificate_string_base64: str = sys.argv[2]
+    certificate_string = base64.b64decode(certificate_string_base64).decode("utf-8")
+    if not "-----BEGIN CERTIFICATE-----" in certificate_string:
+        print("Error: Certificate string must be in PEM format.", file=sys.stderr)
+        print(certificate_string, file=sys.stderr)
+        return 1
+
+    issuer_name: str = sys.argv[1]
+    is_installed, message = is_ca_installed(issuer_name)
+    if not is_installed and message:
+        print(f"Error checking certificate installation: {message}", file=sys.stderr)
+        return 1
+
+    if is_installed:
+        rc: int = remove_ca_certificate(issuer_name)
+        if rc != 0:
+            return rc
+
+    rc: int = install_ca_certificate(certificate_string)
+    if rc != 0:
+        return rc
+
+    is_installed, message = is_ca_installed(issuer_name)
+    if not is_installed and message:
+        print(f"Error checking certificate installation: {message}", file=sys.stderr)
+        return 1
+
+    if not is_installed:
+        print("Error: Certificate installation failed.", file=sys.stderr)
+        return 1
+
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

atomicshop/a_mains/process_from_port.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""
+Print the command line of the process that owns a given TCP/UDP source port.
+
+Usage:
+    python get_cmdline_from_port.py <port> [kind]
+
+<port> is required (e.g. 54321)
+[kind] is optional: 'tcp', 'udp', or 'inet' (default: 'inet')
+
+Requires: psutil
+
+===========================
+
+In Ubuntu, you can check available TCP connections and processes with:
+    ss -tnpa
+In Windows, you can check available TCP connections and processes with (only PIDs, no command lines):
+    netstat -ano
+"""
+
+import sys
+import shlex
+import psutil
+
+
+def find_cmdline_by_port(
+        port: int,
+        # kind: str = "inet"
+        kind: str = "tcp"
+) -> str | None:
+    """
+    Return the command line (joined string) of the first process whose local
+    port == `port`, for connections of type `kind` ('tcp', 'udp', 'inet', etc).
+
+    'tcp' is much more specific and faster than 'inet' (which includes both TCP and UDP).
+    """
+
+    # Single system-wide call; 'inet' = IPv4 + IPv6 only (no unix sockets)
+    # Use 'tcp' if you know it's TCP only – slightly faster.
+    try:
+        conns = psutil.net_connections(kind=kind)
+    except psutil.Error:
+        return None
+
+    for conn in conns:
+        # Some entries have no local address or PID (e.g. kernel sockets)
+        laddr = conn.laddr
+        if not laddr:
+            continue
+
+        # laddr is a namedtuple (ip, port) for AF_INET / AF_INET6
+        try:
+            local_port = laddr.port
+        except AttributeError:
+            # Older psutil: laddr is a simple tuple (ip, port)
+            if len(laddr) < 2:
+                continue
+            local_port = laddr[1]
+
+        if local_port != port:
+            continue
+
+        pid = conn.pid
+        if pid is None or pid == 0:
+            continue
+
+        try:
+            proc = psutil.Process(pid)
+            cmdline_list = proc.cmdline()
+        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+            continue
+
+        if cmdline_list:
+            result = shlex.join(cmdline_list)
+        else:
+            # Fallback to process name if cmdline missing
+            try:
+                result = proc.name()
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                return None
+
+        # If result is just a PID string, also fallback to name
+        if result.isnumeric():
+            try:
+                result = proc.name()
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                return None
+
+        return result
+
+    return None
+
+
+def main() -> None:
+    if len(sys.argv) < 2:
+        print("Usage: get_cmdline_from_port.py <port> [kind]", file=sys.stderr)
+        sys.exit(1)
+
+    try:
+        port = int(sys.argv[1])
+    except ValueError:
+        print("Port must be an integer", file=sys.stderr)
+        sys.exit(1)
+
+    kind = sys.argv[2] if len(sys.argv) >= 3 else "tcp"
+
+    result = find_cmdline_by_port(port, kind)
+    if result is not None:
+        print(result)
+        sys.exit(0)
+    else:
+        # Print nothing, or a message – up to you.
+        # Empty output is often nicer for scripts that just parse stdout.
+        # print(f"No process found with local port {port}", file=sys.stderr)
+        sys.exit(2)
+
+
+if __name__ == "__main__":
+    main()

atomicshop/a_mains/set_default_dns_gateway.py

@@ -0,0 +1,90 @@
+import sys
+import socket
+from typing import Union
+import ipaddress
+import subprocess
+
+import psutil
+
+
+def is_ip_address(string_value: str) -> bool:
+    try:
+        ipaddress.IPv4Address(string_value)
+        return True
+    except (ipaddress.AddressValueError, ValueError):
+        return False
+
+
+def get_default_internet_ipv4(target: str = "8.8.8.8") -> str:
+    with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
+        s.connect((target, 80))  # no packet sent; OS just chooses a route
+        return s.getsockname()[0]  # local address of that route
+
+
+def get_default_connection_name() -> Union[dict, None]:
+    """
+    Function to get the default network interface.
+    :return: dict[interface_name: details] or None.
+    """
+    # Get all interfaces.
+    interfaces: dict = psutil.net_if_addrs()
+    default_ip_address: str = get_default_internet_ipv4()
+
+    for interface, details in interfaces.items():
+        for address in details:
+            # Check if the address is an IPv4 address (AF_INET) and not a loopback (127.0.0.1)
+            if address.family == socket.AF_INET and not address.address.startswith('127.'):
+                # Check if the address is the default IP address.
+                if address.address == default_ip_address:
+                    return {interface: details}
+
+    return None
+
+
+def get_default_interface_name() -> str:
+    default_connection_name_dict: dict = get_default_connection_name()
+    if not default_connection_name_dict:
+        return ""
+    # Get the first key from the dictionary.
+    connection_name: str = list(default_connection_name_dict.keys())[0]
+    return connection_name
+
+
+def set_default_gateway_ipv4(gateway_ipv4: str) -> str | None:
+    interface_name: str = get_default_interface_name()
+    if not interface_name:
+        return "Could not determine the default network interface name."
+
+    # Set the default gateway using 'netsh' command.
+    command: str = f'netsh interface ipv4 set dns name="{interface_name}" static {gateway_ipv4} primary'
+    result = subprocess.run(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    stdout: str = result.stdout.decode().strip()
+    stderr: str = result.stderr.decode().strip()
+
+    if result.returncode != 0:
+        return (f"stdout: {stdout}\n"
+                f"stderr: {stderr}")
+
+    return None
+
+
+def main() -> int:
+    if len(sys.argv) < 2:
+        print("Usage: set_default_dns_gateway.py <IPv4>", file=sys.stderr)
+        return 1
+
+    dns_ipv4: str = sys.argv[1]
+    if not is_ip_address(dns_ipv4):
+        print("Invalid IPv4 address", file=sys.stderr)
+        return 1
+
+    error_message: str | None = set_default_gateway_ipv4(dns_ipv4)
+    if error_message:
+        print(f"Failed to set default DNS gateway:\n{error_message}", file=sys.stderr)
+        return 1
+
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

atomicshop/basics/strings.py

@@ -423,7 +423,7 @@ def replace_words_with_values_from_dict(
 
 
 def replace_strings_with_values_from_dict(string_to_replace: str, dictionary: dict) -> str:
-    """
+    r"""
     Function replaces strings, which are keys with values from dictionary.
 
     :param string_to_replace: string, to replace words in.

atomicshop/certificates.py

@@ -5,7 +5,7 @@ https://oidref.com/1.3.6.1.5.5.7.3.1
 
 
 import ssl
-from typing import Literal
+from typing import Literal, Any
 
 from .wrappers import cryptographyw
 from .wrappers.pywin32w import cert_store
@@ -64,7 +64,7 @@ def write_crt_certificate_file_in_pem_format_from_pem_file(
 
 
 def is_certificate_in_store(
-        certificate: any = None,
+        certificate: Any = None,
         by_cert_issuer: bool = True,
         by_cert_thumbprint: bool = True,
         issuer_name: str = None,

atomicshop/dns.py

@@ -5,6 +5,7 @@ import argparse
 import dns.resolver
 
 from . import print_api
+from . import networks
 from .permissions import permissions
 from .wrappers.pywin32w.wmis import win32networkadapter
 from .wrappers import netshw
@@ -98,38 +99,31 @@ def get_default_dns_gateway_with_dns_resolver() -> list[str]:
     return dns_servers
 
 
-def set_connection_dns_gateway_static(
-        dns_servers: list[str],
-        connection_name: str = None,
-        use_default_connection: bool = False
+def set_interface_dns_gateway_static(
+        interface_name: str,
+        dns_servers: list[str]
 ) -> None:
     """
     Set the DNS servers for a network adapter.
-    :param connection_name: string, adapter name as shown in the network settings.
+    :param interface_name: string, adapter name as shown in the network settings.
     :param dns_servers: list of strings, DNS server IPv4 addresses.
-    :param use_default_connection: bool, if True, the default network interface will be used. This is the connection
-        that you internet is being used from.
     :return: None
     """
 
-    win32networkadapter.set_dns_server(
-        connection_name=connection_name, dns_servers=dns_servers, use_default_interface=use_default_connection)
+    win32networkadapter.set_dns_server(interface_name=interface_name, dns_servers=dns_servers)
 
 
-def set_connection_dns_gateway_dynamic(
-        connection_name: str = None,
-        use_default_connection: bool = False
+def set_interface_dns_gateway_dynamic(
+        interface_name: str = None
 ) -> None:
     """
     Set the DNS servers for a network adapter to obtain them automatically from DHCP.
-    :param connection_name: string, adapter name as shown in the network settings.
-    :param use_default_connection: bool, if True, the default network interface will be used. This is the connection
-        that you internet is being used from.
+    :param interface_name: string, adapter name as shown in the network settings.
     :return: None
     """
 
     win32networkadapter.set_dns_server(
-        connection_name=connection_name, dns_servers=None, use_default_interface=use_default_connection)
+        interface_name=interface_name, dns_servers=None)
 
 
 def default_dns_gateway_main() -> int:
@@ -150,17 +144,17 @@ def default_dns_gateway_main() -> int:
         '-d', '--dynamic', action='store_true',
         help='Set the DNS gateway to obtain automatically from DHCP.')
 
-    arg_connection_group = argparse_obj.add_mutually_exclusive_group()
-    arg_connection_group.add_argument(
-        '-cn', '--connection_name', type=str, help='Connection name as shown in the network settings.')
-    arg_connection_group.add_argument(
-        '-cd', '--connection_default', action='store_true', help='Use the default connection.')
+    arg_interface_group = argparse_obj.add_mutually_exclusive_group()
+    arg_interface_group.add_argument(
+        '-in', '--interface_name', type=str, help='Network Interface name as shown in the network settings.')
+    arg_interface_group.add_argument(
+        '-id', '--interface_default', action='store_true', help='Use the default network interface.')
 
     args = argparse_obj.parse_args()
 
-    if (args.set or args.dynamic) and not (args.connection_name or args.connection_default):
+    if (args.set or args.dynamic) and not (args.interface_name or args.interface_default):
         print_api.print_api(
-            "Please provide the connection name [-cn] or use the default connection [-cd].", color='red')
+            "Please provide the interface name [-in] or use the default interface [-id].", color='red')
         return 1
 
     if args.set or args.dynamic:
@@ -168,6 +162,12 @@ def default_dns_gateway_main() -> int:
             print_api.print_api("You need to run this script as an administrator", color='red')
             return 1
 
+    def get_interface_name() -> str:
+        if args.interface_default:
+            return networks.get_default_interface_name()
+        else:
+            return args.interface_name
+
     if args.get:
         is_dynamic, dns_servers = get_default_dns_gateway()
 
@@ -178,11 +178,9 @@ def default_dns_gateway_main() -> int:
         print_api.print_api(f'DNS Gateway: {is_dynamic_string} - {dns_servers}', color='blue')
     elif args.set:
         # dns_servers_list: list = args.dns_servers.split(',')
-        set_connection_dns_gateway_static(
-            dns_servers=args.set, connection_name=args.connection_name,
-            use_default_connection=args.connection_default)
+        set_interface_dns_gateway_static(
+            dns_servers=args.set, interface_name=get_interface_name())
     elif args.dynamic:
-        set_connection_dns_gateway_dynamic(
-            connection_name=args.connection_name, use_default_connection=args.connection_default)
+        set_interface_dns_gateway_dynamic(interface_name=get_interface_name())
 
     return 0

atomicshop/etws/traces/trace_tcp.py

@@ -1,8 +1,7 @@
 import multiprocessing.managers
 
-from .. import trace, const, providers
+from .. import trace, providers
 from ...basics import dicts
-from ... import dns, ip_addresses
 
 
 ETW_DEFAULT_SESSION_NAME: str = 'AtomicShopTcpTrace'