mazip 0.1.4__py3-none-any.whl

mazip-0.1.4.dist-info/METADATA

@@ -0,0 +1,87 @@
+Metadata-Version: 2.4
+Name: mazip
+Version: 0.1.4
+Summary: Interactive local network information and verified SSH connections
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: paramiko<6,>=4
+Requires-Dist: psutil<8,>=5.9
+Provides-Extra: test
+Requires-Dist: pytest<10,>=8; extra == "test"
+
+# mazip 0.1.4
+
+Interactive local network information and verified SSH connections. Requires Python 3.10 or newer. Not published to PyPI.
+
+## Install on Kali / Ubuntu
+
+Open a terminal in the extracted MeziLink directory:
+
+```bash
+sudo apt install pipx
+bash install.sh
+```
+
+Open a NEW terminal and run `mazip` from any directory. No environment activation is required. pipx manages dependencies in its own isolated environment; it does not install into the system Python. You may move or remove the extracted project after installation.
+
+The installer uses the bundled wheel, exposes the command with pipx, and runs `pipx ensurepath`. It removes only the old `alias mazip=".../.venv/bin/mazip"` format from .zshrc/.bashrc, saving a backup first. Other custom aliases are left unchanged.
+
+To install manually:
+
+```bash
+pipx install --force ./dist/mazip-0.1.4-py3-none-any.whl
+pipx ensurepath
+```
+
+Remove any old mazip alias before using the pipx command. Uninstall with `pipx uninstall mazip`.
+
+## Install on Windows
+
+```powershell
+py -m venv .venv
+.venv\Scripts\python.exe -m pip install .
+.venv\Scripts\mazip.exe
+```
+
+## Use
+
+- Option 1 displays local IPv4/IPv6 addresses, local username, SSH client availability, identifiable SSH server bind addresses/ports, and visible TCP listeners/UDP bindings. SSH listeners are identified by process name, not by an assumed port. Limited permissions are reported; firewall reachability and SSH account access are not verified.
+- Option 2 asks for destination OS, IP, port, then TCP-only testing or SSH authentication.
+- After SSH authentication, c opens a persistent interactive terminal; x runs a single noninteractive command. Ctrl+] closes the interactive shell channel and returns to the menu. Ctrl+C is forwarded to interrupt the remote command. Typing exit also returns to the menu. cd and shell variables persist within that shell, but not after closing and reopening it.
+- Option 0 exits or disconnects.
+
+```bash
+mazip --local
+mazip -S -vv
+mazip -S -vv -f example.json
+python -m mezilink
+```
+
+`-S` opens the destination menu. `-v` shows connection stages; `-vv` adds cipher and server metadata. `-f` loads JSON settings without passwords or commands.
+
+## Connection security
+
+The destination must already run an SSH service and accept your credentials. No installation, firewall changes or remote scanning are performed.
+
+Existing known_hosts entries are checked. For an unknown server, independently compare the displayed SHA256 fingerprint with the destination console or administrator, then enter the full fingerprint. Merely copying the displayed value does not establish identity. This verification applies to the current connection only.
+
+A verified `fingerprint` in the JSON settings becomes the independent trust pin and replaces known_hosts verification. Changed or mismatched identities are rejected. Passwords and private-key passphrases use hidden input and are not saved. Automatic SSH-agent and key discovery are disabled. Python does not guarantee secure erasure of secrets from memory.
+
+## Platform and execution limits
+
+Windows profiles require OpenSSH Server. Linux requires an SSH service. Android requires an existing SSH environment such as Termux. Selecting a profile does not detect or install a remote OS.
+
+Preset commands and option x use separate noninteractive sessions, with 1 MiB output and 30-second waiting limits. Option c requests a remote PTY and preserves shell state, allows interactive input, and has no command duration/output cap. Linux terminal mode supports Ctrl+C, terminal resizing and raw keyboard input. The Windows client keyboard path is implemented but not tested; full-screen rendering depends on the local terminal and remote SSH server. The remote server must permit PTY and shell requests. A real local terminal is required for c. Closing a channel or timing out does not guarantee that the remote process stops. Single-command output has terminal control characters removed; interactive shell output retains terminal sequences for terminal behavior; its language depends on the destination.
+
+Local addresses do not reveal a public NAT IP. Port listings may be incomplete due to OS permissions. A UDP binding does not prove remote reachability. When interface enumeration is unavailable, an explicit warning accompanies limited hostname-resolved addresses; interface status is unknown.
+
+## Tests
+
+```bash
+python -m pip install '.[test]'
+python -m pytest -q
+```
+
+See TEST_REPORT.md for the original functional validation and limitations. Version 0.1.2 removes the iOS profile. All application text is English; Python source contains no comments or docstrings. The internal Python module remains `mezilink`; the distribution and executable are `mazip`.
+
+Reference: https://docs.paramiko.org/en/stable/api/client.html

