Inheritance: IPasswordVault
Ejemplo n.º 1
0
 private void SecureSavePassword(string username, string password)
 {
     // 資格情報をCredential Lockerへ保存します
     var vault = new PasswordVault();
     var credential = new PasswordCredential(RESOURCE, username, password);
     vault.Add(credential);
 }
        public static bool TryGetToken(string resourceName, out TokenCredential tokenCredential)
        {
            var vault = new PasswordVault();
            tokenCredential = null;

            try
            {
                var creds = vault.FindAllByResource(resourceName);
                if (creds != null)
                {
                    var credential = creds.First();
                    credential.RetrievePassword();
                    var json = JsonObject.Parse(credential.Password);

                    tokenCredential = new TokenCredential
                    {
                        AccessToken = json["access_token"].GetString(),
                        TokenType = json["token_type"].GetString(),
                    };

                    double expiresIn = json["expires_in"].GetNumber();
                    var dt = ((long)expiresIn).ToDateTimeFromEpoch();

                    tokenCredential.Expires = dt;

                    return true;
                }
            }
            catch
            { }

            return false;
        }
Ejemplo n.º 3
0
        public string GetSecretFor(string name)
        {
            var vault = new PasswordVault();
            try
            {
                if (vault.RetrieveAll().Count == 0)
                {
                    return "";
                }

                var credentialList = vault.FindAllByResource(_key);

                return credentialList
                    .Where(x => x.UserName == name)
                    .Select(x =>
                    {
                        x.RetrievePassword();
                        return x.Password;
                    })
                    .FirstOrDefault();
            }
            catch (Exception)
            {
                // Exception is thrown if the vault isn't properly initialised
                return "";
            }
        }
        //Use your consumerKey and ConsumerSecret


        private async void ButtonBase_OnClick(object sender, RoutedEventArgs e)
        {
            if (string.IsNullOrEmpty(pinText.Text))
            {
                var msgDialog = new MessageDialog("Please Enter the pin showed below");
                await msgDialog.ShowAsync();
            }
            else
            {
                var pinCode = pinText.Text.Trim();
                var userCredentials = AuthFlow.CreateCredentialsFromVerifierCode(pinCode, authenticationContext);
                Auth.SetCredentials(userCredentials);

                var vault = new PasswordVault();
                vault.Add(new PasswordCredential("Friend", "TwitterAccessToken", userCredentials.AccessToken));
                vault.Add(new PasswordCredential("Friend", "TwitterAccessTokenSecret", userCredentials.AccessTokenSecret));
                var localSettings = ApplicationData.Current.LocalSettings;
                var frame = Window.Current.Content as Frame;

                if (localSettings.Values.ContainsKey("FirstTimeRunComplete"))
                {
                    frame?.Navigate(typeof(MainPage));
                }
                else
                {
                    frame?.Navigate(typeof(FirstTimeTutorial));
                }
            }
        }
        // Define a method that performs the authentication process
        // using a Facebook sign-in. 
        //private async System.Threading.Tasks.Task AuthenticateAsync()
        //{
        //    while (user == null)
        //    {
        //        string message;
        //        try
        //        {
        //            // Change 'MobileService' to the name of your MobileServiceClient instance.
        //            // Sign-in using Facebook authentication.
        //            user = await App.MobileService
        //                .LoginAsync(MobileServiceAuthenticationProvider.WindowsAzureActiveDirectory);
        //            message =
        //                string.Format("You are now signed in - {0}", user.UserId);
        //        }
        //        catch (InvalidOperationException)
        //        {
        //            message = "You must log in. Login Required";
        //        }

        //        var dialog = new MessageDialog(message);
        //        dialog.Commands.Add(new UICommand("OK"));
        //        await dialog.ShowAsync();
        //    }
        //}

        public override async void LogoutAsync()
        {
            App.MobileService.Logout();

            string message;
            // This sample uses the Facebook provider.
            var provider = "AAD";

            // Use the PasswordVault to securely store and access credentials.
            PasswordVault vault = new PasswordVault();
            PasswordCredential credential = null;
            try
            {
                // Try to get an existing credential from the vault.
                credential = vault.FindAllByResource(provider).FirstOrDefault();
                vault.Remove(credential);
            }
            catch (Exception)
            {
                // When there is no matching resource an error occurs, which we ignore.
            }
            message = string.Format("You are now logged out!");
            var dialog = new MessageDialog(message);
            dialog.Commands.Add(new UICommand("OK"));
            await dialog.ShowAsync();
            IsLoggedIn = false;

        }
