ssh-tower 1.0.0__tar.gz

ssh_tower-1.0.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: ssh-tower
+Version: 1.0.0
+Summary: An advanced SSH connection manager with AirDrop-style UDP pairing and network scanning.
+Author-email: JuniorSir <juniorsir.bot@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: paramiko>=3.0.0
+Requires-Dist: cryptography>=43.0.0

ssh_tower-1.0.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "ssh-tower"
+version = "1.0.0"
+authors = [
+  { name="JuniorSir", email="juniorsir.bot@gmail.com" },
+]
+description = "An advanced SSH connection manager with AirDrop-style UDP pairing and network scanning."
+readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "paramiko>=3.0.0",
+    "cryptography>=43.0.0"
+]
+
+[project.scripts]
+# This lets users type 'ssh-nexus' in their terminal to launch the app!
+tower = "tower.cli:main"

ssh_tower-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ssh_tower-1.0.0/ssh_tower.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: ssh-tower
+Version: 1.0.0
+Summary: An advanced SSH connection manager with AirDrop-style UDP pairing and network scanning.
+Author-email: JuniorSir <juniorsir.bot@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: paramiko>=3.0.0
+Requires-Dist: cryptography>=43.0.0

ssh_tower-1.0.0/ssh_tower.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+pyproject.toml
+ssh_tower.egg-info/PKG-INFO
+ssh_tower.egg-info/SOURCES.txt
+ssh_tower.egg-info/dependency_links.txt
+ssh_tower.egg-info/entry_points.txt
+ssh_tower.egg-info/requires.txt
+ssh_tower.egg-info/top_level.txt
+tower/__init__.py
+tower/cli.py
+tower/pairing.py
+tower/scanner.py
+tower/security.py
+tower/ssh_manager.py

ssh_tower-1.0.0/ssh_tower.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ssh_tower-1.0.0/ssh_tower.egg-info/entry_points.txt

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

ssh_tower-1.0.0/ssh_tower.egg-info/requires.txt

@@ -0,0 +1,2 @@
+paramiko>=3.0.0
+cryptography>=43.0.0

ssh_tower-1.0.0/ssh_tower.egg-info/top_level.txt

@@ -0,0 +1 @@
+tower

ssh_tower-1.0.0/tower/__init__.py

@@ -0,0 +1 @@
+

ssh_tower-1.0.0/tower/cli.py

