public async Task <UserDto> DownloadUserDataAsync(string operationId, long nodeId)
{
var nodeConnection = connectionsService.GetNodeConnection(nodeId);
if (nodeConnection != null)
{
string requestUriString = $"https://{nodeConnection.Uri.Authority}/UserMigration/Download";
HttpWebRequest httpWebRequest = WebRequest.CreateHttp(requestUriString);
byte[] encryptedData = Encryptor.SymmetricDataEncrypt(
Encoding.UTF8.GetBytes(operationId),
NodeData.Instance.NodeKeys.SignPrivateKey,
nodeConnection.SymmetricKey,
MessageDataType.Binary,
NodeData.Instance.NodeKeys.Password);
httpWebRequest.Headers.Add("encryptedOperationId", Convert.ToBase64String(encryptedData));
httpWebRequest.Headers.Add("nodeId", NodeSettings.Configs.Node.Id.ToString());
using (WebResponse response = await httpWebRequest.GetResponseAsync().ConfigureAwait(false))
{
var responseStream = response.GetResponseStream();
byte[] responseData = responseStream.ReadAllBytes();
byte[] decryptedData = Encryptor.SymmetricDataDecrypt(
responseData,
nodeConnection.SignPublicKey,
nodeConnection.SymmetricKey,
NodeData.Instance.NodeKeys.Password).DecryptedData;
return(ObjectSerializer.ByteArrayToObject <UserDto>(decryptedData));
}
}
else
{
throw new ArgumentNullException(nameof(nodeId));
}
}
public async Task SendPendingMessagesAsync(long nodeId)
{
try
{
var nodeConnection = _connectionsService.GetNodeConnection(nodeId);
if (nodeConnection != null)
{
var pendingMessages = await _pendingMessagesService.GetNodePendingMessagesAsync(nodeId).ConfigureAwait(false);
if (pendingMessages != null && pendingMessages.Any())
{
foreach (var message in pendingMessages)
{
await SendNoticeToNodeAsync(
nodeConnection,
ObjectSerializer.ByteArrayToObject <NodeNotice>(Convert.FromBase64String(message.Content))).ConfigureAwait(false);
}
await _pendingMessagesService.RemovePendingMessagesAsync(pendingMessages.Select(message => message.Id)).ConfigureAwait(false);
}
}
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
public ConnectData GetConnectData(byte[] symmetricKey, byte[] signPublicKey, byte[] masterPassword)
{
byte[] decryptedData = Encryptor.SymmetricDataDecrypt(Data, signPublicKey, symmetricKey, masterPassword).DecryptedData;
ConnectData connectData = ObjectSerializer.ByteArrayToObject <ConnectData>(decryptedData);
connectData.SymmetricKey = symmetricKey;
return(connectData);
}
public T GetObjectByKey <T>(object keyValue)
{
try
{
return(ObjectSerializer.ByteArrayToObject <T>(redisDb.StringGet(keyValue.ToString())));
}
catch
{
return(default);
public async Task <ConversationPreviewVm> GetObject(string key)
{
byte[] array = (await redisDb.ListRangeAsync(key, 0, 0).ConfigureAwait(false)).FirstOrDefault();
if (array == null)
{
return(null);
}
return(ObjectSerializer.ByteArrayToObject <ConversationPreviewVm>(array));
}
public ConnectData GetConnectData(byte[] signPublicKey, byte[] masterPassword, byte[] encPrivateKey = null)
{
ConnectData connectData;
byte[] symmetricKey = Encryptor.AsymmetricDecryptKey(EncryptedKey, encPrivateKey, signPublicKey, masterPassword).Data;
byte[] decryptedData = Encryptor.SymmetricDataDecrypt(Data, signPublicKey, symmetricKey, masterPassword).DecryptedData;
connectData = ObjectSerializer.ByteArrayToObject <ConnectData>(decryptedData);
connectData.SymmetricKey = symmetricKey;
return(connectData);
}
public async Task <List <BlockVm> > GetBlockchainBlocksAsync(long startId, long endId)
{
using (WebClient webClient = new WebClient())
{
byte[] responseData = await webClient.DownloadDataTaskAsync($"https://{NodeSettings.Configs.LicensorUrl}/api/Blockchain/Download?startId={startId}&endId={endId}")
.ConfigureAwait(false);
return(ObjectSerializer.ByteArrayToObject <List <BlockVm> >(responseData));
}
}
public async Task <VerificationCodeInfo> GetObject(string key)
{
byte[] array = await redisDb.StringGetAsync(key).ConfigureAwait(false);
if (array == null)
{
return(null);
}
return(ObjectSerializer.ByteArrayToObject <VerificationCodeInfo>(array));
}
public async Task <IEnumerable <ConversationPreviewVm> > GetObjects(string key, long length)
{
RedisValue[] conversations = await redisDb.ListRangeAsync(key, 0, length).ConfigureAwait(false);
if (conversations == null || !conversations.Any())
{
return(null);
}
return(conversations.Select(opt => ObjectSerializer.ByteArrayToObject <ConversationPreviewVm>(opt)));
}
public void Handle(byte[] data, NodeConnection current)
{
try
{
CommunicationObject @object;
if (current.IsEncryptedConnection)
{
byte[] decryptedData = Encryptor.SymmetricDataDecrypt(
data,
current.SignPublicKey,
current.SymmetricKey,
NodeData.Instance.NodeKeys.Password)
.DecryptedData;
@object = ObjectSerializer.ByteArrayToObject <CommunicationObject>(decryptedData);
}
else
{
@object = ObjectSerializer.ByteArrayToObject <CommunicationObject>(data);
}
nodeConnection = current;
switch (@object.Type)
{
case ObjectType.NodeNotice:
{
var notice = (NodeNotice)@object;
HandleNotice(notice);
}
break;
case ObjectType.NodeRequest:
{
var request = (NodeRequest)@object;
HandleRequest(request, current);
}
break;
case ObjectType.NodeResponse:
{
var response = (NodeResponse)@object;
HandleResponse(response);
}
break;
}
Logger.WriteLog(@object);
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
public async Task <IEnumerable <BlockSegmentVm> > GetObjects(string key, long length)
{
List <BlockSegmentVm> result = new List <BlockSegmentVm>();
RedisValue[] segments = await redisDb.ListRangeAsync(key, 0, length - 1).ConfigureAwait(false);
await redisDb.ListTrimAsync(key, length, -1).ConfigureAwait(false);
foreach (RedisValue serializedSegment in segments)
{
result.Add(ObjectSerializer.ByteArrayToObject <BlockSegmentVm>(serializedSegment));
}
return(result);
}
public async Task <BlockchainInfo> GetBlockchainInfoAsync()
{
try
{
using (WebClient webClient = new WebClient())
{
var data = await webClient.DownloadDataTaskAsync($"https://{NodeSettings.Configs.LicensorUrl}/api/Blockchain/Information").ConfigureAwait(false);
return(ObjectSerializer.ByteArrayToObject <BlockchainInfo>(data));
}
}
catch (WebException ex)
{
Logger.WriteLog(ex);
return(null);
}
}
private async void BeginReceiveAsync()
{
try
{
while (webSocket.State == WebSocketState.Open)
{
try
{
byte[] receivedData = await ReceiveBytesAsync().ConfigureAwait(false);
if (IsEncrypted)
{
receivedData = Encryptor.SymmetricDataDecrypt(
receivedData,
licensorSignPublicKey,
symmetricKey,
NodeData.Instance.NodeKeys.Password).DecryptedData;
}
CommunicationObject communicationObject = ObjectSerializer.ByteArrayToObject <CommunicationObject>(receivedData);
if (communicationObject is LicensorResponse response)
{
Console.WriteLine($"Response received: {response.ResponseType}");
ResponseReceivedEvent.Invoke(response);
}
else if (communicationObject is LicensorNotice licensorNotice)
{
LicensorNoticeManager licensorNoticeManager = new LicensorNoticeManager();
await licensorNoticeManager.HandleNoticeAsync(licensorNotice).ConfigureAwait(false);
}
}
catch (Exception ex)
{
Logger.WriteLog(ex);
return;
}
}
}
catch (Exception ex)
{
Logger.WriteLog(ex);
}
}
private async Task <List <BlockVm> > GetBlocksAsync(NodeConnection node, long startId, long endId)
{
HttpWebRequest webRequest = WebRequest.CreateHttp($"https://{node.Uri.Authority}/Blockchain/Download?startId={startId}&endId={endId}");
webRequest.Method = "GET";
using (var response = await webRequest.GetResponseAsync().ConfigureAwait(false))
{
byte[] responseBuffer = new byte[128 * 1024];
List <byte> responseData = new List <byte>();
using (Stream stream = response.GetResponseStream())
{
using (BinaryReader bReader = new BinaryReader(stream))
{
int count;
while ((count = bReader.Read(responseBuffer, 0, responseBuffer.Length)) > 0)
{
responseData.AddRange(responseBuffer.Take(count));
await stream.FlushAsync().ConfigureAwait(false);
}
return(ObjectSerializer.ByteArrayToObject <List <BlockVm> >(responseData.ToArray()));
}
}
}
}
public async Task <BlockSegmentVm> GetObject(string key)
{
byte[] array = await redisDb.ListLeftPopAsync(key).ConfigureAwait(false);
return(ObjectSerializer.ByteArrayToObject <BlockSegmentVm>(array));
}
public async Task <bool> AuthAsync(bool recursive = false)
{
if (string.IsNullOrWhiteSpace(NodeSettings.Configs.LicensorUrl))
{
return(false);
}
if (webSocket.State != WebSocketState.Open)
{
try
{
await ConnectAndListenAsync().ConfigureAwait(false);
}
catch (Exception ex)
{
throw new LicensorException("No connection.", ex);
}
}
try
{
AuthRequest request = new AuthRequest(NodeData.Instance.NodeKeys.PublicKey, NodeSettings.Configs.Node.Id);
await SendRequestAsync(request).ConfigureAwait(false);
var response = await GetResponseAsync(request).ConfigureAwait(false);
if (response is AuthResponse authResponse)
{
symmetricKey = Encryptor.AsymmetricDecryptKey(
authResponse.EncryptedKey,
NodeData.Instance.NodeKeys.PrivateKey,
authResponse.LicensorSignPublicKey,
NodeData.Instance.NodeKeys.Password).Data;
var nodeDecryptedData = Encryptor.SymmetricDataDecrypt(
authResponse.EncryptedNode,
authResponse.LicensorSignPublicKey,
symmetricKey,
NodeData.Instance.NodeKeys.Password).DecryptedData;
var tokenDecryptedData = Encryptor.SymmetricDataDecrypt(
authResponse.EncryptedAccessToken,
authResponse.LicensorSignPublicKey,
symmetricKey,
NodeData.Instance.NodeKeys.Password).DecryptedData;
NodeVm node = ObjectSerializer.ByteArrayToObject <NodeVm>(nodeDecryptedData);
var licensorSign = authResponse.LicensorSign;
node.StartDay = node.StartDay.ToUniversalTime();
var nodeJson = ObjectSerializer.ObjectToJson(node);
licensorPublicKey = authResponse.LicensorPublicKey;
licensorSignPublicKey = authResponse.LicensorSignPublicKey;
expiredAt = DateTime.UtcNow.AddDays(7).ToUnixTime();
bool isValid = Encryptor.CheckSign(
licensorSign.Sign,
licensorSignPublicKey,
Encoding.UTF8.GetBytes(nodeJson),
NodeData.Instance.NodeKeys.Password);
if (isValid)
{
NodeSettings.Configs.LicensorSign = licensorSign;
}
return(true);
}
else if (response is ResultResponse resultResponse)
{
if (resultResponse.ErrorCode == ObjectsLibrary.LicensorResponseClasses.ErrorCode.KeyNotFound || resultResponse.ErrorCode == ObjectsLibrary.LicensorResponseClasses.ErrorCode.IdNotFound)
{
if (!recursive)
{
var nodeKeys = await AppServiceProvider.Instance.KeysService.GetActualNodeKeysAsync(NodeSettings.Configs.Node.Id).ConfigureAwait(false);
await AddNewKeyAsync(nodeKeys.PublicKey, nodeKeys.SignPublicKey, nodeKeys.KeyId, nodeKeys.ExpirationTime, nodeKeys.GenerationTime, false).ConfigureAwait(false);
await AuthAsync(recursive : true).ConfigureAwait(false);
return(true);
}
}
throw new ResponseException($"Authorization failed. Response error message: {resultResponse.ErrorMessage}");
}
return(false);
}
catch (Exception ex)
{
Logger.WriteLog(ex);
return(false);
}
}
public async Task <bool> UpdateObject(string key, ConversationPreviewVm conversation)
{
RedisValue[] conversations = await redisDb.ListRangeAsync(key, -2, 0).ConfigureAwait(false);
await redisDb.ListTrimAsync(key, 0, -2).ConfigureAwait(false);
List <ConversationPreviewVm> userConversations = conversations.Select(opt => ObjectSerializer.ByteArrayToObject <ConversationPreviewVm>(opt)).ToList();
RedisValue[] serializedChats = System.Array.Empty <RedisValue>();
userConversations.ForEach(item =>
{
if (item.ConversationId == conversation.ConversationId)
{
item = conversation;
}
serializedChats = serializedChats.Append(ObjectSerializer.ObjectToByteArray(item)).ToArray();
});
return(await redisDb.ListRightPushAsync(key, serializedChats).ConfigureAwait(false) > 0);
}
private async Task RestoreOldBlockchainDataAsync()
{
using (BlockchainDbContext context = new BlockchainDbContext())
{
long maxId = await context.ObsoleteBlocks.MaxAsync(opt => opt.Id).ConfigureAwait(false);
long minId = await context.ObsoleteBlocks.MinAsync(opt => opt.Id).ConfigureAwait(false);
byte limit = 100;
for (long i = minId; i < maxId; i += limit)
{
var obsoleteBlocks = await context.ObsoleteBlocks
.Where(block => block.Id >= i)
.Take(limit)
.ToListAsync().ConfigureAwait(false);
List <BlockVm> blocks = obsoleteBlocks.Select(block => ObjectSerializer.ByteArrayToObject <BlockVm>(block.Data)).ToList();
List <BlockSegmentVm> allSegments = new List <BlockSegmentVm>();
List <BlockSegmentVm> noexistentSegments = new List <BlockSegmentVm>();
foreach (var block in blocks)
{
allSegments.AddRange(block.BlockSegments);
}
var segmentsCondition = PredicateBuilder.New <BlockSegment>();
segmentsCondition = allSegments.Aggregate(segmentsCondition,
(current, value) => current.Or(opt => opt.SegmentHash.SequenceEqual(value.SegmentHash)).Expand());
var existentSegments = await context.BlockSegments.Where(segmentsCondition).ToListAsync().ConfigureAwait(false);
noexistentSegments = allSegments
.Where(segment => !existentSegments.Any(exSegment => segment.SegmentHash.SequenceEqual(exSegment.SegmentHash)))
?.ToList();
if (!noexistentSegments.IsNullOrEmpty())
{
BlockGenerationHelper.Instance.AddSegments(noexistentSegments);
}
}
NpgsqlParameter blockIdParam = new NpgsqlParameter("blockId", minId);
RawSqlString sqlString = new RawSqlString(@"DELETE FROM ""ObsoleteBlocks"" WHERE ""Id"" >= @blockId");
await context.Database.ExecuteSqlCommandAsync(sqlString, blockIdParam).ConfigureAwait(false);
}
}