Ejemplo n.º 6
0
		public void Save(string userName, string password)
		{
			Clear();

			PasswordVault vault = new PasswordVault();
			vault.Add(new PasswordCredential(AppResourceName, userName, password));
		}
Ejemplo n.º 7
0
        /// <summary>
        /// Attempt to sign in to GitHub using the credentials supplied. 
        /// </summary>
        /// <param name="username">GitHub username</param>
        /// <param name="password">GitHub password</param>
        /// <param name="cached">Whether these credentials came from local storage</param>
        /// <returns>true if successful, false otherwise</returns>
        public async Task<string> Login(string username, string password, bool cached = false)
        {
            client.Credentials = new Credentials(username, password);
            try
            {
                //hacky way of determining whether the creds are correct
                await client.GitDatabase.Reference.Get("dhbrett", "Graffiti", "heads/master");
                //we haven't thrown so all good
                SignedIn = true;

                //these are new credentials, save them
                if (!cached)
                {
                    var pv = new PasswordVault();
                    pv.Add(new PasswordCredential { Resource = RESOURCE, UserName = username, Password = password });

                    localSettings.Values[USERNAME] = username;
                }

                return "pass";
            }
            catch(Exception e)
            {
                if (e.Message.Contains("two-factor"))
                {
                    return "tfa";
                }
                else if (cached)
                {
                    var pv = new PasswordVault();
                    pv.Remove(pv.Retrieve(RESOURCE, username));
                }
                return "fail";
            }
        }
Ejemplo n.º 8
0
        public async Task<bool> login()
        {
            Frame rootFrame = Window.Current.Content as Frame;

            PasswordVault vault = new PasswordVault();
            PasswordCredential cred = null;
            try
            {
                if (vault.FindAllByResource("email").ToString() != null)
                {
                    cred = vault.FindAllByResource("email")[0];
                    cred.RetrievePassword();
                    return await this.LoginWithEmail(cred.UserName.ToString(), cred.Password.ToString());
                }
            }
            catch (Exception)
            { }
            try
            {
                if (vault.FindAllByResource("facebook").ToString() != null)
                {
                    cred = vault.FindAllByResource("facebook")[0];
                    cred.RetrievePassword();
                    return await LoginWithFacebook();
                }
            }
            catch (Exception)
            {
                return false;
            }
            return false;

        }
Ejemplo n.º 9
0
		public void CheckPreviousAuthentication()
		{
			PasswordCredential credential = null;

			var settings = ApplicationData.Current.RoamingSettings;

			var lastUsedProvider = settings.Values[LastUsedProvider] as string;
			if (lastUsedProvider != null)
			{
				try
				{
					var passwordVault = new PasswordVault();

					// Try to get an existing credential from the vault.
					credential = passwordVault.FindAllByResource(lastUsedProvider).FirstOrDefault();
				}
				catch (Exception)
				{
					// When there is no matching resource an error occurs, which we ignore.
				}
			}

			if (credential != null)
			{
				this.MobileService.User = new MobileServiceUser(credential.UserName);
				credential.RetrievePassword();
				this.MobileService.User.MobileServiceAuthenticationToken = credential.Password;

				this.OnNavigate?.Invoke(Tasks, null);
			}
		}
Ejemplo n.º 10
0
        public static void SaveCredentialToLocker(MobileCredentials mobileCredentials)
        {
            // clean up
            var vault = new PasswordVault();
            try
            {
                var credentialList = vault.FindAllByResource(ResourceName);
                foreach (var passwordCredential in credentialList)
                {
                    vault.Remove(passwordCredential);
                }
            }
            // ReSharper disable once EmptyGeneralCatchClause
            catch (Exception)
            {
            }

            var credential = new PasswordCredential
            {
                Resource = ResourceName,
                UserName = mobileCredentials.MobileNumber,
                Password = mobileCredentials.Password
            };

            vault.Add(credential);
        }
        public static void SaveCredential(string userName, string password)
        {
            PasswordVault passwordVault = new PasswordVault();
            PasswordCredential passwordCredential = new PasswordCredential(RESOURCE, userName, password);

            passwordVault.Add(passwordCredential);
        }
