public void SaveCookies() { if (_account != null) { _accountStore.Save(_account, ServiceId); } }
/// <summary> /// Adds a credential to the Credential Locker. /// </summary> /// <param name="resource">The resource for which the credentials are used.</param> /// <param name="userName">The user name that must be present in the credentials.</param> /// <param name="password">The password for the created credentials.</param> /// <exception cref="ArgumentNullException">Dispatched when <paramref name="resource"/>, <paramref name="userName"/> or /// <paramref name="password"/> is <c>Null</c> /// </exception> public bool CreateAccount(string resource, string userName, string password) { if (string.IsNullOrEmpty(resource)) { throw new ArgumentNullException(nameof(resource), "The argument is null"); } if (string.IsNullOrEmpty(userName)) { throw new ArgumentNullException(nameof(userName), "The argument is null"); } if (string.IsNullOrEmpty(password)) { throw new ArgumentNullException(nameof(password), "The argument is null"); } try { account = new Account { Username = userName }; account.Properties.Add(resource, password); vault.Save(account, AppName); var lista = vault.FindAccountsForService(AppName); return(true); } catch (Exception e) { return(false); } }
async void RefreshButtonClicked(object sender, EventArgs e) { var refreshToken = account.Properties["refresh_token"]; if (string.IsNullOrWhiteSpace(refreshToken)) { return; } var queryValues = new Dictionary <string, string> { { "refresh_token", refreshToken }, { "client_id", ServerInfo.ClientId }, { "grant_type", "refresh_token" }, { "client_secret", ServerInfo.ClientSecret }, }; var authenticator = new OAuth2Authenticator ( ServerInfo.ClientId, ServerInfo.ClientSecret, "profile", ServerInfo.AuthorizationEndpoint, ServerInfo.RedirectionEndpoint, ServerInfo.TokenEndpoint, null, isUsingNativeUI: true ); try { var result = await authenticator.RequestAccessTokenAsync(queryValues); if (result.ContainsKey("access_token")) { account.Properties["access_token"] = result["access_token"]; } if (result.ContainsKey("refresh_token")) { account.Properties["refresh_token"] = result["refresh_token"]; } store.Save(account, ServiceId); statusText.Text = "Refresh succeeded"; } catch (Exception ex) { statusText.Text = "Refresh failed " + ex.Message; } return; }
public bool Save(string keyString, string valueString) { try { _account.Properties?.Add(keyString, valueString); _accountStore.Save(_account, _serviceIdstring); return(true); } catch (AccountStoreException exception) { Console.WriteLine(exception.StackTrace); return(false); } }
public bool LoginToAccount(string username, string password) { if (string.IsNullOrEmpty(username) || string.IsNullOrEmpty(password)) { return(false); } AccountStore store = AccountStore.Create(); Account account = GetAccountFromStore(AccountStore.Create(), username); if (account == null) { return(false); } byte[] salt, hashedPassword; // Upgrade existing passwords to our new format. if (!account.Properties.ContainsKey(saltKey)) { salt = CryptoUtilities.Get256BitSalt(); hashedPassword = CryptoUtilities.GetKeyDerivation(CryptoUtilities.StringToByteArray(account.Properties[pwKey]), salt); account.Properties[pwKey] = Convert.ToBase64String(hashedPassword); account.Properties.Add(saltKey, Convert.ToBase64String(salt)); store.Save(account, serviceID); } salt = Convert.FromBase64String(account.Properties[saltKey]); hashedPassword = CryptoUtilities.GetKeyDerivation(CryptoUtilities.StringToByteArray(password), salt); return(account.Properties[pwKey] == Convert.ToBase64String(hashedPassword)); }
public void SaveAccount(Account account) { accountStore.Save(account, OAUTH_SERVICE_NAME); _Token = account.Properties ["access_token"]; // broadcast a message that authentication was successful MessagingCenter.Send <App> (this, "Authenticated"); }
void OnAuthCompleted(object sender, AuthenticatorCompletedEventArgs e) { var authenticator = sender as OAuth2Authenticator; if (authenticator != null) { authenticator.Completed -= OnAuthCompleted; authenticator.Error -= OnAuthError; } if (e.IsAuthenticated) { if (this.account != null) { store.Delete(this.account, ServiceId); } store.Save(account = e.Account, ServiceId); statusText.Text = "Authentication succeeded"; } else { statusText.Text = "Authentication failed"; } }
public void StoreTokenInSecureStore(MobileServiceUser user) { var account = new Account(user.UserId); account.Properties.Add("token", user.MobileServiceAuthenticationToken); AccountStore.Save(account, "tasklist"); }
/// <summary> /// Register new or save old account /// </summary> /// <param name="userName"></param> /// <param name="password"></param> public async Task <bool> SaveCredentials(string userName, string password, string email) { if (AreDetailsValid(userName, password)) { //Check if exist var account = await GetAccount(userName); if (account != null) { account.Properties["Password"] = password; account.Properties["Email"] = email; } else { account = new Account { Username = userName }; account.Properties.Add("Password", password); account.Properties.Add("Email", email); } store.Save(account, App.AppName); return(true); } return(false); }
public void saveToken(AuthToken token) { clearTokens(); var newAccount = new Account(); newAccount.Username = token.accessToken; if (token.expiresIn != null) { newAccount.Properties.Add("exires_in", token.expiresIn); } if (token.tokenType != null) { newAccount.Properties.Add("token_type", token.tokenType); } if (token.scope != null) { newAccount.Properties.Add("scope", token.scope); } if (token.refreshToken != null) { newAccount.Properties.Add("refresh_token", token.refreshToken); } store.Save(newAccount, context); }
private void StoreTokenInSecureStore(MobileServiceUser user) { var account = new Account(user.UserId); account.Properties.Add(AppUrlConsts.AppUserTokenKey, user.MobileServiceAuthenticationToken); _accountStore.Save(account, AppUrlConsts.AppServiceId); }
public bool CreateAndSaveAccount(string username, string password) { if (string.IsNullOrEmpty(username) || string.IsNullOrEmpty(password)) { return(false); } byte[] salt = CryptoUtilities.Get256BitSalt(); byte[] hashedPassword = CryptoUtilities.GetKeyDerivation(CryptoUtilities.StringToByteArray(password), salt); AccountStore store = AccountStore.Create(); if (GetAccountFromStore(store, username) != null) { return(false); } Account account = new Account(username); account.Properties.Add(pwKey, Convert.ToBase64String(hashedPassword)); account.Properties.Add(saltKey, Convert.ToBase64String(salt)); store.Save(account, serviceID); return(true); }
public void StoreTokenInSecureStore(RefreshTokenInfo user) { ClearSecureStore(); var account = new Account(user.UserId); account.Properties.Add("token", user.RefreshToken); account.Properties.Add("provider", user.Provider); _accountStore.Save(account, _serviceId); }
public void StoreTokenInSecureStore(string userId, string key, string token = "") { if (storeAccount == null) { storeAccount = AccountStore.Create(); } var account = new Account(userId); account.Properties.Add("token", token); storeAccount.Save(account, key); }
public void Save(long userId, string userName, string secret, AuthorizationType authorizationType, OrganizationLink organization) { var props = new Dictionary <string, string>(); props.Add("UserName", userName); props.Add("Secret", secret); props.Add("AuthorizationType", authorizationType.ToString()); props.Add("Organization", organization.ToJsonOrEmptyString()); props.Add("AvatarUrl", userId.ToString().AsAvatarUrl(organization.HostName)); _accountStore.Save(new Account(userId.ToString(), props), _applicationSettings.AppName); }
public void SaveCredentials(string userName, string password) { if (!string.IsNullOrWhiteSpace(userName) && !string.IsNullOrWhiteSpace(password)) { DeleteCredentials(); Account account = new Account { Username = userName }; account.Properties.Add("Password", password); _accountStore.Save(account, _AppName); } }
private void AccountStoreTests(AuthenticatorCompletedEventArgs ee) { AccountStore account_store = AccountStore.Create(); account_store.Save(ee.Account, provider); Account account1 = account_store.FindAccountsForService(provider).FirstOrDefault(); AccountStore.Create().Save(ee.Account, provider + ".v.2"); // throws on iOS // Account account2 = AccountStore.Create().FindAccountsForService(provider + ".v.2").FirstOrDefault(); return; }
protected override void OnElementChanged(ElementChangedEventArgs <Page> e) { base.OnElementChanged(e); // this is a ViewGroup - so should be able to load an AXML file and FindView<> var activity = this.Context as Activity; AccountStore store = AccountStore.Create(this.Context); try { OAuth2Authenticator auth = new OAuth2Authenticator( Constants.ClientId, // your OAuth2 client id Constants.Scope, // the scopes for the particular API you're accessing, delimited by "+" symbols new Uri(Constants.AuthorizeUrl), // the auth URL for the service new Uri(Constants.RedirectUrl)); // the redirect URL for the service auth.Completed += (sender, eventArgs) => { if (eventArgs.IsAuthenticated) { // Use eventArgs.Account to do wonderful things //App.CredManager.DeleteCredentials(); store.Save(eventArgs.Account, Constants.AppName); App.SuccessfulLoginAction.Invoke(); } else // Authentication failed { Toast.MakeText(this.Context, "Authentication Failed", ToastLength.Long).Show(); } }; Account savedAccount = store.FindAccountsForService(Constants.AppName).FirstOrDefault(); if (savedAccount != null) { //TODO: check tokens expired? may not be needed bc this is the login page so they couldnt be. should check for login at login button click } else { activity.StartActivity(auth.GetUI(activity)); }; } catch (Exception ex) { Toast.MakeText(this.Context, "Error logging in", ToastLength.Long).Show(); } }
protected override void StoreCredentials(string username, string userid, string usertoken, int accountId) { base.StoreCredentials(username, userid, usertoken, accountId); Dictionary <String, String> accountOptions = new Dictionary <String, String>(); accountOptions.Add(USER_TOKEN_KEY, usertoken); accountOptions.Add(USER_ID_KEY, userid); accountOptions.Add(USERNAME_ID_KEY, username); accountOptions.Add(USER_TRAVELER_ID_KEY, accountId.ToString()); Account account = new Account(username, accountOptions); AccountStore acStore = AccountStore.Create(context); acStore.Save(account, SERVICE_ID); }
private async Task SaveAccessToken(string normalizedUsername, string serviceId, AccessToken accessToken, CancellationToken cancellationToken) { await Task.Factory.StartNew( () => { var account = _accountStore.FindAccountsForService(serviceId).FirstOrDefault(a => string.Equals(a.Username, normalizedUsername, StringComparison.CurrentCultureIgnoreCase)); if (account != null) { _accountStore.Delete(account, serviceId); } _accountStore.Save(new Account(normalizedUsername, accessToken.ToDictionary()), serviceId); }, cancellationToken).ConfigureAwait(false); }
public bool CreateAndSaveAccount(string username, string password) { if (string.IsNullOrEmpty(username) || string.IsNullOrEmpty(password)) { return(false); } AccountStore store = AccountStore.Create(); if (GetAccountFromStore(store, username) != null) { return(false); } Account account = new Account(username); account.Properties.Add(pwKey, password); store.Save(account, serviceID); return(true); }
void OnAuthCompleted(object sender, AuthenticatorCompletedEventArgs e) { var authenticator = sender as OAuth2Authenticator; if (authenticator != null) { authenticator.Completed -= OnAuthCompleted; authenticator.Error -= OnAuthError; } if (e.IsAuthenticated) { getProfileButton.IsEnabled = true; if (this.account != null) { store.Delete(this.account, ServiceId); } store.Save(account = e.Account, ServiceId); getProfileButton.IsEnabled = true; if (account.Properties.ContainsKey("expires_in")) { var expires = int.Parse(account.Properties ["expires_in"]); statusText.Text = "Token lifetime is: " + expires + "s"; } else { statusText.Text = "Authentication succeeded"; } } else { statusText.Text = "Authentication failed"; } }
async void OnAuthCompleted(object sender, AuthenticatorCompletedEventArgs e) { var authenticator = sender as OAuth2Authenticator; if (authenticator != null) { authenticator.Completed -= OnAuthCompleted; authenticator.Error -= OnAuthError; } if (e.IsAuthenticated) { // If the user is authenticated, request their basic user data from Google // UserInfoUrl = https://www.googleapis.com/oauth2/v2/userinfo var request = new OAuth2Request("GET", new Uri(Constants.UserInfoUrl), null, e.Account); var response = await request.GetResponseAsync(); if (response != null) { // Deserialize the data and store it in the account store // The users email address will be used to identify data in SimpleDB string userJson = await response.GetResponseTextAsync(); App.User = JsonConvert.DeserializeObject <User>(userJson); } if (account != null) { store.Delete(account, Constants.AppName); } store.Save(account = e.Account, Constants.AppName); Navigation.InsertPageBefore(new TodoListPage(), this); await Navigation.PopToRootAsync(); } }
public void SaveAccountInSecureStore(Account account) { AccountStore.Save(account, Locations.AppName); }
private void AccountStoreTests(object authenticator, AuthenticatorCompletedEventArgs ee) { AccountStore account_store = AccountStore.Create(); account_store.Save(ee.Account, provider); // https://kb.xamarin.com/agent/case/225411 //------------------------------------------------------------------ // Android // cannot reproduce Account account1 = account_store.FindAccountsForService(provider).FirstOrDefault(); if (null != account1) { //------------------------------------------------------------------ string token = default(string); if (null != account1) { string token_name = default(string); Type t = authenticator.GetType(); if (t == typeof(Xamarin.Auth._MobileServices.OAuth2Authenticator)) { token_name = "access_token"; token = account1.Properties[token_name].ToString(); } else if (t == typeof(Xamarin.Auth._MobileServices.OAuth1Authenticator)) { token_name = "oauth_token"; token = account1.Properties[token_name].ToString(); } } //------------------------------------------------------------------ } //------------------------------------------------------------------ AccountStore.Create().Save(ee.Account, provider + ".v.2"); //------------------------------------------------------------------ // throws on iOS // Account account2 = AccountStore.Create().FindAccountsForService(provider + ".v.2").FirstOrDefault(); if (null != account2) { //------------------------------------------------------------------ string token = default(string); if (null != account2) { string token_name = default(string); Type t = authenticator.GetType(); if (t == typeof(Xamarin.Auth._MobileServices.OAuth2Authenticator)) { token_name = "access_token"; token = account2.Properties[token_name].ToString(); } else if (t == typeof(Xamarin.Auth._MobileServices.OAuth1Authenticator)) { token_name = "oauth_token"; token = account2.Properties[token_name].ToString(); } } //------------------------------------------------------------------ } //------------------------------------------------------------------ return; }
private void AccountStoreTests(object authenticator, AuthenticatorCompletedEventArgs ee) { // Step 4.2 Store the account AccountStore account_store = AccountStore.Create(); account_store.Save(ee.Account, provider); try { // Stp 4.3 Retrieve stored accounts IEnumerable <Account> accounts = account_store.FindAccountsForService(provider); Account account1 = accounts.FirstOrDefault(); //------------------------------------------------------------------ if (null != account1) { string token = default(string); string token_name = default(string); Type t = authenticator.GetType(); if (t == typeof(Xamarin.Auth.OAuth2Authenticator)) { token_name = "access_token"; token = account1.Properties[token_name].ToString(); } else if (t == typeof(Xamarin.Auth.OAuth1Authenticator)) { token_name = "oauth_token"; token = account1.Properties[token_name].ToString(); } UIAlertView alert = new UIAlertView ( "Token 1", "access_token = " + token, null, "OK", null ); alert.Show(); } } catch (System.Exception exc) { // Xamarin.iOS // exc {System.ArgumentNullException: Value cannot be null. // Parameter name: data // at Foundation.NSString.Fr…} System.ArgumentNullException // Value cannot be null. // Parameter name: data string msg = exc.Message; System.Diagnostics.Debug.WriteLine("Exception AccountStore: " + msg); } try { AccountStore.Create().Save(ee.Account, provider + ".v.2"); } catch (System.Exception exc) { string msg = exc.Message; System.Diagnostics.Debug.WriteLine("Exception AccountStore: " + msg); } try { //------------------------------------------------------------------ // Xamarin.iOS - throws IEnumerable <Account> accounts = account_store.FindAccountsForService(provider + ".v.2"); Account account2 = accounts.FirstOrDefault(); //------------------------------------------------------------------ if (null != account2) { string token = default(string); string token_name = default(string); Type t = authenticator.GetType(); if (t == typeof(Xamarin.Auth.OAuth2Authenticator)) { token_name = "access_token"; token = account2.Properties[token_name].ToString(); } else if (t == typeof(Xamarin.Auth.OAuth1Authenticator)) { token_name = "oauth_token"; token = account2.Properties[token_name].ToString(); } UIAlertView alert = new UIAlertView ( "Token 2", "access_token = " + token, null, "OK", null ); alert.Show(); } } catch (System.Exception exc) { string msg = exc.Message; System.Diagnostics.Debug.WriteLine("Exception AccountStore: " + msg); } return; }
private Task SaveAccessToken(string normalizedUsername, string serviceId, AccessToken accessToken, CancellationToken cancellationToken) { return(Task.Factory.StartNew(() => _accountStore.Save(new Account(normalizedUsername, accessToken.ToDictionary()), serviceId), cancellationToken)); }
private void SaveAccount() { AccountStore.Save(_account, Constants.SERVICE_ID); }
async void OnAuthCompleted(object sender, AuthenticatorCompletedEventArgs e) { StaticMethods.ShowLoader(); var authenticator = sender as OAuth2Authenticator; if (authenticator != null) { authenticator.Completed -= OnAuthCompleted; authenticator.Error -= OnAuthError; } try { if (e.IsAuthenticated) { // If the user is authenticated, request their basic user data from Google var UserInfoUrlFacebook = "https://graph.facebook.com/me?fields=email,first_name,last_name"; var UserInfoUrl = "https://www.googleapis.com/oauth2/v2/userinfo"; var GetUserDataUrl = string.Empty; if (flag) { GetUserDataUrl = UserInfoUrlFacebook; } else { GetUserDataUrl = UserInfoUrl; } var request = new OAuth2Request("GET", new Uri(GetUserDataUrl), null, e.Account); var response = await request.GetResponseAsync(); if (response != null) { // Deserialize the data and store it in the account store // The users email address will be used to identify data in SimpleDB string userJson = await response.GetResponseTextAsync(); if (userJson != "Not Found") { App.User = JsonConvert.DeserializeObject <User>(userJson); } } if (account != null) { store.Delete(account, Constants.AppName); } store.Save(account = e.Account, Constants.AppName); if (App.User.Email != null) { SignUp(App.User).Wait(); } //App.Current.MainPage = new NavigationPage(new MainPage()); } } catch (Exception ex) { } finally { StaticMethods.DismissLoader(); } //Navigation.InsertPageBefore(new HomePage(), this); //await Navigation.PopToRootAsync(); }
private async void AccountStoreTests(object authenticator, AuthenticatorCompletedEventArgs ee) { string title = "AccountStore tests"; string msg = ""; AccountStore account_store = AccountStore.Create(); account_store.Save(ee.Account, provider); //------------------------------------------------------------------ // Android // https://kb.xamarin.com/agent/case/225411 // cannot reproduce Account account1 = account_store.FindAccountsForService(provider).FirstOrDefault(); if (null != account1) { //------------------------------------------------------------------ string token = default(string); if (null != account1) { string token_name = default(string); Type t = authenticator.GetType(); if (t == typeof(Xamarin.Auth.OAuth2Authenticator)) { token_name = "access_token"; token = account1.Properties[token_name].ToString(); } else if (t == typeof(Xamarin.Auth.OAuth1Authenticator)) { token_name = "oauth_token"; token = account1.Properties[token_name].ToString(); } } //------------------------------------------------------------------ MessageDialog md = new MessageDialog(msg, title); await md.ShowAsync(); } //------------------------------------------------------------------ AccountStore.Create().Save(ee.Account, provider + ".v.2"); //------------------------------------------------------------------ // throws on iOS // Account account2 = AccountStore.Create().FindAccountsForService(provider + ".v.2").FirstOrDefault(); if (null != account2) { //------------------------------------------------------------------ string token = default(string); if (null != account2) { string token_name = default(string); Type t = authenticator.GetType(); if (t == typeof(Xamarin.Auth.OAuth2Authenticator)) { token_name = "access_token"; token = account2.Properties[token_name].ToString(); } else if (t == typeof(Xamarin.Auth.OAuth1Authenticator)) { token_name = "oauth_token"; token = account2.Properties[token_name].ToString(); } } //------------------------------------------------------------------ MessageDialog md = new MessageDialog ( "access_token = " + token, "Access Token" ); await md.ShowAsync(); } //------------------------------------------------------------------ return; }