public async Task ParseAuthenticationResult(WebAuthenticationResult result) { switch (result.ResponseStatus) { //connection error case WebAuthenticationStatus.ErrorHttp: Debug.WriteLine("Connection error"); break; //authentication successfull case WebAuthenticationStatus.Success: var pattern = string.Format("{0}#access_token={1}&expires_in={2}", WebAuthenticationBroker.GetCurrentApplicationCallbackUri(), "(?<access_token>.+)", "(?<expires_in>.+)"); var match = Regex.Match(result.ResponseData, pattern); var access_token = match.Groups["access_token"]; var expires_in = match.Groups["expires_in"]; AccessToken = access_token.Value; TokenExpiry = DateTime.Now.AddSeconds(double.Parse(expires_in.Value)); await ShowUserInfo(); InviteFriends.Visibility = Visibility.Visible; break; //operation aborted by the user case WebAuthenticationStatus.UserCancel: Debug.WriteLine("Operation aborted"); break; default: break; } }
static WebAuthenticationResult() { UserCancel = new WebAuthenticationResult { ResponseStatus = WebAuthenticationStatus.UserCancel }; }
public void AuthenticationComplete(WebAuthenticationResult result) { if (pendingLoginTask == null) { throw new InvalidOperationException(Resources.IAuthenticationBroker_NoLoginInProgress); } if (result.ResponseStatus != WebAuthenticationStatus.Success) { string message; if (result.ResponseStatus == WebAuthenticationStatus.UserCancel) { message = Resources.IAuthenticationBroker_AuthenticationCanceled; } else { message = string.Format(CultureInfo.InvariantCulture, Resources.IAuthenticationBroker_AuthenticationFailed, result.ResponseErrorDetail); } pendingLoginTask.SetException(new InvalidOperationException(message)); } else { string tokenString = GetTokenStringFromResult(result); pendingLoginTask.SetResult(tokenString); } pendingLoginTask = null; }
public void AuthenticationComplete(WebAuthenticationResult result) { if (pendingLoginTask == null) { throw new InvalidOperationException("Authentication has not been started."); } if (result.ResponseStatus != WebAuthenticationStatus.Success) { string message; if (result.ResponseStatus == WebAuthenticationStatus.UserCancel) { message = "Authentication was cancelled by the user."; } else { message = string.Format(CultureInfo.InvariantCulture, "Authentication failed with HTTP response code {0}.", result.ResponseErrorDetail); } pendingLoginTask.SetException(new InvalidOperationException(message)); } else { string tokenString = GetTokenStringFromResult(result); pendingLoginTask.SetResult(tokenString); } pendingLoginTask = null; }
void browserControl_NavigationFailed(object sender, NavigationFailedEventArgs e) { WebBrowserNavigationException ex = e.Exception as WebBrowserNavigationException; uint error = ex != null ? (uint)ex.StatusCode : 0u; WebAuthenticationResult result = new WebAuthenticationResult("", WebAuthenticationStatus.ErrorHttp, error); WebAuthenticationResultSource.TrySetResult(result); e.Handled = true; }
public static string GetVerificationToken(WebAuthenticationResult result) { var url = result.ResponseData; var uri = new Uri(url); var query = uri.QueryDictionary(); var verification = query["oauth_verifier"]; return verification; }
void browserControl_Navigating(object sender, NavigatingEventArgs e) { if (IsEndUri(e.Uri)) { WebAuthenticationResult result = new WebAuthenticationResult(e.Uri.AbsoluteUri, WebAuthenticationStatus.Success, 0u); WebAuthenticationResultSource.TrySetResult(result); } }
public void ContinueWebAuthentication(WebAuthenticationResult results) { try { WebAuthenticationResult result = results; var tcs = _tcs; _tcs = null; tcs.SetResult(DecodeParameters(new Uri(result.ResponseData))); } catch (Exception ex) { throw (ex); } }
public string ParseAuthenticationResult(FacebookClient fb, WebAuthenticationResult result) { switch (result.ResponseStatus) { case WebAuthenticationStatus.ErrorHttp: return "Error"; case WebAuthenticationStatus.Success: var oAuthResult = fb.ParseOAuthCallbackUrl(new Uri(result.ResponseData)); return oAuthResult.AccessToken; case WebAuthenticationStatus.UserCancel: return "Operation aborted"; } return null; }
/// <summary> /// Processes the result. /// </summary> /// <param name="result">The result.</param> /// <exception cref="UniversalDemo.OAuthException"> /// Raised if there was an HTTP error during the authentication process. /// </exception> /// <exception cref="UniversalDemo.OAuthUserCancelledException"> /// Raised if the user cancelled authentication. /// </exception> private static void ProcessResult(WebAuthenticationResult result) { switch (result.ResponseStatus) { case WebAuthenticationStatus.Success: var response = DropboxOAuth2Helper.ParseTokenFragment( new Uri(result.ResponseData)); ((App)Application.Current).AccessToken = response.AccessToken; break; case WebAuthenticationStatus.ErrorHttp: throw new OAuthException(result.ResponseErrorDetail); case WebAuthenticationStatus.UserCancel: default: throw new OAuthUserCancelledException(); } }
public static async Task<string> RetrieveToken(WebAuthenticationResult result, string oauthKey, string oauthSecret) { if (result.ResponseStatus == WebAuthenticationStatus.Success) { string code = GetCode(result.ResponseData); return await GetToken(code, oauthKey, oauthSecret); } if (result.ResponseStatus == WebAuthenticationStatus.ErrorHttp) { throw new ApiAuthException(WebAuthenticationStatus.ErrorHttp); } if (result.ResponseStatus == WebAuthenticationStatus.UserCancel) { throw new ApiAuthException(WebAuthenticationStatus.UserCancel); } return null; }
private void ValidateAndProccessResult(WebAuthenticationResult result) { if (result.ResponseStatus == WebAuthenticationStatus.Success) { var responseUri = new Uri(result.ResponseData); var facebookOAuthResult = _fb.ParseOAuthCallbackUrl(responseUri); if (string.IsNullOrWhiteSpace(facebookOAuthResult.Error)) _fb.AccessToken = facebookOAuthResult.AccessToken; } else if (result.ResponseStatus == WebAuthenticationStatus.ErrorHttp) { // error de http } else { _fb.AccessToken = null; //Keep null when user signout from facebook } }
private void ValidateAndProccessResult(WebAuthenticationResult result) { if (result.ResponseStatus == WebAuthenticationStatus.Success) { var responseUri = new Uri(result.ResponseData.ToString()); var facebookOAuthResult = _fb.ParseOAuthCallbackUrl(responseUri); if (string.IsNullOrWhiteSpace(facebookOAuthResult.Error)) _fb.AccessToken = facebookOAuthResult.AccessToken; else {//error de acceso denegado por cancelación en página } } else if (result.ResponseStatus == WebAuthenticationStatus.ErrorHttp) {// error de http } else {// otras condiciones de error } }
public static void SetAuthorizationResultUri(WebAuthenticationResult webAuthenticationResult) { switch (webAuthenticationResult.ResponseStatus) { case WebAuthenticationStatus.Success: authorizationResult = new AuthorizationResult(AuthorizationStatus.Success, webAuthenticationResult.ResponseData); break; case WebAuthenticationStatus.ErrorHttp: authorizationResult = new AuthorizationResult(AuthorizationStatus.ErrorHttp, null); break; case WebAuthenticationStatus.UserCancel: authorizationResult = new AuthorizationResult(AuthorizationStatus.UserCancel, null); break; default: authorizationResult = new AuthorizationResult(AuthorizationStatus.UnknownError, null); break; } returnedUriReady.Release(); }
private static AuthorizationResult ProcessAuthorizationResult(WebAuthenticationResult webAuthenticationResult, CallState callState) { AuthorizationResult result; switch (webAuthenticationResult.ResponseStatus) { case WebAuthenticationStatus.Success: result = OAuth2Response.ParseAuthorizeResponse(webAuthenticationResult.ResponseData, callState); break; case WebAuthenticationStatus.ErrorHttp: result = new AuthorizationResult(AdalError.AuthenticationFailed, webAuthenticationResult.ResponseErrorDetail.ToString()); break; case WebAuthenticationStatus.UserCancel: result = new AuthorizationResult(AdalError.AuthenticationCanceled, AdalErrorMessage.AuthenticationCanceled); break; default: result = new AuthorizationResult(AdalError.AuthenticationFailed, AdalErrorMessage.AuthorizationServerInvalidResponse); break; } return result; }
private static AuthorizationResult ProcessAuthorizationResult(WebAuthenticationResult webAuthenticationResult, CallState callState) { AuthorizationResult result; switch (webAuthenticationResult.ResponseStatus) { case WebAuthenticationStatus.Success: result = new AuthorizationResult(AuthorizationStatus.Success, webAuthenticationResult.ResponseData); break; case WebAuthenticationStatus.ErrorHttp: result = new AuthorizationResult(AuthorizationStatus.ErrorHttp, webAuthenticationResult.ResponseErrorDetail.ToString(CultureInfo.InvariantCulture)); break; case WebAuthenticationStatus.UserCancel: result = new AuthorizationResult(AuthorizationStatus.UserCancel, null); break; default: result = new AuthorizationResult(AuthorizationStatus.UnknownError, null); break; } return result; }
public async Task ContinueAuthorizationAsync(WebAuthenticationResult result) { if (null == result || result.ResponseStatus != WebAuthenticationStatus.Success) { InfoMessage = _loader.GetString("AuthZ_OAuthFailed"); return; } try { ShowAuthorizeButton = false; Working = true; InfoMessage = _loader.GetString("AuthZ_CompletingOAuthFlow_AcquiringAccessToken"); bool ok = await _githubService.CompleteOAuthFlowAsync(result.ResponseData); if (ok) { _navigationService .UriFor<MainViewModel>() .Navigate(); } else { InfoMessage = _loader.GetString("AuthZ_ObtainingAccessTokenFailed"); } } catch (Exception ex) { Debug.WriteLine(ex.ToString()); } finally { ShowAuthorizeButton = true; Working = false; } }
/// <summary>Constructs a new instance of the class and set its properties by the specified result.</summary> public SerializableWebAuthResult(WebAuthenticationResult result) { this.ResponseData = result.ResponseData; this.ResponseErrorDetail = result.ResponseErrorDetail; this.ResponseStatus = result.ResponseStatus; }
public void ParseAuthenticationResult(WebAuthenticationResult result) { switch (result.ResponseStatus) { //connection error case WebAuthenticationStatus.ErrorHttp: _fcallback.loginFailed(SilverlightImplementation.toJava("Failed to connect.")); break; //authentication successfull case WebAuthenticationStatus.Success: var oAuthResult = fb.ParseOAuthCallbackUrl(new Uri(result.ResponseData)); com.codename1.io.Preferences.set(PREF_TOKEN, SilverlightImplementation.toJava(oAuthResult.AccessToken)); com.codename1.io.Preferences.set(PREF_EXPIRES, oAuthResult.Expires.Ticks); _fcallback.loginSuccessful(); break; //operation aborted by the user case WebAuthenticationStatus.UserCancel: _fcallback.loginFailed(SilverlightImplementation.toJava("Operation aborted")); break; default: break; } }
private async Task<Session> GetSession(WebAuthenticationResult result) { if (result.ResponseStatus == WebAuthenticationStatus.Success) { var code = GetCode(result.ResponseData); var serviceRequest = await GetToken(code); return new Session { AccessToken = serviceRequest.access_token, ExpireDate = new DateTime(long.Parse(serviceRequest.expires_in)), Id = serviceRequest.id_token, Provider = Constants.GoogleProvider }; } if (result.ResponseStatus == WebAuthenticationStatus.ErrorHttp) { throw new Exception("Error http"); } if (result.ResponseStatus == WebAuthenticationStatus.UserCancel) { throw new Exception("User Canceled."); } return null; }
/// <summary> /// Finishes the login process asynchronously. /// </summary> /// <param name="webAuthenticationResult">The web authentication result.</param> private async Task FinishLoginAsync(WebAuthenticationResult webAuthenticationResult) { if (webAuthenticationResult.ResponseStatus == WebAuthenticationStatus.ErrorHttp) { this._exceptionHandler.Handle(new Exception(webAuthenticationResult.ResponseData)); } else if (webAuthenticationResult.ResponseStatus == WebAuthenticationStatus.UserCancel) { LogTo.Debug("User cancelled the login."); } else if (webAuthenticationResult.ResponseStatus == WebAuthenticationStatus.Success) { var responseUri = new Uri(webAuthenticationResult.ResponseData); var decoder = new WwwFormUrlDecoder(responseUri.Query); string accessToken = decoder.GetFirstValueByName("code"); var client = this.GetClient(); await client.Core.OAuth2.TokenAsync(accessToken); AccountInfo dropboxUserInfo = await client.Core.Accounts.AccountInfoAsync(); this._sessionService.UserLoggedIn(client.UserAccessToken, dropboxUserInfo.uid); await this._eventAggregator.PublishOnUIThreadAsync(new UserLoggedInEvent()); } }
private Session GetSession(WebAuthenticationResult result) { if (result.ResponseStatus == WebAuthenticationStatus.Success) { string accessToken; string expiresIn; GetKeyValues(result.ResponseData, out accessToken, out expiresIn); return new Session { AccessToken = accessToken, ExpireDate = new DateTime(long.Parse(expiresIn)), Provider = Constants.FacebookProvider }; } if (result.ResponseStatus == WebAuthenticationStatus.ErrorHttp) { throw new Exception("Error http"); } if (result.ResponseStatus == WebAuthenticationStatus.UserCancel) { throw new Exception("User Canceled."); } return null; }
void LoginPage_BackKeyPress(object sender, global::System.ComponentModel.CancelEventArgs e) { WebAuthenticationResult result = new WebAuthenticationResult("", WebAuthenticationStatus.UserCancel, 0u); WebAuthenticationResultSource.TrySetResult(result); }
public AuthResult(WebAuthenticationResult result) { Status = result.ResponseStatus; ResponseUri = result.ResponseData; }
/// <summary> /// Manages the result of the authentication operation /// </summary> /// <param name="webAuthenticationResult">result of the authentication operation</param> public async Task ManageAuthenticateResult(WebAuthenticationResult webAuthenticationResult) { if (webAuthenticationResult.ResponseStatus != WebAuthenticationStatus.Success) { throw new UnauthorizedAccessException(); } var responseData = webAuthenticationResult.ResponseData.Substring(GetCallbackUrl().Length + 1).Split('&'); var keyValuePairs = new Dictionary<string, string>(); foreach (var str in responseData) { var keyValue = str.Split('='); keyValuePairs.Add(keyValue[0], keyValue[1]); } if (keyValuePairs["action"] != "allow" || keyValuePairs["state"] != "iloverd") { throw new UnauthorizedAccessException(); } await UpdateTokens(keyValuePairs["code"], "authorization_code"); }
public void ParseAuthenticationResult(WebAuthenticationResult result) { switch (result.ResponseStatus) { case WebAuthenticationStatus.ErrorHttp: //Debug.WriteLine("Error"); break; case WebAuthenticationStatus.Success: var pattern = string.Format("{0}#access_token={1}&expires_in={2}", WebAuthenticationBroker.GetCurrentApplicationCallbackUri(), "(?<access_token>.+)", "(?<expires_in>.+)"); var match = Regex.Match(result.ResponseData, pattern); var access_token = match.Groups["access_token"]; var expires_in = match.Groups["expires_in"]; _accessToken = access_token.Value; _tokenExpiry = DateTime.Now.AddSeconds(double.Parse(expires_in.Value)); var dm = new PassportDataModel(); dm.Token = _accessToken; dm.TokenExpiry = _tokenExpiry; //dm.TokenSecret = AccessToken.TokenSecret; //dm.Verifier = xoauth_verifier; dm.PassType = GroupingType; //dm.UserId = AccessToken.UserId; //dm.UserName = AccessToken.Username; //dm.FullName = AccessToken.FullName; //dm.ScreenName = AccessToken.ScreenName; dm.APIKeyFKID = apiKey.Id; StorageService.Instance.Storage.Insert(dm); IsLoggedInVisible = Visibility.Visible; IsLoginVisible = Visibility.Collapsed; IsAPIEditorVisible = Visibility.Collapsed; break; case WebAuthenticationStatus.UserCancel: //Debug.WriteLine("Operation aborted"); break; default: break; } }
/// <summary> /// Continues the authenticate user flow by extracting results from the Windows-specific /// auth method and moving on to the final common step. /// </summary> /// <param name="authResult">The result from the WebAuthenticationBroker call.</param> /// <returns> /// Whether the token was retrieved /// </returns> internal async Task<Response<AuthResultCode>> ConvertAuthPermissionParams(WebAuthenticationResult authResult) { try { switch (authResult.ResponseStatus) { case WebAuthenticationStatus.Success: // ResponseData will give us the final URI with a Querystring containing an auth code or error details // e.g. code=90e754fd-0a4a-4eb5-b5f6-25dad9face6a or error=access_denied AuthResultCode resultCode = AuthResultCode.Unknown; string authorizationCode = null; if (OAuthResultParser.ParseQuerystringForCompletedFlags(authResult.ResponseData, out resultCode, out authorizationCode)) { // Move on to obtain a token return await this.ObtainToken(authorizationCode, null, resultCode); } else { return new Response<AuthResultCode>(null, AuthResultCode.Unknown, Guid.Empty); } case WebAuthenticationStatus.ErrorHttp: switch ((HttpStatusCode)authResult.ResponseErrorDetail) { case HttpStatusCode.BadRequest: return new Response<AuthResultCode>(null, AuthResultCode.InvalidScope, Guid.Empty); case HttpStatusCode.Unauthorized: return new Response<AuthResultCode>(null, AuthResultCode.UnauthorizedClient, Guid.Empty); case HttpStatusCode.InternalServerError: return new Response<AuthResultCode>(null, AuthResultCode.ServerError, Guid.Empty); } // Any other items will return as cancelled below... break; } } catch { // Usually means we got cancelled } return new Response<AuthResultCode>(null, AuthResultCode.Cancelled, Guid.Empty); }
/// <summary> /// Completes the authenticate user call. /// </summary> /// <param name="client">The MixRadio client.</param> /// <param name="clientSecret">The client secret obtained during app registration</param> /// <param name="result">The result received through LaunchActivatedEventArgs.</param> /// <param name="cancellationToken">The cancellation token to cancel operation</param> /// <returns> /// An AuthResultCode indicating the result /// </returns> /// <remarks>This method is for Windows Phone 8.1 use</remarks> public static async Task<AuthResultCode> CompleteAuthenticateUserAsync(this MusicClient client, string clientSecret, WebAuthenticationResult result, CancellationToken? cancellationToken = null) { if (result != null) { if (result.ResponseStatus == WebAuthenticationStatus.Success) { var authResult = AuthResultCode.Unknown; string code = null; OAuthResultParser.ParseQuerystringForCompletedFlags(result.ResponseData, out authResult, out code); if (authResult == AuthResultCode.Success) { var authToken = await client.GetAuthenticationTokenAsync(clientSecret, code, cancellationToken); if (authToken != null) { await StoreOAuthToken(authToken, client.ClientId, clientSecret, cancellationToken).ConfigureAwait(false); } } return authResult; } } return AuthResultCode.Unknown; }
/// <summary> /// Gets the JSON string that represents the Mobile Service authentication token /// from the <see cref="WebAuthenticationResult"/>. /// </summary> /// <param name="result">The <see cref="WebAuthenticationResult"/> returned /// from the <see cref="WebAuthenticationBroker"/>.</param> /// <returns> /// A JSON string that represents a Mobile Service authentication token. /// </returns> /// <exception cref="InvalidOperationException"> /// Thrown if the authentication flow resulted in an error message or an invalid response. /// </exception> private string GetTokenStringFromResult(WebAuthenticationResult result) { Debug.Assert(result != null); Debug.Assert(result.ResponseStatus == WebAuthenticationStatus.Success); string tokenString = null; string responseData = result.ResponseData; if (!string.IsNullOrEmpty(responseData)) { tokenString = GetSubStringAfterMatch(responseData, "#token="); } if (string.IsNullOrEmpty(tokenString)) { string message = null; string errorString = GetSubStringAfterMatch(responseData, "#error="); if (string.IsNullOrEmpty(errorString)) { message = "Invalid format of the authentication response."; } else { message = string.Format(CultureInfo.InvariantCulture, "Login failed: {0}", errorString); } throw new InvalidOperationException(message); } return tokenString; }
public AuthenticationEventArgs(WebAuthenticationResult result) { Result = result; }