public void Send(byte[] data, int length) { IEncryptor encryptor = EncryptorFactory.GetEncryptor(_server.method, _server.password, _server.auth, true); byte[] dataIn = new byte[length - 3 + IVEncryptor.ONETIMEAUTH_BYTES]; Array.Copy(data, 3, dataIn, 0, length - 3); byte[] dataOut = new byte[length - 3 + 16 + IVEncryptor.ONETIMEAUTH_BYTES]; int outlen; encryptor.Encrypt(dataIn, length - 3, dataOut, out outlen); Logging.Debug($"++++++Send Server Port, size:" + outlen); _remote.SendTo(dataOut, outlen, SocketFlags.None, _remoteEndPoint); }
public void CreateRemote(EndPoint destination) { Server server = _controller.GetAServer(IStrategyCallerType.TCP, (IPEndPoint)_connection.RemoteEndPoint, destination); if (server == null || server.server == "") { throw new ArgumentException("No server configured"); } encryptor = EncryptorFactory.GetEncryptor(server.method, server.password); decryptor = EncryptorFactory.GetEncryptor(server.method, server.password); _server = server; }
public void Send(byte[] data, int length) { IEncryptor encryptor = EncryptorFactory.GetEncryptor(_server.method, _server.password); byte[] dataIn = new byte[length - 3]; Array.Copy(data, 3, dataIn, 0, length - 3); byte[] dataOut = new byte[65536]; // enough space for AEAD ciphers int outlen; encryptor.EncryptUDP(dataIn, length - 3, dataOut, out outlen); Logging.Debug(_localEndPoint, _remoteEndPoint, outlen, "UDP Relay"); _remote?.SendTo(dataOut, outlen, SocketFlags.None, _remoteEndPoint); }
public ConfigWindow(ShadowsocksController controller, int focusIndex) { InitializeComponent(); SizeChanged += (o, args) => { GenQr(LinkTextBox.Text); }; Splitter2.DragDelta += (o, args) => { GenQr(LinkTextBox.Text); }; Closed += (o, e) => { _controller.ConfigChanged -= controller_ConfigChanged; ServerViewModel.ServersChanged -= ServerViewModel_ServersChanged; }; _controller = controller; foreach (var name in EncryptorFactory.GetEncryptor().Keys) { var info = EncryptorFactory.GetEncryptorInfo(name); if (info.display) { EncryptionComboBox.Items.Add(name); } } foreach (var protocol in Protocols) { ProtocolComboBox.Items.Add(protocol); } foreach (var obfs in ObfsStrings) { ObfsComboBox.Items.Add(obfs); } _controller.ConfigChanged += controller_ConfigChanged; LoadCurrentConfiguration(); ServerViewModel.ServersChanged += ServerViewModel_ServersChanged; if (focusIndex == -1) { var index = _modifiedConfiguration.index + 1; if (index < 0 || index > _modifiedConfiguration.configs.Count) { index = _modifiedConfiguration.configs.Count; } focusIndex = index; } if (focusIndex >= 0 && focusIndex < _modifiedConfiguration.configs.Count) { SetServerListSelectedIndex(focusIndex); } }
public void EncryptStringTest() { var largeBytes = new byte[ushort.MaxValue * 100]; RandomNumberGenerator.Fill(largeBytes); var largeStr = Encoding.UTF8.GetString(largeBytes); var encryptor = EncryptorFactory.GetEncryptor(@"aes-256-cfb", @"密码"); var encodeStr = Utils.EncryptLargeBytesToBase64String(encryptor, largeBytes); var decodeStr = Encoding.UTF8.GetString(Utils.DecryptLargeBase64StringToBytes(encryptor, encodeStr)); Assert.AreEqual(largeStr, decodeStr); }
public async Task InitiateTransfer(CustomConnection connection, EncryptionTypes allowedEncryption) { EncryptorFactory.EncryptorResult result; if (connection.IsIncoming) { result = await EncryptorFactory.CheckIncomingConnectionAsync(connection, allowedEncryption, rig.Engine.Settings, HandshakeMessage.HandshakeLength, new [] { rig.Manager.InfoHash }); } else { result = await EncryptorFactory.CheckOutgoingConnectionAsync(connection, allowedEncryption, rig.Engine.Settings, rig.Manager.InfoHash); } decryptor = result.Decryptor; encryptor = result.Encryptor; TestHandshake(result.InitialData, connection); }
public override byte[] ClientUdpPreEncrypt(byte[] plaindata, int datalength, out int outlength) { byte[] outdata = new byte[datalength + 1024]; if (user_key == null) { user_id = new byte[4]; int index_of_split = Server.param.IndexOf(':'); if (index_of_split > 0) { try { uint user = uint.Parse(Server.param.Substring(0, index_of_split)); user_key = System.Text.Encoding.UTF8.GetBytes(Server.param.Substring(index_of_split + 1)); BitConverter.GetBytes(user).CopyTo(user_id, 0); } catch (Exception ex) { Logging.Log(LogLevel.Warn, $"Faild to parse auth param, fallback to basic mode. {ex}"); } } if (user_key == null) { random.NextBytes(user_id); user_key = Server.key; } } byte[] auth_data = new byte[3]; random.NextBytes(auth_data); byte[] md5data = MbedTLS.ComputeHash(Server.key, auth_data, 0, auth_data.Length); int rand_len = UdpGetRandLen(random_client, md5data); byte[] rand_data = new byte[rand_len]; random.NextBytes(rand_data); outlength = datalength + rand_len + 8; encryptor = EncryptorFactory.GetEncryptor("rc4", Convert.ToBase64String(user_key) + Convert.ToBase64String(md5data, 0, 16)); encryptor.Encrypt(plaindata, datalength, outdata, out datalength); rand_data.CopyTo(outdata, datalength); auth_data.CopyTo(outdata, outlength - 8); byte[] uid = new byte[4]; for (int i = 0; i < 4; ++i) { uid[i] = (byte)(user_id[i] ^ md5data[i]); } uid.CopyTo(outdata, outlength - 5); md5data = MbedTLS.ComputeHash(user_key, outdata, 0, outlength - 1); return(outdata); }
public void Send(byte[] data, int length) { IEncryptor encryptor = EncryptorFactory.GetEncryptor(_server.method, _server.password); //?what's the futrue of data byte[] dataIn = new byte[length - 3]; Array.Copy(data, 3, dataIn, 0, length - 3); //?what's the futrue of data byte[] dataOut = new byte[length - 3 + 16]; int outlen; encryptor.Encrypt(dataIn, dataIn.Length, dataOut, out outlen); _remote.SendTo(dataOut, _remoteEndPoint); }
public ConfigForm(ShadowsocksController controller) { Font = SystemFonts.MessageBoxFont; InitializeComponent(); EncryptionSelect.Items.AddRange(EncryptorFactory.ListAvaliableCiphers().ToArray()); PerformLayout(); UpdateTexts(); SetupValueChangedListeners(); Icon = Icon.FromHandle(Resources.ssw128.GetHicon()); this.controller = controller; controller.ConfigChanged += Controller_ConfigChanged; LoadCurrentConfiguration(); }
public void CreateRemote() { Server server = _controller.GetAServer(IStrategyCallerType.TCP, (IPEndPoint)_connection.RemoteEndPoint); if (server == null || server.server == "") { throw new ArgumentException("No server configured"); } lock (_encryptionLock) { lock (_decryptionLock) { _encryptor = EncryptorFactory.GetEncryptor(server.method, server.password, server.auth, false); } } this._server = server; }
public void CreateRemote() { Server server = _controller.GetAServer(IStrategyCallerType.TCP, (IPEndPoint)_connection.RemoteEndPoint, _destEndPoint); if (server == null || server.server == "") { throw new ArgumentException("No server configured"); } _encryptor = EncryptorFactory.GetEncryptor(server.method, server.password); this._server = server; /* prepare address buffer length for AEAD */ Logger.Debug($"_addrBufLength={_addrBufLength}"); _encryptor.AddrBufLength = _addrBufLength; }
private void CreateRemote() { Server server = _controller.GetAServer((IPEndPoint)_localSocket.RemoteEndPoint, _destEndPoint); if (server == null || server.server == "") { throw new ArgumentException("No server configured"); } _encryptor = EncryptorFactory.GetEncryptor(server.method, server.password); _server = server; /* prepare address buffer length for AEAD */ Logging.Debug($"_addrBufLength={_addrBufLength}"); _encryptor.AddrBufLength = _addrBufLength; }
public bool Handle(byte[] firstPacket, int length, Socket socket) { if (length < 2 || firstPacket[0] != 5) { return(false); } socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, true); Handler handler = new Handler(); handler.connection = socket; Server server = _config.GetCurrentServer(); handler.encryptor = EncryptorFactory.GetEncryptor(server.method, server.password); handler.server = server; handler.Start(firstPacket, length); return(true); }
async void ConnectionReceived(object sender, NewConnectionEventArgs e) { await ClientEngine.MainLoop; try { if (Engine.ConnectionManager.ShouldBanPeer(e.Peer)) { e.Connection.Dispose(); return; } if (!e.Connection.IsIncoming) { var id = new PeerId(e.Peer, e.TorrentManager, e.Connection); id.LastMessageSent.Restart(); id.LastMessageReceived.Restart(); Engine.ConnectionManager.ProcessNewOutgoingConnection(id); return; } Logger.Log(e.Connection, "ListenManager - ConnectionReceived"); var skeys = new List <InfoHash>(); for (int i = 0; i < Engine.Torrents.Count; i++) { skeys.Add(Engine.Torrents[i].InfoHash); } var result = await EncryptorFactory.CheckIncomingConnectionAsync(e.Connection, e.Peer.AllowedEncryption, Engine.Settings, HandshakeMessage.HandshakeLength, skeys.ToArray()); var handshake = new HandshakeMessage(); handshake.Decode(result.InitialData, 0, result.InitialData.Length); if (!await HandleHandshake(e.Peer, e.Connection, handshake, result.Decryptor, result.Encryptor)) { e.Connection.Dispose(); } } catch { e.Connection.Dispose(); } }
public static void Save(Configuration config) { if (config.index >= config.configs.Count) { config.index = config.configs.Count - 1; } if (config.index < 0) { config.index = 0; } try { var jsonString = JsonConvert.SerializeObject(config, Formatting.Indented); if (GlobalConfiguration.config_password.Length > 0) { using var encryptor = EncryptorFactory.GetEncryptor(@"aes-256-cfb", GlobalConfiguration.config_password); var cfgData = Encoding.UTF8.GetBytes(jsonString); jsonString = Utils.EncryptLargeBytesToBase64String(encryptor, cfgData); } using (var sw = new StreamWriter(File.Open(CONFIG_FILE, FileMode.Create))) { sw.Write(jsonString); sw.Flush(); } if (File.Exists(CONFIG_FILE_BACKUP)) { var dt = File.GetLastWriteTimeUtc(CONFIG_FILE_BACKUP); var now = DateTime.Now; if ((now - dt).TotalHours > 4) { File.Copy(CONFIG_FILE, CONFIG_FILE_BACKUP, true); } } else { File.Copy(CONFIG_FILE, CONFIG_FILE_BACKUP, true); } } catch (IOException e) { Console.Error.WriteLine(e); } }
public static void Save(Configuration config) { if (config.index >= config.configs.Count) { config.index = config.configs.Count - 1; } if (config.index < 0) { config.index = 0; } try { string jsonString = SimpleJson.SimpleJson.SerializeObject(config); if (GlobalConfiguration.config_password.Length > 0) { IEncryptor encryptor = EncryptorFactory.GetEncryptor("aes-256-cfb", GlobalConfiguration.config_password, false); byte[] cfg_data = UTF8Encoding.UTF8.GetBytes(jsonString); byte[] cfg_encrypt = new byte[cfg_data.Length + 128]; int data_len = 0; const int buffer_size = 32768; byte[] input = new byte[buffer_size]; byte[] ouput = new byte[buffer_size + 128]; for (int start_pos = 0; start_pos < cfg_data.Length; start_pos += buffer_size) { int len = Math.Min(cfg_data.Length - start_pos, buffer_size); int out_len; Buffer.BlockCopy(cfg_data, start_pos, input, 0, len); encryptor.Encrypt(input, len, ouput, out out_len); Buffer.BlockCopy(ouput, 0, cfg_encrypt, data_len, out_len); data_len += out_len; } jsonString = System.Convert.ToBase64String(cfg_encrypt, 0, data_len); } using (StreamWriter sw = new StreamWriter(File.Open(CONFIG_FILE, FileMode.Create))) { sw.Write(jsonString); sw.Flush(); } } catch (IOException e) { Console.Error.WriteLine(e); } }
async void ConnectionReceived(object sender, NewConnectionEventArgs e) { await ClientEngine.MainLoop; try { if (Engine.ConnectionManager.ShouldBanPeer(e.Peer)) { e.Connection.Dispose(); return; } if (!e.Connection.IsIncoming) { var id = new PeerId(e.Peer, e.Connection, e.TorrentManager.Bitfield?.Clone().SetAll(false)); id.LastMessageSent.Restart(); id.LastMessageReceived.Restart(); Engine.ConnectionManager.ProcessNewOutgoingConnection(e.TorrentManager, id); return; } Logger.Log(e.Connection, "ListenManager - ConnectionReceived"); var skeys = new List <InfoHash>(); for (int i = 0; i < Engine.Torrents.Count; i++) { skeys.Add(Engine.Torrents[i].InfoHash); } var connection = ConnectionConverter.Convert(e.Connection); var result = await EncryptorFactory.CheckIncomingConnectionAsync(connection, e.Peer.AllowedEncryption, Engine.Settings, skeys.ToArray()); if (!await HandleHandshake(e.Peer, connection, result.Handshake, result.Decryptor, result.Encryptor)) { connection.Dispose(); } } catch { e.Connection.Dispose(); } }
public async Task Setup(bool metadataMode, bool multiFile = false, bool metadataOnly = false) { pair = new ConnectionPair().WithTimeout(); rig = multiFile ? TestRig.CreateMultiFile(32768, metadataMode) : TestRig.CreateSingleFile(1024 * 1024 * 1024, 32768, metadataMode); rig.RecreateManager().Wait(); rig.Manager.HashChecked = true; await rig.Manager.StartAsync(metadataOnly); rig.AddConnection(pair.Outgoing); var connection = pair.Incoming; PeerId id = new PeerId(new Peer("", connection.Uri), connection, rig.Manager.Bitfield?.Clone().SetAll(false)); var result = await EncryptorFactory.CheckIncomingConnectionAsync(id.Connection, id.Peer.AllowedEncryption, new[] { rig.Manager.InfoHash }); decryptor = id.Decryptor = result.Decryptor; encryptor = id.Encryptor = result.Encryptor; }
public static Configuration Load(string config_str) { try { if (GlobalConfiguration.config_password.Length > 0) { var cfg_encrypt = Convert.FromBase64String(config_str); var encryptor = EncryptorFactory.GetEncryptor("aes-256-cfb", GlobalConfiguration.config_password); var cfg_data = new byte[cfg_encrypt.Length]; var data_len = 0; const int buffer_size = 32768; var input = new byte[buffer_size]; var output = new byte[buffer_size + 128]; for (var start_pos = 0; start_pos < cfg_encrypt.Length; start_pos += buffer_size) { var len = Math.Min(cfg_encrypt.Length - start_pos, buffer_size); Buffer.BlockCopy(cfg_encrypt, start_pos, input, 0, len); encryptor.Decrypt(input, len, output, out var out_len); Buffer.BlockCopy(output, 0, cfg_data, data_len, out_len); data_len += out_len; } config_str = Encoding.UTF8.GetString(cfg_data, 0, data_len); } } catch { // ignored } try { var config = JsonConvert.DeserializeObject <Configuration>(config_str); config.FixConfiguration(); return(config); } catch { // ignored } return(null); }
public static void Save(ServerTransferTotal config) { try { using var sw = new StreamWriter(File.Open(LOG_FILE, FileMode.Create)); var jsonString = JsonConvert.SerializeObject(config.servers, Formatting.Indented); if (GlobalConfiguration.config_password.Length > 0) { using var encryptor = EncryptorFactory.GetEncryptor(@"aes-256-cfb", GlobalConfiguration.config_password); var cfgData = Encoding.UTF8.GetBytes(jsonString); jsonString = Utils.EncryptLargeBytesToBase64String(encryptor, cfgData); } sw.Write(jsonString); sw.Flush(); } catch (IOException e) { Console.Error.WriteLine(e); } }
public async Task Setup(bool metadataMode, string metadataPath) { pair = new ConnectionPair(55432); rig = TestRig.CreateSingleFile(1024 * 1024 * 1024, 32768, metadataMode); rig.MetadataPath = metadataPath; rig.RecreateManager().Wait(); rig.Manager.HashChecked = true; await rig.Manager.StartAsync(); rig.AddConnection(pair.Outgoing); var connection = pair.Incoming; PeerId id = new PeerId(new Peer("", connection.Uri), rig.Manager, connection); var result = await EncryptorFactory.CheckIncomingConnectionAsync(id.Connection, id.Peer.AllowedEncryption, rig.Engine.Settings, HandshakeMessage.HandshakeLength, new InfoHash[] { id.TorrentManager.InfoHash }); decryptor = id.Decryptor = result.Decryptor; encryptor = id.Encryptor = result.Encryptor; }
public void Send(byte[] data, int length) { IEncryptor encryptor = EncryptorFactory.GetEncryptor(_server.method, _server.password); byte[] dataIn = new byte[length - 3]; Array.Copy(data, 3, dataIn, 0, length - 3); byte[] dataOut = new byte[length - 3 + 16]; int outlen; if (encryptor != null) { encryptor.Encrypt(dataIn, dataIn.Length, dataOut, out outlen); } else { dataOut = dataIn; outlen = dataIn.Length; } _remote.SendTo(dataOut, _remoteEndPoint); }
private void StartConnect() { try { if (relay.server.server == null || relay.server.server == "") { throw new ArgumentException("No server configured"); } encryptor = EncryptorFactory.GetEncryptor(relay.server.method, relay.server.password, relay.server.auth, false); // TODO async resolving IPAddress ipAddress; bool parsed = IPAddress.TryParse(relay.server.server, out ipAddress); if (!parsed) { IPHostEntry ipHostInfo = Dns.GetHostEntry(relay.server.server); ipAddress = ipHostInfo.AddressList[0]; } IPEndPoint remoteEP = new IPEndPoint(ipAddress, relay.server.server_port); remote = new Socket(ipAddress.AddressFamily, SocketType.Stream, ProtocolType.Tcp); remote.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, true); _startConnectTime = DateTime.Now; ServerTimer connectTimer = new ServerTimer(3000); connectTimer.AutoReset = false; connectTimer.Elapsed += connectTimer_Elapsed; connectTimer.Enabled = true; connectTimer.Server = relay.server; connected = false; // Connect to the remote endpoint. remote.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), connectTimer); } catch (Exception e) { Logging.LogUsefulException(e); Close(); } }
public override byte[] ClientUdpPostDecrypt(byte[] plaindata, int datalength, out int outlength) { if (datalength <= 8) { outlength = 0; return(plaindata); } byte[] md5data = MbedTLS.ComputeHash(user_key, plaindata, 0, datalength - 1); if (md5data[0] != plaindata[datalength - 1]) { outlength = 0; return(plaindata); } md5data = MbedTLS.ComputeHash(Server.key, plaindata, datalength - 8, 7); int rand_len = UdpGetRandLen(random_server, md5data); outlength = datalength - rand_len - 8; encryptor = EncryptorFactory.GetEncryptor("rc4", Convert.ToBase64String(user_key) + Convert.ToBase64String(md5data, 0, 16)); encryptor.Decrypt(plaindata, outlength, plaindata, out outlength); return(plaindata); }
public void Setup(bool metadataMode, string metadataPath) { pair = new ConnectionPair(55432); rig = TestRig.CreateSingleFile(1024 * 1024 * 1024, 32768, metadataMode); rig.MetadataPath = metadataPath; rig.RecreateManager().Wait(); rig.Manager.HashChecked = true; rig.Manager.Start(); rig.AddConnection(pair.Outgoing); var connection = pair.Incoming; PeerId id = new PeerId(new Peer("", connection.Uri), rig.Manager); id.Connection = connection; byte[] data = EncryptorFactory.CheckEncryptionAsync(id, 68, new InfoHash[] { id.TorrentManager.InfoHash }).Result; decryptor = id.Decryptor; encryptor = id.Encryptor; }
public void AcceptCallback(IAsyncResult ar) { try { // Get the socket that handles the client request. Socket listener = (Socket)ar.AsyncState; if (!listener.Connected) { return; } listener.BeginAccept( new AsyncCallback(AcceptCallback), listener); Socket conn = listener.EndAccept(ar); // Create the state object. Handler handler = new Handler(); handler.connection = conn; //if (encryptor.method == "table") //{ // handler.encryptor = encryptor; //} //else //{ // handler.encryptor = new Encryptor(config.method, config.password); //} handler.encryptor = EncryptorFactory.GetEncryptor(config.method, config.password); handler.config = config; handler.Start(); //handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0, // new AsyncCallback(ReadCallback), state); } catch (Exception e) { Console.WriteLine(e.ToString()); } }
public static Configuration Load(string config_str) { try { if (GlobalConfiguration.config_password.Length > 0) { byte[] cfg_encrypt = System.Convert.FromBase64String(config_str); IEncryptor encryptor = EncryptorFactory.GetEncryptor("aes-256-cfb", GlobalConfiguration.config_password, false); byte[] cfg_data = new byte[cfg_encrypt.Length]; int data_len = 0; const int buffer_size = 32768; byte[] input = new byte[buffer_size]; byte[] ouput = new byte[buffer_size + 128]; for (int start_pos = 0; start_pos < cfg_encrypt.Length; start_pos += buffer_size) { int len = Math.Min(cfg_encrypt.Length - start_pos, buffer_size); int out_len; Buffer.BlockCopy(cfg_encrypt, start_pos, input, 0, len); encryptor.Decrypt(input, len, ouput, out out_len); Buffer.BlockCopy(ouput, 0, cfg_data, data_len, out_len); data_len += out_len; } config_str = UTF8Encoding.UTF8.GetString(cfg_data, 0, data_len); } } catch { } try { Configuration config = SimpleJson.SimpleJson.DeserializeObject <Configuration>(config_str, new JsonSerializerStrategy()); config.FixConfiguration(); return(config); } catch { } return(null); }
public void RecvFromCallback(IAsyncResult ar) { try { EndPoint remoteEndPoint = new IPEndPoint(IPAddress.Any, 0); int bytesRead = _remote.EndReceiveFrom(ar, ref remoteEndPoint); byte[] dataOut = new byte[bytesRead]; int outlen; IEncryptor encryptor = EncryptorFactory.GetEncryptor(_server.method, _server.password); if (encryptor != null) { encryptor.Decrypt(_buffer, bytesRead, dataOut, out outlen); } else { dataOut = _buffer; outlen = bytesRead; } byte[] sendBuf = new byte[outlen + 3]; Array.Copy(dataOut, 0, sendBuf, 3, outlen); _local.SendTo(sendBuf, outlen + 3, 0, _localEndPoint); Receive(); } catch (ObjectDisposedException) { // TODO: handle the ObjectDisposedException } catch (Exception) { // TODO: need more think about handle other Exceptions, or should remove this catch(). } finally { } }
private void SetServerDetailsToUI(Server server) { IPTextBox.Text = server.server; ServerPortTextBox.Text = server.server_port.ToString(); PasswordTextBox.Text = server.password; EncryptionSelect.SelectedItem = EncryptorFactory.GetCipherInfo(server.method ?? Server.DefaultMethod); PluginTextBox.Text = server.plugin; PluginOptionsTextBox.Text = server.plugin_opts; PluginArgumentsTextBox.Text = server.plugin_args; bool showPluginArgInput = !string.IsNullOrEmpty(server.plugin_args); NeedPluginArgCheckBox.Checked = showPluginArgInput; ShowHidePluginArgInput(showPluginArgInput); RemarksTextBox.Text = server.remarks; TimeoutTextBox.Text = server.timeout.ToString(); GroupTextBox.Text = server.group; isChange = false; }
/// <summary> /// 处理数据,并发送给ss服务器 /// </summary> /// <param name="data"></param> /// <param name="length"></param> public void Send(byte[] data, int length) { /* +----+------+------+----------+----------+----------+ |RSV | FRAG | ATYP | DST.ADDR | DST.PORT | DATA | +----+------+------+----------+----------+----------+ | 2 | 1 | 1 | Variable | 2 | Variable | +----+------+------+----------+----------+----------+ | | trim => (去掉前三位,猜测是无用信息,减小数据大小/网络开销) | +------+----------+----------+----------+ | ATYP | DST.ADDR | DST.PORT | DATA | +------+----------+----------+----------+ | 1 | Variable | 2 | Variable | +------+----------+----------+----------+ | | encrypt => (加密) | +-------+--------------+ | IV | PAYLOAD | +-------+--------------+ | Fixed | Variable | +-------+--------------+ */ // 去掉前三个字节 IEncryptor encryptor = EncryptorFactory.GetEncryptor(_server.method, _server.password, _server.auth, true); byte[] dataIn = new byte[length - 3 + IVEncryptor.ONETIMEAUTH_BYTES]; Array.Copy(data, 3, dataIn, 0, length - 3); byte[] dataOut = new byte[length - 3 + 16 + IVEncryptor.ONETIMEAUTH_BYTES]; int outlen; // 加密 encryptor.Encrypt(dataIn, length - 3, dataOut, out outlen); Logging.Debug($"++++++Send Server Port, size:" + outlen); // 发送给ss服务器 _remote.SendTo(dataOut, outlen, SocketFlags.None, _remoteEndPoint); }