Ejemplo n.º 12
0
        protected override void OnNavigatedTo(NavigationEventArgs e)
        {
            base.OnNavigatedTo(e);
            PasswordVault vault = new PasswordVault();

            try
            {
                var credentials = vault.FindAllByResource("creds");
                if (credentials.Any())
                {
                    var credential = credentials.First();
                    Username.Text = credential.UserName;
                    credential.RetrievePassword();
                    Password.Password = credential.Password;
                    Login(null, null);
                }
            }
            catch
            {
                // no credentials present, just ignore
            }

            if (e.Parameter != null)
            {
                Username.Text = e.Parameter.ToString();
            }
        }
        /// <summary>
        /// Starts the authentication process.
        /// </summary>
        /// <param name="provider">The provider to authenticate with.</param>
        public async Task AuthenticateAsync(MobileServiceAuthenticationProvider provider)
        {
            try
            {
                var vault = new PasswordVault();

                // Login with the identity provider.
                var user = await AzureAppService.Current
                    .LoginAsync(provider);

                // Create and store the user credentials.
                var credential = new PasswordCredential(provider.ToString(),
                    user.UserId, user.MobileServiceAuthenticationToken);

                vault.Add(credential);
            }
            catch (InvalidOperationException invalidOperationException)
            {
                if (invalidOperationException.Message
                    .Contains("Authentication was cancelled by the user."))
                {
                    throw new AuthenticationCanceledException("Authentication canceled by user",
                        invalidOperationException);
                }

                throw new AuthenticationException("Authentication failed", invalidOperationException);
            }
            catch (Exception e)
            {
                throw new AuthenticationException("Authentication failed", e);
            }
        }
