protected override void OnMessage(MessageEventArgs e)
{
Container container;
try {
container = JsonConvert.DeserializeObject <Container>(e.Data);
} catch {
Pool.Server.Clients.RemoveAll(c => c.ClientId == ID);
Sessions.CloseSession(ID);
return;
}
var client = Pool.Server.Clients.Find(c => c.ClientId == ID);
var package = client.ReadContainer(container);
if (package.Type == PackageType.AES)
{
//client.SetAesParameters(JsonConvert.DeserializeObject<AesParameters>(NeoCryptoProvider.Instance.RsaDecrypt(package.Content, Pool.Server.RSAPrivateParameters)));
var payload = package.GetContentTypesafe <AesPackageContent>();
var parameters = new AesParameters(Convert.FromBase64String(payload.AesKey), Convert.FromBase64String(payload.AesIV));
client.SetAesParameters(parameters);
}
else
{
Pool.Server.OnPackage(ID, package);
}
}
public async Task DowngradeCipherSettings()
{
DateTime lastPasswordChange = this.document.Metadata.MasterKeyChanged.Value;
Assert.AreEqual(EncryptionAlgorithm.ChaCha20, this.settingsVm.Cipher, "ChaCha20 should be the encryption algorithm before the test starts");
this.writer.Cipher = EncryptionAlgorithm.Aes;
Assert.IsInstanceOfType(this.settingsVm.GetKdfParameters(), typeof(Argon2Parameters), "Argon2 should be the KDF before the test starts according to the VM");
Assert.IsInstanceOfType(this.writer.KdfParameters, typeof(Argon2Parameters), "Argon2 should be the KDF before the test starts according to the KdbxWriter");
this.settingsVm.KdfGuid = AesParameters.AesUuid;
this.settingsVm.KdfIterations = 6001;
Assert.IsInstanceOfType(this.writer.KdfParameters, typeof(AesParameters), "Changes to the settings VM should be reflected in the KdbxWriter");
Assert.IsTrue(await this.persistenceService.Save(this.document));
KdbxReader reader = new KdbxReader();
using (IRandomAccessStream stream = await this.saveFile.AsIStorageFile.OpenReadAsync())
{
await reader.ReadHeaderAsync(stream, CancellationToken.None);
Assert.AreEqual(EncryptionAlgorithm.Aes, reader.HeaderData.Cipher, "New reader should have the correct cipher");
AesParameters aesParams = reader.HeaderData.KdfParameters as AesParameters;
Assert.IsNotNull(aesParams, "Database should have properly persisted with AES");
Assert.AreEqual(6001, (int)aesParams.Rounds, "AES iteration count should have been persisted correctly");
KdbxDecryptionResult decryption = await reader.DecryptFileAsync(stream, this.dbPassword, this.dbKeyFile, CancellationToken.None);
Assert.AreEqual(KdbxParserCode.Success, decryption.Result.Code);
KdbxDocument document = decryption.GetDocument();
Assert.AreEqual(lastPasswordChange, document.Metadata.MasterKeyChanged.Value, "MasterKeyChanged timestamp should not have changed");
}
}
public DatabaseSettingsViewModel(IDatabaseSettingsProvider settingsProvider)
{
this.settingsProvider = settingsProvider ?? throw new ArgumentNullException(nameof(settingsProvider));
if (KdfGuid.Equals(AesParameters.AesUuid))
{
this._aesParams = this.settingsProvider.KdfParameters as AesParameters;
DebugHelper.Assert(this._aesParams != null);
this._argonParams = new Argon2Parameters(2, 64, 100);
}
else
{
DebugHelper.Assert(KdfGuid.Equals(Argon2Parameters.Argon2Uuid));
this._argonParams = this.settingsProvider.KdfParameters as Argon2Parameters;
DebugHelper.Assert(this._argonParams != null);
this._aesParams = new AesParameters(6000);
}
}
public MainViewModel(ISettingsService settingsService, ILog log)
{
this.settingsService = settingsService ?? throw new ArgumentNullException(nameof(settingsService));
this.log = log ?? throw new ArgumentNullException(nameof(log));
string keySetting;
if (settingsService.TryGetSetting(keySettingId, out keySetting) &&
!string.IsNullOrWhiteSpace(keySetting))
{
key = keySetting;
}
else
{
AesParameters parameters = encryptor.GenerateAesParameters();
var keyBytes = parameters.Key;
key = Convert.ToBase64String(keyBytes);
settingsService.SetSetting(keySettingId, key);
settingsService.SetSetting(firstKeyId, key);
}
}
/// <summary>
/// Sets the <see cref="AesParameters"/> of this <see cref="Client"/>.
/// </summary>
/// <param name="parameters">The <see cref="AesParameters"/> structure to set.</param>
internal void SetAesParameters(AesParameters parameters)
{
aesParameters = parameters;
}
/// <summary>
/// Writes out the KDBX header.
/// </summary>
/// <param name="writer">The DataWriter to write to.</param>
/// <returns>A Task representing the asynchronous operation.</returns>
private async Task WriteOuterHeaderAsync(DataWriter writer)
{
WriteFieldId(writer, OuterHeaderField.CipherID);
WriteFieldSize(writer, 16);
writer.WriteBytes(GetCipherUuid(HeaderData.Cipher).ToByteArray());
await writer.StoreAsync();
WriteFieldId(writer, OuterHeaderField.CompressionFlags);
WriteFieldSize(writer, 4);
writer.WriteUInt32((uint)HeaderData.Compression);
await writer.StoreAsync();
WriteFieldId(writer, OuterHeaderField.MasterSeed);
WriteFieldSize(writer, 32);
writer.WriteBuffer(HeaderData.MasterSeed);
await writer.StoreAsync();
if (!this.parameters.UseExtensibleKdf)
{
AesParameters kdfParams = HeaderData.KdfParameters as AesParameters;
DebugHelper.Assert(kdfParams != null);
WriteFieldId(writer, OuterHeaderField.TransformSeed);
WriteFieldSize(writer, 32);
writer.WriteBuffer(kdfParams.Seed);
await writer.StoreAsync();
WriteFieldId(writer, OuterHeaderField.TransformRounds);
WriteFieldSize(writer, 8);
writer.WriteUInt64(kdfParams.Rounds);
await writer.StoreAsync();
}
else
{
WriteFieldId(writer, OuterHeaderField.KdfParameters);
VariantDictionary kdfDict = HeaderData.KdfParameters.ToVariantDictionary();
WriteFieldSize(writer, (uint)kdfDict.GetSerializedSize());
await kdfDict.WriteToAsync(writer);
}
WriteFieldId(writer, OuterHeaderField.EncryptionIV);
WriteFieldSize(writer, HeaderData.EncryptionIV.Length);
writer.WriteBuffer(HeaderData.EncryptionIV);
await writer.StoreAsync();
if (!this.parameters.UseHmacBlocks)
{
WriteFieldId(writer, OuterHeaderField.StreamStartBytes);
WriteFieldSize(writer, HeaderData.StreamStartBytes.Length);
writer.WriteBuffer(HeaderData.StreamStartBytes);
await writer.StoreAsync();
}
if (!this.parameters.UseInnerHeader)
{
WriteFieldId(writer, OuterHeaderField.ProtectedStreamKey);
WriteFieldSize(writer, 32);
writer.WriteBytes(HeaderData.InnerRandomStreamKey);
await writer.StoreAsync();
WriteFieldId(writer, OuterHeaderField.InnerRandomStreamID);
WriteFieldSize(writer, 4);
writer.WriteUInt32((uint)HeaderData.InnerRandomStream);
await writer.StoreAsync();
}
WriteFieldId(writer, OuterHeaderField.EndOfHeader);
WriteFieldSize(writer, 4);
writer.WriteByte(0x0D);
writer.WriteByte(0x0A);
writer.WriteByte(0x0D);
writer.WriteByte(0x0A);
await writer.StoreAsync();
}
