private void RunEncryptionRound(IEncryptor encryptor, IEncryptor decryptor)
{
byte[] plain = new byte[16384];
byte[] cipher = new byte[plain.Length + 16];
byte[] plain2 = new byte[plain.Length + 16];
int outLen = 0;
int outLen2 = 0;
var random = new Random();
random.NextBytes(plain);
encryptor.Encrypt(plain, plain.Length, cipher, out outLen);
decryptor.Decrypt(cipher, outLen, plain2, out outLen2);
Assert.AreEqual(plain.Length, outLen2);
for (int j = 0; j < plain.Length; j++)
{
Assert.AreEqual(plain[j], plain2[j]);
}
encryptor.Encrypt(plain, 1000, cipher, out outLen);
decryptor.Decrypt(cipher, outLen, plain2, out outLen2);
Assert.AreEqual(1000, outLen2);
for (int j = 0; j < outLen2; j++)
{
Assert.AreEqual(plain[j], plain2[j]);
}
encryptor.Encrypt(plain, 12333, cipher, out outLen);
decryptor.Decrypt(cipher, outLen, plain2, out outLen2);
Assert.AreEqual(12333, outLen2);
for (int j = 0; j < outLen2; j++)
{
Assert.AreEqual(plain[j], plain2[j]);
}
}
public static string EncryptLargeBytesToBase64String(IEncryptor encryptor, byte[] cfgData)
{
var cfgEncrypt = new byte[cfgData.Length + 128];
var dataLen = 0;
const int bufferSize = 32768;
var input = new byte[bufferSize];
var output = new byte[bufferSize + 128];
for (var startPos = 0; startPos < cfgData.Length; startPos += bufferSize)
{
var len = Math.Min(cfgData.Length - startPos, bufferSize);
Buffer.BlockCopy(cfgData, startPos, input, 0, len);
encryptor.Encrypt(input, len, output, out var outLen);
Buffer.BlockCopy(output, 0, cfgEncrypt, dataLen, outLen);
dataLen += outLen;
}
return(Convert.ToBase64String(cfgEncrypt, 0, dataLen));
}
private async Task TestEncryptDecrypt(IEncryptor encr, Stream input, string inputData)
{
using (var encrOutput = new MemoryStream())
{
await encr.Encrypt(input, encrOutput);
Assert.AreNotEqual(0, encrOutput.Length);
Assert.IsTrue(encr.Policy.IsReadOnly);
using (var decrOutput = new MemoryStream())
{
await encr.Decrypt(encrOutput, decrOutput);
var decrResult = await decrOutput.ReadStringAsync();
Assert.AreEqual(inputData, decrResult);
}
}
}
private void PipeConnectionReceiveCallback(IAsyncResult ar)
{
if (closed)
{
return;
}
try
{
int bytesRead = connection.EndReceive(ar);
totalWrite += bytesRead;
if (bytesRead > 0)
{
int bytesToSend;
lock (encryptionLock)
{
if (closed)
{
return;
}
encryptor.Encrypt(connetionRecvBuffer, bytesRead, connetionSendBuffer, out bytesToSend);
}
remote.BeginSend(connetionSendBuffer, 0, bytesToSend, 0, new AsyncCallback(PipeRemoteSendCallback), null);
IStrategy strategy = controller.GetCurrentStrategy();
if (strategy != null)
{
strategy.UpdateLastWrite(this.server);
}
}
else
{
remote.Shutdown(SocketShutdown.Send);
remoteShutdown = true;
CheckClose();
}
}
catch (Exception e)
{
Logging.LogUsefulException(e);
this.Close();
}
}
/// <summary>
/// Authenticates the specified user.
/// </summary>
/// <param name="context">The context.</param>
/// <returns></returns>
public async Task Consume(ConsumeContext <IAuthenticateUser> context)
{
var checkResult = await _checkCredentialsRequest.Request(new CheckCredentials(context.Message.UserName, context.Message.Password));
if (!checkResult.Valid)
{
await context.RespondAsync(AuthenticateUserResult.Failed());
return;
}
var user = checkResult.User;
var roles = new List <string>();
// select delegated privileges
var delegatedRights = _databaseContext.DelegatedRights.Filter(x => x.Grantee == user.UserName);
var onBehalfOf = delegatedRights.Select(x => x.Grantor).ToArray();
// add manager role
if (user.IsManager || onBehalfOf.Length > 0)
{
roles.Add(WellKnownRoles.Manager);
}
/* IMPORTANT NOTE:
* This is a temporary solution. User group name cannot be hardcoded.
* We should provide a feature that allows to map User Groups to the application roles.
* But this is postponded, because of time limit.
*/
var userGroups = user.Groups;
if (userGroups.Any(x => x.DisplayName == "Access Control Clients"))
{
roles.Add(WellKnownRoles.ClientService);
}
// create a ticket
var ticket = new Ticket(user, roles.ToArray(), onBehalfOf);
var encryptedTicket = _encryptor.Encrypt(ticket);
await context.RespondAsync(new AuthenticateUserResult(true, encryptedTicket, user));
}
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 PipeConnectionReceiveCallback(IAsyncResult ar)
{
if (closed)
{
return;
}
try
{
int bytesRead = connection.EndReceive(ar);
totalWrite += bytesRead;
if (bytesRead > 0)
{
int bytesToSend;
lock (encryptionLock)
{
if (closed)
{
return;
}
encryptor.Encrypt(connetionRecvBuffer, bytesRead, connetionSendBuffer, out bytesToSend);
}
Logging.Debug(remote, bytesToSend, "TCP Relay", "@PipeConnectionReceiveCallback() (upload)");
tcprelay.UpdateOutboundCounter(relay.server, bytesToSend);
_startSendingTime = DateTime.Now;
_bytesToSend = bytesToSend;
remote.BeginSend(connetionSendBuffer, 0, bytesToSend, 0, new AsyncCallback(PipeRemoteSendCallback), null);
}
else
{
remote.Shutdown(SocketShutdown.Send);
remoteShutdown = true;
CheckClose();
}
}
catch (Exception e)
{
Logging.LogUsefulException(e);
Close();
}
}
public void PackData(byte[] data, int datalength, byte[] outdata, out int outlength)
{
int rand_len = GetRandLen(datalength);
outlength = rand_len + datalength + 2;
outdata[0] = (byte)(datalength ^ last_client_hash[14]);
outdata[1] = (byte)((datalength >> 8) ^ last_client_hash[15]);
{
byte[] rnd_data = new byte[rand_len];
random.NextBytes(rnd_data);
encryptor.Encrypt(data, datalength, data, out datalength);
if (datalength > 0)
{
if (rand_len > 0)
{
int start_pos = GetRandStartPos(rand_len, random_client);
Array.Copy(data, 0, outdata, 2 + start_pos, datalength);
Array.Copy(rnd_data, 0, outdata, 2, start_pos);
Array.Copy(rnd_data, start_pos, outdata, 2 + start_pos + datalength, rand_len - start_pos);
}
else
{
Array.Copy(data, 0, outdata, 2, datalength);
}
}
else
{
rnd_data.CopyTo(outdata, 2);
}
}
byte[] key = new byte[user_key.Length + 4];
user_key.CopyTo(key, 0);
BitConverter.GetBytes(pack_id).CopyTo(key, key.Length - 4);
++pack_id;
byte[] md5data = MbedTLS.ComputeHash(key, outdata, 0, outlength);
last_client_hash = md5data;
Array.Copy(md5data, 0, outdata, outlength, 2);
outlength += 2;
}
internal static XElement Save(this ISettingRecord settingRecord, IEncryptor encryptor)
{
var root = new XElement(Xml.SettingRecord.NodeListName);
var username = new XElement(Xml.SettingRecord.PortalUsername);
username.SetAttributeValue(Xml.Attributes.Value, settingRecord.PortalUsername);
root.Add(username);
var password = new XElement(Xml.SettingRecord.PortalPassword);
password.SetAttributeValue(Xml.Attributes.Value, encryptor.Encrypt(settingRecord.PortalPassword));
root.Add(password);
var useDownloadCDn = new XElement(Xml.SettingRecord.UseDownloadCDN);
useDownloadCDn.SetAttributeValue(Xml.Attributes.Value, settingRecord.UseDownloadCDN);
root.Add(useDownloadCDn);
var sendCrashDetails = new XElement(Xml.SettingRecord.SendCrashDetails);
sendCrashDetails.SetAttributeValue(Xml.Attributes.Value, settingRecord.SendCrashDetails);
root.Add(sendCrashDetails);
var pluginsRepository = new XElement(Xml.SettingRecord.PluginsRepository);
pluginsRepository.SetAttributeValue(Xml.Attributes.Value, settingRecord.PluginsRepository);
root.Add(pluginsRepository);
var customPluginsFolder = new XElement(Xml.SettingRecord.CustomPluginsFolder);
customPluginsFolder.SetAttributeValue(Xml.Attributes.Value, settingRecord.CustomPluginsFolder);
root.Add(customPluginsFolder);
var alignVersions = new XElement(Xml.SettingRecord.AlignVersions);
alignVersions.SetAttributeValue(Xml.Attributes.Value, settingRecord.AlignVersions);
root.Add(alignVersions);
return(root);
}
public void numbers_are_numbers()
{
var bytes = _encryptor.Encrypt("test");
foreach (int diff in bytes)
{
if (diff == 0 || diff == 1)
{
}
else
{
throw new Exception();
}
}
}
public void Compile(FileInfo inputFile, FileInfo outputFile)
{
if (!inputFile.Exists)
{
UnityEngine.Debug.LogErrorFormat("Not found the file \"{0}\"", inputFile.FullName);
return;
}
if (!outputFile.Directory.Exists)
{
outputFile.Directory.Create();
}
RunCMD(command, string.Format(" -o {0} {1}", outputFile.FullName, inputFile.FullName));
if (this.encryptor != null && outputFile.Exists)
{
byte[] buffer = File.ReadAllBytes(outputFile.FullName);
File.WriteAllBytes(outputFile.FullName, encryptor.Encrypt(buffer));
}
}
/****************************************************************************/
/// <summary>
/// Encrypt a string
/// </summary>
/// <param name="data">Data to encrypt</param>
/// <returns>A base64 encoded string of the encrypted data</returns>
public static async Task <string> Encrypt(this IEncryptor encryptor, string data)
{
if (string.IsNullOrEmpty(data))
{
return(data);
}
// Get encrypted array of bytes.
var toEncrypt = Encoding.UTF8.GetBytes(data);
try
{
var encrypted = await encryptor.Encrypt(toEncrypt);
return(Convert.ToBase64String(encrypted));
}
finally
{
Array.Clear(toEncrypt, 0, toEncrypt.Length);
}
}
/// <summary>
/// Encrypts the outgoing <see cref="TransportMessage"/> and adds appropriate headers
/// </summary>
public async Task Process(OutgoingStepContext context, Func <Task> next)
{
var transportMessage = context.Load <TransportMessage>();
if (transportMessage.Headers.ContainsKey(EncryptionHeaders.DisableEncryptionHeader))
{
await next();
return;
}
var headers = transportMessage.Headers.Clone();
var bodyBytes = transportMessage.Body;
var encryptedData = _encryptor.Encrypt(bodyBytes);
headers[EncryptionHeaders.ContentEncryption] = _encryptor.ContentEncryptionValue;
headers[EncryptionHeaders.ContentInitializationVector] = Convert.ToBase64String(encryptedData.Iv);
context.Save(new TransportMessage(headers, encryptedData.Bytes));
await next();
}
private async Task TestEncryptDecrypt(IEncryptor encr, Stream input, string inputData)
{
using (var encrOutput = new MemoryStream())
{
await encr.Encrypt(input, encrOutput);
var outputData = await encrOutput.ReadStringAsync();
Assert.IsFalse(string.IsNullOrEmpty(outputData));
Assert.AreNotEqual(inputData, outputData);
using (var decrOutput = new MemoryStream())
{
await encr.Decrypt(encrOutput, decrOutput);
var decrResult = await decrOutput.ReadStringAsync();
Assert.AreEqual(inputData, decrResult);
}
}
}
/// <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);
}
public void Init()
{
conection = new MSSQLDB(new DBConfiguration());
_PREP = new ProfessorRepository(conection);
_encryptor = new Encryptor();
handler = new ProfessorQueryHandler(_PREP);
var db = conection.GetCon();
var cpf = "357.034.413-40";
string password = cpf.Replace("-", "").Replace(".", "");
password = _encryptor.Encrypt(password, out string salt);
professor = new Professor("Lívia", "Emanuelly Elisa", cpf, "*****@*****.**", "(21) 2682-8370", EDegree.Master, password, salt);
_PREP.Create(professor);
commandGet = new ProfessorInputGet()
{
ProfessorId = professor.Id
};
}
public async Task <ValidationResult <UpdatePasswordFailure> > UpdatePasswordAsync(Guid id, string password)
{
var user = Users.Local.FirstOrDefault(x => x.ID == id) ?? await Users.FirstOrDefaultAsync(x => x.ID == id);
if (user == null)
{
throw new ArgumentException($"User '{id}' does not exist");
}
if (!_passwordComplexity.Validate(password))
{
return(new ValidationResult <UpdatePasswordFailure>(UpdatePasswordFailure.PasswordNotComplex, _passwordComplexity.ComplexityMessage));
}
string passwordHash, salt;
passwordHash = _encryptor.Encrypt(password, out salt);
user.PasswordHash = passwordHash;
user.Salt = salt;
return(new ValidationResult <UpdatePasswordFailure>());
}
public ICommandResult Handle(ProfessorInputRegister command)
{
string password = string.Empty;
string salt = string.Empty;
if (!string.IsNullOrEmpty(command.CPF))
{
password = _encryptor.Encrypt(command.CPF.Replace("-", "").Replace(".", ""), out salt);
}
var professor = new Professor(command.FirstName, command.LastName, command.CPF,
command.Email, command.Phone, command.Degree, password, salt);
var result = new StandardResult();
result.AddRange(professor.Notifications);
if (result.Notifications.Count == 0)
{
_PREP.Create(professor);
result.Notifications.Add("Success", "O Professor foi salvo");
}
return(result);
}
private void pipeConnectionReceiveCallback(IAsyncResult ar)
{
try
{
int bytesRead = connection.EndReceive(ar);
if (bytesRead > 0)
{
byte[] buf = encryptor.Encrypt(connetionBuffer, bytesRead);
remote.BeginSend(buf, 0, buf.Length, 0, new AsyncCallback(pipeRemoteSendCallback), null);
}
else
{
Console.WriteLine("bytesRead: " + bytesRead.ToString());
this.Close();
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
this.Close();
}
}
public async Task SignUp(User model)
{
try
{
bool isUserEmailExist = await this._unitOfWork.UserRepository.IsEmailExistAsync(model.Email);
if (isUserEmailExist)
{
throw new BaseCustomException("User email already exists");
}
string encryptedPassword = _encryptor.Encrypt(model.Password);
var entityModel = new User()
{
Email = model.Email,
Name = model.Name,
Password = encryptedPassword,
Birthdate = model.Birthdate,
Picture = model.Picture,
PictureMimeType = model.PictureMimeType,
PermissionId = (int)PermissionType.User // default
};
this._unitOfWork.UserRepository.Create(entityModel);
await this._unitOfWork.UserRepository.SaveAsync();
}
catch (BaseCustomException ex)
{
this._logger.LogInformation(ex, ex.Message);
throw;
}
catch (Exception ex)
{
this._logger.LogError(ex, ex.Message);
throw new BaseCustomException();
}
}
public void Init()
{
conection = new MSSQLDB(new DBConfiguration());
_PREP = new ProfessorRepository(conection);
_encryptor = new Encryptor();
handler = new ProfessorCommandHandler(_PREP, _encryptor);
var db = conection.GetCon();
var cpf = "357.034.413-40";
string password = cpf.Replace("-", "").Replace(".", "");
password = _encryptor.Encrypt(password, out string salt);
professor = new Professor("Lívia", "Emanuelly Elisa", cpf, "*****@*****.**", "(21) 2682-8370", EDegree.Master, password, salt);
_PREP.Create(professor);
commandRegister = new ProfessorInputRegister()
{
FirstName = "Lívia",
LastName = "Emanuelly Elisa",
CPF = cpf,
Email = "*****@*****.**",
Phone = "(21) 2682-8370",
Degree = EDegree.Master
};
commandUpdate = new ProfessorInputUpdate()
{
ProfessorId = professor.Id,
FirstName = "Lívia",
LastName = "Emanuelly Elisa",
Email = "*****@*****.**",
Phone = "(21) 2682-8370",
Degree = EDegree.Master
};
}
private void SendToServer(AsyncSession session)
{
var length = data.Length;
_totalWrite += length;
int bytesToSend;
Array.Copy(data, _connetionRecvBuffer, data.Length);
lock (_encryptionLock)
{
try
{
_encryptor.Encrypt(_connetionRecvBuffer, length, _connetionSendBuffer, out bytesToSend);
}
catch (CryptoErrorException)
{
Close();
return;
}
}
_startSendingTime = DateTime.Now;
session.Remote.BeginSend(_connetionSendBuffer, 0, bytesToSend, SocketFlags.None,
PipeRemoteSendCallback, new object[] { session, bytesToSend });
}
private void SendToServer(int length, AsyncSession session)
{
_totalWrite += length;
int bytesToSend;
lock (_encryptionLock)
{
try
{
_encryptor.Encrypt(_connetionRecvBuffer, length, _connetionSendBuffer, out bytesToSend);
}
catch (CryptoErrorException)
{
Logger.Debug("encryption error");
Close();
return;
}
}
OnOutbound?.Invoke(this, new SSTransmitEventArgs(_server, bytesToSend));
_startSendingTime = DateTime.Now;
session.Remote.BeginSend(_connetionSendBuffer, 0, bytesToSend, SocketFlags.None,
PipeRemoteSendCallback, new object[] { session, bytesToSend });
}
private void PipeConnectionReceiveCallback(IAsyncResult ar)
{
if (closed)
{
return;
}
try
{
int bytesRead = connection.EndReceive(ar);
if (bytesRead > 0)
{
int bytesToSend;
lock (encryptionLock)
{
if (closed)
{
return;
}
encryptor.Encrypt(connetionRecvBuffer, bytesRead, connetionSendBuffer, out bytesToSend);
}
remote.BeginSend(connetionSendBuffer, 0, bytesToSend, 0, new AsyncCallback(PipeRemoteSendCallback), null);
}
else
{
remote.Shutdown(SocketShutdown.Send);
remoteShutdown = true;
CheckClose();
}
}
catch (Exception e)
{
Logging.LogUsefulException(e);
this.Close();
}
}
public string EncodeJson(AuthenticationTicket ticket)
{
var value = _encryptor.Encrypt(JsonUtil.ToJson(ticket));
return(HttpUtility.UrlEncode(value));
}
private async Task StartConnect()
{
SaeaAwaitable serverSaea = null;
try
{
CreateRemote();
_serverSocket = new Socket(SocketType.Stream, ProtocolType.Tcp);
_serverSocket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, true);
_serverSocket.SetTFO();
// encrypt and attach encrypted buffer to ConnectAsync
serverSaea = _argsPool.Rent();
var realSaea = serverSaea.Saea;
var encryptedbufLen = -1;
Logging.Dump("StartConnect(): enc addrBuf", _addrBuf, _addrBufLength);
lock (_encryptionLock)
{
_encryptor.Encrypt(_addrBuf, _addrBufLength, realSaea.Buffer, out encryptedbufLen);
}
Logging.Debug("StartConnect(): addrBuf enc len " + encryptedbufLen);
if (_remainingBytesLen > 0)
{
Logging.Debug($"StartConnect(): remainingBytesLen: {_remainingBytesLen}");
var encRemainingBufLen = -1;
byte[] tmp = new byte[4096];
Logging.Dump("StartConnect(): enc remaining", _remainingBytes, _remainingBytesLen);
lock (_encryptionLock)
{
_encryptor.Encrypt(_remainingBytes, _remainingBytesLen, tmp, out encRemainingBufLen);
}
Logging.Debug("StartConnect(): remaining enc len " + encRemainingBufLen);
Buffer.BlockCopy(tmp, 0, realSaea.Buffer, encryptedbufLen, encRemainingBufLen);
encryptedbufLen += encRemainingBufLen;
}
Logging.Debug("actual enc buf len " + encryptedbufLen);
realSaea.RemoteEndPoint = SocketUtil.GetEndPoint(_server.server, _server.server_port);
realSaea.SetBuffer(0, encryptedbufLen);
var err = await _serverSocket.ConnectAsync(serverSaea);
if (err != SocketError.Success)
{
Logging.Error($"StartConnect: {err}");
Close();
return;
}
Logging.Debug("remote connected");
if (serverSaea.Saea.BytesTransferred != encryptedbufLen)
{
// not sent all data, it may caused by TFO, disable it
Logging.Info("Disable TCP Fast Open due to initial send failure");
Program.DisableTFO();
Close();
return;
}
_argsPool.Return(serverSaea);
serverSaea = null;
if (_config.isVerboseLogging)
{
Logging.Info($"Socket connected to ss server: {_server.FriendlyName()}");
}
Task.Factory.StartNew(StartPipe, TaskCreationOptions.PreferFairness).Forget();
}
catch (AggregateException agex)
{
foreach (var ex in agex.InnerExceptions)
{
Logging.LogUsefulException(ex);
}
Close();
}
catch (Exception e)
{
Logging.LogUsefulException(e);
Close();
}
finally
{
_argsPool.Return(serverSaea);
serverSaea = null;
}
}
/// <summary>
/// Attempts to acquire the lock synchronously. Usage:
/// <code>
/// using (var handle = myLock.TryAcquire(...))
/// {
/// if (handle != null) { /* we have the lock! */ }
/// }
/// // dispose releases the lock if we took it
/// </code>
/// </summary>
/// <param name="lock"></param>
/// <param name="timeout">How long to wait before giving up on acquiring the lock. Defaults to 0</param>
/// <returns>An <see cref="IDisposable"/> "handle" which can be used to release the lock, or null if the lock was not taken</returns>
public LockAcquisitionResult TryAcquire(string @lock, TimeSpan timeout = default(TimeSpan))
{
// synchronous mode
var timeoutMillis = timeout.ToInt32Timeout();
// calculate safe lock name
var lockName = ToSafeLockName(@lock, MaxLockNameLength, s => s);
DbConnection acquireConnection = null;
var cleanup = true;
try
{
acquireConnection = GetConnection();
if (_connectionString != null)
{
acquireConnection.Open();
}
else if (acquireConnection == null)
{
throw new InvalidOperationException("The transaction had been disposed");
}
else if (acquireConnection.State != ConnectionState.Open)
{
throw new InvalidOperationException("The connection is not open");
}
var checkCommand = SqlHelpers.CreateCheckLockAvailabilityCommand(acquireConnection, timeoutMillis, lockName);
var exists = (int)checkCommand.ExecuteScalar() > 0;
if (exists)
{
return(LockAcquisitionResult.Fail);
}
var id = Guid.NewGuid();
SqlParameter insertReturnValue;
using (var insertCommand = SqlHelpers.CreateInsertApplicationLockCommand(acquireConnection, id,
timeoutMillis, lockName, Utc, out insertReturnValue))
{
insertCommand.ExecuteNonQuery();
}
var ret = (int)insertReturnValue.Value;
cleanup = ret == 0;
var success = ret == 0;
var owner = string.Empty;
if (success)
{
// hash owner
owner = _encryptor.Encrypt(id.ToString());
// check no duplicates.
var checkDuplicateCommand = SqlHelpers.CreateCheckLockAvailabilityCommand(acquireConnection, timeoutMillis, lockName);
var duplicatesExist = (int)checkDuplicateCommand.ExecuteScalar() > 1;
if (duplicatesExist)
{
// delete current lock
ReleaseLock(lockName, owner);
return(LockAcquisitionResult.Fail);
}
}
return(new LockAcquisitionResult
{
Success = success,
LockOwner = owner
});
}
catch
{
// in case we fail to create lock scope or something
cleanup = true;
throw;
}
finally
{
if (cleanup)
{
Cleanup(acquireConnection);
}
}
}
public string CreateUserToken(AccountAuthorizeInfo info)
{
string data = $"UAT|{info.LoginId}|{info.Client}|{info.Guid}";
return(encryptor.Encrypt(data));
}
public static string Encrypt(string plainText)
{
try
{
return(EncryptionCache.GetOrAdd(string.Concat(plainText, "-en-"), s => _encryptor.Encrypt(plainText)));
}
catch
{
EncryptionCache.Clear();
throw;
}
}
public string EncryptMessage(string Message)
{
return(_encryptor.Encrypt(Message + " alone."));
}
private void PipeConnectionReceiveCallback(IAsyncResult ar)
{
if (_closed)
{
return;
}
try
{
int bytesRead = _connection.EndReceive(ar);
_totalWrite += bytesRead;
var session = (AsyncSession <bool>)ar.AsyncState;
var remote = session.Remote;
if (bytesRead > 0)
{
/*
* Only the first packet contains the socks5 header, it doesn't make sense to parse every packets.
* Also it's unnecessary to parse these data if we turn off the VerboseLogging.
*/
if (session.State && _config.isVerboseLogging)
{
int atyp = _connetionRecvBuffer[0];
string dst_addr;
int dst_port;
switch (atyp)
{
case 1: // IPv4 address, 4 bytes
dst_addr = new IPAddress(_connetionRecvBuffer.Skip(1).Take(4).ToArray()).ToString();
dst_port = (_connetionRecvBuffer[5] << 8) + _connetionRecvBuffer[6];
Logging.Info($"connect to {dst_addr}:{dst_port}");
session.State = false;
break;
case 3: // domain name, length + str
int len = _connetionRecvBuffer[1];
dst_addr = System.Text.Encoding.UTF8.GetString(_connetionRecvBuffer, 2, len);
dst_port = (_connetionRecvBuffer[len + 2] << 8) + _connetionRecvBuffer[len + 3];
Logging.Info($"connect to {dst_addr}:{dst_port}");
session.State = false;
break;
case 4: // IPv6 address, 16 bytes
dst_addr = new IPAddress(_connetionRecvBuffer.Skip(1).Take(16).ToArray()).ToString();
dst_port = (_connetionRecvBuffer[17] << 8) + _connetionRecvBuffer[18];
Logging.Info($"connect to [{dst_addr}]:{dst_port}");
session.State = false;
break;
}
}
int bytesToSend;
lock (_encryptionLock)
{
_encryptor.Encrypt(_connetionRecvBuffer, bytesRead, _connetionSendBuffer, out bytesToSend);
}
_tcprelay.UpdateOutboundCounter(_server, bytesToSend);
_startSendingTime = DateTime.Now;
remote.BeginSend(_connetionSendBuffer, 0, bytesToSend, SocketFlags.None, new AsyncCallback(PipeRemoteSendCallback), session);
IStrategy strategy = _controller.GetCurrentStrategy();
strategy?.UpdateLastWrite(_server);
}
else
{
remote.Shutdown(SocketShutdown.Send);
_remoteShutdown = true;
CheckClose();
}
}
catch (Exception e)
{
Logging.LogUsefulException(e);
Close();
}
}