@@ -0,0 +1,183 @@
+import sys
+import getpass
+
+from tower.security import SecurityManager
+from tower.scanner import NetworkScanner
+from tower.ssh_manager import SSHSession
+from tower.pairing import PairingSystem
+
+# ANSI Colors
+CYAN = '\033[96m'
+MAGENTA = '\033[95m'
+YELLOW = '\033[93m'
+GREEN = '\033[92m'
+RED = '\033[91m'
+BLUE = '\033[94m'
+BOLD = '\033[1m'
+RESET = '\033[0m'
+
+sec_mgr = SecurityManager()
+session = SSHSession(sec_mgr)
+pairing = PairingSystem(sec_mgr)
+
+def print_banner():
+    print(f"\n{CYAN}{'='*50}{RESET}")
+    print(f"{BOLD}{CYAN}   SSH tower{RESET} - Advanced Remote Management Tool")
+    print(f"{CYAN}{'='*50}{RESET}\n")
+
+def scan_network_menu():
+    print(f"{YELLOW}Initiating high-speed network sweep (Port 22)...{RESET}")
+    hosts = NetworkScanner.scan_network()
+    
+    if not hosts:
+        print(f"{RED}No SSH devices found on the local network.{RESET}\n")
+        return
+
+    print(f"\n{BOLD}{CYAN}{'IP Address'.ljust(18)} {MAGENTA}Hostname{RESET}")
+    print("-" * 50)
+    for h in hosts:
+        print(f"{CYAN}{h['ip'].ljust(18)}{RESET} {MAGENTA}{h['hostname']}{RESET}")
+    print()
+
+def connect_ssh_menu():
+    profiles = list(sec_mgr.db["profiles"].keys())
+    if not profiles:
+        print(f"{RED}No profiles found. Add one first.{RESET}\n")
+        return
+    
+    for idx, p in enumerate(profiles):
+        print(f"[{idx}] {p} ({sec_mgr.db['profiles'][p]['ip']})")
+    
+    try:
+        choice = int(input(f"\nSelect profile index: "))
+        if 0 <= choice < len(profiles):
+            name = profiles[choice]
+            prof = sec_mgr.db["profiles"][name]
+            print(f"{YELLOW}Connecting to {name}...{RESET}")
+            success, msg = session.connect(name, prof)
+            
+            if success:
+                print(f"{BOLD}{GREEN}Connection Established!{RESET}\n")
+                session_menu()
+            else:
+                print(f"{BOLD}{RED}Failed: {msg}{RESET}\n")
+        else:
+            print(f"{RED}Invalid index.{RESET}\n")
+    except ValueError:
+        print(f"{RED}Please enter a valid number.{RESET}\n")
+
+def session_menu():
+    while session.connected:
+        print(f"\n{BOLD}{BLUE}--- Active Session Menu ---{RESET}")
+        print("1. Execute Command")
+        print("2. Freeze Device (Simulate)")
+        print("3. Disconnect")
+        
+        choice = input(f"\nSelect action (1/2/3): ").strip()
+        
+        if choice == "1":
+            cmd = input("Enter command: ")
+            out = session.execute(cmd)
+            print(f"\n{GREEN}--- Output ---{RESET}\n{out}\n{GREEN}--------------{RESET}")
+        elif choice == "2":
+            session.freeze_device()
+            print(f"{BOLD}{RED}Device Frozen (CPU spiked via dummy process).{RESET}")
+        elif choice == "3":
+            session.disconnect()
+            print(f"{YELLOW}Disconnected.{RESET}\n")
+
+def add_profile_menu():
+    print(f"{BOLD}--- Add New SSH Profile ---{RESET}")
+    name = input("Profile Name: ")
+    ip = input("IP Address: ")
+    user = input("Username: ")
+    
+    auth_type = ""
+    while auth_type not in ["1", "2"]:
+        auth_type = input("Auth Type [1=Password, 2=Key]: ").strip()
+    
+    if auth_type == "1":
+        pwd = getpass.getpass("Password (hidden): ")
+        sec_mgr.add_profile(name, ip, 22, user, password=pwd)
+    else:
+        k_path = input("Private Key Path: ")
+        sec_mgr.add_profile(name, ip, 22, user, key_path=k_path)
+    
+    print(f"{BOLD}{GREEN}Profile Saved!{RESET}\n")
+
+def pairing_menu():
+    print(f"\n{BOLD}--- AirDrop Pairing System ---{RESET}")
+    print("1. Host a Pairing Session (Broadcast presence)")
+    print("2. Scan & Connect to a Host")
+    choice = input("\nSelect (1/2): ").strip()
+    
+    if choice == "1":
+        pairing.start_host()
+        input(f"\n{MAGENTA}Press Enter at any time to stop hosting...{RESET}\n")
+        pairing.stop_host()
+        print(f"{YELLOW}Hosting stopped.{RESET}\n")
+        
+    elif choice == "2":
+        print(f"{YELLOW}Scanning airwaves for tower Hosts (3 seconds)...{RESET}")
+        discovered = pairing.discover_hosts()
+        
+        if not discovered:
+            print(f"{RED}No broadcasting hosts found on the network.{RESET}\n")
+            return
+            
+        print(f"\n{BOLD}{GREEN}Discovered Hosts:{RESET}")
+        host_list = list(discovered.items())
+        for idx, (ip, name) in enumerate(host_list):
+            print(f"[{idx}] {name} ({ip})")
+            
+        try:
+            h_choice = int(input("\nSelect host index to pair with: "))
+            if 0 <= h_choice < len(host_list):
+                target_ip = host_list[h_choice][0]
+                pin = input(f"Enter the 6-digit PIN shown on {host_list[h_choice][1]}: ")
+                
+                print(f"{YELLOW}Verifying PIN and establishing secure link...{RESET}")
+                success, data = pairing.connect_to_host(target_ip, pin)
+                
+                if success:
+                    print(f"{BOLD}{GREEN}Paired Successfully! Received Credentials.{RESET}")
+                    sec_mgr.add_profile(f"Auto_{target_ip}", target_ip, 22, data["user"], password=data["password"])
+                else:
+                    print(f"{BOLD}{RED}Pairing Failed: {data}{RESET}\n")
+            else:
+                print(f"{RED}Invalid selection.{RESET}\n")
+        except ValueError:
+            print(f"{RED}Please enter a valid number.{RESET}\n")
+
+def main():
+    while True:
+        print_banner()
+        print("1. Connect to Profile")
+        print("2. Add Profile")
+        print(f"3. Scan Network {GREEN}(High-Speed){RESET}")
+        print(f"4. AirDrop Pairing {MAGENTA}(Auto-Discovery){RESET}")
+        print("5. Recent Connections History")
+        print("6. Exit")
+        
+        choice = input(f"\n{BOLD}Choose an option:{RESET} ").strip()
+        print()
+        
+        if choice == "1": connect_ssh_menu()
+        elif choice == "2": add_profile_menu()
+        elif choice == "3": scan_network_menu()
+        elif choice == "4": pairing_menu()
+        elif choice == "5":
+            print(f"{BOLD}--- Recent Connections ---{RESET}")
+            print(f"{CYAN}{'Name'.ljust(15)} {MAGENTA}{'IP'.ljust(15)} {GREEN}Duration{RESET}")
+            print("-" * 45)
+            for h in sec_mgr.db["history"]:
+                print(f"{CYAN}{h['name'].ljust(15)}{RESET} {MAGENTA}{h['ip'].ljust(15)}{RESET} {GREEN}{h['duration']}{RESET}")
+            print()
+        elif choice == "6":
+            print(f"{YELLOW}Exiting SSH tower...{RESET}")
+            sys.exit(0)
+        else:
+            print(f"{RED}Invalid option. Try again.{RESET}")
+
+if __name__ == "__main__":
+    main()

