public void Close()
{
_socket.Close();
if (_protocol != null)
{
_protocol.Dispose();
_protocol = null;
}
if (_obfs != null)
{
_obfs.Dispose();
_obfs = null;
}
lock (_encryptionLock)
{
lock (_decryptionLock)
{
if (_encryptor != null)
{
_encryptor.Dispose();
_encryptor = null;
}
}
}
_socket = null;
SendEncryptBuffer = null;
ReceiveDecryptBuffer = null;
}
public void Close()
{
manualResetEvent?.Set();
lock (_closeConnLock)
{
if (_closed)
{
return;
}
_closed = true;
}
if (_currentRemoteSession != null)
{
try
{
var remote = _currentRemoteSession.Remote;
remote.Shutdown(SocketShutdown.Both);
remote.Close();
}
catch (Exception e)
{
Logging.LogUsefulException(e);
}
}
lock (_encryptionLock)
{
lock (_decryptionLock)
{
_encryptor?.Dispose();
}
}
}
protected override void Disposing()
{
if (encryptor != null)
{
encryptor.Dispose();
encryptor = null;
}
}
private void DisposeEncryptor()
{
lock (_encryptionLock)
{
lock (_decryptionLock)
{
_encryptor?.Dispose();
}
}
}
public static EncryptorInfo GetEncryptorInfo(string method)
{
if (string.IsNullOrEmpty(method))
{
method = "aes-256-cfb";
}
method = method.ToLowerInvariant();
Type t = _registeredEncryptors[method];
ConstructorInfo c = t.GetConstructor(_constructorTypes);
IEncryptor result = (IEncryptor)c.Invoke(new object[] { method, "0" });
EncryptorInfo info = result.getInfo();
result.Dispose();
return(info);
}
public void Close()
{
lock (_closeConnLock)
{
if (_closed)
{
return;
}
_closed = true;
}
lock (_tcprelay.Handlers)
{
_tcprelay.Handlers.Remove(this);
}
try
{
_connection.Shutdown(SocketShutdown.Both);
_connection.Close();
}
catch (Exception e)
{
Logger.LogUsefulException(e);
}
if (_currentRemoteSession != null)
{
try
{
var remote = _currentRemoteSession.Remote;
remote.Shutdown(SocketShutdown.Both);
remote.Close();
}
catch (Exception e)
{
Logger.LogUsefulException(e);
}
}
lock (_encryptionLock)
{
lock (_decryptionLock)
{
_encryptor?.Dispose();
}
}
}
public void Close()
{
lock (_closeConnLock)
{
if (_closed)
{
return;
}
_closed = true;
}
OnClosed?.Invoke(this, new SSRelayEventArgs(_server));
try
{
_connection.Shutdown(SocketShutdown.Both);
_connection.Close();
}
catch (Exception e)
{
Logger.LogUsefulException(e);
}
if (_currentRemoteSession != null)
{
try
{
IProxy remote = _currentRemoteSession.Remote;
remote.Shutdown(SocketShutdown.Both);
remote.Close();
}
catch (Exception e)
{
Logger.LogUsefulException(e);
}
}
lock (_encryptionLock)
{
lock (_decryptionLock)
{
_encryptor?.Dispose();
}
}
}
public void Close()
{
int origin = Interlocked.CompareExchange(ref _state, _disposed, _running);
if (origin == _disposed)
{
return;
}
lock (_tcprelay.Handlers)
{
_tcprelay.Handlers.Remove(this);
}
Logging.Debug("Closing local and server socket");
Logging.Debug($"_localShutdown: {_localShutdown} _remoteShutdown: {_remoteShutdown}");
try
{
_localSocket?.Shutdown(SocketShutdown.Both);
_localSocket?.Close();
}
catch (Exception e)
{
Logging.LogUsefulException(e);
}
try
{
_serverSocket?.Shutdown(SocketShutdown.Both);
_serverSocket?.Close();
}
catch (Exception e)
{
Logging.LogUsefulException(e);
}
lock (_encryptionLock)
{
lock (_decryptionLock)
{
_encryptor?.Dispose();
}
}
_tcprelay.DecrementTCPConnectionCounter();
}
public void Close()
{
lock (_closeConnLock)
{
if (_closed)
{
return;
}
_closed = true;
}
lock (_tcprelay.Handlers)
{
_tcprelay.Handlers.Remove(this);
}
try
{
_connection.Shutdown(SocketShutdown.Both);
_connection.Close();
}
catch (Exception e)
{
Logging.LogUsefulException(e);
}
try
{
_remote.Shutdown(SocketShutdown.Both);
_remote.Close();
}
catch (Exception e)
{
Logging.LogUsefulException(e);
}
lock (_encryptionLock)
{
lock (_decryptionLock)
{
_encryptor?.Dispose();
}
}
}
public void Close()
{
lock (tcprelay.Handlers)
{
tcprelay.Handlers.Remove(this);
}
lock (this) {
if (_closed)
{
return;
}
_closed = true;
}
try
{
connection?.Shutdown(SocketShutdown.Both);
connection?.Close();
}
catch (Exception e)
{
Logging.LogUsefulException(e);
}
try
{
var remote = _currentRemoteSession?.Remote;
remote?.Shutdown(SocketShutdown.Both);
remote?.Close();
}
catch (Exception e)
{
Logging.LogUsefulException(e);
}
lock (_encryptionLock)
{
lock (_decryptionLock)
{
encryptor?.Dispose();
}
}
}
public void ServerFromSS(string ssURL)
{
// ss://obfs:protocol:method:passwd@host:port/#remarks
string[] r1 = Regex.Split(ssURL, "ss://", RegexOptions.IgnoreCase);
string base64 = r1[1].ToString();
string data = DecodeBase64(base64);
if (data.Length == 0)
{
throw new FormatException();
}
try
{
int indexLastAt = data.LastIndexOf('@');
int remarkIndexLastAt = data.IndexOf('#', indexLastAt);
if (remarkIndexLastAt > 0)
{
if (remarkIndexLastAt + 1 < data.Length)
{
this.remarks_base64 = data.Substring(remarkIndexLastAt + 1);
}
data = data.Substring(0, remarkIndexLastAt);
}
remarkIndexLastAt = data.IndexOf('/', indexLastAt);
string param = "";
if (remarkIndexLastAt > 0)
{
if (remarkIndexLastAt + 1 < data.Length)
{
param = data.Substring(remarkIndexLastAt + 1);
}
data = data.Substring(0, remarkIndexLastAt);
}
//int paramIndexLastAt = param.IndexOf('?', indexLastAt);
//Dictionary<string, string> params_dict = new Dictionary<string, string>();
//if (paramIndexLastAt >= 0)
//{
// string[] obfs_params = param.Substring(paramIndexLastAt + 1).Split('&');
// foreach (string p in obfs_params)
// {
// if (p.IndexOf('=') > 0)
// {
// int index = p.IndexOf('=');
// string key, val;
// key = p.Substring(0, index);
// val = p.Substring(index + 1);
// try
// {
// byte[] b64_bytes = System.Convert.FromBase64String(val);
// if (b64_bytes != null)
// {
// val = Encoding.UTF8.GetString(b64_bytes);
// }
// }
// catch (FormatException)
// {
// continue;
// }
// params_dict[key] = val;
// }
// }
//}
string afterAt = data.Substring(indexLastAt + 1);
int indexLastColon = afterAt.LastIndexOf(':');
this.server_port = int.Parse(afterAt.Substring(indexLastColon + 1));
this.server = afterAt.Substring(0, indexLastColon);
string beforeAt = data.Substring(0, indexLastAt);
this.method = "";
for (bool next = true; next;)
{
string[] parts = beforeAt.Split(new[] { ':' }, 2);
if (parts.Length > 1)
{
try
{
Obfs.ObfsBase obfs = (Obfs.ObfsBase)Obfs.ObfsFactory.GetObfs(parts[0]);
if (obfs.GetObfs().ContainsKey(parts[0]))
{
int[] p = obfs.GetObfs()[parts[0]];
if (p[0] == 1)
{
this.protocol = parts[0];
}
if (p[1] == 1)
{
this.obfs = parts[0];
}
}
else
{
next = false;
}
}
catch
{
try
{
IEncryptor encryptor = EncryptorFactory.GetEncryptor(parts[0], "m");
encryptor.Dispose();
this.method = parts[0];
beforeAt = parts[1];
}
catch
{
}
break;
}
beforeAt = parts[1];
}
else
{
break;
}
}
if (this.method.Length == 0)
{
throw new FormatException();
}
this.password = beforeAt;
//if (params_dict.ContainsKey("obfs"))
//{
// this.obfsparam = params_dict["obfs"];
//}
}
catch (IndexOutOfRangeException)
{
throw new FormatException();
}
}
public void PackAuthData(byte[] data, int datalength, byte[] outdata, out int outlength)
{
const int authhead_len = 4 + 8 + 4 + 16 + 4;
byte[] encrypt = new byte[24];
AuthDataAesChain authData = Server.data as AuthDataAesChain;
lock (authData)
{
if (authData.connectionID > 0xFF000000)
{
authData.clientID = null;
}
if (authData.clientID == null)
{
authData.clientID = new byte[4];
g_random.GetBytes(authData.clientID);
authData.connectionID = (UInt32)BitConverter.ToInt32(authData.clientID, 0) % 0xFFFFFD;
}
authData.connectionID += 1;
Array.Copy(authData.clientID, 0, encrypt, 4, 4);
Array.Copy(BitConverter.GetBytes(authData.connectionID), 0, encrypt, 8, 4);
}
outlength = authhead_len;
byte[] encrypt_data = new byte[32];
byte[] key = new byte[Server.iv.Length + Server.key.Length];
Server.iv.CopyTo(key, 0);
Server.key.CopyTo(key, Server.iv.Length);
UInt64 utc_time_second = (UInt64)Math.Floor(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1, 0, 0, 0)).TotalSeconds);
UInt32 utc_time = (UInt32)(utc_time_second);
Array.Copy(BitConverter.GetBytes(utc_time), 0, encrypt, 0, 4);
encrypt[12] = (byte)(Server.overhead);
encrypt[13] = (byte)(Server.overhead >> 8);
// first 12 bytes
{
byte[] rnd = new byte[4];
random.NextBytes(rnd);
rnd.CopyTo(outdata, 0);
byte[] md5data = MbedTLS.ComputeHash(key, rnd, 0, rnd.Length);
last_client_hash = md5data;
Array.Copy(md5data, 0, outdata, rnd.Length, 8);
}
// uid & 16 bytes auth data
{
byte[] uid = 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(uid, 0);
}
catch (Exception ex)
{
Logging.Log(LogLevel.Warn, $"Faild to parse auth param, fallback to basic mode. {ex}");
}
}
if (user_key == null)
{
random.NextBytes(uid);
user_key = Server.key;
}
for (int i = 0; i < 4; ++i)
{
uid[i] ^= last_client_hash[8 + i];
}
byte[] encrypt_key = user_key;
IEncryptor encryptor = EncryptorFactory.GetEncryptor("aes-128-cbc", Convert.ToBase64String(encrypt_key) + SALT);
encryptor.SetIV(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 });
encryptor.Encrypt(encrypt, 16, encrypt_data, out int enc_outlen);
encryptor.Dispose();
Array.Copy(encrypt_data, 16, encrypt, 4, 16);
uid.CopyTo(encrypt, 0);
}
// final HMAC
{
byte[] md5data = MbedTLS.ComputeHash(user_key, encrypt, 0, 20);
last_server_hash = md5data;
Array.Copy(md5data, 0, encrypt, 20, 4);
}
encrypt.CopyTo(outdata, 12);
encryptor = EncryptorFactory.GetEncryptor("rc4", Convert.ToBase64String(user_key) + Convert.ToBase64String(last_client_hash, 0, 16));
// combine first chunk
{
byte[] pack_outdata = new byte[outdata.Length];
PackData(data, datalength, pack_outdata, out int pack_outlength);
Array.Copy(pack_outdata, 0, outdata, outlength, pack_outlength);
outlength += pack_outlength;
}
}
