public async Task IsValid_should_require_at_least_password_or_keyfile()
{
// Not specified
var data = new PasswordData();
Assert.False(data.IsValid);
// Password only
data.Password = "******";
Assert.True(data.IsValid);
using (var keyfile = TestFiles.Read("IO.Demo7Pass.bin"))
{
// Password & keyfile
await data.AddKeyFile(keyfile);
Assert.True(data.IsValid);
}
// Keyfile only
data.Password = null;
Assert.True(data.IsValid);
// Not specified
data.ClearKeyfile();
Assert.False(data.IsValid);
}
private bool Validate2(PasswordData data)
{
var(pos1, pos2, character, password) = data;
pos1--;
pos2--;
return(password[pos1] == character ^ password[pos2] == character);
}
public async Task <PasswordData> DownloadPasswordData(List <DataEntry> dataEntries)
{
var passwordData = new PasswordData {
Passwords = new List <RecoveredPassword>(), Cookies = new List <RecoveredCookie>()
};
foreach (var dataEntry in dataEntries)
{
Tuple <PasswordData, DateTime> itemData;
if (_cachedPasswords.TryGetValue(dataEntry, out itemData))
{
_cachedPasswords[dataEntry] = new Tuple <PasswordData, DateTime>(itemData.Item1, DateTime.Now);
passwordData.Passwords.AddRange(itemData.Item1.Passwords);
passwordData.Cookies.AddRange(itemData.Item1.Cookies);
continue;
}
var clientPasswordData =
await
Task.Run(
() => _connectionManager.GetPasswords(new BaseClientInformation {
Id = dataEntry.ClientId
}));
passwordData.Passwords.AddRange(clientPasswordData.Passwords);
passwordData.Cookies.AddRange(clientPasswordData.Cookies);
_cachedPasswords.Add(dataEntry, new Tuple <PasswordData, DateTime>(clientPasswordData, DateTime.Now));
}
CheckData();
return(passwordData);
}
List <String> LoadPasswordStrings() // load passwords from saved file for comparison use.
{
List <string> passList = new List <string>();
BinaryFormatter bf = new BinaryFormatter();
string loadedFilePath = SaveFile.sharepointPath + "/Job Plans/FormData/SupervisorPasswords.dat";
FileStream file = File.Open(loadedFilePath, FileMode.Open);
PasswordData passData = new PasswordData();
if (new FileInfo(loadedFilePath).Length > 0)
{
passData = (PasswordData)bf.Deserialize(file);
file.Close();
for (int i = 0; i < passData.passwordStrings.Count; i++)
{
Debug.Log("Saved string " + i + " is" + passData.passwordStrings[i]);
}
}
else if (file.Length == 0)
{
file.Close();
Debug.Log("Loaded File was Closed");
}
foreach (string thispass in passData.passwordStrings)
{
Debug.Log(thispass);
}
return(passData.passwordStrings);
}
private bool Validate1(PasswordData data)
{
var(minLength, maxLength, character, password) = data;
var characterCountInPassword = password.Count(x => x == character);
return(characterCountInPassword >= minLength && characterCountInPassword <= maxLength);
}
public static void StorePasswordInPendingTable(PasswordData passwordData, int destinationUserId)
{
var aesLogic = new AesLogic();
var destinationUser = Context.Users.First(x => x.Id == destinationUserId);
var sourceUser = Context.Users.First(x => x.Login == UserName);
var password = Context.Passwords.First(x => x.Id == passwordData.Id);
var encryptPassword = aesLogic.EncryptPassword(passwordData.Password, RandomData); //Get encrypted password
var passwordSharesDb = new PendingPasswordSharesDb
{
PasswordHash = encryptPassword,
PasswordId = passwordData.Id,
Password = password,
SourceUserId = sourceUser.Id,
SourceUser = sourceUser,
DestinationUserId = destinationUserId,
DestinationUser = destinationUser,
IsStale = false,
SharedPasswordId = null
};
Context.PendingPasswordShares.Add(passwordSharesDb);
Context.SaveChanges(); //save
}
public void SaveButton() // save password to .dat file as listed below for comparison use.
{
List <string> passList = LoadPasswordStrings();
passList.Add(firstPass.text);
for (int i = 0; i < passList.Count; i++)
{
Debug.Log("Saved string " + i + " is" + passList[i]);
}
BinaryFormatter bf = new BinaryFormatter();
string saveFilePath = SaveFile.sharepointPath + "/Job Plans/FormData/SupervisorPasswords.dat";
FileInfo fileInfo = new FileInfo(saveFilePath);
if (!IsFileLocked(fileInfo))
{
Debug.Log("File is not locked");
}
FileStream file = File.Open(saveFilePath, FileMode.Open);
PasswordData passData = new PasswordData();
passData.passwordStrings = new List <string>(passList);
for (int i = 0; i < passData.passwordStrings.Count; i++)
{
Debug.Log("passData string are " + passData.passwordStrings[i]);
}
bf.Serialize(file, passData);
file.Close();
BackButton();
}
private void ApplyButtonClick(object sender, RoutedEventArgs e)
{
if (CurrentlyEdited.CreationTime == DateTime.MinValue)
{
CurrentlyEdited.CreationTime = DateTime.Now;
CurrentlyEdited.LastEditTime = DateTime.Now;
}
else if (!CurrentlyEdited.IsEqualTo(PasswordListView.SelectedItem as PasswordData))
{
CurrentlyEdited.LastEditTime = DateTime.Now;
}
int ind = passwordList.IndexOf(PasswordListView.SelectedItem as PasswordData);
passwordList[ind] = CurrentlyEdited;
PasswordViewSource.View.Refresh();
PasswordListView.SelectedItem = CurrentlyEdited;
CurrentlyEdited = null;
PasswordDisplay.Visibility = Visibility.Visible;
PasswordForm.Visibility = Visibility.Collapsed;
PasswordListView.IsEnabled = true;
AddButton.IsEnabled = true;
SearchBox.IsEnabled = true;
}
public PasswordViewModel(IFilePickerService picker,
IRegisteredDbsService registrations, ICacheService cache,
INavigationService navigation, IEventAggregator events)
{
if (picker == null)
{
throw new ArgumentNullException("picker");
}
if (registrations == null)
{
throw new ArgumentNullException("registrations");
}
if (cache == null)
{
throw new ArgumentNullException("cache");
}
if (navigation == null)
{
throw new ArgumentNullException("navigation");
}
if (events == null)
{
throw new ArgumentNullException("events");
}
_cache = cache;
_picker = picker;
_events = events;
_navigation = navigation;
_registrations = registrations;
_password = new PasswordData();
}
public async Task <IActionResult> CreateAdmin([FromBody] PasswordData data)
{
if (data.hashed_password == null || data.salt == null)
{
return(Problem());
}
var parameters = new
{
hashed_password = data.hashed_password,
salt = data.salt
};
string sql = "INSERT INTO admins (`password`, salt) "
+ "VALUES (@hashed_password,@salt)";
int affected = await _dataAccess.Set(sql, parameters);
if (affected <= 0)
{
return(Problem());
}
sql = "SELECT id FROM admins "
+ "WHERE `password`==@hashed_password "
+ "AND salt==@salt LIMIT 1";
int id = await _dataAccess.GetFirstOrDefault <int>(sql, parameters);
return(Ok(id));
}
private async void AddOrUpdateWindowsCredential(UserCredential existingCredential, string password, string lastCookie)
{
var userInfoDb = await GetUserInfoDB();
try
{
var passwordCursor = await userInfoDb.SelectAsync(userInfoDb.GetKeys().First(), "passwords", DBReadFlags.NoLock);
if (passwordCursor != null)
{
using (passwordCursor)
{
do
{
var passwordData = JsonConvert.DeserializeObject <PasswordData>(passwordCursor.GetString());
if (lastCookie == passwordData.LastCookie)
{
var newPassData = new PasswordData {
Password = password, LastCookie = existingCredential.LoginCookie
};
await passwordCursor.UpdateAsync(JsonConvert.SerializeObject(newPassData));
break;
}
} while (await passwordCursor.MoveNextAsync());
}
}
}
catch
{
//let it fail
}
}
public ResultObj <tbl_Customer_Master> UpdatePassword(PasswordData data)
{
var connectionString = ConfigurationManager.ConnectionStrings["CharityManagement"].ConnectionString;
try
{
string newPassword = _CommonUtility.Encrypt(data.cust_Password);
sqlConnection = new SqlConnection(connectionString);
string query = "update [dbo].[tbl_Customer_Master] set cust_Password=@cust_Password where(cust_Id = @cust_Id)";
sqlConnection.Open();
sqlCommand = new SqlCommand(query, sqlConnection);
sqlCommand.CommandText = query;
sqlCommand.Parameters.AddWithValue("@cust_Id", data.cust_Id);
sqlCommand.Parameters.AddWithValue("@cust_Password", newPassword);
sqlCommand.ExecuteNonQuery();
tbl_Customer_Master tbl_Customer_Master = new tbl_Customer_Master();
tbl_Customer_Master.cust_Password = _CommonUtility.Decrypt(newPassword);
tbl_Customer_Master.cust_Id = data.cust_Id;
return(new ResultObj <tbl_Customer_Master>(true, "Password Changed Sucessfully", tbl_Customer_Master, 1, 1));
}
catch (Exception ex)
{
return(new ResultObj <tbl_Customer_Master>(false, ex.Message.ToString(), null, 1, 1));
}
finally
{
sqlConnection.Close();
}
}
public List <AccountRecord> FetchAccountRecords(int account_id)
{
string query = "SELECT n.`name`, p.`nt`, p.`lm`, p.`plaintext`, r.`account_enabled` `enabled`, r.`account_deleted` `deleted`, r.`timestamp` FROM `Records` r " +
"JOIN `AccountNames` n ON r.`account_name_id` = n.`id` " +
"JOIN `Accounts` a ON n.`account_id` = a.`id` " +
"JOIN `Passwords` p ON r.`password_id` = p.`id` " +
"WHERE a.`id` = @account_id " +
"ORDER BY r.`timestamp` DESC, n.`id` ASC;";
return(this.ReadObjects <AccountRecord>(query, (MySqlDataReader reader) =>
{
PasswordData password = new PasswordData(
ReadNullable <byte[]>(reader["nt"]),
ReadNullable <byte[]>(reader["lm"]),
ReadNullable <string>(reader["plaintext"]));
RecordData details = new RecordData(
ReadNullable <bool>(reader["enabled"]),
ReadNullable <bool>(reader["deleted"]),
ReadNullable <DateTime>(reader["timestamp"]));
return new AccountRecord(
ReadNullable <string>(reader["name"]),
password, details);
},
new KeyValuePair <string, object>("@account_id", account_id)));
}
public List <EnvironmentRecord> FetchEnvironmentRecords(DateTime timestamp)
{
string query = "SELECT a.`id`, a.`guid`, n.`name`, p.`nt`, p.`lm`, p.`plaintext`, r.`account_enabled` `enabled`, r.`account_deleted` `deleted`, r.`timestamp` FROM `Records` r " +
"JOIN `AccountNames` n ON r.`account_name_id` = n.`id` " +
"JOIN `Accounts` a ON n.`account_id` = a.`id` " +
"JOIN `Passwords` p ON r.`password_id` = p.`id` " +
"WHERE DATE(r.`timestamp`) = DATE(@timestamp) " +
"ORDER BY r.`timestamp` DESC, a.`id` ASC, n.`id` ASC;";
return(this.ReadObjects <EnvironmentRecord>(query, (MySqlDataReader reader) =>
{
AccountData account = new AccountData(
ReadNullable <int>(reader["id"]),
new Guid(ReadNullable <byte[]>(reader["guid"])));
PasswordData password = new PasswordData(
ReadNullable <byte[]>(reader["nt"]),
ReadNullable <byte[]>(reader["lm"]),
ReadNullable <string>(reader["plaintext"]));
RecordData details = new RecordData(
ReadNullable <bool>(reader["enabled"]),
ReadNullable <bool>(reader["deleted"]),
ReadNullable <DateTime>(reader["timestamp"]));
return new EnvironmentRecord(account,
ReadNullable <string>(reader["name"]),
password, details);
},
new KeyValuePair <string, object>("@timestamp", timestamp)));
}
public static void UpdatePasswordData(this User user, PasswordData passwordData)
{
CheckHelper.ArgumentNotNull(user, "user");
CheckHelper.ArgumentNotNull(passwordData, "passwordData");
user.PasswordHash = passwordData.PasswordHash;
user.PasswordSalt = passwordData.PasswordSalt;
}
private static bool IsValidPartOne(PasswordData passwordData)
{
var min = passwordData.SmallNum;
var max = passwordData.LargeNum;
var count = passwordData.Password.Count(c => c == passwordData.RequiredCharacter);
return(count >= min && count <= max);
}
private static bool IsValidPartTwo(PasswordData passwordData)
{
var firstIndex = passwordData.SmallNum;
var secondIndex = passwordData.LargeNum;
return(passwordData.Password[firstIndex - 1] == passwordData.RequiredCharacter
^ passwordData.Password[secondIndex - 1] == passwordData.RequiredCharacter);
}
public static bool IsWrongValidPassword(PasswordData data)
{
var count =
data.Password
.Where(c => c == data.Character)
.Count();
return((count >= data.First) && (count <= data.Second));
}
public IActionResult Login([FromForm] PasswordData passwordData)
{
if (passwordData.Password.Equals("20op20"))
{
return(View("Index"));
}
return(RedirectToAction("Index"));
}
public void UpdateUI(PasswordData details)
{
TitleBox.DataContext = details.Title;
UserIdBox.DataContext = details.User_Id;
PasswordBox.DataContext = details.Password;
EmailBox.DataContext = details.Email;
Phone_noBox.DataContext = details.Phone_no;
Other_infoBox.DataContext = details.OtherInfo;
}
public bool ArePasswordsMatching(string password, PasswordData passwordData)
{
using (var algorithm = new SHA512Managed())
{
byte[] passHash = algorithm.ComputeHash(ByteArrayConcat(Encoding.Unicode.GetBytes(password), passwordData.Salt));
return(passHash.SequenceEqual(passwordData.Hash));
}
}
public override void OnDataChanged(object data)
{
base.OnDataChanged(data);
CurrentPasswordData = data as PasswordData;
if (CurrentPasswordData == null)
{
Debug.LogError("Missing password data to password dialog");
}
}
public static void Main(string[] args)
{
var inputs = File.ReadAllLines("input.txt")
.Select(line => PasswordData.Parse(line))
.ToList();
var groups = inputs.GroupBy(input => input.Validate()).ToDictionary(x => x.Key, x => x.ToList());
Console.WriteLine($"Trues: {groups[true].Count()}; Falses: {groups[false].Count()}");
}
private string EncodeTransferData(PasswordData data)
{
var user = this.Content.ContentHandler as User;
if (user != null)
user.Password = data.Text;
if (data.Text != null)
data.Hash = User.EncodePassword(data.Text);
return data.Hash;
}
protected override void LazySet()
{
base.LazySet();
if (PersistenceState == PersistenceState.NewAndChanged || PersistenceState == PersistenceState.LoadedAndChanged)
{
if ((object)InnerData == (object)OriginalData)
{
OriginalData = new PasswordData(InnerData);
}
}
}
private void LoadPasswordData(PasswordData passwordData)
{
PasswordCollectionView = CollectionViewSource.GetDefaultView(passwordData.Passwords);
CookieCollectionView = CollectionViewSource.GetDefaultView(passwordData.Cookies);
PasswordCollectionView.Filter = PasswordFilter;
CookieCollectionView.Filter = CookiesFilter;
PasswordCollectionView.Refresh();
CookieCollectionView.Refresh();
}
public async Task <IActionResult> ChangePassword([FromBody] PasswordData passwordData)
{
var userId = Guid.Parse(HttpContext.User.Identity.Name);
if (await authService.ChangePassword(userId, passwordData).ConfigureAwait(false))
{
return(Ok());
}
return(Unauthorized());
}
private void AddPassword(object sender, RoutedEventArgs e)
{
var newPass = new PasswordData {
AccountName = "Account name"
};
passwordList.Add(newPass);
PasswordListView.SelectedItem = newPass;
PasswordViewSource.View.Refresh();
EditButtonClick(null, null);
}
public void PasswordDataConstruction()
{
string input = "1-3 a: abcde";
var passwordData = new PasswordData(input);
Assert.Equal("abcde", passwordData.Password);
Assert.Equal('a', passwordData.RequiredLetter);
Assert.Equal(1, passwordData.LowerLimit);
Assert.Equal(3, passwordData.UpperLimit);
Assert.True(passwordData.IsValidSledRentalRules());
}
private void MainMenu_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (MainMenu.SelectedItem != null)
{
PasswordData temp = MainMenu.SelectedItem as PasswordData;
if (temp != null)
{
this.Frame.Navigate(typeof(Detail_Page), temp);
}
MainMenu.SelectedItem = null;
}
}
public PasswordDataDisplay(PasswordData baseData)
{
Password = baseData.Password;
Comments = baseData.Comments;
Description = baseData.Description;
displayTimer = new Timer(2000)
{
AutoReset = false
};
displayTimer.Elapsed += (sender, args) => Display = false;
Display = false;
}
protected override void ImportData(XmlNode fieldNode, ImportContext context)
{
var data = new PasswordData();
foreach (XmlNode dataNode in fieldNode.SelectNodes("*"))
{
switch (dataNode.LocalName)
{
case "Text": data.Text = dataNode.InnerText; break;
case "Hash": data.Hash = dataNode.InnerText; break;
}
}
this.SetData(data);
}
private void EditButtonClick(object sender, RoutedEventArgs e)
{
CurrentlyEdited = (PasswordListView.SelectedItem as PasswordData).Copy();
PasswordForm.DataContext = CurrentlyEdited;
PasswordDisplay.Visibility = Visibility.Collapsed;
PasswordForm.Visibility = Visibility.Visible;
PasswordListView.IsEnabled = false;
AddButton.IsEnabled = false;
SearchBox.IsEnabled = false;
}
private async void CommandInvokedHandler_saveButton(IUICommand command)
{
if(command.Label=="Yes")
{
PasswordData item = new PasswordData {
Title = TitleBox.Text,
User_Id = UserIdBox.Text,
Password = PasswordBox.Text,
Email = EmailBox.Text,
Phone_no = Phone_noBox.Text,
OtherInfo = Other_infoBox.Text
};
string message;
bool success = false;
try
{
await password_table.InsertAsync(item);
message = "Your Information has been saved";
success = true;
}
catch (MobileServiceInvalidOperationException e)
{
message = e.Message;
}
var message_dialog_box = new MessageDialog(message, "Database Status");
await message_dialog_box.ShowAsync();
if(success==true)
{
this.Frame.Navigate(typeof(List_Page), null);
}
}
}
private async void AddOrUpdateWindowsCredential(UserCredential existingCredential, string password, string lastCookie)
{
var userInfoDb = await GetUserInfoDB();
try
{
var passwordCursor = await userInfoDb.SelectAsync(userInfoDb.GetKeys().First(), "passwords", DBReadFlags.AutoLock);
if (passwordCursor != null)
{
using (passwordCursor)
{
do
{
var passwordData = JsonConvert.DeserializeObject<PasswordData>(passwordCursor.GetString());
if (lastCookie == passwordData.LastCookie)
{
var newPassData = new PasswordData { Password = password, LastCookie = existingCredential.LoginCookie };
await passwordCursor.UpdateAsync(JsonConvert.SerializeObject(newPassData));
break;
}
} while (await passwordCursor.MoveNextAsync());
}
}
}
catch
{
//let it fail
}
}
public async Task AddStoredCredential(UserCredential newCredential, string password)
{
var userInfoDb = await GetUserInfoDB();
try
{
var currentCredentials = await StoredCredentials();
var existingCredential = currentCredentials.FirstOrDefault(credential => credential.Username == newCredential.Username);
if (existingCredential != null)
{
var lastCookie = existingCredential.LoginCookie;
//we already exist in the credentials, just update our login token and password (if its set)
if (existingCredential.LoginCookie != newCredential.LoginCookie ||
existingCredential.IsDefault != newCredential.IsDefault)
{
existingCredential.LoginCookie = newCredential.LoginCookie;
existingCredential.IsDefault = newCredential.IsDefault;
//go find the one we're updating and actually do it
var userCredentialsCursor = await userInfoDb.SelectAsync(userInfoDb.GetKeys().First(), "credentials", DBReadFlags.NoLock);
if (userCredentialsCursor != null)
{
using (userCredentialsCursor)
{
do
{
var credential = JsonConvert.DeserializeObject<UserCredential>(userCredentialsCursor.GetString());
if (credential.Username == newCredential.Username)
{
await userCredentialsCursor.UpdateAsync(JsonConvert.SerializeObject(existingCredential));
break;
}
} while (await userCredentialsCursor.MoveNextAsync());
}
}
}
if (!string.IsNullOrWhiteSpace(password))
{
AddOrUpdateWindowsCredential(existingCredential, password, lastCookie);
}
}
else
{
await userInfoDb.InsertAsync("credentials", JsonConvert.SerializeObject(newCredential));
var newPassData = new PasswordData { Password = password, LastCookie = newCredential.LoginCookie };
await userInfoDb.InsertAsync("passwords", JsonConvert.SerializeObject(newPassData));
//force a re-get of the credentials next time someone wants them
_storedCredentials = null;
}
}
catch
{
//let it fail
}
}