ssh_tower-1.0.0/tower/pairing.py

@@ -0,0 +1,118 @@
+import socket
+import random
+import json
+import threading
+import time
+
+CYAN = '\033[96m'
+YELLOW = '\033[93m'
+GREEN = '\033[92m'
+RED = '\033[91m'
+BOLD = '\033[1m'
+RESET = '\033[0m'
+
+class PairingSystem:
+    def __init__(self, sec_mgr):
+        self.sec_mgr = sec_mgr
+        self.tcp_port = 55555
+        self.udp_port = 55556
+        self.active_pin = None
+        self.hosting = False
+
+    def start_host(self):
+        self.active_pin = str(random.randint(100000, 999999))
+        local_ip = socket.gethostbyname(socket.gethostname())
+        self.hosting = True
+        
+        print(f"\n{BOLD}{CYAN}AirDrop Hosting Active!{RESET}")
+        print(f"Tell the other device to scan, then enter PIN: {BOLD}{YELLOW}{self.active_pin}{RESET}")
+
+        # Start TCP Listener for the actual PIN exchange
+        threading.Thread(target=self._listen_for_pairing, args=(local_ip,), daemon=True).start()
+        # Start UDP Broadcaster so clients can auto-discover this device
+        threading.Thread(target=self._broadcast_presence, args=(local_ip,), daemon=True).start()
+
+    def _broadcast_presence(self, local_ip):
+        """Invisibly broadcasts presence to the local network."""
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+        hostname = socket.gethostname()
+        
+        while self.hosting:
+            msg = f"NEXUS:{hostname}:{local_ip}"
+            try:
+                s.sendto(msg.encode(), ('<broadcast>', self.udp_port))
+            except Exception:
+                pass
+            time.sleep(1.5)
+        s.close()
+
+    def stop_host(self):
+        self.hosting = False
+        self.active_pin = None
+
+    def _listen_for_pairing(self, ip):
+        server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        server.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        server.bind(("0.0.0.0", self.tcp_port))
+        server.listen(1)
+        server.settimeout(1) # Allows us to check if hosting was stopped
+        
+        while self.hosting:
+            try:
+                client, addr = server.accept()
+                data = client.recv(1024).decode()
+                if data == self.active_pin:
+                    print(f"\n{BOLD}{GREEN}[!] Device at {addr[0]} entered correct PIN!{RESET}")
+                    print(f"{YELLOW}Securely transmitting SSH credentials...{RESET}\n")
+                    # In a real app, prompt the host to ACCEPT/REJECT here.
+                    creds = json.dumps({"user": "admin", "password": "dummy_password"})
+                    client.send(self.sec_mgr.encrypt(creds).encode())
+                    self.stop_host() # Stop hosting after success
+                else:
+                    client.send(b"DENIED")
+                client.close()
+            except socket.timeout:
+                continue
+            except Exception:
+                break
+        server.close()
+
+    def discover_hosts(self):
+        """Scans the network for active AirDrop hosts broadcasting UDP."""
+        s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        s.bind(('', self.udp_port))
+        s.settimeout(3.0) # Listen for 3 seconds
+        
+        hosts = {}
+        try:
+            while True:
+                data, addr = s.recvfrom(1024)
+                if data.startswith(b"NEXUS:"):
+                    _, name, ip = data.decode().split(":")
+                    if ip not in hosts:
+                        hosts[ip] = name
+        except socket.timeout:
+            pass
+        finally:
+            s.close()
+            
+        return hosts
+
+    def connect_to_host(self, ip, pin):
+        try:
+            client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            client.settimeout(5)
+            client.connect((ip, self.tcp_port))
+            client.send(pin.encode())
+            response = client.recv(2048).decode()
+            client.close()
+            
+            if response == "DENIED":
+                return False, "Pairing rejected or invalid PIN."
+                
+            creds = json.loads(self.sec_mgr.decrypt(response))
+            return True, creds
+        except Exception as e:
+            return False, f"Connection error: {str(e)}"

