/// <summary>
/// Adds the keys.
/// </summary>
/// <returns>The keys.</returns>
/// <param name="identifier">Identifier.</param>
/// <param name="password">Password.</param>
/// <param name="pkSk">Pk sk.</param>
public async Task <bool> AddKey(SecureString identifier, SecureString password, PkSkDto pkSk)
{
Guard.Argument(identifier, nameof(identifier)).NotNull();
Guard.Argument(password, nameof(password)).NotNull();
Guard.Argument(pkSk, nameof(pkSk)).NotNull();
bool added = false;
using (var insecureIdentifier = identifier.Insecure())
{
try
{
var data = await vaultServiceClient.GetDataAsync(identifier, password, $"wallets/{insecureIdentifier.Value}/wallet");
if (data.Data.TryGetValue("storeKeys", out object keys))
{
((JArray)keys).Add(JObject.FromObject(pkSk));
await vaultServiceClient.SaveDataAsync(identifier, password, $"wallets/{insecureIdentifier.Value}/wallet", data.Data);
added = true;
}
}
catch (Exception ex)
{
logger.LogError(ex.Message);
}
}
return(added);
}
/// <summary>
/// Adds the or replace.
/// </summary>
/// <returns>The or replace.</returns>
/// <param name="session">Session.</param>
/// <param name="name">Name.</param>
/// <param name="key">Key.</param>
/// <param name="value">Value.</param>
public async Task <TaskResult <bool> > AddOrReplace(Session session, TEntity value)
{
Guard.Argument(session, nameof(session)).NotNull();
Guard.Argument(value, nameof(value)).NotNull();
using (await addOrReplaceMutex.LockAsync())
{
try
{
var primaryKey = Util.GetPrimaryKeyName(value);
var vault = await vaultServiceClient.GetDataAsync(session.Identifier, session.MasterKey, $"wallets/{session.Identifier.ToUnSecureString()}/wallet");
if (vault.Data.TryGetValue(store.ToString(), out object d))
{
var wallet = (JArray)d;
var jToken = wallet.FirstOrDefault(x => x.Value <string>(primaryKey) == Util.GetPropertyValue(value, primaryKey));
switch (jToken)
{
case null:
wallet.Add(JObject.FromObject(value));
break;
default:
wallet.RemoveAt(wallet.IndexOf(jToken));
wallet.Add(JObject.FromObject(value));
break;
}
}
else
{
vault.Data.Add(store.ToString(), new List <TEntity> {
value
});
}
await vaultServiceClient.SaveDataAsync(session.Identifier, session.MasterKey, $"wallets/{session.Identifier.ToUnSecureString()}/wallet", vault.Data);
}
catch (Exception ex)
{
logger.LogError(ex.Message);
return(TaskResult <bool> .CreateFailure(ex));
}
}
return(TaskResult <bool> .CreateSuccess(true));
}
/// <summary>
/// Create new wallet.
/// </summary>
/// <returns>The wallet.</returns>
public async Task <CredentialsDto> CreateWallet()
{
var walletId = NewID(16);
var passphrase = Passphrase();
var pkSk = CreatePkSk();
walletId.MakeReadOnly();
passphrase.MakeReadOnly();
try
{
await vaultServiceClient.CreateUserAsync(walletId, passphrase);
var dic = new Dictionary <string, object>
{
{ "storeKeys", new List <PkSkDto> {
pkSk
} }
};
await vaultServiceClient.SaveDataAsync(
walletId,
passphrase,
$"wallets/{walletId.ToUnSecureString()}/wallet",
dic);
return(new CredentialsDto {
Identifier = walletId.ToUnSecureString(), Password = passphrase.ToUnSecureString()
});
}
catch (Exception ex)
{
logger.LogError(ex.Message);
throw new Exception("Failed to create wallet. Is the vault unsealed?");
}
finally
{
walletId.Dispose();
passphrase.Dispose();
}
}