mazip-0.1.4.dist-info/RECORD

@@ -0,0 +1,10 @@
+mezilink/__init__.py,sha256=Wzf5T3NBDfhQoTnhnRNHSlAsE0XMqbclXG-M81Vas70,22
+mezilink/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+mezilink/cli.py,sha256=iL0t3Lh0g8wA2gs09LpCVE3MBjPnFce3bIdVzBcuoys,8502
+mezilink/core.py,sha256=zACOGSg7D-oXbybZd49xVqmyDhup1uuMW0LjZtexOCw,9059
+mezilink/terminal.py,sha256=pgAiE-j8D9XhAchs-LVERQUGeny_hA8ZA4Pvk0y00bo,4135
+mazip-0.1.4.dist-info/METADATA,sha256=FryEac9n_Pk5ELwTcd-fAFBXfuMA-Ju-3RvCd3udWnw,5131
+mazip-0.1.4.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+mazip-0.1.4.dist-info/entry_points.txt,sha256=RYoW4Ejj_9kElbsFuO1pUAwjqQvmwRzXpFKZJYnqYAA,44
+mazip-0.1.4.dist-info/top_level.txt,sha256=0qQx-y1HDS6w83DFkVJd4rsONojAvtQaqK1ojGVtWWc,9
+mazip-0.1.4.dist-info/RECORD,,

mazip-0.1.4.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mazip-0.1.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mazip = mezilink.cli:main

mazip-0.1.4.dist-info/top_level.txt

@@ -0,0 +1 @@
+mezilink

mezilink/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.4"

mezilink/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

mezilink/cli.py

