private IEnumerable <Claim> GenerateClaims(string email, string password)
{
var userClaimId = UniqueIdGenerationService.GenerateRandomId();
var passwordHash = Convert.ToBase64String(SHA256.Create().ComputeHash(Encoding.UTF8.GetBytes(password)));
using (var dbContext = HttpContextAccessor.HttpContext.RequestServices.GetService(typeof(DissertationThesisContext)) as DissertationThesisContext)
{
var user = dbContext.Users.FirstOrDefault(x => x.User == email && x.PasswordHash == passwordHash);
if (user == null)
{
dbContext.Users.Add(new Users
{
Id = userClaimId,
User = email,
PasswordHash = passwordHash,
Role = "Member"
});
dbContext.SaveChanges();
}
userClaimId = user.Id;
}
return(new List <Claim>
{
new Claim("id", userClaimId),
new Claim("user", email),
new Claim("hash", passwordHash),
new Claim("role", "Member")
});
}
public PublishMessage(string topic, dynamic details, int requestId = 0, bool acknowledge = false, bool excludeMe = true, dynamic arguments = null)
{
RequestId = requestId != 0 ? requestId : UniqueIdGenerationService.GenerateUniqueId();
Acknowledge = acknowledge;
ExcludeMe = excludeMe;
Topic = topic;
Details = details;
Arguments = arguments;
}
public SubscribeMessage(string topic, long requestId = 0, dynamic options = null)
{
if (requestId == 0)
{
requestId = UniqueIdGenerationService.GenerateUniqueId();
}
RequestId = requestId;
Topic = topic;
Options = options;
}
private void OnSubscribe(object sender, SubscribeMessage message)
{
var subscriptionId = UniqueIdGenerationService.GenerateUniqueId();
if (!subscriptions.ContainsKey(message.Topic))
{
cache.SubscribeAsync(message.Topic);
subscriptions.Add(message.Topic, subscriptionId);
}
else
{
subscriptions[message.Topic] = subscriptionId;
}
Send(new SubscribedMessage(message.RequestId, subscriptionId));
}
public void GenerateKeyPair(IEnumerable <Claim> claims, string keyPurpose)
{
var userId = claims.First(x => x.Type == "id").Value;
var keyId = new UniqueIdGenerationService().GenerateRandomId();
var directoryPath = Path.Combine(keyDirectory, userId, keyId);
var filePath = Path.Combine(directoryPath, keyPurpose);
if (Directory.Exists(directoryPath))
{
GenerateKeyPair(claims, keyPurpose);
return;
}
Directory.CreateDirectory(directoryPath);
DataProtector.GenerateKey(
$"{filePath}.public.asc",
$"{filePath}.private.asc",
claims.First(x => x.Type == "user").Value,
claims.First(x => x.Type == "hash").Value);
}
public Task <IEnumerable <DataContract> > GetDataContracts(IEnumerable <DecryptedData> decryptedData)
{
var publicKeyPaths = this.FileAccessor.GetLocalPublicKeyTemporaryPaths();
var dataContracts = new List <DataContract>();
foreach (var item in decryptedData)
{
var jsonData = JsonConvert.SerializeObject(item);
var binaryData = Encoding.UTF8.GetBytes(jsonData);
var inputTempFilePath = Path.Combine(this.RootPath, "temp.bin");
File.WriteAllBytes(inputTempFilePath, binaryData);
var outputTempFilePath = this.DataProtector.EncryptFile(inputTempFilePath, publicKeyPaths);
var encryptedData = File.ReadAllBytes(outputTempFilePath);
dataContracts.Add(new DataContract()
{
PacketId = UniqueIdGenerationService.GenerateRandomId(),
UserId = App.USER_ID,
EncryptedData = Convert.ToBase64String(encryptedData)
});
File.Delete(inputTempFilePath);
File.Delete(outputTempFilePath);
}
publicKeyPaths.All(p =>
{
File.Delete(p);
return(true);
});
return(Task.FromResult(dataContracts.AsEnumerable()));
}
protected virtual long GetSessionId()
{
return(UniqueIdGenerationService.GenerateUniqueId());
}
