private ListRecordsOutput GetRecords(KyprClient client, Shared.Models.InMemory.Vault vault)
{
var output = new ListRecordsOutput();
client.UnlockVault(vault);
client.UnlockRecordSummaries(vault);
output.Vault = new()
{
Id = vault.Id !.Value,
Label = vault.Summary !.Label,
};
var records = Deleted
? client.ListDeletedRecords(vault)
: client.ListRecords(vault);
foreach (var r in records)
{
output.Records.Add(new()
{
Id = r.Id !.Value,
Label = r.Summary !.Label,
});
}
return(output);
}
public async Task Create_Vaults_List_Vaults()
{
var username = "******";
var password = "******";
var vaultLabels = Enumerable.Range(1, 10)
.Select(_ => "Vault " + Guid.NewGuid())
.ToList();
using var client1 = new KyprClient(_server1);
await client1.CreateAccountAsync(username + "1", password);
var acct1 = client1.Account;
var vaults1 = await Task.WhenAll(vaultLabels.Select(async x => await client1.CreateVaultAsync(x)).ToList());
using var client2 = new KyprClient(_server1);
await client2.CreateAccountAsync(username + "2", password);
var acct2 = client2.Account;
var vaults2 = await Task.WhenAll(vaultLabels.Select(async x => await client2.CreateVaultAsync(x)).ToList());
Assert.Equal(vaults1, client1.ListVaults());
Assert.Equal(vaults2, client2.ListVaults());
}
public async Task Create_Vault_Unique_Vault_Keys()
{
var username = "******";
var password = "******";
var vaultLabel1 = "Vault #1";
var vaultLabel2 = "Vault #2";
using var client1 = new KyprClient(_server1);
using var client2 = new KyprClient(_server1);
await client1.CreateAccountAsync(username + "1", password);
var acct1 = client1.Account;
var acct1Vault1 = await client1.CreateVaultAsync(vaultLabel1);
var acct1Vault2 = await client1.CreateVaultAsync(vaultLabel2);
await client2.CreateAccountAsync(username + "2", password);
var acct2 = client2.Account;
var acct2Vault1 = await client1.CreateVaultAsync(vaultLabel1);
var acct2Vault2 = await client1.CreateVaultAsync(vaultLabel2);
Assert.NotEqual(
acct1Vault1 !.SecretKey,
acct1Vault2 !.SecretKey);
Assert.NotEqual(
acct1Vault1 !.SecretKey,
acct2Vault1 !.SecretKey);
}
/// <summary>
/// Resolves a Vault reference to a specific Vault instance, or failing
/// that, will print an appropriate error message to console and return
/// <c>null</c>.
/// </summary>
public Vault?GetVault(KyprClient client, string vaultRef)
{
client.UnlockVaults();
// First try by Id
var vaults = client.ListVaults().Where(x =>
x.Id.ToString() !.StartsWith(vaultRef !, StringComparison.OrdinalIgnoreCase));
if (vaults.Count() == 0)
{
// Next try by label
vaults = client.ListVaults().Where(x =>
x.Summary !.Label !.StartsWith(vaultRef !, StringComparison.OrdinalIgnoreCase));
}
if (vaults.Count() == 0)
{
_console.WriteError("no Vaults match the specified reference.");
return(null);
}
if (vaults.Count() > 1)
{
_console.WriteError("multiple Vaults match the specified reference.");
return(null);
}
return(vaults.Single());
}
public async Task Create_Records_and_Recover_With_Second_Client()
{
var username = "******";
var password = "******";
var recordLabels = Enumerable.Range(1, 10)
.Select(_ => Guid.NewGuid())
.SelectMany(x => Enumerable.Range(1, 5).Select(_ =>
x + "-_" + Guid.NewGuid()))
.ToList();
var recordValues = recordLabels.ToDictionary(x => x, x => Guid.NewGuid().ToString());
using (var client1 = new KyprClient(_server1))
{
await client1.CreateAccountAsync(username, password);
var vault1 = await client1.CreateVaultAsync("vault1");
foreach (var rl in recordLabels)
{
await client1.SaveRecordAsync(vault1, new()
{
Summary = new()
{
Label = "Record " + rl,
Username = "******" + recordValues[rl],
},
Content = new()
{
Password = "******" + recordValues[rl],
}
});
}
}
using var client1a = new KyprClient(_server2);
await client1a.AuthenticateAccountAsync(username, password);
await client1a.RefreshVaultsAsync();
var vault1a = client1a.Vaults.Single();
client1a.UnlockVault(vault1a);
client1a.UnlockRecordSummaries(vault1a);
Assert.Equal("vault1", vault1a.Summary !.Label);
foreach (var rl in recordLabels)
{
var rlParts = rl.Split("_");
var hits1 = client1a.SearchRecords(vault1a, rlParts[0]);
var hits2 = client1a.SearchRecords(vault1a, rlParts[1]);
Assert.Equal(5, hits1.Count());
Assert.Single(hits2);
}
Assert.Equal(vault1a.Records, client1a.SearchRecords(vault1a, "RECORD"));
}
public async Task Create_and_Lock_and_Unlock_Account()
{
var username = "******";
var password = "******";
using var client = new KyprClient(_server1);
await client.CreateAccountAsync(username, password);
client.LockAccount();
client.UnlockAccount(password);
}
public async Task Create_and_Lock_and_Fail_Unlock_Account_With_Bad_Password()
{
var username = "******";
var password = "******";
using var client = new KyprClient(_server1);
await client.CreateAccountAsync(username, password);
client.LockAccount();
Assert.Throws <CryptographicException>(() =>
client.UnlockAccount("not" + password));
}
/// <summary>
/// Resolves a Record reference to a specific Record instance, or failing
/// that, will print an appropriate error message to console and return
/// <c>null</c>.
/// </summary>
public Record?GetRecord(KyprClient client, ref Vault?vault, string recordRef)
{
IEnumerable <Vault>?vaults;
if (vault != null)
{
client.UnlockVault(vault);
client.UnlockRecordSummaries(vault);
vaults = new[] { vault };
}
else
{
client.UnlockVaults();
vaults = client.ListVaults();
foreach (var v in vaults)
{
client.UnlockRecordSummaries(v);
}
}
var records = vaults
.SelectMany(x => x.Records.Select(y => (vault: x, record: y)))
.Where(x => x.record.Id.ToString() !.StartsWith(recordRef !, StringComparison.OrdinalIgnoreCase));
if (records.Count() == 0)
{
// Next try by label
records = vaults
.SelectMany(x => x.Records.Select(y => (vault: x, record: y)))
.Where(x => x.record.Summary !.Label !.StartsWith(recordRef !, StringComparison.OrdinalIgnoreCase));
}
if (records.Count() == 0)
{
_console.WriteError("no Records match the specified reference.");
return(null);
}
if (records.Count() > 1)
{
_console.WriteError("multiple Records match the specified reference.");
return(null);
}
var match = records.Single();
vault = match.vault;
return(match.record);
}
public async Task Create_and_Search_Records()
{
using var server1 = await GetTestServiceClient();
var username = "******";
var password = "******";
var recordLabels = Enumerable.Range(1, 10)
.Select(_ => Guid.NewGuid())
.SelectMany(x => Enumerable.Range(1, 5).Select(_ =>
x + "-_" + Guid.NewGuid()))
.ToList();
using var client = new KyprClient(server1);
await client.CreateAccountAsync(username, password);
var vault = await client.CreateVaultAsync("Vault #1");
foreach (var rl in recordLabels)
{
await client.SaveRecordAsync(vault, new()
{
Summary = new()
{
Label = "Record " + rl,
Username = Guid.NewGuid().ToString(),
},
Content = new()
{
Password = "******",
}
});
}
foreach (var rl in recordLabels)
{
var rlParts = rl.Split("_");
var hits1 = client.SearchRecords(vault, rlParts[0]);
var hits2 = client.SearchRecords(vault, rlParts[1]);
Assert.Equal(5, hits1.Count());
Assert.Single(hits2);
}
Assert.Equal(vault.Records, client.SearchRecords(vault, "RECORD"));
}
public async Task Create_Account_Unique_Master_Keys()
{
var username = "******";
var password = "******";
using var client1 = new KyprClient(_server1);
using var client2 = new KyprClient(_server1);
await client1.CreateAccountAsync(username + "1", password);
await client2.CreateAccountAsync(username + "2", password);
var acct1 = client1.Account;
var acct2 = client2.Account;
Assert.NotEqual(
acct1 !.MasterKey,
acct2 !.MasterKey);
}
public async Task Create_Lock_and_Unlock_Vault()
{
var username = "******";
var password = "******";
using var client = new KyprClient(_server1);
await client.CreateAccountAsync(username, password);
var vault = await client.CreateVaultAsync("vault1");
Assert.NotEmpty(vault.SecretKey);
client.LockVault(vault);
Assert.Null(vault.SecretKey);
client.UnlockVault(vault);
Assert.NotEmpty(vault.SecretKey);
client.LockAccount();
Assert.Null(vault.SecretKey);
}
public async Task Create_Records_and_Recover_With_Second_Server_and_Session()
{
var username = "******";
var password = "******";
var recordLabels = Enumerable.Range(1, 10)
.Select(_ => Guid.NewGuid())
.SelectMany(x => Enumerable.Range(1, 5).Select(_ =>
x + "-_" + Guid.NewGuid()))
.ToList();
var recordValues = recordLabels.ToDictionary(x => x, x => Guid.NewGuid().ToString());
KyprSession?session;
Account? account;
using (var client1 = new KyprClient(_server1))
{
await client1.CreateAccountAsync(username, password);
session = client1.Session;
account = client1.Account;
var vault1 = await client1.CreateVaultAsync("vault1");
foreach (var rl in recordLabels)
{
await client1.SaveRecordAsync(vault1, new()
{
Summary = new()
{
Label = "Record " + rl,
Username = "******" + recordValues[rl],
},
Content = new()
{
Password = "******" + recordValues[rl],
}
});
}
}
using var server = new ServerImpl(_loggerFactory.CreateLogger <ServerImpl>(), _db2, session);
using var client2 = new KyprClient(server);
client2.Session = session;
client2.Account = account;
// This was automatically locked by
// client1 when it was disposed
Assert.True(client2.IsAccountLocked());
client2.UnlockAccount(password);
await client2.RefreshVaultsAsync();
var vault1a = client2.Vaults.Single();
client2.UnlockVault(vault1a);
client2.UnlockRecordSummaries(vault1a);
Assert.Equal("vault1", vault1a.Summary !.Label);
var records = client2.ListRecords(vault1a).ToArray();
Assert.Equal(50, records.Length);
foreach (var rl in recordLabels)
{
var rlParts = rl.Split("_");
var hits1 = client2.SearchRecords(vault1a, rlParts[0]);
var hits2 = client2.SearchRecords(vault1a, rlParts[1]);
Assert.Equal(5, hits1.Count());
Assert.Single(hits2);
}
Assert.Equal(vault1a.Records, client2.SearchRecords(vault1a, "RECORD"));
}
public async Task Create_Lock_and_Unlock_Records()
{
var username = "******";
var password = "******";
var recordLabels = Enumerable.Range(1, 10)
.Select(_ => Guid.NewGuid())
.SelectMany(x => Enumerable.Range(1, 5).Select(_ =>
x + "-_" + Guid.NewGuid()))
.ToList();
var recordValues = recordLabels.ToDictionary(x => x, x => Guid.NewGuid().ToString());
using var client = new KyprClient(_server1);
await client.CreateAccountAsync(username, password);
var vault = await client.CreateVaultAsync("vault1");
foreach (var rl in recordLabels)
{
await client.SaveRecordAsync(vault, new()
{
Summary = new()
{
Label = "Record " + rl,
Username = "******" + recordValues[rl],
},
Content = new()
{
Password = "******" + recordValues[rl],
}
});
}
client.LockAccount();
// Vault should be locked
Assert.Null(vault.SecretKey);
// All records should be locked
foreach (var r in vault.Records)
{
Assert.Null(r.Summary);
Assert.Null(r.SummarySer);
Assert.Null(r.Content);
Assert.Null(r.ContentSer);
}
client.UnlockAccount(password);
client.UnlockVault(vault);
Assert.NotEmpty(vault.SecretKey);
client.UnlockRecordSummaries(vault);
foreach (var r in vault.Records)
{
Assert.NotNull(r.Summary);
Assert.NotEmpty(r.SummarySer);
Assert.Null(r.Content);
Assert.Null(r.ContentSer);
}
foreach (var r in vault.Records)
{
client.UnlockRecord(vault, r);
Assert.NotNull(r.Summary);
Assert.NotEmpty(r.SummarySer);
Assert.NotNull(r.Content);
Assert.NotEmpty(r.ContentSer);
}
foreach (var rl in recordLabels)
{
var rlParts = rl.Split("_");
var hits1 = client.SearchRecords(vault, rlParts[0]);
var hits2 = client.SearchRecords(vault, rlParts[1]);
Assert.Equal(5, hits1.Count());
Assert.Single(hits2);
}
Assert.Equal(vault.Records, client.SearchRecords(vault, "RECORD"));
}
public async Task Create_Vaults_List_Vaults()
{
using var server1 = await GetTestServiceClient();
var username = "******";
var password = "******";
var vaultLabels = Enumerable.Range(1, 10)
.Select(_ => "Vault " + Guid.NewGuid())
.ToList();
using var client1 = new KyprClient(server1);
await client1.CreateAccountAsync(username + "1", password);
var vaults1 = vaultLabels
.Select(x => client1.CreateVaultAsync(x).Result)
.OrderBy(x => x.Id)
.Select(x => JsonSerializer.Serialize(x))
.ToList();
using var client2 = new KyprClient(server1);
await client2.CreateAccountAsync(username + "2", password);
var vaults2 = vaultLabels
.Select(x => client2.CreateVaultAsync(x).Result)
.OrderBy(x => x.Id)
.Select(x => JsonSerializer.Serialize(x))
.ToList();
var listedVaults1 = client1.ListVaults()
.OrderBy(x => x.Id)
.Select(x => JsonSerializer.Serialize(x))
.ToList();
var listedVaults2 = client2.ListVaults()
.OrderBy(x => x.Id)
.Select(x => JsonSerializer.Serialize(x))
.ToList();
Assert.Equal(vaultLabels.Count, listedVaults1.Count);
Assert.Equal(vaultLabels.Count, listedVaults2.Count);
Assert.Equal(vaults1, listedVaults1);
Assert.Equal(vaults2, listedVaults2);
using var client3 = new KyprClient(server1);
await client3.AuthenticateAccountAsync(username + "1", password);
await client3.RefreshVaultsAsync();
client3.UnlockVaults();
var listedVaults3 = client3.ListVaults()
.OrderBy(x => x.Id)
.Select(x => JsonSerializer.Serialize(x))
.ToList();
_testOut.WriteLine(JsonSerializer.Serialize(vaults1));
_testOut.WriteLine(JsonSerializer.Serialize(listedVaults3));
Assert.Equal(vaultLabels.Count, listedVaults3.Count);
Assert.Equal(vaults1, listedVaults3);
}