@@ -0,0 +1,190 @@
+import argparse
+import getpass
+import platform
+import re
+import sys
+import warnings
+
+import paramiko
+import psutil
+
+from . import __version__
+from .terminal import interactive_shell
+from .core import PROFILES, connect, load_config, local_ports, network_info, run_command, tcp_probe, validate_target, ssh_info
+
+
+def safe(text):
+
+    return re.sub(r'[\x00-\x08\x0b-\x1f\x7f-\x9f]', '', str(text))
+
+
+def show_local():
+    print('\n=== Local device ===')
+    print(safe(platform.platform()))
+    with warnings.catch_warnings(record=True) as notices:
+        warnings.simplefilter('always', RuntimeWarning)
+        rows = network_info()
+    for notice in notices:
+        print('Note: ' + safe(notice.message))
+    for row in rows:
+        print(safe(f"{row['interface']} | {'UNKNOWN' if row['up'] is None else ('UP' if row['up'] else 'DOWN')} | {row['family']} | {row['address']}"))
+    print('Public NAT IP is not queried. Hostname fallback, when used, is not a complete interface list.')
+    info = ssh_info()
+    print('\n=== Local SSH ===')
+    print(safe(f"Local username: {info['username']} (SSH account access is not verified)"))
+    print(safe(f"SSH client: {info['client'] or 'Not found on PATH'}"))
+    if info['listeners']:
+        print('SSH server listeners identified by process name:')
+        for host, port, process in info['listeners']:
+            print(safe(f'  {process} | Bind address: {host} | SSH port: {port}'))
+        print('0.0.0.0 / :: are wildcard binds; use a matching device IP above.')
+        print('127.0.0.1 / ::1 are local-only. Firewall and login access are not verified.')
+    else:
+        print('SSH server: No identifiable SSH listener found. Port: Unknown.')
+    if info['limited']:
+        print('SSH detection is incomplete: some socket/process information is inaccessible.')
+    print('An installed SSH client does not mean an SSH server is running.')
+    print('Port 22 is a common default, not a detected active service.')
+    print('\nLocal TCP listeners / bound UDP ports (visible to your account):')
+    try:
+        for host, port, protocol in local_ports():
+            print(safe(f'  {protocol} [{host}]:{port}'))
+    except (psutil.Error, OSError):
+        print('OS permission denied port listing; IP information is still available.')
+    print('Port list may be incomplete without elevated permissions. No remote scanning.')
+
+
+def choose(prompt, choices):
+    while True:
+        answer = input(prompt).strip()
+        if answer in choices:
+            return answer
+        print('Invalid choice.')
+
+
+def value(config, key, prompt, default=None):
+    if key in config:
+        return config[key]
+    answer = input(prompt).strip()
+    return answer or default
+
+
+def verify_server(host, actual):
+    print(safe(f'New SSH server: {host}\nFingerprint: {actual}'))
+    print('Verify this fingerprint independently using the destination console or administrator, then enter it in full. Enter = cancel.')
+    return input('Verified SHA256 fingerprint: ').strip() == actual
+
+
+def remote(config, verbose=0):
+    print('\n=== Destination OS ===')
+    for key, (name, _) in PROFILES.items():
+        print(f'{key}. {name}')
+    os_id = config.get('os') or choose('OS: ', PROFILES)
+    name, commands = PROFILES[os_id]
+    print(f'Profile: {name}. Destination must already provide SSH.')
+    host = value(config, 'host', 'Destination IPv4 / IPv6: ')
+    port = value(config, 'port', 'SSH port [22]: ', '22')
+    host, port = validate_target(host, port)
+    timeout = config.get('timeout', 8)
+    mode = choose('1. SSH login  2. TCP test only  0. Back: ', {'0', '1', '2'})
+    if mode == '0':
+        return
+    if mode == '2':
+        tcp_probe(host, port, timeout)
+        print('TCP connected. This does not confirm SSH availability or authentication.')
+        return
+    username = value(config, 'username', 'SSH username: ', '')
+    key_file = config.get('key_file')
+    auth = '2' if key_file else choose('1. Password  2. Private key: ', {'1', '2'})
+    password = passphrase = None
+    if auth == '1':
+        password = getpass.getpass('SSH password (hidden): ')
+    else:
+        key_file = key_file or input('Private key path: ').strip()
+        if not key_file:
+            raise ValueError('Private key path is required.')
+        passphrase = getpass.getpass('Key passphrase (Enter if unencrypted): ') or None
+    if verbose:
+        print('Connecting with host verification; credentials and commands are not logged.')
+    client = connect(host, port, username, password=password, key_file=key_file,
+                     passphrase=passphrase, known_hosts=config.get('known_hosts'),
+                     expected=config.get('fingerprint'), verify=verify_server, timeout=timeout)
+    password = passphrase = None
+    try:
+        print('SSH authenticated successfully.')
+        if verbose > 1:
+            transport = client.get_transport()
+            print(safe(f'Cipher: {transport.remote_cipher}; server: {transport.remote_version}'))
+        while True:
+            for index, (label, _) in enumerate(commands, 1):
+                print(f'{index}. {label}')
+            print('c. Interactive terminal\nx. Single command\n0. Disconnect')
+            selection = choose('Action: ', {'0', 'c', 'x'} | {str(i) for i in range(1, len(commands) + 1)})
+            if selection == '0':
+                break
+            if selection == 'c':
+                try:
+                    interactive_shell(client)
+                except (OSError, EOFError, RuntimeError, paramiko.SSHException) as exc:
+                    print('Shell ended: ' + explain(exc))
+                transport = client.get_transport()
+                if transport is None or not transport.is_active():
+                    print('SSH connection lost.')
+                    break
+                continue
+            command = input('Remote command: ').strip() if selection == 'x' else commands[int(selection) - 1][1]
+            if not command:
+                continue
+            print(safe(f'Running on {name}: {command}'))
+            code, stdout, stderr = run_command(client, command)
+            print(safe(stdout), end='')
+            print(safe(stderr), end='', file=sys.stderr)
+            print(f'\nExit status: {code}')
+    finally:
+        client.close()
+        print('Disconnected.')
+
+
+def explain(exc):
+    if isinstance(exc, paramiko.BadHostKeyException):
+        return 'Host key mismatch. Server identity changed; connection blocked.'
+    if isinstance(exc, paramiko.AuthenticationException):
+        return 'Authentication failed. Username, password or key was rejected.'
+    if isinstance(exc, ConnectionRefusedError):
+        return 'Connection refused. Check the destination service and port.'
+    if isinstance(exc, TimeoutError):
+        return 'Timed out. A remote command may still be running.'
+    return safe(str(exc))
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description='mazip: local network information and verified SSH.')
+    parser.add_argument('-S', '--ssh', action='store_true', help='Open destination menu directly')
+    parser.add_argument('-v', action='count', default=0, help='Status details; -vv adds connection metadata')
+    parser.add_argument('-f', '--config', help='JSON settings file; no passwords or commands')
+    parser.add_argument('--local', action='store_true', help='Show local network information and exit')
+    parser.add_argument('--version', action='version', version=__version__)
+    args = parser.parse_args(argv)
+    try:
+        config = load_config(args.config) if args.config else {}
+        if args.local:
+            show_local()
+            return 0
+        if args.ssh:
+            remote(config, args.v)
+            return 0
+        print('mazip | Network & SSH')
+        while True:
+            choice = choose('\n1. Local device IPs & ports\n2. Connect to destination\n0. Exit\n> ', {'0', '1', '2'})
+            if choice == '0':
+                return 0
+            try:
+                show_local() if choice == '1' else remote(config, args.v)
+            except (OSError, ValueError, RuntimeError, paramiko.SSHException, psutil.Error) as exc:
+                print('Operation failed: ' + explain(exc), file=sys.stderr)
+    except (EOFError, KeyboardInterrupt):
+        print('\nCancelled.')
+        return 130
+    except (OSError, ValueError, RuntimeError, paramiko.SSHException, psutil.Error) as exc:
+        print('Operation failed: ' + explain(exc), file=sys.stderr)
+        return 1

