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);
}
