C# - 无需端口转发即可远程控制 PC(如 TeamViewer)

Question

编辑
我弄清楚了问题所在，但现在我遇到了另一个问题。我想从另一台 PC 远程控制一台 PC，那部分工作，但你必须转发端口。是否可以像 TeamViewer 一样连接？所以我绕过防火墙并且不必转发端口？如果是，如何？如果有人能帮助我，那就太棒了:)

• 布拉姆

原帖

我编写了一个代码，这样您就可以从另一台计算机控制一台计算机。唯一的问题是它不适用于您自己网络之外的计算机(也许我连接了错误的 IP？我尝试了那个人的 IPv4 和来自 WhatIsMyIP 的 IP)。我怎样才能使它适用于我的网络外部？

这是服务器类(我删除了很多代码，因为它没有意义)

    public partial class Form1 : Form
    {
        [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)]
        public static extern void mouse_event(long dwFlags, long dx, long dy, long cButtons, long dwExtraInfo);

        private const int MOUSE_LEFTDOWN = 0x02;
        private const int MOUSE_LEFTUP = 0x04;
        private const int MOUSE_RIGTDOWN = 0x08;
        private const int MOUSE_RIGHTUP = 0x10;

        private TcpListener listener;
        private Socket mainSocket;
        private int port;
        private Stream s;
        private Thread eventWatcher;
        private int imageDelay;
        string connString;
        string connToString;
        string db;
        MySqlCommand command;
        MySqlCommand command2;
        MySqlCommand command3;
        MySqlCommand command4;

        MySqlConnection connection = null;

        public Form1()
        {
            InitializeComponent();
            port = 1338;
            imageDelay = 1000;
        }
        public Form1(int p)
        {
            port = p;
            imageDelay = 1000;
            InitializeComponent();
        }

        private void Form1_Load(object sender, EventArgs e)
        {
            MessageBox.Show(getIP());
            startConnection();

            command = connection.CreateCommand();
            command2 = connection.CreateCommand();
            command3 = connection.CreateCommand();
            command4 = connection.CreateCommand();
            MessageBox.Show(connString);
            MessageBox.Show(db);

            this.Hide();
            port = 1338;
            while (true)
            {
                try
                {
                    startListening();
                }
                catch (Exception)
                {
                }
            }
        }

        public void startListening()
        {
            try
            {
                listener = new TcpListener(port);
                listener.Start();
                mainSocket = listener.AcceptSocket();
                s = new NetworkStream(mainSocket);
                eventWatcher = new Thread(new ThreadStart(waitForKeys));
                eventWatcher.Start();
                while (true)
                {
                    Bitmap screeny = new Bitmap(Screen.PrimaryScreen.Bounds.Width, Screen.PrimaryScreen.Bounds.Height, PixelFormat.Format32bppArgb);
                    Graphics theShot = Graphics.FromImage(screeny);
                    theShot.ScaleTransform(.25F, .25F);
                    theShot.CopyFromScreen(Screen.PrimaryScreen.Bounds.X, Screen.PrimaryScreen.Bounds.Y, 0, 0, Screen.PrimaryScreen.Bounds.Size, CopyPixelOperation.SourceCopy);
                    BinaryFormatter bFormat = new BinaryFormatter();
                    bFormat.Serialize(s, screeny);
                    Thread.Sleep(imageDelay);
                    theShot.Dispose();
                    screeny.Dispose();
                }
            }
            catch (Exception)
            {
                if (mainSocket.IsBound)
                    mainSocket.Close();
                if (listener != null)
                    listener.Stop();
            }
        }

        private static void trigger(IAsyncResult i) { }

