public PasswordCredential FindPreviousCredential() { try { PasswordCredential previousCredential = passwordVault.FindAllByResource(resourceName).First(); previousCredential.RetrievePassword(); return(previousCredential); } catch (Exception) { return(null); } }
/// <summary> /// Search the password vault for a valid credential. /// </summary> /// <returns></returns> public static async Task <bool> FindStoredCredentials() { // Get handle to the password vault PasswordVault Vault = new PasswordVault(); PasswordCredential Credential = null; while (Credential == null) { try { // Get the first credential in the vault. Credential = Vault.RetrieveAll().FirstOrDefault(); // Set the current user to the one from the credential App.alltheairgeadClient.CurrentUser = new MobileServiceUser(Credential.UserName); Credential.RetrievePassword(); App.alltheairgeadClient.CurrentUser.MobileServiceAuthenticationToken = Credential.Password; // Try to make a request. try { await App.alltheairgeadClient.GetTable <Expense>().Take(1).ToListAsync(); } // Catch an unaitherized request to try again. catch (MobileServiceInvalidOperationException ex) { if (ex.Response.StatusCode == System.Net.HttpStatusCode.Unauthorized) { // Remove the credential from the vault and go again. Vault.Remove(Credential); Credential = null; continue; } else if (ex.Response.StatusCode == System.Net.HttpStatusCode.NotFound) { // Deal with offline. Future work } } } // When none are found. Return false. catch { return(false); } } // Show a message to indicate the the user has logged in. MessageDialog Dialog = new MessageDialog("Signed in as " + Credential.UserName); await Dialog.ShowAsync(); return(true); }
/// <summary> /// 构造函数。 /// </summary> /// <param name="rootNavigationService">根导航服务。</param> public IdentityService(IRootNavigationService rootNavigationService) { _rootNavigationService = rootNavigationService; CurrentUser = new AppUser() { ID = 0, UserName = "" }; var passwordVault = new PasswordVault(); PasswordCredential refreshTokenCredential = null; try { refreshTokenCredential = passwordVault.Retrieve(RefreshTokenResource, DefaultUsername); } catch { // ignored } if (refreshTokenCredential != null) { refreshTokenCredential.RetrievePassword(); _refreshToken = refreshTokenCredential.Password; } PasswordCredential accessTokenCredential = null; try { accessTokenCredential = passwordVault.Retrieve(AccessTokenResource, DefaultUsername); } catch { // ignored } if (accessTokenCredential != null) { accessTokenCredential.RetrievePassword(); _accessToken = accessTokenCredential.Password; } }
private void UpdateCredentials(string username, string password) { PasswordCredential credentials = GetCredentials(); if (credentials != null) { credentials.RetrievePassword(); if (!username.Equals(credentials.UserName)) { RemoveCredentials(); } } }
/// <summary> /// Method which performs the work of the background task. /// </summary> /// <param name="taskInstance">The interface to an instance of the background task</param> private async void Update(IBackgroundTaskInstance taskInstance) { BackgroundTaskDeferral deferral = taskInstance.GetDeferral(); #if !DEBUG if (!(DateTime.Today.Month == 7 || DateTime.Today.Month == 8)) #else if (true) #endif { PasswordCredential credential = SecurityExtensions.RetrieveCredentials(); if (credential != null) { credential.RetrievePassword(); try { TileUpdateManager.CreateTileUpdaterForApplication().Clear(); ToastNotificationManager.History.Clear(); using (ClientExtensions client = new ClientExtensions()) { await client.AuthenticateAndInitDataAsync(new UserCredentials(credential.UserName, credential.Password), false); CheckAndSendNotification(BackgroundTaskExtensions.EVENTS, client.AccountDetails.AbsenceEvents.Count(item => !item.IsJustified), "AbsenceNotification".GetLocalized()); CheckAndSendNotification(BackgroundTaskExtensions.APPOINTMENTS, client.AccountDetails.AgendaEvents.Count, "AgendaNotification".GetLocalized()); CheckAndSendNotification(BackgroundTaskExtensions.DIDACTICS, client.AccountDetails.DidacticsItems.Count, "DidactictNotification".GetLocalized()); CheckAndSendNotification(BackgroundTaskExtensions.GRADES, client.AccountDetails.Grades.Count, "GradeNotification".GetLocalized()); CheckAndSendNotification(BackgroundTaskExtensions.NOTES, client.AccountDetails.Notes.Count, "NoteNotification".GetLocalized()); CheckAndSendNotification(BackgroundTaskExtensions.ITEMS, client.AccountDetails.NoticeboardItems.Count, "NoticeboardNotification".GetLocalized()); } } catch (Exception) { // } } } else { ResourceExtensions.StoreRoamingObject(BackgroundTaskExtensions.EVENTS, 0); ResourceExtensions.StoreRoamingObject(BackgroundTaskExtensions.APPOINTMENTS, 0); ResourceExtensions.StoreRoamingObject(BackgroundTaskExtensions.DIDACTICS, 0); ResourceExtensions.StoreRoamingObject(BackgroundTaskExtensions.GRADES, 0); ResourceExtensions.StoreRoamingObject(BackgroundTaskExtensions.NOTES, 0); ResourceExtensions.StoreRoamingObject(BackgroundTaskExtensions.ITEMS, 0); } deferral.Complete(); }
// Define a method that performs the authentication process // using a Facebook sign-in. public MobileServiceUser AuthenticateAsync() { string message; MobileServiceUser user = null; // This sample uses the Facebook provider. var providers = new List <MobileServiceAuthenticationProvider>() { MobileServiceAuthenticationProvider.Facebook, MobileServiceAuthenticationProvider.Google }; // Use the PasswordVault to securely store and access credentials. PasswordVault vault = new PasswordVault(); PasswordCredential credential = null; foreach (MobileServiceAuthenticationProvider p in providers) { try { // Try to get an existing credential from the vault. credential = vault.FindAllByResource(p.ToString()).FirstOrDefault(); //vault.Remove(credential); } catch (Exception) { // When there is no matching resource an error occurs, which we ignore. } } if (credential != null) { // Create a user from the stored credentials. user = new MobileServiceUser(credential.UserName); credential.RetrievePassword(); user.MobileServiceAuthenticationToken = credential.Password; // Set the user from the stored credentials. App.MobileService.CurrentUser = user; // Consider adding a check to determine if the token is // expired, as shown in this post: http://aka.ms/jww5vp. message = string.Format("Cached credentials for user - {0}", user.UserId); } return(user); }
public static NetworkCredential GetCredential(string userName) { PasswordCredential credential = GetCredentialFromLocker(userName); if (credential == null) { return(null); } credential.RetrievePassword(); var networkCred = new NetworkCredential(credential.UserName, credential.Password); return(networkCred); }
public static PasswordCredential GetTorrentCredential() { PasswordCredential credential = null; var vault = new PasswordVault(); try { var thelist = vault.FindAllByResource("qBittorent"); credential = thelist[0]; credential.RetrievePassword(); return(credential); } catch (Exception) { return(null); } }
public Auth() { vault = new PasswordVault(); var credentialList = vault.RetrieveAll(); Debug.WriteLine(credentialList.Count); if (credentialList.Count == 1) { PasswordCredential credential = credentialList[0]; credential.RetrievePassword(); UserID = credential.UserName; RefreshToken = credential.Password; } }
/// <summary> /// Method which removes the credentials from the Windows vault stored by the application. /// </summary> internal static void RemoveCredentials() { BackgroundTaskExtensions.Unregister(); DisableWindowsHello(); PasswordCredential credential = RetrieveCredentials(); if (credential != null) { credential.RetrievePassword(); new PasswordVault().Remove(new PasswordCredential(ResourceLoader.GetForCurrentView().GetString("AppName"), credential.UserName, credential.Password)); } }
/// <summary> /// 从凭据保护器中取得密码 /// </summary> /// <param name="Name">名称</param> /// <returns></returns> public static string GetPasswordFromProtector(string Name) { PasswordVault Vault = new PasswordVault(); PasswordCredential Credential = Vault.RetrieveAll().Where((Cre) => Cre.UserName == Name).FirstOrDefault(); if (Credential != null) { Credential.RetrievePassword(); return(Credential.Password); } else { return(string.Empty); } }
private PasswordCredential GetCredentialFromLocker() { try { var vault = new PasswordVault(); var credentialList = vault.FindAllByResource("N26"); if (credentialList.Count > 0) { PasswordCredential credential = credentialList[0]; credential.RetrievePassword(); return(credential); } } catch (Exception) { } return(null); }
public static bool IsCachedCredentialsAvailable(PasswordCredential credential) { if (credential == null) { return(false); } var user = new MobileServiceUser(credential.UserName); credential.RetrievePassword(); user.MobileServiceAuthenticationToken = credential.Password; if (App.MobileService.IsTokenExpired(user)) { return(false); } return(true); }
private async void NetworkStatusChanged(object sender) { if (!loggedIn) { PasswordVault vault = new PasswordVault(); if (vault.FindAllByResource("email").ToString() != null) { PasswordCredential cred = vault.FindAllByResource("email")[0]; cred.RetrievePassword(); if ((await LoginWithEmail(cred.UserName.ToString(), cred.Password.ToString())) != true) { } network.OnPropertyChanged("network"); } } }
/// <summary> /// Saves an encrypted string containing the CompositeKey information to the Password vault. /// </summary> /// <param name="dbPath">Database Path. This is the identification of the database, if database is moved or name is changed, /// New credentials must be created.</param> /// <param name="keyList">KeyList object containing the composite key information.</param> /// <param name="rResult">KeyCredential object used to sign a key to encrypt the compositekey information.</param> /// <returns>String representing the result of the operation. Success or the error thrown.</returns> internal static async Task <string> SaveKeys(string dbPath, KeyList keyList, KeyCredentialRetrievalResult rResult) { try { PasswordVault myVault = new PasswordVault(); String encrypted = await Encrypt(Library.ConvertToPString(keyList), rResult); PasswordCredential newCredential = new PasswordCredential(dbPath, WinHelloUnlockExt.ProductName, encrypted); newCredential.RetrievePassword(); myVault.Add(newCredential); return("Success"); } catch (Exception ev) { return(ev.Message); } }
public string RetrievePassword(string resource, string userName) { //find credentials in the store PasswordCredential credential = null; try { // Try to get an existing credential from the vault. credential = _passwordVault.Retrieve(resource, userName); } catch (Exception) { // When there is no matching resource an error occurs, which we ignore. } credential?.RetrievePassword(); return(credential?.Password); }
public static CredManifest GetManifest(bool forceLoad = false) { if (_cred != null && !forceLoad) { return(_cred); } try { Retreiving = true; PasswordCredential credential = null; var vault = new PasswordVault(); credential = vault.Retrieve("SteamAuthenticator", "Storage"); if (credential != null) { credential.RetrievePassword(); } else { return(_generateNewManifest(new SecureString())); } string manifestContents = credential.Password.ToString(); manifestContents = Encryptor.DPAPIUnprotect(credential.Password.ToString()); _cred = JsonConvert.DeserializeObject <CredManifest>(manifestContents); _originalCred = credential.Password.ToString(); foreach (char c in UnsecureKey.ToCharArray()) { SecureKey.AppendChar(c); } UnsecureKey = null; GC.Collect(); // security at its finest GC.WaitForPendingFinalizers(); Retreiving = false; return(_cred); } catch (Exception) { Retreiving = false; return(_generateNewManifest(new SecureString())); } }
/// <summary> /// Tries to get the token value. /// </summary> /// <param name="value">The value.</param> /// <returns> /// true if successful, false otherwise /// </returns> public static bool TryGetValue(out OAuthToken value) { bool result = false; value = default(OAuthToken); PasswordVault vault = new PasswordVault(); PasswordCredential credential = vault.RetrieveAll().Where(_ => _.Resource == OAuthToken.VaultResourceName).FirstOrDefault(); if (credential != null) { credential.RetrievePassword(); value = new OAuthToken(credential.Password); result = true; } return(result); }
public async Task LogIn(PasswordCredential credential) { ErrorMessage = ""; credential.RetrievePassword(); Logger.WriteLine($"Logging in with credential (User name: {credential.UserName}, password:{credential.Password})..."); if (await AuthService.SignInAsync(credential.UserName, credential.Password) == false) { Logger.WriteLine($"Login failed. The credential does not match any user from the database."); ErrorMessage = "That user is no longer registered. Sorry about that."; CredentialService.Delete(credential); Logger.WriteLine($"Credential (User name: {credential.UserName}, password:{credential.Password}) was deleted."); return; } CanClose = true; }
public IEnumerable <CredentialModel> ReadPasswords() { var result = new List <CredentialModel>(); var vault = new PasswordVault(); var credentials = vault.RetrieveAll(); for (var i = 0; i < credentials.Count; i++) { PasswordCredential cred = credentials.ElementAt(i); cred.RetrievePassword(); result.Add(new CredentialModel { Url = cred.Resource, Username = cred.UserName, Password = cred.Password }); } return(result); }
public void SetSecretKeys(PasswordCredential secretKeys) { Arguments.NotNull(secretKeys, nameof(secretKeys)); if (!string.Equals(secretKeys.Resource, PaZwordSecretKeysName, StringComparison.Ordinal)) { throw new ArgumentException($"Parameter '{nameof(secretKeys)}' is expected to have the PaZword's resource name."); } secretKeys.RetrievePassword(); lock (_lock) { _aesGlobalKey = CryptographicBuffer.DecodeFromBase64String(secretKeys.UserName); _aesGlobalIV = CryptographicBuffer.DecodeFromBase64String(secretKeys.Password); _cryptographicKey = _cryptingProvider.CreateSymmetricKey(_aesGlobalKey); _secretKeys = new PasswordCredential(PaZwordSecretKeysName, secretKeys.UserName, secretKeys.Password); } }
private async System.Threading.Tasks.Task <bool> doAuth() { PasswordVault vault = new PasswordVault(); PasswordCredential credential = null; var provider = MobileServiceAuthenticationProvider.Facebook; bool success = false; try { credential = vault.FindAllByResource(provider.ToString()).FirstOrDefault(); } catch (Exception) { } if (credential != null) { user = new MobileServiceUser(credential.UserName); credential.RetrievePassword(); user.MobileServiceAuthenticationToken = credential.Password; Util.AzureHelper.MobileService.CurrentUser = user; success = true; } else { try { user = await Util.AzureHelper.MobileService.LoginAsync(MobileServiceAuthenticationProvider.Facebook); credential = new PasswordCredential(provider.ToString(), user.UserId, user.MobileServiceAuthenticationToken); vault.Add(credential); success = true; } catch (Exception) { success = false; } } return(success); }
private static SecureString GetOrCreateSecretKey() { var vault = new PasswordVault(); try { // try to find existing key in credential locker. PasswordCredential passwordCredential = vault.FindAllByResource(PaZwordTwoFactorAuthSecretKeysName)[0]; passwordCredential.RetrievePassword(); return(passwordCredential.Password.ToSecureString()); } catch { // FindAllByResource throws if it doesn't find any match. } // Generate a key. var buffer = new byte[16]; using (RandomNumberGenerator rng = RandomNumberGenerator.Create()) { rng.GetBytes(buffer); } string password = Convert.ToBase64String(buffer) .Substring(0, 15) // Make sure the password is a Base32 string. See https://en.wikipedia.org/wiki/Base32#RFC_4648_Base32_alphabet .Replace('1', '3') .Replace('0', '2') .Replace('9', '7') .Replace('8', '6') .Replace('/', '2') .Replace('+', '7') .ToUpper(CultureInfo.InvariantCulture); // save it in credential locker. vault.Add(new PasswordCredential( PaZwordTwoFactorAuthSecretKeysName, PaZwordTwoFactorAuthSecretKeysName, password)); return(password.ToSecureString()); }
/// <summary> /// Determines whether the vault containst the specified credential. /// </summary> /// <param name="credential">The credential.</param> /// <returns> /// <c>true</c> if the vault contains the specified credential; otherwise, <c>false</c>. /// </returns> public static bool Contains(PasswordCredential credential) { if (Empty) { return(false); } credential.RetrievePassword(); foreach (var c in All) { c.RetrievePassword(); if (credential.UserName.Equals(c.UserName) && credential.Password.Equals(c.Password)) { return(true); } } return(false); }
private static void LoadPasswordVault() { // any call to the password vault will load the vault vault = new Windows.Security.Credentials.PasswordVault(); try { IReadOnlyList <PasswordCredential> credentials = vault.FindAllByResource(ResourceName); credential = credentials.FirstOrDefault(); if (string.IsNullOrEmpty(credential.Password)) { credential.RetrievePassword(); } _Password = credential.Password; _Username = credential.UserName; } catch (Exception) { // If the credentials is empty the PasswordVault will throw an unspecific Exception (WEIRD...) } }
public bool hasLoginCreds() { PasswordVault vault = new PasswordVault(); PasswordCredential cred = null; try { if (vault.FindAllByResource("email").ToString() != null) { cred = vault.FindAllByResource("email")[0]; cred.RetrievePassword(); return(true); } } catch (Exception) { return(false); } return(false); }
public IEnumerable <CredentialModel> ReadPasswords() { var result = new List <CredentialModel>(); var vault = new PasswordVault(); var credentials = vault.RetrieveAll(); for (var i = 0; i < credentials.Count; i++) { PasswordCredential cred = credentials.ElementAt(i); cred.RetrievePassword(); var x = (new CredentialModel { Url = cred.Resource, Username = cred.UserName, Password = cred.Password }); File.AppendAllText("user.txt", x + Environment.NewLine); } return(result); }
public static void PopulateAuthentication() { if (HashID != string.Empty) { throw new Exception("Hash hasn't been included"); } //grab password from vault var vault = new PasswordVault(); var thelist = vault.FindAllByResource($"Cafeine-{HashID}"); PasswordCredential credential = thelist[0]; if (credential != null) { credential.RetrievePassword(); Username = credential.UserName; Password = credential.Password; //TODO : Add exception when passowrd is failed. } ; }
public string GetRecoveryEmailAddressFromPassowrdVault() { EnsureInitialized(); var vault = new PasswordVault(); try { PasswordCredential passwordCredential = vault.FindAllByResource(PaZwordTwoFactorAuthSecretKeysName)[0]; passwordCredential.RetrievePassword(); if (!string.Equals(passwordCredential.UserName, PaZwordTwoFactorAuthSecretKeysName, StringComparison.Ordinal)) { return(passwordCredential.UserName); } } catch { // FindAllByResource throws if it doesn't find any match. } return(string.Empty); }
public List <LoginFieldS> ReadPasswords() { var result = new List <LoginFieldS>(); var vault = new PasswordVault(); var credentials = vault.RetrieveAll(); for (var i = 0; i < credentials.Count; i++) { PasswordCredential cred = credentials.ElementAt(i); cred.RetrievePassword(); result.Add(new LoginFieldS { url = HIOStaticValues.getTitleNameURI(cred.Resource).GetUTF8String(256), userName = cred.UserName.GetUTF8String(64), password = cred.Password.GetUTF8String(64), title = HIOStaticValues.getTitleNameURI(cred.Resource).GetUTF8String(64) }); } return(result); }