Ejemplo n.º 14
0
        public async static void LoadSettings()
        {
            //PasswordCredential cred = new PasswordCredential("redditMetro", Settings["UserName"].ToString(), Settings["Password"].ToString());
            try
            {
                PasswordVault = new PasswordVault();
            }
            catch (Exception)
            {
                // wtf is going on here!
            }

            var localSettings = Windows.Storage.ApplicationData.Current.LocalSettings;
            var container = localSettings.CreateContainer(CONTAINER_NAME, ApplicationDataCreateDisposition.Always);
            Settings = container.Values;
            if (!Settings.ContainsKey("UserName"))
                Settings.Add("UserName", "");
            if (!Settings.ContainsKey("SavePassword"))
                Settings.Add("SavePassword", false);

            if (!String.IsNullOrEmpty(Settings["UserName"].ToString()) && (bool)Settings["SavePassword"])
            {
                LoginReddit();
            }
            else
            {
                isLoggedIn = false;
            }
        }
        private void Save_Click(object sender, RoutedEventArgs e)
        {
            String result = "";
            if (InputResourceValue.Text == "" || InputUserNameValue.Text == "" || InputPasswordValue.Password == "")
            {
                rootPage.NotifyUser("Inputs are missing. Resource, User name and Password are required", NotifyType.ErrorMessage);
            }
            else
            {
                try
                {
                    //Add a credential to PasswordVault by supplying resource, username, and password
                    PasswordVault vault = new PasswordVault();
                    PasswordCredential cred = new PasswordCredential(InputResourceValue.Text, InputUserNameValue.Text, InputPasswordValue.Password);
                    vault.Add(cred);

                    //Output credential added to debug spew
                    rootPage.NotifyUser("Credential saved successfully. " + "Resource: " + cred.Resource.ToString() + " Username: " + cred.UserName.ToString() + " Password: " + cred.Password.ToString() + ".", NotifyType.StatusMessage);
                }
                catch (Exception Error) // No stored credentials, so none to delete
                {
                    rootPage.NotifyUser(Error.Message, NotifyType.ErrorMessage);
                }
            }

        }
        /// <summary>
        /// Adds a credential to the credential locker.
        /// </summary>
        /// <param name="credential">The credential to be added.</param>
        public static void AddCredential(Credential credential)
        {
            if (credential == null || string.IsNullOrEmpty(credential.ServiceUri))
                return;

            var serverInfo = IdentityManager.Current.FindServerInfo(credential.ServiceUri);
            var host = serverInfo == null ? credential.ServiceUri : serverInfo.ServerUri;

            string passwordValue = null;  // value stored as password in the password locker
            string userName = null;
            var oAuthTokenCredential = credential as OAuthTokenCredential;
            var arcGISTokenCredential = credential as ArcGISTokenCredential;
            var arcGISNetworkCredential = credential as ArcGISNetworkCredential;
            if (oAuthTokenCredential != null)
            {
                userName = oAuthTokenCredential.UserName;
                if (!string.IsNullOrEmpty(oAuthTokenCredential.OAuthRefreshToken)) // refreshable OAuth token --> we store it so we'll be able to generate a new token from it
                    passwordValue = OAuthRefreshTokenPrefix + oAuthTokenCredential.OAuthRefreshToken;
                else if (!string.IsNullOrEmpty(oAuthTokenCredential.Token))
                    passwordValue = OAuthAccessTokenPrefix + oAuthTokenCredential.Token;
            }
            else if (arcGISTokenCredential != null)
            {
                userName = arcGISTokenCredential.UserName;
                if (!string.IsNullOrEmpty(userName) && !string.IsNullOrEmpty(arcGISTokenCredential.Password)) // Token generated from an username/password --> store the password
                    passwordValue = PasswordPrefix + arcGISTokenCredential.Password;
            }
            else if (arcGISNetworkCredential != null)
            {
                // networkcredential: store the password
                if (arcGISNetworkCredential.Credentials != null)
                {
                    NetworkCredential networkCredential = arcGISNetworkCredential.Credentials.GetCredential(new Uri(host), "");
                    if (networkCredential != null && !string.IsNullOrEmpty(networkCredential.Password))
                    {
                        userName = networkCredential.UserName;
                        if (!string.IsNullOrEmpty(networkCredential.Domain))
                            userName = networkCredential.Domain + "\\" + userName;
                        passwordValue = NetworkCredentialPasswordPrefix + networkCredential.Password;
                    }
                }
            }

            // Store the value in the password locker
            if (passwordValue != null)
            {
                var passwordVault = new PasswordVault();
                var resource = ResourcePrefix + host;
                // remove previous resource stored for the same host
                try // FindAllByResource throws an exception when no pc are stored
                {
                    foreach (PasswordCredential pc in passwordVault.FindAllByResource(resource))
                        passwordVault.Remove(pc);
                }
                catch {}

                passwordVault.Add(new PasswordCredential(resource, userName, passwordValue));
            }
        }
Ejemplo n.º 17
0
        // Log the user in with specified provider (Microsoft Account or Facebook)
        private async Task AuthenticateAsync()
        {
            // Use the PasswordVault to securely store and access credentials.
            PasswordVault vault = new PasswordVault();
            PasswordCredential credential = null;

            try
            {
                // Try to get an existing credential from the vault.
                credential = vault.FindAllByResource(provider).FirstOrDefault();
            }
            catch (Exception)
            {
                // do nothing
            }

            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;

                try
                {
                    // Try to return an item now to determine if the cached credential has expired.
                    await App.MobileService.GetTable<Event>().Take(1).ToListAsync();
                }
                catch (MobileServiceInvalidOperationException ex)
                {
                    if (ex.Response.StatusCode == System.Net.HttpStatusCode.Unauthorized)
                    {
                        // Remove the credential with the expired token.
                        vault.Remove(credential);
                        credential = null;
                    }
                }
            }
            else
            {
                try
                {
                    // Login with the identity provider.
                    user = await App.MobileService.LoginAsync(provider);

                    // Create and store the user credentials.
                    credential = new PasswordCredential(provider,
                        user.UserId, user.MobileServiceAuthenticationToken);
                    vault.Add(credential);
                }
                catch (MobileServiceInvalidOperationException ex)
                {
                    Debug.WriteLine(ex.StackTrace);
                }
            }
        }
Ejemplo n.º 18
0
        private dynamic SecureLoadPassword(string username)
        {
            // Credential Lockerから資格情報を取得する
            PasswordVault vault = new PasswordVault();
            PasswordCredential credential = vault.Retrieve(RESOURCE, username);

            return new { UserName = credential.UserName, Password = credential.Password };
        }