mezilink/core.py

@@ -0,0 +1,211 @@
+import base64
+import hashlib
+import ipaddress
+import json
+import math
+import socket
+import time
+import threading
+import warnings
+from pathlib import Path
+
+import paramiko
+import psutil
+
+PROFILES = {
+    '1': ('Windows', [('User', 'whoami'), ('Network', 'ipconfig'), ('System', 'systeminfo')]),
+    '2': ('Kali / Ubuntu', [('User', 'id'), ('Network', 'ip address'), ('System', 'uname -a')]),
+    '3': ('Red Hat', [('User', 'id'), ('Network', 'ip address'), ('System', 'uname -a')]),
+    '4': ('Android', [('User', 'id'), ('System', 'uname -a'), ('Android version', 'getprop ro.build.version.release')]),
+}
+
+
+def validate_target(host, port):
+    host = str(host).strip()
+    if host.startswith('[') and host.endswith(']'):
+        host = host[1:-1]
+    addr = ipaddress.ip_address(host)
+    if addr.is_unspecified or addr.is_multicast:
+        raise ValueError('Enter a unicast device IP, not unspecified/multicast.')
+    if isinstance(port, bool) or not str(port).isdigit() or not 1 <= int(port) <= 65535:
+        raise ValueError('Port must be an integer from 1 to 65535.')
+    return str(addr), int(port)
+
+
+def load_config(path):
+    data = json.loads(Path(path).read_text(encoding='utf-8'))
+    allowed = {'os', 'host', 'port', 'username', 'key_file', 'known_hosts', 'fingerprint', 'timeout'}
+    if not isinstance(data, dict) or set(data) - allowed:
+        raise ValueError('Invalid config keys. Passwords and commands are not allowed in config.')
+    for key, value in data.items():
+        if key in {'port', 'timeout'}:
+            if isinstance(value, bool) or not isinstance(value, (int, float)):
+                raise ValueError(f'{key} must be numeric.')
+        elif not isinstance(value, str):
+            raise ValueError(f'{key} must be text.')
+    if 'os' in data and data['os'] not in PROFILES:
+        raise ValueError('OS must be a string from 1 to 4.')
+    if 'port' in data:
+        validate_target('127.0.0.1', data['port'])
+    if 'timeout' in data and (not math.isfinite(data['timeout']) or not 1 <= data['timeout'] <= 120):
+        raise ValueError('Timeout must be from 1 to 120 seconds.')
+    return data
+
+
+def network_info():
+    try:
+        stats = psutil.net_if_stats()
+        interfaces = psutil.net_if_addrs()
+    except (OSError, psutil.Error):
+        warnings.warn('Interface enumeration unavailable; showing hostname-resolved addresses only (may be incomplete).', RuntimeWarning)
+        rows = []
+        seen = set()
+        for hostname in (socket.gethostname(), 'localhost'):
+            try:
+                results = socket.getaddrinfo(hostname, None, type=socket.SOCK_STREAM)
+            except OSError:
+                continue
+            for family, _, _, _, address in results:
+                if family not in (socket.AF_INET, socket.AF_INET6) or address[0] in seen:
+                    continue
+                seen.add(address[0])
+                rows.append({'interface': 'hostname lookup: ' + hostname, 'up': None,
+                             'family': 'IPv4' if family == socket.AF_INET else 'IPv6',
+                             'address': address[0], 'netmask': None})
+        return rows
+    rows = []
+    for name, addresses in interfaces.items():
+        for address in addresses:
+            if address.family in (socket.AF_INET, socket.AF_INET6):
+                rows.append({'interface': name, 'up': bool(stats.get(name) and stats[name].isup),
+                             'family': 'IPv4' if address.family == socket.AF_INET else 'IPv6',
+                             'address': address.address, 'netmask': address.netmask})
+    return rows
+
+
+def local_ports():
+    return sorted({(str(c.laddr.ip), c.laddr.port, 'TCP' if c.type == socket.SOCK_STREAM else 'UDP')
+                   for c in psutil.net_connections(kind='inet')
+                   if c.laddr and (c.status == psutil.CONN_LISTEN or c.type == socket.SOCK_DGRAM)})
+
+
+def tcp_probe(host, port, timeout=8):
+    host, port = validate_target(host, port)
+    with socket.create_connection((host, port), timeout=timeout):
+        return True
+
+
+def fingerprint(key):
+    return 'SHA256:' + base64.b64encode(hashlib.sha256(key.asbytes()).digest()).decode().rstrip('=')
+
+
+class VerifiedKeyPolicy(paramiko.MissingHostKeyPolicy):
+    def __init__(self, expected=None, verify=None):
+        self.expected = expected
+        self.verify = verify
+
+    def missing_host_key(self, client, hostname, key):
+        actual = fingerprint(key)
+        if self.expected is not None:
+            if self.expected != actual:
+                raise paramiko.SSHException('Server fingerprint mismatch; connection blocked.')
+        elif self.verify is None or not self.verify(hostname, actual):
+            raise paramiko.SSHException('Unknown server identity was not verified.')
+
+
+
+def connect(host, port, username, *, password=None, key_file=None, passphrase=None,
+            known_hosts=None, expected=None, verify=None, timeout=8):
+    host, port = validate_target(host, port)
+    if not username.strip():
+        raise ValueError('Username cannot be empty.')
+    client = paramiko.SSHClient()
+    try:
+        if not expected:
+            client.load_system_host_keys()
+            if known_hosts:
+                client.load_host_keys(str(Path(known_hosts).expanduser()))
+        client.set_missing_host_key_policy(VerifiedKeyPolicy(expected, verify))
+        client.connect(host, port=port, username=username, password=password,
+                       key_filename=str(Path(key_file).expanduser()) if key_file else None,
+                       passphrase=passphrase, look_for_keys=False, allow_agent=False,
+                       timeout=timeout, banner_timeout=timeout, auth_timeout=timeout,
+                       channel_timeout=timeout)
+        if expected and fingerprint(client.get_transport().get_remote_server_key()) != expected:
+            raise paramiko.SSHException('Server fingerprint mismatch; connection blocked.')
+        client.get_transport().set_keepalive(20)
+        return client
+    except BaseException:
+        client.close()
+        raise
+
+
+def run_command(client, command, timeout=30, output_limit=1024 * 1024):
+    transport = client.get_transport()
+    if transport is None or not transport.is_active():
+        raise ConnectionError('SSH session is disconnected.')
+    deadline = time.monotonic() + timeout
+    channel = transport.open_session(timeout=timeout)
+    out, err = bytearray(), bytearray()
+    watchdog = threading.Timer(max(0.01, deadline - time.monotonic()), channel.close)
+    watchdog.daemon = True
+    watchdog.start()
+    try:
+        channel.settimeout(timeout)
+        channel.exec_command(command)
+        channel.shutdown_write()
+        while True:
+            for ready, receive, target in ((channel.recv_ready, channel.recv, out),
+                                            (channel.recv_stderr_ready, channel.recv_stderr, err)):
+                if ready():
+                    target.extend(receive(32768))
+            if len(out) + len(err) > output_limit:
+                raise RuntimeError('Output limit exceeded; channel closed.')
+            if channel.exit_status_ready() and not channel.recv_ready() and not channel.recv_stderr_ready():
+                status = channel.recv_exit_status()
+                if status == -1:
+                    raise ConnectionError('Remote channel closed without an exit status.')
+                return status, out.decode('utf-8', 'replace'), err.decode('utf-8', 'replace')
+            if not transport.is_active():
+                raise ConnectionError('SSH connection lost.')
+            if time.monotonic() >= deadline:
+                raise TimeoutError('Command timed out; remote process may still be running.')
+            time.sleep(0.01)
+    except Exception as exc:
+        if time.monotonic() >= deadline:
+            raise TimeoutError('Command timed out; remote process may still be running.') from exc
+        raise
+    finally:
+        watchdog.cancel()
+        channel.close()
+
+
+def ssh_info():
+    import getpass
+    import shutil
+    result = {'username': getpass.getuser(), 'client': shutil.which('ssh'),
+              'listeners': [], 'unidentified': 0, 'limited': False}
+    try:
+        connections = psutil.net_connections(kind='tcp')
+    except (psutil.Error, OSError):
+        result['limited'] = True
+        return result
+    seen = set()
+    for item in connections:
+        if item.status != psutil.CONN_LISTEN or not item.laddr:
+            continue
+        try:
+            if item.pid is None:
+                raise psutil.AccessDenied()
+            name = psutil.Process(item.pid).name().lower()
+        except (psutil.Error, OSError):
+            result['unidentified'] += 1
+            result['limited'] = True
+            continue
+        if name not in {'sshd', 'sshd.exe', 'sshd-session', 'sshd-auth', 'dropbear'}:
+            continue
+        address = (item.laddr.ip, item.laddr.port, name)
+        if address not in seen:
+            result['listeners'].append(address)
+            seen.add(address)
+    return result

