/// <summary> /// Build a merged list of safes. /// </summary> /// <param name="leftItems">List of safes from the left repository, whose order has precedence.</param> /// <param name="rightItems">List of safes from the right side repository.</param> /// <returns>List of safes for the new merged repository.</returns> private static SafeListModel BuildMergedListOfSafes(SafeListModel leftItems, SafeListModel rightItems) { SafeListModel result = new SafeListModel(); var map = OuterJoin(leftItems, rightItems, item => item.Id); foreach (Tuple <SafeModel, SafeModel> pair in map) { if (pair.Item1 == null) { // Only available on the right side result.Add(pair.Item2.Clone()); } else if (pair.Item2 == null) { // Only available on the left side result.Add(pair.Item1.Clone()); } else { // Take the more recent SafeModel lastModifiedItem = ChooseLastModified( pair.Item1, pair.Item2, item => item.ModifiedAt, null); result.Add(lastModifiedItem.Clone()); } } return(result); }
private void Ok() { List <SafeInfo> matchingSafes = TryPasswordOnSafes(OldPassword); InvalidOldPasswordError = matchingSafes.Count == 0; InvalidPasswordError = !ValidatePassword(Password); InvalidPasswordConfirmationError = !ValidatePasswordConfirmation(Password, PasswordConfirmation); if (InvalidOldPasswordError || InvalidPasswordError || InvalidPasswordConfirmationError) { return; } // Change the encrypted key of each safe which could have been opened with the password. string algorithm = _settingsService.LoadSettingsOrDefault().SelectedEncryptionAlgorithm; foreach (SafeInfo safeInfo in matchingSafes) { // No need to open or close the safe, just replace the encrypted key. safeInfo.Safe.SerializeableKey = SafeModel.EncryptKey(safeInfo.Key, Password, _randomService, algorithm); safeInfo.Safe.RefreshModifiedAt(); } Modified = true; _navigationService.Navigate(new Navigation(ControllerNames.NoteRepository)); }
/// <summary> /// Tries the password on all safes and returns a list of decrypted safes/keys. /// The function does not change the open/close state of the safe. /// </summary> /// <param name="password">Password to test with.</param> /// <returns>List of safes where the password matches.</returns> private List <SafeInfo> TryPasswordOnSafes(SecureString password) { List <SafeInfo> result = new List <SafeInfo>(); foreach (SafeModel safe in Model.Safes) { if (SafeModel.TryDecryptKey(safe.SerializeableKey, password, out byte[] key))
public IActionResult Delete(String id) { var model = new SafeModel(); model.DisableLogin(id); return(RedirectToAction("Index")); }
private void CreateNewSafe(SecureString password) { SafeModel safe = new SafeModel(); string algorithm = _settingsService.LoadSettingsOrDefault().SelectedEncryptionAlgorithm; safe.GenerateNewKey(password, _randomService, algorithm); Model.Safes.Add(safe); }
public IActionResult LogOff() { var model = new SafeModel(); model.LogOff(); return(RedirectToAction("Index", "Users")); }
/// <summary> /// Encrpyts the unlocked content with the key of the assigned safe. /// </summary> /// <param name="unlockedContent">Content to encrypt.</param> /// <returns>Encrypted content.</returns> public string Lock(string unlockedContent) { string encryptionAlgorithm = _settingsService.LoadSettingsOrDefault().SelectedEncryptionAlgorithm; SafeModel safe = _safes.FindById(Model.SafeId); byte[] binaryContent = CryptoUtils.StringToBytes(unlockedContent); byte[] lockedContent = _cryptor.Encrypt(binaryContent, safe.Key, encryptionAlgorithm, null); return(CryptoUtils.BytesToBase64String(lockedContent)); }
public void MergeSafes() { Guid safe1Id = new Guid("10000000000000000000000000000000"); Guid safe2Id = new Guid("20000000000000000000000000000000"); Guid safe3Id = new Guid("30000000000000000000000000000000"); Guid safe4Id = new Guid("40000000000000000000000000000000"); Guid safe5Id = new Guid("50000000000000000000000000000000"); Guid safe6Id = new Guid("60000000000000000000000000000000"); DateTime newerDate = new DateTime(2008, 08, 08); DateTime middleDate = new DateTime(2006, 06, 06); NoteRepositoryModel serverRepo = new NoteRepositoryModel(); SafeModel safeS1 = new SafeModel { Id = safe2Id, SerializeableKey = "s1", ModifiedAt = newerDate }; SafeModel safeS2 = new SafeModel { Id = safe4Id, SerializeableKey = "s2", ModifiedAt = middleDate }; SafeModel safeS3 = new SafeModel { Id = safe6Id, SerializeableKey = "s3", ModifiedAt = middleDate }; serverRepo.Safes.AddRange(new[] { safeS1, safeS2, safeS3 }); AddNotesWithSafeIds(serverRepo, new[] { safe2Id, safe4Id, safe6Id }); NoteRepositoryModel clientRepo = new NoteRepositoryModel(); SafeModel safeC1 = new SafeModel { Id = safe5Id, SerializeableKey = "c1", ModifiedAt = middleDate }; SafeModel safeC2 = new SafeModel { Id = safe4Id, SerializeableKey = "c2", ModifiedAt = newerDate }; SafeModel safeC3 = new SafeModel { Id = safe2Id, SerializeableKey = "c3", ModifiedAt = middleDate }; SafeModel safeC4 = new SafeModel { Id = safe1Id, SerializeableKey = "c4", ModifiedAt = middleDate }; SafeModel safeC5 = new SafeModel { Id = safe3Id, SerializeableKey = "c5", ModifiedAt = middleDate }; clientRepo.Safes.AddRange(new[] { safeC1, safeC2, safeC3, safeC4, safeC5 }); AddNotesWithSafeIds(clientRepo, new[] { safe5Id, safe4Id, safe2Id, safe1Id, safe3Id }); NoteRepositoryMerger merger = new NoteRepositoryMerger(); NoteRepositoryModel result = merger.Merge(clientRepo, serverRepo); SafeListModel safes = result.Safes; Assert.AreEqual(6, safes.Count); Assert.AreEqual(safe5Id, safes[0].Id); Assert.AreEqual("c1", safes[0].SerializeableKey); Assert.AreEqual(safe2Id, safes[1].Id); Assert.AreEqual("s1", safes[1].SerializeableKey); Assert.AreEqual(safe1Id, safes[2].Id); Assert.AreEqual("c4", safes[2].SerializeableKey); Assert.AreEqual(safe3Id, safes[3].Id); Assert.AreEqual("c5", safes[3].SerializeableKey); Assert.AreEqual(safe4Id, safes[4].Id); Assert.AreEqual("c2", safes[4].SerializeableKey); Assert.AreEqual(safe6Id, safes[5].Id); Assert.AreEqual("s3", safes[5].SerializeableKey); }
public void EnsureBackwardsCompatibilityDecryption() { string encryptedKey = "U2lsZW50U2FmZSB2PTIkYWVzX2djbSQ2ZXVQN3NSQ2dHQStadTJGeE80QkJRPT0kcGJrZGYyJEs0TjY5dmllRTBvaEg1UlVvVDUydGc9PSQxMDAwMCQkT1cFrC+EM9E5PlM4uPGUv0HsOQ=="; SecureString password = CryptoUtils.StringToSecureString("testpassword"); bool res = SafeModel.TryDecryptKey(encryptedKey, password, out byte[] decryptedKey); byte[] originalKey = new byte[] { 88, 99, 11 }; Assert.IsTrue(res); Assert.IsTrue(originalKey.SequenceEqual(decryptedKey)); }
public void EncryptedKeyCanBeDecrypted() { byte[] key = new byte[] { 88, 99, 11 }; SecureString password = CryptoUtils.StringToSecureString("testpassword"); ICryptoRandomSource randomSource = CommonMocksAndStubs.CryptoRandomService(); string encryptedKey = SafeModel.EncryptKey(key, password, randomSource, BouncyCastleAesGcm.CryptoAlgorithmName); bool res = SafeModel.TryDecryptKey(encryptedKey, password, out byte[] decryptedKey); Assert.IsTrue(res); Assert.IsTrue(key.SequenceEqual(decryptedKey)); }
/// <summary> /// Decrypts the note, if the belonging safe is open. /// </summary> /// <returns>Decrypted note content, or null if the safe is closed.</returns> private string UnlockIfSafeOpen(string lockedContent) { SafeModel safe = _safes.FindById(Model.SafeId); if ((safe != null) && safe.IsOpen) { byte[] binaryContent = CryptoUtils.Base64StringToBytes(lockedContent); byte[] unlockedContent = _cryptor.Decrypt(binaryContent, safe.Key); return(CryptoUtils.BytesToString(unlockedContent)); } return(null); }
public void AddNoteToSafe(Guid noteId) { NoteViewModel note = AllNotes.Find(item => item.Id == noteId); SafeModel oldestOpenSafe = Model.Safes.FindOldestOpenSafe(); if ((note != null) && (oldestOpenSafe != null)) { note.Model.SafeId = oldestOpenSafe.Id; note.Model.HtmlContent = note.Lock(note.UnlockedHtmlContent); note.Model.RefreshModifiedAt(); Modified = true; } }
private static void AddSafeToOtherRepositoryIfMissing(NoteRepositoryModel myRepository, NoteRepositoryModel otherRepository, Guid?safeId) { bool isMissingInOtherRepository = (safeId != null) && (otherRepository.Safes.FindById(safeId) == null); if (isMissingInOtherRepository) { SafeModel mySafe = myRepository.Safes.FindById(safeId); if (mySafe != null) { otherRepository.Safes.Add(mySafe.Clone()); } } }
// Kasa public ActionResult Index(SafeModel model) { var aaax = db.SRFs.Where(w => w.Active == true && w.SFRState == EnumProductState.SFRWasDelivered).ToList(); foreach (var item in aaax) { var y = db.Customers.Where(w => w.Id == item.CustomerId).FirstOrDefault(); if (y != null) { item.customer.UserName = y.UserName; } var z = db.Products.Where(w => w.Id == item.ProductId).FirstOrDefault(); if (z != null) { item.product.PBrand = z.PBrand; item.product.PModel = z.PModel; } } var datetime1 = new DateTime(0001, 01, 01); if (model.Start == datetime1) { model.Start = new DateTime(2018, 01, 01); } SafeModel Safe = new SafeModel() { Start = model.Start, End = model.End, }; if (Safe.End.Hour < 24) { int x = 23 - Safe.End.Hour; Safe.End = Safe.End.AddHours(x); } if (Safe.Start.Hour > 0) { int y = Safe.Start.Hour - 0; Safe.Start = Safe.Start.AddHours(-y); } //var Bank = db.Banks.Where(w => w.BankTime >= Safe.Start && w.BankTime <= Safe.End).ToList(); //foreach (var item in Bank) //{ // Safe.TotalGain = item.Payment + Safe.TotalGain; //} Safe.ServiceRegistrationForms = aaax.Where(w => w.SRFDatetime >= model.Start && w.SRFDatetime <= model.End).ToList(); Safe.Total = Safe.ServiceRegistrationForms.Sum(s => s.Price); return(View(Safe)); }
public void ClosingTheSafeWillRemoveKeyFromMemory() { byte[] key = new byte[] { 88, 99, 11 }; SafeModel safe = new SafeModel { SerializeableKey = "sugus", Key = key, }; safe.Close(); bool hasUncleanedBytes = key.Any(item => item != 0); Assert.IsNull(safe.Key); Assert.IsFalse(hasUncleanedBytes); }
/// <inheritdoc/> public override bool NeedsNavigationRedirect(Navigation original, out Navigation redirectTo) { if (original.Variables.TryGetValue(ControllerParameters.NoteId, out string noteId)) { // Get the note from the repository _repositoryService.LoadRepositoryOrDefault(out NoteRepositoryModel noteRepository); NoteModel note = noteRepository.Notes.FindById(new Guid(noteId)); // Find its safe and check if it needs to be opened SafeModel safe = noteRepository.Safes.FindById(note?.SafeId); if ((safe != null) && (!safe.IsOpen)) { redirectTo = new Navigation(ControllerNames.OpenSafe, ControllerParameters.NoteId, noteId); return(true); } } redirectTo = null; return(false); }
public void CloneCopiesAllProperties() { SafeModel note1 = new SafeModel { Id = Guid.NewGuid(), CreatedAt = new DateTime(2000, 10, 22, 18, 55, 30), ModifiedAt = new DateTime(2001, 10, 22, 18, 55, 30), MaintainedAt = new DateTime(2002, 10, 22, 18, 55, 30), SerializeableKey = "sugus", Key = new byte[] { 88 }, }; SafeModel note2 = note1.Clone(); Assert.AreEqual(note1.Id, note2.Id); Assert.AreEqual(note1.CreatedAt, note2.CreatedAt); Assert.AreEqual(note1.ModifiedAt, note2.ModifiedAt); Assert.AreEqual(note1.MaintainedAt, note2.MaintainedAt); Assert.AreEqual(note1.SerializeableKey, note2.SerializeableKey); Assert.IsNull(note2.Key); // The unprotected key won't be cloned, the safe is closed. }
public void FindOldestOpenSafeWorksCorrectly() { SafeListModel list = new SafeListModel(); byte[] testKey = new byte[0]; // Search in empty list Assert.IsNull(list.FindOldestOpenSafe()); // Search with only one element SafeModel safe2002 = new SafeModel { CreatedAt = new DateTime(2002, 02, 02), Key = testKey }; list.Add(safe2002); Assert.AreSame(safe2002, list.FindOldestOpenSafe()); // Add newer element SafeModel safe2003 = new SafeModel { CreatedAt = new DateTime(2003, 03, 03), Key = testKey }; list.Add(safe2003); Assert.AreSame(safe2002, list.FindOldestOpenSafe()); // Add closed safe SafeModel safe2000 = new SafeModel { CreatedAt = new DateTime(2000, 01, 01), Key = null }; list.Add(safe2000); Assert.AreSame(safe2002, list.FindOldestOpenSafe()); // Add older element SafeModel safe2001 = new SafeModel { CreatedAt = new DateTime(2001, 01, 01), Key = testKey }; list.Add(safe2001); Assert.AreSame(safe2001, list.FindOldestOpenSafe()); }
public void RemoveUnusedSafesWorksCorrectly() { Guid safe1Id = new Guid("10000000000000000000000000000000"); Guid safe2Id = new Guid("20000000000000000000000000000000"); NoteRepositoryModel repository = new NoteRepositoryModel(); SafeModel safeS1 = new SafeModel { Id = safe1Id }; SafeModel safeS2 = new SafeModel { Id = safe2Id }; repository.Safes.AddRange(new[] { safeS1, safeS2 }); NoteModel noteN2 = new NoteModel { SafeId = safe2Id }; repository.Notes.Add(noteN2); repository.RemoveUnusedSafes(); Assert.AreEqual(1, repository.Safes.Count); Assert.AreEqual(safe2Id, repository.Safes[0].Id); }
public ActionResult SafePost(SafeModel safe) { return(RedirectToAction("Index", safe)); }