ssh_tower-1.0.0/tower/scanner.py

@@ -0,0 +1,72 @@
+import socket
+import subprocess
+import platform
+from concurrent.futures import ThreadPoolExecutor
+
+class NetworkScanner:
+    @staticmethod
+    def get_local_ip():
+        try:
+            s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            s.connect(("8.8.8.8", 80))
+            ip = s.getsockname()[0]
+            s.close()
+            return ip
+        except Exception:
+            return "127.0.0.1"
+
+    @staticmethod
+    def get_arp_ips():
+        """Reads the ARP table for instant local device discovery (Fastest)."""
+        ips = set()
+        try:
+            if platform.system() == "Linux" or "termux" in platform.release().lower():
+                with open('/proc/net/arp') as f:
+                    next(f) # Skip header
+                    for line in f:
+                        parts = line.split()
+                        if len(parts) >= 4 and parts[3] != "00:00:00:00:00:00":
+                            ips.add(parts[0])
+        except Exception:
+            pass
+        return ips
+
+    @staticmethod
+    def scan_port(ip, port=22, timeout=0.2):
+        """Checks if port 22 is open on a given IP."""
+        try:
+            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            s.settimeout(timeout)
+            result = s.connect_ex((ip, port))
+            s.close()
+            if result == 0:
+                try:
+                    hostname = socket.gethostbyaddr(ip)[0]
+                except socket.herror:
+                    hostname = "Unknown Device"
+                return {"ip": ip, "hostname": hostname}
+        except Exception:
+            pass
+        return None
+
+    @staticmethod
+    def scan_network():
+        """Combines ARP checking with a threaded subnet sweep."""
+        local_ip = NetworkScanner.get_local_ip()
+        base_ip = ".".join(local_ip.split(".")[:-1]) + "."
+        
+        # Build list of IPs to scan: 1-255 + any known ARP IPs
+        target_ips = set([f"{base_ip}{i}" for i in range(1, 255)])
+        target_ips.update(NetworkScanner.get_arp_ips())
+        
+        active_hosts = []
+        
+        # Aggressive 100-thread sweep for blazing fast discovery
+        with ThreadPoolExecutor(max_workers=100) as executor:
+            futures = [executor.submit(NetworkScanner.scan_port, ip) for ip in target_ips]
+            for future in futures:
+                result = future.result()
+                if result:
+                    active_hosts.append(result)
+                    
+        return sorted(active_hosts, key=lambda x: x['ip'])

ssh_tower-1.0.0/tower/security.py