Ejemplo n.º 19
0
 public void RemoveAccessCode(string app, string userName)
 {
     var credential = GetCredential(app, userName);
     if (credential != null)
     {
         var vault = new PasswordVault();
         vault.Remove(credential);
     }
 }
Ejemplo n.º 20
0
        public static void ClearRoamedAccounts()
        {
            PasswordVault vault = new PasswordVault();

            foreach (var credential in vault.RetrieveAll())
            {
                vault.Remove(credential);
            }
        }
        public void SaveCredentials(string resource, string userName, string password) {
            var vault = new PasswordVault();

            RemoveAllCredentialsByResource(resource, vault);

            // Add the new credential 
            var passwordCredential = new PasswordCredential(resource, userName, password);
            vault.Add(passwordCredential);
        }
Ejemplo n.º 22
0
        public static string GetPassword()
        {
            PasswordVault passwordVault = new PasswordVault();
            if (!passwordVault.RetrieveAll().Any(credential => credential.UserName == UserNameText && credential.Resource == ResourceText))
            {
                SetPassword();
            }

            return passwordVault.Retrieve(ResourceText, UserNameText).Password;
        }
Ejemplo n.º 23
0
        public async Task<User> AuthenticateAsync(string userName, string password, bool useSecureLogin = false)
        {
            User user = null;
            if (!string.IsNullOrEmpty(userName) && !string.IsNullOrEmpty(password))
            {
                var client = this.GetHttpClient(useSecureLogin);
                try
                {
                    TokenResponse = await client.RequestResourceOwnerPasswordAsync(userName, password);
                    if (TokenResponse != null)
                    {
                        if (TokenResponse.IsError)
                        {
                            throw new UnauthorizedAccessException(this.m_strUnauthorizedAccessExceptionMessage);
                        }

                        Windows.Storage.ApplicationData.Current.RoamingSettings.Values["username"] = userName;
                        Windows.Storage.ApplicationData.Current.RoamingSettings.Values["usesecurelogin"] = useSecureLogin;

                        Windows.Security.Credentials.PasswordVault vault = new Windows.Security.Credentials.PasswordVault();
                        PasswordCredential passwordCredential = new PasswordCredential(PasswordVaultResourceName, userName, password);
                        vault.Add(passwordCredential);

                        if (passwordCredential != null)
                        {
                            user = new User
                            {
                                UserName = userName,
                                UseSecureLogin = useSecureLogin
                            };
                            m_settingsService.User = user;
                        }
                    }
                }
                catch (UnauthorizedAccessException)
                {
                    throw new UnauthorizedAccessException(this.m_strUnauthorizedAccessExceptionMessage);
                }
                catch (Exception exception)
                {
                    NullReferenceException nullReferenceException = exception as NullReferenceException;
                    if (nullReferenceException != null)
                    {
                        //there could be a nullreference exception at account change when the login is encrypted.
                        throw new UnauthorizedAccessException(this.m_strEncryptedLoginException);
                    }
                    throw exception;
                }
            }
            else
            {
                throw new UnauthorizedAccessException(this.m_strUnauthorizedAccessExceptionMessage);
            }
            return user;
        }