mezilink/terminal.py

@@ -0,0 +1,130 @@
+import os
+import select
+import shutil
+import signal
+import sys
+import threading
+import time
+
+
+def open_shell(client, timeout=10):
+    transport = client.get_transport()
+    if transport is None or not transport.is_active():
+        raise ConnectionError('SSH session is disconnected.')
+    channel = transport.open_session(timeout=timeout)
+    expired = threading.Event()
+
+    def abort():
+        expired.set()
+        channel.close()
+
+    timer = threading.Timer(timeout, abort)
+    timer.daemon = True
+    timer.start()
+    try:
+        size = shutil.get_terminal_size((80, 24))
+        channel.settimeout(timeout)
+        channel.get_pty(term=os.environ.get('TERM') or 'xterm', width=size.columns, height=size.lines)
+        channel.invoke_shell()
+        if expired.is_set():
+            raise TimeoutError('Remote shell startup timed out.')
+        return channel
+    except BaseException:
+        channel.close()
+        if expired.is_set():
+            raise TimeoutError('Remote shell startup timed out.') from None
+        raise
+    finally:
+        timer.cancel()
+
+
+def write_output(data):
+    stream = getattr(sys.stdout, 'buffer', None)
+    if stream is not None:
+        stream.write(data)
+        stream.flush()
+    else:
+        sys.stdout.write(data.decode('utf-8', 'replace'))
+        sys.stdout.flush()
+
+
+def forward_input(channel, data):
+    before, escape, _ = data.partition(b'\x1d')
+    if before:
+        channel.sendall(before)
+    return not bool(escape)
+
+
+def posix_terminal(channel):
+    import termios
+    import tty
+    fd = sys.stdin.fileno()
+    original = termios.tcgetattr(fd)
+    previous_handler = signal.getsignal(signal.SIGWINCH)
+    resized = threading.Event()
+
+    def on_resize(signum, frame):
+        resized.set()
+
+    try:
+        signal.signal(signal.SIGWINCH, on_resize)
+        tty.setraw(fd, termios.TCSANOW)
+        while True:
+            if resized.is_set():
+                resized.clear()
+                size = shutil.get_terminal_size((80, 24))
+                channel.resize_pty(width=size.columns, height=size.lines)
+            readable, _, _ = select.select([channel, fd], [], [], .2)
+            if channel in readable:
+                data = channel.recv(32768)
+                if not data:
+                    return
+                write_output(data)
+            if fd in readable:
+                data = os.read(fd, 4096)
+                if not data or not forward_input(channel, data):
+                    return
+            if channel.closed and not channel.recv_ready():
+                return
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, original)
+        signal.signal(signal.SIGWINCH, previous_handler)
+
+
+def windows_terminal(channel):
+    import msvcrt
+    arrows = {'H': b'\x1b[A', 'P': b'\x1b[B', 'M': b'\x1b[C', 'K': b'\x1b[D',
+              'G': b'\x1b[H', 'O': b'\x1b[F', 'S': b'\x1b[3~'}
+    while True:
+        if channel.recv_ready():
+            data = channel.recv(32768)
+            if not data:
+                return
+            write_output(data)
+        if channel.closed and not channel.recv_ready():
+            return
+        try:
+            if msvcrt.kbhit():
+                char = msvcrt.getwch()
+                data = arrows.get(msvcrt.getwch(), b'') if char in ('\x00', '\xe0') else char.encode('utf-8')
+                if not forward_input(channel, data):
+                    return
+        except KeyboardInterrupt:
+            channel.sendall(b'\x03')
+        time.sleep(.01)
+
+
+def interactive_shell(client):
+    if not sys.stdin.isatty() or not sys.stdout.isatty():
+        raise RuntimeError('Interactive shell requires a terminal. Use x for a single command.')
+    print('\nRemote terminal: Ctrl+] returns to mazip; Ctrl+C interrupts the remote command.')
+    print('Type exit to close the remote shell. Terminal output comes directly from the server.', flush=True)
+    channel = open_shell(client)
+    try:
+        if os.name == 'nt':
+            windows_terminal(channel)
+        else:
+            posix_terminal(channel)
+    finally:
+        channel.close()
+        print('\nReturned to mazip menu.', flush=True)