和客户端代码(同样，删除了很多):

    public class StateObject
    {
        public Socket workSocket = null;
        public const int BufferSize = 256;
        public byte[] buffer = new byte[BufferSize];
        public StringBuilder sb = new StringBuilder();
    }

    public partial class Form2 : Form
    {
        private static string response;

        private Stream stream;
        private StreamWriter eventSender;
        private Thread theThread;
        private TcpClient client;
        private Form1 mForm;
        private int resolutionX;
        private int resolutionY;
        //private int sendDelay = 250;
        //private Thread delayThread;
        public bool sendKeysAndMouse = false;

        private static ManualResetEvent sendDone = new ManualResetEvent(false);
        private static ManualResetEvent receiveDone = new ManualResetEvent(false);

        public Form2()
        {
            InitializeComponent();
        }
        public Form2(TcpClient s, Form1 callingForm)
        {
            client = s;
            mForm = callingForm;
            InitializeComponent();
            theThread = new Thread(new ThreadStart(startRead));
            theThread.Start();
        }

        private void Form2_FormClosed(object sender, FormClosedEventArgs e)
        {
            if (theThread.IsAlive)
                theThread.Abort();
            mForm.form2Closed();
        }
        private void startRead()
        {
            try
            {
                stream = client.GetStream();
                eventSender = new StreamWriter(stream);
                while (true)
                {
                    BinaryFormatter bFormat = new BinaryFormatter();
                    Bitmap inImage = bFormat.Deserialize(stream) as Bitmap;
                    resolutionX = inImage.Width;
                    resolutionY = inImage.Height;
                    theImage.Image = (Image)inImage;
                }
            }
            catch (Exception) { }
            /*try
            {
                Image theDesktop;
                stream = client.GetStream();
                theDesktop.Save(stream,new ImageFormat(
                while (true)
                {
                    while (stream.Read(buffer, 0, 1024) > 0)
                        theDesktop.Read(buffer, 0, 1024);
                    if(theDesktop != null) {
                        theDesktop.
                        theImage.Image = temp;
                }
            }
            catch (Exception gay) { }*/
        }

        private void Form2_ResizeEnd(object sender, EventArgs e)
        {

        }

        private void Form2_Load(object sender, EventArgs e)
        {

        }


        private void Form2_MouseMove(object sender, MouseEventArgs e)
        {
        }


        private void theImage_MouseClick(object sender, MouseEventArgs e)
        {
            if (!sendKeysAndMouse)
                return;
            eventSender.Write("LCLICK\n");
            eventSender.Flush();
        }

        private void theImage_MouseDown(object sender, MouseEventArgs e)
        {
            if (!sendKeysAndMouse)
                return;
            eventSender.Write("LDOWN\n");
            eventSender.Flush();
        }

        private void theImage_MouseUp(object sender, MouseEventArgs e)
        {
            if (!sendKeysAndMouse)
                return;
            eventSender.Write("LUP\n");
            eventSender.Flush();
        }

        private void Receive(Socket client)
        {
            try
            {
                StateObject state = new StateObject();
                state.workSocket = client;

                client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }

        private void Send(Socket client, String data)
        {
            byte[] byteData = Encoding.ASCII.GetBytes(data);

            client.BeginSend(byteData, 0, byteData.Length, 0, new AsyncCallback(SendCallback), client);
        }

        private void ReceiveCallback(IAsyncResult ar)
        {
            try
            {
                StateObject state = (StateObject)ar.AsyncState;
                Socket client = state.workSocket;

                int bytesRead = client.EndReceive(ar);

                if (bytesRead > 0)
                {
                    state.sb.Append(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));

                    client.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, new AsyncCallback(ReceiveCallback), state);
                }
                else
                {
                    if (state.sb.Length > 1)
                    {
                        response = state.sb.ToString();
                    }
                    receiveDone.Set();
                }
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }

        private void SendCallback(IAsyncResult ar)
        {
            try
            {
                Socket client = (Socket)ar.AsyncState;

                int bytesSent = client.EndSend(ar);
                Console.WriteLine("Sent {0} bytes to server.", bytesSent);

                sendDone.Set();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.ToString());
            }
        }
    }
}

我希望有人能帮助我，或者向我解释我做错了什么以及我如何才能让它发挥作用。

Answer 1

Team Viewer 执行此操作的方式是在交互中有第三台计算机。 Team Viewer 在 Internet 上有一个公共(public)服务器，您和您所连接的人都可以与之交谈，它所做的只是充当一座桥梁，将传入的消息从一端转发到另一端。现在两端都有出站连接，不需要端口转发。

要对您的系统执行相同的操作，您需要在互联网上设置、托管(付费)和维护一个公共(public)服务器，您的程序的所有用户都可以与之交谈并充当通信的桥梁。

步骤是这样的:

1. Computer1 打开到 Server1 的出站连接并保持打开状态，他们现在可以在没有端口转发的情况下来回交谈。
2. 计算机 2 打开到服务器 1 的出站连接并保持打开状态，他们现在可以在没有端口转发的情况下来回交谈。
3. Computer1 向 Server1 发送一条消息，内容为“将以下内容转发给 Computer2”
4. 服务器 1 使用计算机 2 启动的步骤 2 中的打开连接来转发消息。
5. 当 Computer2 想要回复时，它会向 Server1 发送一条消息，内容为“将以下内容转发给 Computer1”
6. Server1 使用 Computer1 发起的第 1 步中的打开连接来转发消息。