@@ -0,0 +1,64 @@
+import os
+import json
+import base64
+import logging
+from datetime import datetime
+from cryptography.fernet import Fernet
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+
+HOME_DIR = os.path.expanduser("~/.tower")
+os.mkdir(HOME_DIR, exist_ok=True)
+
+DB_FILE = os.path.join(HOME_DIR, "tower_data.json")
+KEY_FILE = os.path.join(HOME_DIR, "tower.key")
+LOG_FILE = os.path.join(HOME_DIR, "tower.log")
+
+logging.basicConfig(filename="nexus.log", level=logging.INFO, 
+                    format="%(asctime)s - %(levelname)s - %(message)s")
+
+class SecurityManager:
+    def __init__(self):
+        self.key = self._load_or_create_key()
+        self.cipher = Fernet(self.key)
+        self.db = self._load_db()
+
+    def _load_or_create_key(self):
+        if not os.path.exists(KEY_FILE):
+            key = Fernet.generate_key()
+            with open(KEY_FILE, "wb") as f:
+                f.write(key)
+        else:
+            with open(KEY_FILE, "rb") as f:
+                key = f.read()
+        return key
+
+    def _load_db(self):
+        if not os.path.exists(DB_FILE):
+            return {"profiles": {}, "history": [], "trusted": []}
+        with open(DB_FILE, "r") as f:
+            return json.load(f)
+
+    def save_db(self):
+        with open(DB_FILE, "w") as f:
+            json.dump(self.db, f, indent=4)
+
+    def encrypt(self, data: str) -> str:
+        return self.cipher.encrypt(data.encode()).decode()
+
+    def decrypt(self, data: str) -> str:
+        return self.cipher.decrypt(data.encode()).decode()
+
+    def add_profile(self, name, ip, port, user, password=None, key_path=None):
+        profile = {"ip": ip, "port": port, "user": user}
+        if password: profile["password"] = self.encrypt(password)
+        if key_path: profile["key_path"] = key_path
+        self.db["profiles"][name] = profile
+        self.save_db()
+        logging.info(f"Profile saved: {name}")
+
+    def log_connection(self, name, ip, duration):
+        entry = {"name": name, "ip": ip, "date": str(datetime.now()), "duration": duration}
+        self.db["history"].insert(0, entry)
+        self.db["history"] = self.db["history"][:10]  # Keep last 10
+        self.save_db()

ssh_tower-1.0.0/tower/ssh_manager.py

@@ -0,0 +1,53 @@
+import time
+import paramiko
+import logging
+from datetime import datetime
+
+class SSHSession:
+    def __init__(self, sec_mgr):
+        self.client = paramiko.SSHClient()
+        self.client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+        self.sec_mgr = sec_mgr
+        self.connected = False
+        self.start_time = None
+        self.current_ip = None
+        self.current_name = None
+
+    def connect(self, name, profile):
+        try:
+            password = self.sec_mgr.decrypt(profile["password"]) if "password" in profile else None
+            key_path = profile.get("key_path")
+
+            if key_path:
+                self.client.connect(profile["ip"], port=profile["port"], username=profile["user"], key_filename=key_path)
+            else:
+                self.client.connect(profile["ip"], port=profile["port"], username=profile["user"], password=password)
+
+            self.connected = True
+            self.start_time = time.time()
+            self.current_ip = profile["ip"]
+            self.current_name = name
+            logging.info(f"Connected to {name} ({self.current_ip})")
+            return True, "Connected successfully"
+        except Exception as e:
+            logging.error(f"Failed to connect to {name}: {e}")
+            return False, str(e)
+
+    def execute(self, command):
+        if not self.connected: return "Not connected."
+        stdin, stdout, stderr = self.client.exec_command(command)
+        return stdout.read().decode().strip() + stderr.read().decode().strip()
+
+    def freeze_device(self):
+        # Simulates freeze by running a dummy CPU max process in background
+        return self.execute('nohup python3 -c "while True: pass" > /dev/null 2>&1 & echo $!')
+
+    def shutdown_device(self):
+        return self.execute("sudo shutdown -h now")
+
+    def disconnect(self):
+        if self.connected:
+            duration = round(time.time() - self.start_time, 2)
+            self.client.close()
+            self.connected = False
+            self.sec_mgr.log_connection(self.current_name, self.current_ip, f"{duration}s")