TCP接続を行う際、ポート番号を変換するプログラムを作りたい

Question

前提

Azure上の仮想マシン（Windows）にリモートデスクトップ接続することを考えています。
この時に、詳しくは説明できないのですが、ちょっと理由があって、ポート番号を変換して接続することを検討しています。

以下の方式で接続しようと思っています。

【Microsoft リモートデスクトップ (mstsc.exe)】
｜
｜127.0.0.1:13389に接続。
↓
【今から開発するプログラム】
｜
｜Azure VM:3389に接続。
↓
【Azure VM】

【今から開発するプログラム】は、C#での開発を考えています。
TcpListenerクラスで、mstsc.exeから送信されデータを全て受け取り、
受け取ったデータをTcpClientクラスで、Azure VMに送信するという方針で作ろうと思いました。

質問内容

上記のような方針で作ってみたのですが、全くRDP接続できなくて困っています。
そもそもの方針が間違っている可能性も含めて、どうしたらいいか考えています。

どのようにすれば、上記のようなプログラムを作ることができるでしょうか？
C#/Windowsという条件は変えることができません。

発生している問題・エラーメッセージ

RDPが発するエラーメッセージは以下の通りです。

内部エラーが発生しました。

また、後述のプログラムで出力したデバッグメッセージは以下の通りです。

 *** リモートデスクトップ(mstsc.exe)から、19バイトのデータを読み取りました。
 *** 19バイトのデータを送信。（本プログラム -> サーバー）
 *** クライアント -> 本プログラム -> サーバーへのデータ送信完了
 *** サーバーから、19バイトのデータを読み取りました。
 *** 19バイトのデータをクライアント(mstsc.exe)に送信しました。
 *** サーバー -> 本プログラム -> クライアントへのデータ送信完了

 *** リモートデスクトップ(mstsc.exe)から、47バイトのデータを読み取りました。
 *** 47バイトのデータを送信。（本プログラム -> サーバー）
 *** クライアント -> 本プログラム -> サーバーへのデータ送信完了
 *** サーバーから、19バイトのデータを読み取りました。
 *** 19バイトのデータをクライアント(mstsc.exe)に送信しました。
 *** サーバー -> 本プログラム -> クライアントへのデータ送信完了


 *** リモートデスクトップ(mstsc.exe)から、47バイトのデータを読み取りました。
 *** 47バイトのデータを送信。（本プログラム -> サーバー）
 *** クライアント -> 本プログラム -> サーバーへのデータ送信完了
 *** サーバーから、19バイトのデータを読み取りました。
 *** 19バイトのデータをクライアント(mstsc.exe)に送信しました。
 *** サーバー -> 本プログラム -> クライアントへのデータ送信完了

該当のソースコード

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;

namespace WpfApp1
{
    /// <summary>
    /// MainWindow.xaml の相互作用ロジック
    /// </summary>
    public partial class MainWindow : Window
    {
        private TcpListener tcpListener;
        private const int rdpPortNumber = 3389;
        private const int localRdpPortNumber = 13389;
        private const string virtualMachine = "<< Azure 仮想マシンのIPアドレス >>";

        public MainWindow()
        {
            InitializeComponent();
        }

        private void Window_Loaded(object sender, RoutedEventArgs e)
        {
            if (tcpListener != null)
            {
                return;
            }

            tcpListener = new TcpListener(IPAddress.Parse("127.0.0.1"), localRdpPortNumber);
            tcpListener.Start();

            tcpListener.BeginAcceptTcpClient(TcpClientAccepted, null);
        }

