Upload ssh_vnc_start.py

ssh_vnc_start.py

@@ -0,0 +1,272 @@
+#!/usr/bin/env python3
+import subprocess
+import threading
+import time
+import os
+import sys
+import logging
+import traceback
+import socket
+import select
+import fcntl
+
+# 设置日志
+logging.basicConfig(
+    level=logging.INFO, 
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+# 打印启动信息
+logger.info("=" * 50)
+logger.info("VNC SSH反向隧道服务启动")
+logger.info(f"当前工作目录: {os.getcwd()}")
+logger.info(f"Python版本: {sys.version}")
+logger.info("=" * 50)
+
+# 隧道配置
+SSH_SERVER = "www.ip188.net"
+SSH_PORT = 30001
+SSH_USERNAME = "aauser"
+SSH_PASSWORD = "aa123456"
+LOCAL_PORT = 5901  # 本地VNC端口
+REMOTE_PORT = 13698  # 远程暴露端口
+
+def read_nonblocking(pipe):
+    """非阻塞读取管道内容"""
+    output = ""
+    if pipe:
+        # 设置非阻塞模式
+        flags = fcntl.fcntl(pipe, fcntl.F_GETFL)
+        fcntl.fcntl(pipe, fcntl.F_SETFL, flags | os.O_NONBLOCK)
+        
+        # 使用select检查是否有数据可读
+        reads, _, _ = select.select([pipe], [], [], 0)
+        if pipe in reads:
+            try:
+                data = pipe.read()
+                if data:
+                    output = data.decode('utf-8', errors='replace')
+            except (OSError, IOError) as e:
+                logger.error(f"读取管道错误: {e}")
+    return output
+
+def create_ssh_tunnel_paramiko():
+    """使用paramiko库创建SSH反向隧道"""
+    try:
+        import paramiko
+        logger.info("使用paramiko库创建SSH反向隧道")
+        
+        while True:
+            try:
+                # 创建SSH客户端
+                ssh_client = paramiko.SSHClient()
+                ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+                logger.info(f"连接到SSH服务器 {SSH_SERVER}:{SSH_PORT}...")
+                
+                ssh_client.connect(
+                    SSH_SERVER,
+                    port=SSH_PORT,
+                    username=SSH_USERNAME,
+                    password=SSH_PASSWORD,
+                    timeout=60,
+                    allow_agent=False,
+                    look_for_keys=False
+                )
+                
+                # 保活设置
+                transport = ssh_client.get_transport()
+                transport.set_keepalive(60)
+                
+                # 设置远程转发
+                logger.info(f"建立反向隧道 localhost:{LOCAL_PORT} -> {REMOTE_PORT}")
+                transport.request_port_forward("", REMOTE_PORT)
+                
+                # 处理转发连接的类
+                class ForwardServer(threading.Thread):
+                    def __init__(self, transport):
+                        threading.Thread.__init__(self)
+                        self.transport = transport
+                        self.daemon = True
+                    
+                    def run(self):
+                        logger.info("SSH VNC隧道已建立，等待连接...")
+                        
+                        try:
+                            while transport.is_active():
+                                try:
+                                    chan = transport.accept(60)
+                                    if chan is None:
+                                        continue
+                                    
+                                    # 为每个连接创建线程处理
+                                    thr = threading.Thread(target=self.handler, args=(chan,))
+                                    thr.daemon = True
+                                    thr.start()
+                                except Exception as e:
+                                    if transport.is_active():
+                                        logger.error(f"处理隧道连接时出错: {e}")
+                                    else:
+                                        break
+                            
+                            logger.info("隧道传输已关闭")
+                        except Exception as e:
+                            logger.error(f"转发服务器错误: {e}")
+                    
+                    def handler(self, chan):
+                        try:
+                            sock = socket.socket()
+                            try:
+                                sock.connect(('127.0.0.1', LOCAL_PORT))
+                            except ConnectionRefusedError:
+                                logger.error(f"连接本地VNC端口 {LOCAL_PORT} 被拒绝")
+                                chan.close()
+                                return
+                            
+                            logger.info(f"处理转发连接: {REMOTE_PORT} -> localhost:{LOCAL_PORT}")
+                            
+                            # 在两个方向上转发数据
+                            while True:
+                                r, w, x = select.select([sock, chan], [], [])
+                                if sock in r:
+                                    data = sock.recv(1024)
+                                    if len(data) == 0:
+                                        break
+                                    chan.send(data)
+                                if chan in r:
+                                    data = chan.recv(1024)
+                                    if len(data) == 0:
+                                        break
+                                    sock.send(data)
+                        except Exception as e:
+                            logger.error(f"处理VNC连接时出错: {e}")
+                        finally:
+                            try:
+                                sock.close()
+                                chan.close()
+                            except:
+                                pass
+                
+                # 启动转发服务器
+                forward_server = ForwardServer(transport)
+                forward_server.start()
+                
+                # 保持连接
+                while transport.is_active():
+                    time.sleep(60)
+                    logger.info("SSH VNC隧道保持活跃状态")
+                
+                logger.info("SSH连接已关闭，准备重新连接")
+                
+            except Exception as e:
+                logger.error(f"SSH VNC隧道错误: {e}")
+                logger.error(traceback.format_exc())
+                time.sleep(10)  # 等待10秒后重试
+    
+    except ImportError:
+        logger.error("未找到paramiko库，尝试安装...")
+        try:
+            subprocess.run([sys.executable, "-m", "pip", "install", "paramiko"], check=True)
+            logger.info("paramiko库安装成功，重新尝试创建隧道")
+            create_ssh_tunnel_paramiko()  # 递归调用自己
+        except Exception as install_error:
+            logger.error(f"安装paramiko失败: {install_error}")
+            create_ssh_tunnel_command()  # 回退到命令行方式
+
+def create_ssh_tunnel_command():
+    """使用ssh命令创建反向隧道"""
+    logger.info("使用ssh命令创建VNC反向隧道")
+    
+    while True:
+        try:
+            # 检查ssh命令是否可用
+            ssh_check = subprocess.run(["which", "ssh"], capture_output=True, text=True)
+            if ssh_check.returncode != 0:
+                logger.error("未找到ssh命令，请确保已安装openssh-client")
+                time.sleep(30)
+                continue
+            
+            # 创建ssh命令
+            ssh_cmd = [
+                "ssh", 
+                "-o", "StrictHostKeyChecking=no",
+                "-o", "UserKnownHostsFile=/dev/null",
+                "-N", 
+                "-R", f"{REMOTE_PORT}:localhost:{LOCAL_PORT}",
+                "-p", str(SSH_PORT),
+                f"{SSH_USERNAME}@{SSH_SERVER}"
+            ]
+            
+            # 使用sshpass或expect自动提供密码
+            use_sshpass = False
+            sshpass_check = subprocess.run(["which", "sshpass"], capture_output=True, text=True)
+            if sshpass_check.returncode == 0:
+                use_sshpass = True
+                ssh_cmd = ["sshpass", "-p", SSH_PASSWORD] + ssh_cmd
+                logger.info("使用sshpass提供密码")
+            
+            logger.info(f"执行SSH命令: {' '.join(ssh_cmd if not use_sshpass else ['sshpass', '-p', '********'] + ssh_cmd[3:])}")
+            
+            # 执行SSH命令
+            process = subprocess.Popen(
+                ssh_cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                stdin=subprocess.PIPE if not use_sshpass else None
+            )
+            
+            # 如果不使用sshpass，手动提供密码
+            if not use_sshpass:
+                try:
+                    process.stdin.write(f"{SSH_PASSWORD}\n".encode())
+                    process.stdin.flush()
+                except:
+                    logger.error("无法提供密码")
+            
+            logger.info("SSH VNC隧道已启动")
+            
+            # 监控进程
+            while process.poll() is None:
+                # 读取输出
+                stdout_data = read_nonblocking(process.stdout)
+                stderr_data = read_nonblocking(process.stderr)
+                
+                if stdout_data:
+                    logger.info(f"SSH输出: {stdout_data.strip()}")
+                if stderr_data:
+                    logger.error(f"SSH错误: {stderr_data.strip()}")
+                
+                time.sleep(5)
+            
+            # 进程已结束
+            exit_code = process.poll()
+            logger.info(f"SSH VNC隧道进程退出，退出码: {exit_code}")
+            
+            # 重新启动
+            time.sleep(10)
+            
+        except Exception as e:
+            logger.error(f"创建SSH VNC隧道时出错: {e}")
+            logger.error(traceback.format_exc())
+            time.sleep(10)
+
+def main():
+    """主函数"""
+    logger.info("启动SSH VNC反向隧道服务")
+    
+    # 首先尝试使用paramiko库
+    try:
+        # 检查是否安装了paramiko
+        import paramiko
+        create_ssh_tunnel_paramiko()
+    except ImportError:
+        logger.warning("未找到paramiko库，尝试使用ssh命令")
+        create_ssh_tunnel_command()
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        logger.error(f"主程序发生错误: {e}")
+        logger.error(traceback.format_exc())
+        sys.exit(1)