public override string LoadAccountKey(string wallet, string address, string key, IDbConnectorService dbservice, string pubkey = "", string password = "", string name = "", bool storeInDb = true, bool isItMainAccountKey = false, bool alreadyEncrypted = false, EncryptionKeyType type = EncryptionKeyType.BasicSecurity)
{
try
{
if (EconomyMainContext.Wallets.TryGetValue(wallet, out var w))
{
if (w.Accounts.TryGetValue(address, out var account))
{
if (isItMainAccountKey)
{
// todo load already encrypted key
account.AccountKey = new Security.EncryptionKey(key, password);
account.AccountKey.RelatedItemId = account.Id;
account.AccountKey.Type = Security.EncryptionKeyType.AccountKey;
account.AccountKeyId = account.AccountKey.Id;
account.AccountKey.PublicKey = account.Address;
if (!string.IsNullOrEmpty(password))
{
account.AccountKey.PasswordHash = Security.SecurityUtil.HashPassword(password);
}
account.AccountKey.Name = name;
if (EconomyMainContext.WorkWithDb)
{
dbservice.SaveKey(account.AccountKey);
}
account.AccountKeyId = account.AccountKey.Id;
if (EconomyMainContext.WorkWithDb)
{
dbservice.SaveAccount(account);
}
return("OK");
}
else
{
EncryptionKey k = null;
if (!string.IsNullOrEmpty(key) && !string.IsNullOrEmpty(pubkey))
{
// validate the key pair if it is correct combination of RSA keys
try
{
if (type != EncryptionKeyType.AccountKey)
{
if (alreadyEncrypted)
{
var kd = SymetricProvider.DecryptString(password, key);
if (kd != null)
{
key = kd;
}
}
var m = AsymmetricProvider.EncryptString("test", pubkey);
var r = AsymmetricProvider.DecryptString(m, key);
if (r != "test")
{
throw new Exception("Key pair is not valid RSA key pair!");
}
}
k = new EncryptionKey(key, password);
}
catch (Exception ex)
{
throw new Exception("Key pair is not valid RSA key pair!");
}
}
else if (!string.IsNullOrEmpty(key) && string.IsNullOrEmpty(pubkey))
{
if (alreadyEncrypted)
{
var kd = SymetricProvider.DecryptString(password, key);
if (kd != null)
{
k = new Security.EncryptionKey(kd, password);
}
}
else
{
k = new Security.EncryptionKey(key, password);
k.LoadNewKey(key, fromDb: true);
}
}
else if (!string.IsNullOrEmpty(pubkey) && string.IsNullOrEmpty(key))
{
// create enc object
k = new Security.EncryptionKey("passtest", password, true); // this can be used for testing the password
k.PublicKey = pubkey;
}
else if (string.IsNullOrEmpty(key) && string.IsNullOrEmpty(pubkey))
{
// obtain new RSA key pair
var keypair = Security.AsymmetricProvider.GenerateNewKeyPair();
// create enc object
k = new EncryptionKey(keypair.PrivateKey, password);
k.PublicKey = keypair.PublicKey;
}
else
{
throw new Exception("Strange input!");
}
k.RelatedItemId = account.Id;
k.Type = Security.EncryptionKeyType.BasicSecurity;
if (!string.IsNullOrEmpty(password))
{
k.PasswordHash = Security.SecurityUtil.HashPassword(password);
}
k.Name = name;
account.AccountKeys.Add(k);
if (EconomyMainContext.WorkWithDb)
{
dbservice.SaveKey(k);
}
if (isItMainAccountKey)
{
account.AccountKeyId = account.AccountKey.Id;
if (EconomyMainContext.WorkWithDb)
{
dbservice.SaveAccount(account);
}
}
return("OK");
}
}
}
}
catch (Exception ex)
{
log.Error("Cannot load key to the account!", ex);
}
return("Load Account Key - ERROR");
}
public static async Task <string> SendMessage(SendMessageDto dto)
{
if (EconomyMainContext.Wallets.TryGetValue(dto.WalletId, out var wallet))
{
if (wallet.Accounts.TryGetValue(dto.SenderAddress, out var account))
{
var txdto = new SendTokenTxData();
txdto.Amount = 1;
txdto.Id = TokenId; // token ID - todo MSGT
txdto.Symbol = TokenSymbol; // token symbol - todo MSGT
txdto.UseRPCPrimarily = false;
txdto.Password = dto.AccountPassword;
txdto.SenderAddress = dto.SenderAddress;
txdto.ReceiverAddress = dto.ReceiverAddress;
///////////////////////////////
// prepare the message to send
if (dto.InitMessage)
{
// for init message lets create new uid
txdto.Metadata.Add("MessageStreamUID", Guid.NewGuid().ToString());
}
else
{
// for not init message message stream uid must be filled
if (!string.IsNullOrEmpty(dto.MessageStreamUID))
{
txdto.Metadata.Add("MessageStreamUID", dto.MessageStreamUID.ToString());
}
else
{
throw new Exception("Cannot send message - this is not set as init message but no MessageStreamUID was provided!");
}
}
var msg = string.Empty;
var prevmsgdata = string.Empty;
var prevmsg = string.Empty;
var prevtxid = string.Empty;
if (!dto.InitMessage)
{
var pretoken = await NeblioTransactionHelpers.TokenMetadataAsync(TokenTypes.NTP1, TokenId, dto.TokenTxId);
if (string.IsNullOrEmpty(pretoken.TxId))
{
throw new Exception("Cannot send message - Cannot find previous message token metadata!");
}
if (pretoken.MetadataAvailable)
{
if (pretoken.Metadata.TryGetValue("PrevTxId", out var prevtxidfrommeta))
{
prevtxid = prevtxidfrommeta;
}
IToken prepretoken = null;
if (pretoken.Metadata.TryGetValue("InitMessage", out var prevmsginit))
{
if (prevmsginit != "true")
{
prepretoken = await NeblioTransactionHelpers.TokenMetadataAsync(TokenTypes.NTP1, TokenId, prevtxid);
if (string.IsNullOrEmpty(prepretoken.TxId))
{
throw new Exception("Cannot send message - Cannot find pre-previous message token metadata and previous message is not init message!");
}
}
}
if (pretoken.Metadata.TryGetValue("MessageData", out var prevmsgdatafromMeta))
{
prevmsgdata = prevmsgdatafromMeta;
if (prepretoken != null)
{
if (prepretoken.MetadataAvailable)
{
if (prepretoken.Metadata.TryGetValue("SenderPubKey", out var preprevtokenReceiverKey))
{
var accEncKey = account.AccountKeys.FirstOrDefault(k => k.PublicKey == preprevtokenReceiverKey);
if (accEncKey != null)
{
try
{
// dencrypt my prevoious message just when I know that it will be encrypt before send
// if this will not happen, the prevmsgdata will contain original data from token metadata which can be encrypted
if (pretoken.Metadata.ContainsKey("SenderPubKey"))
{
var decprevmsg = AsymmetricProvider.DecryptString(prevmsgdata, accEncKey.GetEncryptedKey(dto.Password));
prevmsgdata = decprevmsg;
}
}
catch (Exception ex)
{
throw new Exception("Cannot send message - Cannot decrypt prevouis message, requeired keuy is not correct format!");
}
}
}
}
}
}
// if sender sent in previous message pubkey he wants to encrypt the message before sending
if (pretoken.Metadata.TryGetValue("SenderPubKey", out var receiverpubkey))
{
if (!string.IsNullOrEmpty(receiverpubkey))
{
try
{
// encrypt new message
msg = AsymmetricProvider.EncryptString(dto.Message, receiverpubkey);
// encrypt prevoius message
prevmsg = AsymmetricProvider.EncryptString(prevmsgdata, receiverpubkey);
}
catch (Exception ex)
{
throw new Exception("Cannot send message - Cannot encrypt the message, probably wrong Key");
}
}
else
{
throw new Exception("Cannot send message - Required key is not correct format!");
}
}
else
{
// if he dont want to encrypt message just copy
msg = dto.Message;
// if he dont want encrypted message copy previous message too
// but if that message was encrypted before witout his new encryption request it will not be provided in decrypted form and he cannot read it
// this is because i dont want to publish my encrypted previous message if this transfer will not be encrypted
prevmsg = prevmsgdata;
}
}
}
var senderPUB = string.Empty;
if (dto.Encrypt)
{
if (!string.IsNullOrEmpty(dto.KeyId))
{
var key = account.AccountKeys.FirstOrDefault(k => k.Id.ToString() == dto.KeyId);
if (key != null)
{
senderPUB = key.PublicKey;
// if encryption is required token metadata will contains sender pub key
txdto.Metadata.Add("SenderPubKey", senderPUB);
}
}
}
if (msg == null)
{
msg = string.Empty;
}
if (dto.InitMessage)
{
txdto.Metadata.Add("InitMessage", "true");
msg = dto.Message;
}
else
{
txdto.Metadata.Add("InitMessage", "false");
}
txdto.Metadata.Add("PrevTxId", dto.TokenTxId);
txdto.Metadata.Add("PreviousMessage", prevmsg);
txdto.Metadata.Add("MessageData", msg);
var res = await NeblioTransactionHelpers.SendNTP1TokenAPI(txdto, 50000);
return(res);
}
else
{
throw new Exception("Cannot send message - Cannot find the Account!");
}
}
else
{
throw new Exception("Cannot send message - Cannot find the wallet!");
}
}