public async Task ChangePass(
byte[] oldPass,
byte[] newPass,
CryptConfigFileHelperScryptParameters
scryptParameters = null
)
{
if (!CheckPass(oldPass))
{
throw new ArgumentException(
MyNameof.GetLocalVarName(() => oldPass)
);
}
var originData = GetOriginData(
oldPass,
scryptParameters
);
Salt = new byte[32];
MiscFuncs.GetRandomBytes(Salt);
EncryptedData = CryptConfigFileHelper.Encrypt(
originData,
newPass,
Salt,
scryptParameters
);
}
public async Task Test1()
{
var data1 = new byte[1000000];
MiscFuncs.GetRandomBytes(data1);
var data2 = new byte[1000000];
MiscFuncs.GetRandomBytes(data2);
var xData1 = data1.ToArray();
var xData2 = data1.Concat(data2).ToArray();
_output.WriteLine("{0}", xData2.Length);
byte[] xDataDiff;
using (var sw = new StopWatchDisposable("GetPatch"))
{
xDataDiff = MyBinDiffHelper.GetPatch(
xData1,
xData2
);
}
_output.WriteLine("{0}", xDataDiff.Length);
byte[] xData2Copy;
using (var sw = new StopWatchDisposable("ApplyPatch"))
{
xData2Copy = MyBinDiffHelper.ApplyPatch(
xData1,
xDataDiff
);
}
_output.WriteLine("{0}", xData2Copy.Length);
Assert.Equal(xData2, xData2Copy);
}
public static AesKeyIvPair GenAesKeyIvPair()
{
var result = new AesKeyIvPair();
MiscFuncs.GetRandomBytes(result.Iv);
MiscFuncs.GetRandomBytes(result.Key);
return(result);
}
public void Dispose()
{
Destination = null;
MiscFuncs.GetRandomBytes(PrivateKey);
MiscFuncs.GetRandomBytes(SigningPrivateKey);
PrivateKey = null;
SigningPrivateKey = null;
}
/**/
public int EncryptType
= (int)ELightCertificateEncryptType.None;
public int EncryptKeySize = 0;
public byte[] PublicEncryptParameters;
public PassEncryptedData PrivateEncryptParameters;
/**/
public static async Task CorruptByteArrays(
params byte[][] byteArrayArray
)
{
foreach (byte[] b in byteArrayArray)
{
if (b != null)
{
MiscFuncs.GetRandomBytes(b);
}
}
}
public void TestEncryptDecrypt()
{
var passBytes = Encoding.UTF8.GetBytes("TestPassword");
var testCertificate =
LightCertificatesHelper.GenerateSelfSignedCertificate(
ELightCertificateSignType.Rsa,
2048,
ELightCertificateEncryptType.Rsa,
2048,
EPrivateKeysKeyDerivationFunction.ScryptDefault,
Guid.NewGuid(),
"TestCertificate",
passBytes
);
foreach (var n in new[] { 1, 2, 3, 5, 10, 16, 32, 48, 64, 63, 65, 191 })
{
var originData = new byte[n];
MiscFuncs.GetRandomBytes(originData);
var encryptedData = testCertificate.EncryptData(originData);
var originDataCopy = testCertificate.DecryptData(encryptedData, passBytes);
Assert.Equal(originData.Length, originDataCopy.Length);
Assert.Equal(originData, originDataCopy);
}
for (int i = 0; i < 10; i++)
{
var aesPair = AesKeyIvPair.GenAesKeyIvPair();
var encryptedPair = LightCertificatesHelper.EncryptAesKeyIvPair(
aesPair,
testCertificate
);
var decryptedPair = LightCertificatesHelper.DecryptAesKeyIvPair(
encryptedPair,
testCertificate,
passBytes
);
Assert.Equal(
aesPair.WriteObjectToJson(),
decryptedPair.WriteObjectToJson()
);
}
}
public ScryptPassEncryptedData(
byte[] originData,
byte[] pass,
byte[] salt = null,
CryptConfigFileHelperScryptParameters scryptParameters = null
)
{
if (salt == null)
{
salt = new byte[32];
MiscFuncs.GetRandomBytes(salt);
}
if (salt.Length != 32)
{
throw new Exception("salt.Length != 32");
}
Salt = salt;
EncryptedData = CryptConfigFileHelper.Encrypt(
originData,
pass,
salt,
scryptParameters
);
}
public void Dispose()
{
MiscFuncs.GetRandomBytes(Key);
MiscFuncs.GetRandomBytes(Iv);
}
public PassEncryptedData()
{
Salt = new byte[32];
MiscFuncs.GetRandomBytes(Salt);
}
public async Task TestReconnectingReliable()
{
const string addressSend = "127.0.0.1";
const int portSend = 7656;
/**/
var proxyHostname = "127.0.0.1";
var proxyPort = 17000;
var proxyServer = await MyTcpProxyServer.CreateInstance(
new MyTcpProxyServerSettings()
{
DestinationHostname = addressSend,
DestinationPort = portSend,
ServerHostname = proxyHostname,
ServerPort = proxyPort
}
).ConfigureAwait(false);
/**/
const string addressRecv = addressSend;
const int portRecv = portSend;
string sendPrivKeys;
/**/
{
var samHelperSend = await SamHelper.CreateInstance(
new SamHelperSettings()
{
SamServerAddress = addressSend,
SamServerPort = portSend
}, CancellationToken.None
).ConfigureAwait(false);
sendPrivKeys = samHelperSend.Session.PrivateKey;
await samHelperSend.MyDisposeAsync().ConfigureAwait(false);
}
/**/
var reconnectingSamHelperSend = await ReconnectingSamHelper.CreateInstance(
new ReconnectingSamHelperSettings()
{
ImplementationHelperSettings =
new SamHelperSettings()
{
SamServerAddress = proxyHostname,
SamServerPort = proxyPort,
SessionPrivateKeys = sendPrivKeys
}
}, CancellationToken.None
).ConfigureAwait(false);
var samHelperReceive = await SamHelper.CreateInstance(
new SamHelperSettings()
{
SamServerAddress = addressRecv,
SamServerPort = portRecv
}, CancellationToken.None
).ConfigureAwait(false);
var reliableHelperSend = new ReliableSamHelper(
reconnectingSamHelperSend,
new ReliableSamHelperSettings()
);
var reliableHelperRecv = new ReliableSamHelper(
samHelperReceive,
new ReliableSamHelperSettings()
);
var data = new byte[200000];
MiscFuncs.GetRandomBytes(data);
/**/
await testSendReceiveFunc(
reliableHelperRecv,
reconnectingSamHelperSend,
reliableHelperSend,
data,
samHelperReceive
).ConfigureAwait(false);
await proxyServer.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("###################################");
await Assert.ThrowsAsync <TimeoutException>(
async() => await testSendReceiveFunc(
reliableHelperRecv,
reconnectingSamHelperSend,
reliableHelperSend,
data,
samHelperReceive
).ConfigureAwait(false)
).ConfigureAwait(false);
/**/
_logger.Trace("###################################");
proxyServer = await MyTcpProxyServer.CreateInstance(
new MyTcpProxyServerSettings()
{
DestinationHostname = addressSend,
DestinationPort = portSend,
ServerHostname = proxyHostname,
ServerPort = proxyPort
}
).ConfigureAwait(false);
reconnectingSamHelperSend.TryToReconnect(DateTime.UtcNow);
await Task.Delay(TimeSpan.FromSeconds(15.0d)).ConfigureAwait(false);
/**/
await testSendReceiveFunc(
reliableHelperRecv,
reconnectingSamHelperSend,
reliableHelperSend,
data,
samHelperReceive
).ConfigureAwait(false);
/**/
await reliableHelperSend.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("reliableHelperSend disposed");
await reliableHelperRecv.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("reliableHelperRecv disposed");
await reconnectingSamHelperSend.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("samHelperSend disposed");
await samHelperReceive.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("samHelperReceive disposed");
await proxyServer.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("{0} disposed", MyNameof.GetLocalVarName(() => proxyServer));
}
public async Task TestSendReceiveOneMessageImpl()
{
const string addressSend = "192.168.56.102"; //"192.168.1.132";
const int portSend = 7656;
const string addressRecv = addressSend; //"127.0.0.1";
const int portRecv = 7656;
var samHelperSend = await SamHelper.CreateInstance(
new SamHelperSettings()
{
SamServerAddress = addressSend,
SamServerPort = portSend
}, CancellationToken.None
).ConfigureAwait(false);
var samHelperReceive = await SamHelper.CreateInstance(
new SamHelperSettings()
{
SamServerAddress = addressRecv,
SamServerPort = portRecv
}, CancellationToken.None
).ConfigureAwait(false);
var reliableHelperSend = new ReliableSamHelper(
samHelperSend,
new ReliableSamHelperSettings()
);
var reliableHelperRecv = new ReliableSamHelper(
samHelperReceive,
new ReliableSamHelperSettings()
);
var data = new byte[1];
MiscFuncs.GetRandomBytes(data);
var waitRecvMessage = reliableHelperRecv.ReliableMessageReceived
.Where(x => x.Destination == samHelperSend.Session.Destination)
.FirstAsync()
.ToTask();
var sendProgress = new Progress <OutMessageProgressInfo>(
x => _logger.Trace(x.ToString())
);
try
{
var messageId = await reliableHelperSend.SendReliableMessage(
samHelperReceive.Session.Destination,
data,
sendProgress
).ConfigureAwait(false);
_logger.Trace("Message sent id {0}", messageId);
}
catch (EnumException <ReliableSamHelper.SendReliableMessageExcs> exc)
{
_logger.Trace("Send error {0}", exc.ExceptionCode);
throw;
}
try
{
var receivedMessage = await waitRecvMessage.ConfigureAwait(false);
_logger.Trace("Message received {0} bytes", receivedMessage.Data.Length);
Assert.Equal(data, receivedMessage.Data);
}
catch (OperationCanceledException exc)
{
_logger.Trace("Recv timeout {0}", exc);
throw;
}
catch (Exception exc)
{
_logger.Trace("Recv error {0}", exc);
throw;
}
_logger.Trace("End Total memory - {0} bytes", GC.GetTotalMemory(true));
await reliableHelperSend.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("reliableHelperSend disposed");
await reliableHelperRecv.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("reliableHelperRecv disposed");
await samHelperSend.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("samHelperSend disposed");
await samHelperReceive.MyDisposeAsync().ConfigureAwait(false);
_logger.Trace("samHelperReceive disposed");
}
public void Dispose()
{
MiscFuncs.GetRandomBytes(_encryptedData);
_aesKeyIvPair.Dispose();
}
