protected async override void OnNavigatedTo(NavigationEventArgs e) { try { var wap = await WebAuthenticationCoreManager.FindAccountProviderAsync("https://login.microsoft.com", "organizations"); WebTokenRequest wtr = new WebTokenRequest(wap, string.Empty, "ba789272-8d97-425c-9cdf-e43c6e76d73c"); const string resource = "https://graph.windows.net"; //wtr.Properties.Add("resource", resource); WebTokenRequestResult wtrr = await WebAuthenticationCoreManager.RequestTokenAsync(wtr); if (wtrr.ResponseStatus == WebTokenRequestStatus.Success) { var userAccount = wtrr.ResponseData[0].WebAccount; } else { var x = wtrr.ResponseError; } } catch (Exception ex) { var s = ex.Message; } }
private async void UIElement_OnTapped(object sender, TappedRoutedEventArgs e) { try { // Check whether there is an app for the provider we want to use (facebook) var provider = await WebAuthenticationCoreManager.FindAccountProviderAsync("https://www.facebook.com"); if (provider != null) { var response = await GetToken(provider, true); if (response != null) { // We have the response token, so we can check if we are authenticated. await ProcessResponse(response, provider); } else { // Ok, so now we need to tell Facebook to give us the token and possibly sign in Fallbacks(); } } else { // Use alternative methods Fallbacks(); } } catch (Exception ex) { var i = 1; } }
private static async Task <WebTokenResponse> RequestTokenAsync(bool forceLogin) { // [SCENARIO] OAuth 2.0 Authorization Code Grant, Public Client // Get a token to authenticate against the Web API. var promptType = forceLogin ? WebTokenRequestPromptType.ForceAuthentication : WebTokenRequestPromptType.Default; var provider = await WebAuthenticationCoreManager.FindAccountProviderAsync("https://login.microsoft.com/", AppConfiguration.AccountProviderAuthority); var request = new WebTokenRequest(provider, string.Empty, AppConfiguration.TodoListWindows10ClientId, promptType); request.Properties.Add("resource", AppConfiguration.TodoListWebApiResourceId); request.Properties.Add("authority", AppConfiguration.StsAuthority); // Skip authority validation for AD FS, otherwise you get the following error: // ERROR: The value specified for 'authority' is invalid. It is not in the valid authority list or not discovered. (3399548934) request.Properties.Add("validateAuthority", AppConfiguration.CanValidateAuthority.ToString()); var result = await WebAuthenticationCoreManager.RequestTokenAsync(request); if (result.ResponseStatus == WebTokenRequestStatus.Success) { // [NOTE] At this point we have the authentication result, including the user information. // From this point on we can use the regular OAuth 2.0 Bearer Token to call the Web API. return(result.ResponseData.Single()); } else if (result.ResponseStatus != WebTokenRequestStatus.UserCancel) { var errorMessage = result.ResponseError == null ? "Unknown error" : result.ResponseError.ErrorMessage; throw new Exception(errorMessage); } else { return(null); } }
public static async Task <List <Tuple <string, string> > > GetMSAccounts() { WebAccountProvider provider = await WebAuthenticationCoreManager.FindAccountProviderAsync("https://login.microsoft.com", "consumers"); int status = GetMSAccounts(out string[] accountNames, out string[] accountIds, out int accountCount); if (status >= ZL_ERRORS_START && status <= ZL_ERRORS_END) { throw new BackendException(status); } else if (status != 0) { Marshal.ThrowExceptionForHR(status); } var accounts = accountNames.Zip(accountIds, Tuple.Create).ToList(); foreach (var account in accounts.ToList()) { if (await WebAuthenticationCoreManager.FindAccountAsync(provider, account.Item2) == null) { accounts.Remove(account); } } return(accounts); }
/// <summary> /// Creates an AccountsSettingsPane with options for MSA or Facebook login. /// </summary> private static async void BuildSettingsPaneAsync(AccountsSettingsPane s, AccountsSettingsPaneCommandsRequestedEventArgs e) { var deferral = e.GetDeferral(); e.HeaderText = _paneMessage + "Get signed in to Lunch Scheduler. " + "You can use an existing Microsoft or Facebook account."; // Microsoft account var msa = new WebAccountProviderCommand( await WebAuthenticationCoreManager.FindAccountProviderAsync("https://login.microsoft.com", "consumers"), MicrosoftAccountAuth); e.WebAccountProviderCommands.Add(msa); // Facebook // Built-in provider exists only on phone; if not availble, use WAB as a fallback var fbProvider = await WebAuthenticationCoreManager.FindAccountProviderAsync("https://facebook.com"); var fb = new WebAccountProviderCommand( fbProvider ?? new WebAccountProvider("LunchScheduler", "Facebook", new Uri(@"ms-appx:///Assets/FbIcon.png")), FacebookAuth); e.WebAccountProviderCommands.Add(fb); // Help commands e.Commands.Add(new SettingsCommand("help", "Get help signing in", async x => await Launcher.LaunchUriAsync(new Uri("http://bing.com")))); e.Commands.Add(new SettingsCommand("privacy", "Privacy policy", async x => await Launcher.LaunchUriAsync(new Uri("http://bing.com")))); deferral.Complete(); }
/// <summary> /// Signs the current user out and clears his account information. /// </summary> public async Task SignOutAccountAsync() { if (ApplicationData.Current.LocalSettings.Values.ContainsKey(CurrentUserKey)) { WebAccountProvider providertoDelete = await WebAuthenticationCoreManager.FindAccountProviderAsync( MicrosoftAccountProviderId, ConsumerAuthority); WebAccount accountToDelete = await WebAuthenticationCoreManager.FindAccountAsync( providertoDelete, (string)ApplicationData.Current.LocalSettings.Values[CurrentUserKey]); if (accountToDelete != null) { await accountToDelete.SignOutAsync(); } ApplicationData.Current.LocalSettings.Values.Remove(CurrentUserKey); ApplicationData.Current.LocalSettings.Values.Remove(CurrentUserProviderKey); UserIsSignedIn = false; UserSignInChange(this, false); Debug.WriteLine("Successfully logged out"); } }
//retrieving token from storage public async Task <string> GetTokenSilentlyAsync() { string providerId = ApplicationData.Current.LocalSettings.Values["CurrentUserProviderId"]?.ToString(); string accountId = ApplicationData.Current.LocalSettings.Values["CurrentUserId"]?.ToString(); if (null == providerId || null == accountId) { return(null); } WebAccountProvider provider = await WebAuthenticationCoreManager.FindAccountProviderAsync(providerId); WebAccount account = await WebAuthenticationCoreManager.FindAccountAsync(provider, accountId); WebTokenRequest request = new WebTokenRequest(provider, "wl.basic"); WebTokenRequestResult result = await WebAuthenticationCoreManager.GetTokenSilentlyAsync(request, account); if (result.ResponseStatus == WebTokenRequestStatus.UserInteractionRequired) { // Unable to get a token silently - you'll need to show the UI return(null); } else if (result.ResponseStatus == WebTokenRequestStatus.Success) { // Success return(result.ResponseData[0].Token); } else { // Other error return(null); } }
private async Task <WebTokenRequestResult?> SilentAuthAsync() { // Ref: https://docs.microsoft.com/en-us/windows/uwp/security/web-account-manager#store-the-account-for-future-use string providerId = _userSettings.Get <string>(UserSettingsConstants.CurrentUserProviderId); string accountId = _userSettings.Get <string>(UserSettingsConstants.CurrentUserId); if (string.IsNullOrWhiteSpace(providerId) || string.IsNullOrWhiteSpace(accountId)) { return(null); } try { WebAccountProvider provider = await WebAuthenticationCoreManager.FindAccountProviderAsync(providerId); WebAccount account = await WebAuthenticationCoreManager.FindAccountAsync(provider, accountId); WebTokenRequest request = new WebTokenRequest(provider, Scope, _clientId); WebTokenRequestResult result = await WebAuthenticationCoreManager.GetTokenSilentlyAsync(request, account); return(result); } catch { return(null); } }
private async Task AddWebAccount(AccountsSettingsPaneCommandsRequestedEventArgs e) { WebAccountProvider provider = await WebAuthenticationCoreManager.FindAccountProviderAsync(MicrosoftAccountProviderId, ConsumerAuthority); String accountID = (String)ApplicationData.Current.LocalSettings.Values[StoredAccountKey]; WebAccount account = await WebAuthenticationCoreManager.FindAccountAsync(provider, accountID); WebAccountProvider web = new WebAccountProvider("818", "MicrosoftAccount", new Uri("ms-appdata:///local/ProfilePicture.jpg")); WebAccount account2 = new WebAccount(web, (string)ApplicationData.Current.LocalSettings.Values[StoredEmailKey], WebAccountState.Connected); if (account == null) { ApplicationData.Current.LocalSettings.Values.Remove(StoredAccountKey); } if (ApplicationData.Current.LocalSettings.Values.ContainsKey(StoredEmailKey)) { WebAccountCommand command = new WebAccountCommand(account2, WebAccountInvoked, SupportedWebAccountActions.Remove); e.WebAccountCommands.Add(command); } else { WebAccountCommand command = new WebAccountCommand(account, WebAccountInvoked, SupportedWebAccountActions.Remove); e.WebAccountCommands.Add(command); } }
public async Task <string> GetAccessTokenForResource(string resource) { string token = null; //first try to get the token silently WebAccountProvider aadAccountProvider = await WebAuthenticationCoreManager.FindAccountProviderAsync("https://login.windows.net"); WebTokenRequest webTokenRequest = new WebTokenRequest(aadAccountProvider, String.Empty, App.Current.Resources["ida:ClientID"].ToString(), WebTokenRequestPromptType.Default); webTokenRequest.Properties.Add("authority", "https://login.windows.net"); webTokenRequest.Properties.Add("resource", resource); WebTokenRequestResult webTokenRequestResult = await WebAuthenticationCoreManager.GetTokenSilentlyAsync(webTokenRequest); if (webTokenRequestResult.ResponseStatus == WebTokenRequestStatus.Success) { WebTokenResponse webTokenResponse = webTokenRequestResult.ResponseData[0]; token = webTokenResponse.Token; } else if (webTokenRequestResult.ResponseStatus == WebTokenRequestStatus.UserInteractionRequired) { //get token through prompt webTokenRequest = new WebTokenRequest(aadAccountProvider, String.Empty, App.Current.Resources["ida:ClientID"].ToString(), WebTokenRequestPromptType.ForceAuthentication); webTokenRequest.Properties.Add("authority", "https://login.windows.net"); webTokenRequest.Properties.Add("resource", resource); webTokenRequestResult = await WebAuthenticationCoreManager.RequestTokenAsync(webTokenRequest); if (webTokenRequestResult.ResponseStatus == WebTokenRequestStatus.Success) { WebTokenResponse webTokenResponse = webTokenRequestResult.ResponseData[0]; token = webTokenResponse.Token; } } return(token); }
public async System.Threading.Tasks.Task <string> GetAzureADUserInteractiveTokenUWP(string ApplicationID, string tenantDomain) { string token = string.Empty; string authority = "https://login.microsoftonline.com/" + tenantDomain; try { // WebAccountProvider wap = await WebAuthenticationCoreManager.FindAccountProviderAsync("https://login.microsoft.com", authority); WebAccountProvider wap = await WebAuthenticationCoreManager.FindAccountProviderAsync("https://login.microsoftonline.com/", authority); string resource = "https://rest.media.azure.net"; WebTokenRequest wtr = new WebTokenRequest(wap, string.Empty, ApplicationID); if (wtr != null) { wtr.Properties.Add("resource", resource); WebTokenRequestResult wtrr = await WebAuthenticationCoreManager.RequestTokenAsync(wtr); if (wtrr.ResponseStatus == WebTokenRequestStatus.Success) { token = wtrr.ResponseData[0].Token; var account = wtrr.ResponseData[0].WebAccount; var properties = wtrr.ResponseData[0].Properties; } } } catch (Exception e) { LogMessage("Exception " + e.Message); token = string.Empty; } return(token); }
/// <summary> /// Add items to the AccountsSettingsPane /// </summary> /// <param></param> /// <returns></returns> public static async Task <ImageMenuItem> AutoSignIn() { IReadOnlyList <User> users = await User.FindAllAsync(); if (users.Count != 0) { User user = User.GetFromId(users.ElementAt(0).NonRoamableId); provider = await WebAuthenticationCoreManager.FindAccountProviderAsync(MicrosoftAccountProviderId, ConsumerAuthority, user); request = new WebTokenRequest(provider, GraphScope, AccountClientId); token = await GetTokenSilently(); if (token != null) { ImageMenuItem userDetails = await GetUser(token, FirstName); return(userDetails); } else { return(null); } } return(null); }
protected override async Task <WebTokenResponse> GetToken(string resource, string authority = null) { if (authority == null) { authority = Authority; } else { authority = $"{LoginBase}/{authority}"; } WebAccountProvider wap = await WebAuthenticationCoreManager.FindAccountProviderAsync("https://login.microsoft.com", authority); var tokenRequest = new WebTokenRequest(wap, string.Empty, AppClientId); tokenRequest.Properties.Add("resource", resource); try { var tokenResponse = await WebAuthenticationCoreManager.RequestTokenAsync(tokenRequest); if (tokenResponse.ResponseStatus != WebTokenRequestStatus.Success) { throw new Exception(tokenResponse.ResponseError.ErrorMessage); } return(tokenResponse.ResponseData.Single()); } catch { throw; } }
public static async Task <bool> LogOut() { WebAccountProvider wap = await WebAuthenticationCoreManager.FindAccountProviderAsync("https://login.microsoft.com", authority); //Getting redirect url //string URI = string.Format("ms-appx-web://Microsoft.AAD.BrokerPlugIn/{0}", WebAuthenticationBroker.GetCurrentApplicationCallbackUri().Host.ToUpper()); //resource = URI; WebTokenRequest wtr = new WebTokenRequest(wap, string.Empty, clientId); wtr.Properties.Add("resource", resource); WebTokenRequestResult wtrr = await WebAuthenticationCoreManager.RequestTokenAsync(wtr); if (wtrr.ResponseStatus == WebTokenRequestStatus.Success) { var account = wtrr.ResponseData[0].WebAccount; await account.SignOutAsync(); return(true); } else { return(false); } }
private async Task GetProvider() { try { IAsyncOperation <WebAccountProvider> provider = WebAuthenticationCoreManager.FindAccountProviderAsync("login.windows.local");//login.windows.local //int count = 5; //while(provider.Status != AsyncStatus.Completed && count > 0) //{ // Thread.Sleep(200); // count--; //} var result = await provider.AsTask(); if (result != null) { Console.WriteLine(result.DisplayName); Console.WriteLine(result.DisplayPurpose); Console.WriteLine(result.Id); } else { Console.WriteLine("there is no default account is setup for the user"); } } catch (Exception ex) { ex.ToString(); } }
public static async Task <string> GetTokenForUserAsync() { //for most Enteprise apps, we only care about AAD version of MSGraph string authority = "organizations"; // string resource = "https://graph.windows.net"; // This is the Azure AD Graph not MS Graph... string resource = "https://graph.microsoft.com"; //Microsoft Graph string TokenForUser = null; var wap = await WebAuthenticationCoreManager.FindAccountProviderAsync("https://login.microsoft.com", authority); // craft the token request for the Graph api //What is the correct scope? WebTokenRequest wtr = new WebTokenRequest(wap, _scopes, _clientId); wtr.Properties.Add("resource", resource); WebTokenRequestResult wtrr = await WebAuthenticationCoreManager.RequestTokenAsync(wtr); if (wtrr.ResponseStatus == WebTokenRequestStatus.Success) { TokenForUser = wtrr.ResponseData[0].Token; } else { System.Diagnostics.Debug.WriteLine(wtrr.ResponseError); } return(TokenForUser); }
public async Task <bool> IsDefaultAccountMsaAsync() { // provider for the "default" account var provider = await WebAuthenticationCoreManager.FindAccountProviderAsync("https://login.windows.local"); return(provider != null && string.Equals(Constants.ConsumerTenant, provider.Authority)); }
private async Task <WebAccount> GetWebAccount() { String accountID = ApplicationData.Current.LocalSettings.Values[Constants.StoredAccountIdKey] as String; String providerID = ApplicationData.Current.LocalSettings.Values[Constants.StoredProviderIdKey] as String; WebAccount account = null; try { WebAccountProvider provider = await WebAuthenticationCoreManager.FindAccountProviderAsync(providerID); account = await WebAuthenticationCoreManager.FindAccountAsync(provider, accountID); // The account has been deleted if FindAccountAsync returns null if (account == null) { DebugPrint("cannot find the account, which might be removed from Settings."); RemoveAccountData(); } } catch (Exception ex) { DebugPrint("GetWebAccount exception: " + ex.Message); } return(account); }
public async Task <WebAccountProvider> GetAccountProviderAsync(string authorityOrTenant) { WebAccountProvider provider = await WebAuthenticationCoreManager.FindAccountProviderAsync( "https://login.microsoft.com", authorityOrTenant); return(provider); }
private async Task AddWebAccountProvider(AccountsSettingsPaneCommandsRequestedEventArgs e) { WebAccountProvider provider = await WebAuthenticationCoreManager.FindAccountProviderAsync(MicrosoftAccountProviderId, ConsumerAuthority); WebAccountProviderCommand providerCommand = new WebAccountProviderCommand(provider, WebAccountProviderCommandInvoked); e.WebAccountProviderCommands.Add(providerCommand); }
private async Task <WebAccountProvider> GetProvider() { if (_wap == null) { _wap = await WebAuthenticationCoreManager.FindAccountProviderAsync(ProviderId, _authority); } return(_wap); }
public async void AuthenticateWithRequestToken( String WebAccountProviderID, String Authority, String Scope, String ClientID, String TokenBindingTarget, String RequestProperties) { try { // //create webTokenRequest with ProviderID, Scope, ClientId // DebugPrint("creating the webAccountProviderID"); WebAccountProvider provider = null; if (String.IsNullOrEmpty(Authority)) { DebugPrint("calling FindAccountProviderAsync..."); provider = await WebAuthenticationCoreManager.FindAccountProviderAsync(WebAccountProviderID); } else { DebugPrint("calling FindAccountProviderWithAuthorityAsync..."); provider = await WebAuthenticationCoreManager.FindAccountProviderAsync( WebAccountProviderID, Authority); } DebugPrint("Provider Id: " + provider.Id); DebugPrint("Provider DisplayName: " + provider.DisplayName); WebTokenRequestPromptType prompt = ForceUiCheckBox.IsChecked.Value ? WebTokenRequestPromptType.ForceAuthentication : WebTokenRequestPromptType.Default; WebTokenRequest webTokenRequest = new WebTokenRequest( provider, Scope, ClientID, prompt); // // add properties to the tokenrequest if the IDP plugin requires // AddRequestProperties(RequestProperties, webTokenRequest); DebugPrint("Call RequestTokenAsync"); WebTokenRequestResult webTokenRequestResult = await WebAuthenticationCoreManager.RequestTokenAsync(webTokenRequest); HandleResult(webTokenRequestResult); } catch (Exception ex) { DebugPrint("RequestToken failed: " + ex.Message); } }
public async Task Initialize() { if (AccountProvider == null) { AccountProvider = await WebAuthenticationCoreManager.FindAccountProviderAsync("https://login.microsoft.com", Authority); } if (AppSettings == null) { AppSettings = ApplicationData.Current.RoamingSettings; } }
private static async Task <string> GetXTokenAsync() { string token = string.Empty; // Get an XToken // Find the account provider using the signed in user. // We always use the 1st signed in user, because we just need a valid token. It doesn't // matter who's it is. Windows.System.User currentUser; WebTokenRequest request; var users = await Windows.System.User.FindAllAsync(); currentUser = users[0]; WebAccountProvider xboxProvider = await WebAuthenticationCoreManager.FindAccountProviderAsync("https://xsts.auth.xboxlive.com", "", currentUser); // Build the web token request using the account provider. // Url = URL of the service we are getting a token for - for example https://apis.mycompany.com/something. // As this is a sample just use xboxlive.com // Target & Policy should always be set to "xboxlive.signin" and "DELEGATION" // For this call to succeed your console needs to be in the XDKS.1 sandbox request = new Windows.Security.Authentication.Web.Core.WebTokenRequest(xboxProvider); request.Properties.Add("Url", "https://xboxlive.com"); request.Properties.Add("Target", "xboxlive.signin"); request.Properties.Add("Policy", "DELEGATION"); // Request a token - correct pattern is to call getTokenSilentlyAsync and if that // fails with WebTokenRequestStatus.userInteractionRequired then call requestTokenAsync // to get the token and prompt the user if required. // getTokenSilentlyAsync can be called on a background thread. WebTokenRequestResult tokenResult = await WebAuthenticationCoreManager.GetTokenSilentlyAsync(request); //If we got back a token call our service with that token if (tokenResult.ResponseStatus == WebTokenRequestStatus.Success) { token = tokenResult.ResponseData[0].Token; } else if (tokenResult.ResponseStatus == WebTokenRequestStatus.UserInteractionRequired) { // WebTokenRequestStatus.userInteractionRequired = 3 // If user interaction is required then call requestTokenAsync instead - this will prompt for user permission if required // Note: RequestTokenAsync cannot be called on a background thread. WebTokenRequestResult tokenResult2 = await WebAuthenticationCoreManager.RequestTokenAsync(request); //If we got back a token call our service with that token if (tokenResult2.ResponseStatus == WebTokenRequestStatus.Success) { token = tokenResult.ResponseData[0].Token; } else if (tokenResult2.ResponseStatus == WebTokenRequestStatus.UserCancel) { // No-op } } return(token); }
private async Task <WebAccountProvider> GetProvider(string ProviderID, string AuthorityId = "") { if (ProviderID == AppSpecificProviderId) { return(new WebAccountProvider(AppSpecificProviderId, AppSpecificProviderName, new Uri(this.BaseUri, "Assets/smallTile-sdk.png"))); } else { return(await WebAuthenticationCoreManager.FindAccountProviderAsync(ProviderID, AuthorityId)); } }
private async void OnAccountCommandsRequested(AccountsSettingsPane sender, AccountsSettingsPaneCommandsRequestedEventArgs e) { AccountsSettingsPaneEventDeferral deferral = e.GetDeferral(); WebAccountProvider provider = await WebAuthenticationCoreManager.FindAccountProviderAsync(ProviderId, Authority); WebAccountProviderCommand providerCommand = new WebAccountProviderCommand(provider, WebAccountProviderCommandInvoked); e.WebAccountProviderCommands.Add(providerCommand); deferral.Complete(); }
private async void MainPage_AccountCommandsRequested(AccountsSettingsPane sender, AccountsSettingsPaneCommandsRequestedEventArgs args) { var d = args.GetDeferral(); var msaProvider = await WebAuthenticationCoreManager.FindAccountProviderAsync( "https://login.microsoft.com", "consumers"); var command = new WebAccountProviderCommand(msaProvider, GetMsaTokenAsync); args.WebAccountProviderCommands.Add(command); d.Complete(); }
private async void BuildPaneAsync(AccountsSettingsPane s, AccountsSettingsPaneCommandsRequestedEventArgs e) { var deferral = e.GetDeferral(); var msaProvider = await WebAuthenticationCoreManager.FindAccountProviderAsync( "https://login.microsoft.com", "consumers"); var command = new WebAccountProviderCommand(msaProvider, GetMsaTokenAsync); e.WebAccountProviderCommands.Add(command); deferral.Complete(); }
public async Task <WebAccount> GetAccountAsync() { var webAccountProvider = await WebAuthenticationCoreManager.FindAccountProviderAsync(_settings.WebAccountProviderId, _settings.Authority); var userId = _appSettings.Values["userId"]; if (string.IsNullOrWhiteSpace(userId as string)) { return(null); } return(await WebAuthenticationCoreManager.FindAccountAsync(webAccountProvider, (string)userId)); }
private void InitializeProvider(User user) { IAsyncOperation <WebAccountProvider> provider; if (user != null && IsMultiUserApplication()) { provider = WebAuthenticationCoreManager.FindAccountProviderAsync("https://xsts.auth.xboxlive.com", "", user); } else { provider = WebAuthenticationCoreManager.FindAccountProviderAsync("https://xsts.auth.xboxlive.com"); } provider.Completed = FindAccountCompleted; }