        private void TcpClientAccepted(IAsyncResult result)
        {
            // client : mstsc.exe
            // bridge : this program.
            // server : azure virtual machine.
            using (var clientToBridge = tcpListener.EndAcceptTcpClient(result))
            {
                tcpListener.BeginAcceptTcpClient(TcpClientAccepted, null);

                if (clientToBridge == null)
                {
                    Debug.WriteLine(" *** clientToBridge == null");
                    return;
                }

                using (var clientToBridgeStream = clientToBridge.GetStream())
                {
                    using (var bridgeToServer = new TcpClient())
                    {
                        bridgeToServer.Connect(IPAddress.Parse(virtualMachine), rdpPortNumber);
                        using (var bridgeToServerStream = bridgeToServer.GetStream())
                        {
                            byte[] buffer = new byte[10240];
                            // client -> this program -> server という経路でデータを送信する。
                            while (true)
                            {
                                // クライアントプログラムからのデータを読み取る。
                                var length = clientToBridgeStream.Read(buffer, 0, buffer.Length);
                                Debug.WriteLine($" *** リモートデスクトップ(mstsc.exe)から、{length}バイトのデータを読み取りました。");
                                if (length > 0)
                                {
                                    // 本プログラムから Azure Virtual Machine にデータを送信する。
                                    bridgeToServerStream.Write(buffer, 0, length);
                                    Debug.WriteLine($" *** {length}バイトのデータを送信。（本プログラム -> サーバー）");
                                }

                                if (length < buffer.Length)
                                {
                                    Debug.WriteLine($" *** クライアント -> 本プログラム -> サーバーへのデータ送信完了");
                                    break;
                                }
                            }

                            // server -> bridge -> client という経路でデータを送信する。
                            while (true)
                            {
                                // サーバーから、本プログラムへのデータを読み取る。
                                var length = bridgeToServerStream.Read(buffer, 0, buffer.Length);
                                Debug.WriteLine($" *** サーバーから、{length}バイトのデータを読み取りました。");
                                if (length > 0)
                                {
                                    clientToBridgeStream.Write(buffer, 0, length);
                                    Debug.WriteLine($" *** {length}バイトのデータをクライアント(mstsc.exe)に送信しました。");
                                }

                                if (length < buffer.Length)
                                {
                                    Debug.WriteLine($" *** サーバー -> 本プログラム -> クライアントへのデータ送信完了");
                                    break;
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

Comments

[KOZ6.0]

ご提示のコードでは一回受送信して終わりに見えますが、どちらかから切断されるまで受送信を繰り返す必要があるはずです。

Answer 1

次のように作ってみてください。

■ 初期処理

(0) TcpListener のインスタンスを作成、開始(Start)を行い、クライアント接続待ちの非同期操作を開始(BeginAcceptTcpClient)。

■ 接続処理 (BeginAcceptTcpClient のコールバック関数内)

(1) RDP クライアントからの接続を受け付け (EndAcceptTcpClient) 、次のクライアント接続待ちの非同期操作を開始(BeginAcceptTcpClient)
(2) RDP サーバーに接続する (TCPClient のインスタンスを作成し、Connect)
(3) RDP クライアントからの非同期受信開始(NetworkStream.BeginRead)
(4) RDP サーバーからの非同期受信開始(NetworkStream.BeginRead)

■ 通信処理 (BeginRead のコールバック関数内)

(5) RDP クライアントから受信したら RDP サーバーに送信
(6) RDP サーバーから受信したら RDP クライアントに送信

(5),(6) は独立して動く必要があります。
（非同期受信のメソッドを使えば自然にそうなります。送信は同期でＯＫ）
EndRead → 受信データを送信バッファにコピー → 次の非同期受信開始(BeginRead) → 同期送信(Write)

■ 切断処理 (BeginRead のコールバック関数内)

相手側から切断されると、受信がゼロバイトで完了します、
その場合は反対側の Socket オブジェクトを Shutdown(SocketShutdown.Send) します。
Socket オブジェクトは TCPClient.Client プロパティで取り出せます。

(7) (5) でRDP クライアントからゼロバイト受信したら RDP サーバー側を Shutdown。
(8) (6) でRDP サーバーからゼロバイト受信したら RDP クライアント側を Shutdown。
(9) 両方でゼロバイト受信が起きたら 両方の TCPClient を閉じて終了です。

Comments

[KOZ6.0]

WinGate を入れてプロキシ経由で通信する方法もありかなと思います。
「WinGate」
https://www.wingate.jp/

[rarirurero3421]

ありがとうございます。
今から作ってみて試してみます。
分からないことがあれば、再度質問するかもしれません。

[rarirurero3421]

> (3) RDP クライアントからの非同期受信開始
> (4) RDP サーバーからの非同期受信開始
>
重ねて、ご回答ありがとうございます。

(3)は分かるのですが、(4)が分からず、どうしたらいいか確認中です。

> (3) RDP クライアントからの非同期受信開始
>
これは以下のコードで問題ないでしょうか？

tcpListener = new TcpListener(IPAddress.Parse("127.0.0.1"), 13389);
tcpListener.Start();
tcpListener.BeginAcceptTcpClient(TcpClientAccepted, null);
注意) tcpListenerはメンバ変数です。
注意) TcpClientAcceptedメソッドは『(5) RDP クライアントから受信したら RDP サーバーに送信』を行っています。

> (4) RDP サーバーからの非同期受信開始
>
こちらは、どうしたらよいでしょうか？
RDPサーバーは、接続先の仮想マシンなので、そのIPアドレスは当然分かるとして・・・
コードは↑と同じように↓のコードになるのでしょうか？

tcpListener = new TcpListener(IPAddress.Parse("<< Azure VMのIPアドレス >>"), 3389);
tcpListener.Start();
tcpListener.BeginAcceptTcpClient(TcpClientAccepted, null);

[KOZ6.0]

(3) RDP クライアントからの非同期受信開始

(1) で接続を受ける(EndAcceptTcpClient) と TcpClient が取り出せますね。
その TcpClient を使って非同期読み込み開始です。
具体的には GetStream メソッドで NetworkStream を取り出して BeginRead です。

(4) RDP サーバーからの非同期受信開始

(2) で TCPClient を使って RDP サーバーに接続します。
(3) と同じように GetStream メソッドで NetworkStream を取り出して BeginRead です。

[KOZ6.0]

「TcpListener.BeginAcceptTcpClient(AsyncCallback, Object) Method」
https://docs.microsoft.com/en-us/dotnet/api/system.net.sockets.tcplistener.beginaccepttcpclient?view=netframework-4.8
「TcpListener.EndAcceptTcpClient(IAsyncResult) Method」
https://docs.microsoft.com/en-us/dotnet/api/system.net.sockets.tcplistener.endaccepttcpclient?view=netframework-4.8
「NetworkStream.BeginRead(Byte[], Int32, Int32, AsyncCallback, Object) Method」
https://docs.microsoft.com/en-us/dotnet/api/system.net.sockets.networkstream.beginread?view=netframework-4.8
「NetworkStream.EndRead(IAsyncResult) Method」
https://docs.microsoft.com/en-us/dotnet/api/system.net.sockets.networkstream.endread?view=netframework-4.8
日本語のページは翻訳の精度があまりよくないので英文のページを紹介しています。
この辺に目をとおしてください。

Answer 2

サンプルを書いてみました。何かあっても自己責任でお願いします。

namespace ConsoleApp8
{
    using System;
    using System.Collections.Generic;
    using System.IO;
    using System.Net;
    using System.Net.Sockets;
    using System.Threading;
    using System.ComponentModel;

    class Program
    {
         private const int rdpPortNumber = 3389;
         private const int localRdpPortNumber = 13389;
         private const string virtualMachine = "<< Azure 仮想マシンのIPアドレス >>";

        static void Main(string[] args) {
            TcpBridge breidge = new TcpBridge(IPAddress.Any, localRdpPortNumber,
                                        IPAddress.Parse(virtualMachine), rdpPortNumber);
            Console.WriteLine("breidge.Start()");
            breidge.Start();
            Console.ReadKey();
            Console.WriteLine("breidge.Stop(true)");
            // 強制切断
            breidge.Stop(true);

            Console.WriteLine("breidge.Start()");
            breidge.Start();
            Console.ReadKey();
            Console.WriteLine("breidge.Stop(false)");
            // 全てのクライアントが切断するまで待機
            breidge.Stop(false);

            Console.WriteLine("Enter キーを押すと終了します。");
            Console.ReadLine();
        }
    }

    class TcpBridge
    {
        private readonly AsyncCallback OnAcceptTcpClientCallback;
        private readonly IPAddress serverAddress;
        private readonly int serverPort;
        private readonly ConnectionCollection connections = new ConnectionCollection();
        private readonly TcpListener listener;

        public bool IsStoped { get; private set; } = true;

        public TcpBridge(IPAddress listenAddress, int listenPort,
                         IPAddress serverAddress, int serverPort) {
            this.serverAddress = serverAddress;
            this.serverPort = serverPort;
            OnAcceptTcpClientCallback = new AsyncCallback(OnAcceptTcpClient);
            listener = new TcpListener(listenAddress, listenPort);
        }

        public void Start() {
            if (!IsStoped) {
                throw new InvalidOperationException("既に開始しています。");
            }
            IsStoped = false;
            try {
                listener.Start();
                listener.BeginAcceptTcpClient(OnAcceptTcpClientCallback, null);
            } catch {
                IsStoped = true;
                throw;
            }
        }

        public void Stop() {
            Stop(false);
        }

        public void Stop(bool force) {
            if (IsStoped) {
                throw new InvalidOperationException("既に終了しています。");
            }
            IsStoped = true;
            connections.WaitAll(force);
            listener.Stop();
        }

        private void OnAcceptTcpClient(IAsyncResult ar) {
            TcpClient client;
            try {
                client = listener.EndAcceptTcpClient(ar);
                if (IsStoped) {
                    client.Close();
                    return;
                }
            } catch (IOException) {
                return;
            } catch (ObjectDisposedException) {
                return;
            }
            Console.WriteLine("Connect From {0}", client.Client.RemoteEndPoint);
            listener.BeginAcceptTcpClient(OnAcceptTcpClientCallback, null);

            try {
                TcpClient server = new TcpClient();
                server.Connect(serverAddress, serverPort);
                Console.WriteLine("Connect To {0}", server.Client.RemoteEndPoint);
                Connection connection = new Connection(client, server);
                connections.Add(connection);

            } catch (SocketException) {
                client.Close();
            }
        }
    }

    class Connection : IDisposable
    {
        private readonly TcpClient client;
        private readonly TcpClient server;

        private readonly Forwarder clientToServer;
        private readonly Forwarder serverToClient;

        public event EventHandler CloseEvent;

        public Connection(TcpClient client, TcpClient server) {
            this.client = client;
            this.server = server;

            clientToServer = new Forwarder(client, server);
            serverToClient = new Forwarder(server, client);

            clientToServer.EndOfStream += EndOfStreamEvent;
            serverToClient.EndOfStream += EndOfStreamEvent;
        }

        private void EndOfStreamEvent(object sender, EventArgs e) {
            if (clientToServer.AtEndOfStream && serverToClient.AtEndOfStream) {
                Close();
            }
        }

        public void Close() {
            Dispose();
        }

        protected virtual void OnCloseEvent(EventArgs e) {
            CloseEvent?.Invoke(this, e);
        }

        private bool disposedValue;

        protected virtual void Dispose(bool disposing) {
            if (!disposedValue) {
                disposedValue = true;
                if (disposing) {
                    Console.WriteLine("Close {0}", client.Client.RemoteEndPoint);
                    Console.WriteLine("Close {0}", server.Client.RemoteEndPoint);
                    client.Close();
                    server.Close();
                    OnCloseEvent(EventArgs.Empty);
                }
            }
        }

        public void Dispose() {
            Dispose(disposing: true);
            GC.SuppressFinalize(this);
        }
    }

    class ConnectionCollection
    {
        private readonly ManualResetEvent resetEvent = new ManualResetEvent(true);
        private readonly List<Connection> list = new List<Connection>();

        public void Add(Connection connection) {
            resetEvent.Reset();
            lock (this) {
                list.Add(connection);
            }
            connection.CloseEvent += Connection_CloseEvent;
        }

        public int Count {
            get {
                return list.Count;
            }
        }

        public Connection this[int index] {
            get {
                return list[index];
            }
        }

        private void Connection_CloseEvent(object sender, EventArgs e) {
            Connection connection = (Connection)sender;
            connection.CloseEvent -= Connection_CloseEvent;
            lock (this) {
                list.Remove(connection);
            }
            if (list.Count == 0) {
                resetEvent.Set();
            }
        }

        public void WaitAll(bool force) {
            if (force) {
                lock (this) {
                    foreach (Connection con in list.ToArray()) {
                        con.Close();
                    }
                }
            }
            resetEvent.WaitOne();
        }
    }

    class Forwarder
    {
        private readonly NetworkStream reader;
        private readonly NetworkStream writer;
        private readonly Socket writerSocket;
        private readonly byte[] readBuffer = new byte[2048];
        private readonly byte[] writeBuffer = new byte[2048];
        private readonly AsyncCallback OnReadCallback;

        public event EventHandler EndOfStream;
        public bool AtEndOfStream { get; private set; } = false;

        public Forwarder(TcpClient readClient, TcpClient writeClient) {
            reader = readClient.GetStream();
            writer = writeClient.GetStream();
            writerSocket = writeClient.Client;
            OnReadCallback = new AsyncCallback(OnRead);
            reader.BeginRead(readBuffer, 0, readBuffer.Length, OnReadCallback, null);
        }

        private void OnRead(IAsyncResult ar) {
            int size = EndRead(ar);
            if (size > 0) {
                Array.Copy(readBuffer, writeBuffer, size);
                reader.BeginRead(readBuffer, 0, readBuffer.Length, OnReadCallback, null);
                if (writer.CanWrite) {
                    writer.Write(writeBuffer, 0, size);
                }
            } else {
                OnEndOfStream(EventArgs.Empty);
            }
        }

        private int EndRead(IAsyncResult ar) {
            int size = 0;
            try {
                size = reader.EndRead(ar);
            } catch (IOException) {
            } catch (ObjectDisposedException) {
            }
            // size がゼロ以上なら正常
            if (size >= 0) {
                return size;
            } else {
                // ゼロ未満ならエラーが発生している
                Win32Exception exception = new Win32Exception();
                Console.WriteLine(exception.ToString());
                return 0;
            }
        }

        protected virtual void OnEndOfStream(EventArgs e) {
            if (writerSocket.Connected) {
                writerSocket.Shutdown(SocketShutdown.Send);
            }
            AtEndOfStream = true;
            EndOfStream?.Invoke(this, e);
        }
    }
}

Comments

[rarirurero3421]

ありがとうございます。とても助かります。
今からこちらを試させていただきます。

[rarirurero3421]

ありがとうございます。
少しだけ変更する必要がありましたが、結果的に動作しました。
とっても助かりました！
（294行周辺を以下のように変えました。）

try
{
size = reader.EndRead(ar);
}
catch (IOException)
{
return 0;
}

[KOZ6.0]

修正ありがとうございます。CanRead が効かないケースがあるんですね。.NET6 です？
そこをそのように修正するなら ObjectDisposeException も catch する必要があると思います。