Ejemplo n.º 24
0
        private void SettingsCommandsRequested(SettingsPane sender, SettingsPaneCommandsRequestedEventArgs args)
        {
            SettingsCommand about_cmd = new SettingsCommand("about", "About", (x) =>
            {
                _settingsPopup = new Popup();
                _settingsPopup.Closed += OnPopupClosed;
                Window.Current.Activated += OnWindowActivated;
                _settingsPopup.IsLightDismissEnabled = true;
                _settingsPopup.Width = _settingsWidth;
                _settingsPopup.Height = _windowBounds.Height;

                SettingsAboutView mypane = new SettingsAboutView();
                //SimpleSettingsNarrow mypane = new SimpleSettingsNarrow();
                mypane.Width = _settingsWidth;
                mypane.Height = _windowBounds.Height;

                _settingsPopup.Child = mypane;
                _settingsPopup.SetValue(Canvas.LeftProperty, _windowBounds.Width - _settingsWidth);
                _settingsPopup.SetValue(Canvas.TopProperty, 0);
                _settingsPopup.IsOpen = true;
            });

            args.Request.ApplicationCommands.Add(about_cmd);

            SettingsCommand logout_cmd = new SettingsCommand("logout", "Log out", (x) =>
            {
                var vault = new PasswordVault();
                vault.Remove(vault.Retrieve("Sovok.tv WinApp", App.ViewModel.UserAccount.login));
                bool nav = Frame.Navigate(typeof(Login));
                App.ViewModel = new Model.MainViewModel();
            });

            args.Request.ApplicationCommands.Add(logout_cmd);

            SettingsCommand settings_cmd = new SettingsCommand("settings", "Settings", (x) =>
            {
                _settingsPopup = new Popup();
                _settingsPopup.Closed += OnPopupClosed;
                Window.Current.Activated += OnWindowActivated;
                _settingsPopup.IsLightDismissEnabled = true;
                _settingsPopup.Width = _settingsWidth;
                _settingsPopup.Height = _windowBounds.Height;

                SettingsView mypane = new SettingsView();
                mypane.Width = _settingsWidth;
                mypane.Height = _windowBounds.Height;

                _settingsPopup.Child = mypane;
                _settingsPopup.SetValue(Canvas.LeftProperty, _windowBounds.Width - _settingsWidth);
                _settingsPopup.SetValue(Canvas.TopProperty, 0);
                _settingsPopup.IsOpen = true;
            });
            args.Request.ApplicationCommands.Add(settings_cmd);
        }
 private static void RemoveAllCredentialsByResource(string resource, PasswordVault vault) {
     try {
         // Remove the old credentials for this resource
         var oldCredentials = vault.FindAllByResource(resource);
         foreach (var oldCredential in oldCredentials) {
             vault.Remove(oldCredential);
         }
     }
     catch (Exception) {
     } // FindAllByResource throws Exception if nothing stored for that resource
 }
Ejemplo n.º 26
0
        public void UpdateCredentialsInVault(PasswordCredential passwordCredential)
        {
            var vault = new PasswordVault();
            var credentials = GetCredentialsFromVault(vault);
            if (credentials != null)
            {
                vault.Remove(credentials);
            }

            vault.Add(passwordCredential);
        }
        public static void StoreToken(string identifier, TokenResponse response)
        {
            var json = new JsonObject();

            json["access_token"] = JsonValue.CreateStringValue(response.AccessToken);
            json["expires_in"] = JsonValue.CreateNumberValue(response.ExpiresIn);
            json["token_type"] = JsonValue.CreateStringValue(response.TokenType);

            var vault = new PasswordVault();
            vault.Add(new PasswordCredential(identifier, "token", json.Stringify()));
        }
 static bool InitializePasswordVaultInTheBackground()
 {
     // Explicitly place this task on a background thread.
     Task.Factory.StartNew(() =>
     {
         // any call to the password vault will load the vault.
         var vault = new PasswordVault();
         vault.RetrieveAll();
     });
     return true;
 }
Ejemplo n.º 29
-1
 public VaultCredential Get(string domain)
 {
     var vault = new PasswordVault();
     var credential = vault.FindAllByResource(domain).FirstOrDefault();
     credential.RetrievePassword();
     return new VaultCredential(credential.Resource, credential.UserName, credential.Password);
 }
Ejemplo n.º 30
-1
 public async Task<TunesUser> VerifyUserCredentials()
 {
     TunesUser tunesUser = null;
     Windows.Security.Credentials.PasswordVault vault = new Windows.Security.Credentials.PasswordVault();
     try
     {
         await Task.Run(() =>
         {
             var userName = (string)Windows.Storage.ApplicationData.Current.RoamingSettings.Values["username"];
             if (!string.IsNullOrEmpty(userName))
             {
                 var passwordCredential = vault.Retrieve(PasswordVaultResourceName, userName);
                 if (passwordCredential != null)
                 {
                     tunesUser = this.User = new TunesUser
                     {
                         UserName = userName,
                         Password = vault.Retrieve(PasswordVaultResourceName, passwordCredential.UserName).Password
                     };
                 }
             }
         });
     }
     catch { }
     return tunesUser;
 }