/// <summary> /// Event handler called when a new page is being loaded in the web browser. /// </summary> /// <param name='url'> /// The URL of the page. /// </param> /// <param name="formParams"> /// The parsed form parameters from the HTTP message body. /// </param> public override void OnPageLoading(Uri url, IDictionary <string, string> formParams) { var query = WebEx.FormDecode(url.Query); var fragment = WebEx.FormDecode(url.Fragment); OnPageEncountered(url, query, fragment, formParams); }
/// <summary> /// Asynchronously makes a request to the access token URL with the given parameters. /// </summary> /// <param name="queryValues">The parameters to make the request with.</param> /// <returns>The data provided in the response to the access token request.</returns> protected async Task <IDictionary <string, string> > RequestAccessTokenAsync(IDictionary <string, string> queryValues) { var content = new FormUrlEncodedContent(queryValues); HttpClient client = new HttpClient(); HttpResponseMessage response = await client.PostAsync(accessTokenUrl, content).ConfigureAwait(false); string text = await response.Content.ReadAsStringAsync().ConfigureAwait(false); // Parse the response var data = text.Contains("{") ? WebEx.JsonDecode(text) : WebEx.FormDecode(text); if (data.ContainsKey("error")) { throw new AuthException("Error authenticating: " + data ["error"]); } else if (data.ContainsKey("access_token")) { return(data); } else { throw new AuthException("Expected access_token in access token response, but did not receive one."); } }
public override Task <Uri> GetInitialUrlAsync() { var req = OAuth1.CreateRequest( "GET", requestTokenUrl, new Dictionary <string, string> (), consumerKey, consumerSecret, "" ); return(req.GetResponseAsync().ContinueWith(respTask => { var content = respTask.Result.GetResponseText(); var r = WebEx.FormDecode(content); token = r["oauth_token"]; tokenSecret = r["oauth_token_secret"]; string paramType = authorizeUrl.AbsoluteUri.IndexOf("?") >= 0 ? "&" : "?"; var url = String.Format("{0}{1}oauth_token={2}&oauth_callback={3}", authorizeUrl.AbsoluteUri, paramType, Uri.EscapeDataString(token), Uri.EscapeDataString(callbackUrl.AbsoluteUri)); return new Uri(url); })); }
/// <summary> /// Gets the UI for this authenticator. /// </summary> /// <returns> /// The UI that needs to be presented. /// </returns> protected override AuthenticateUIType GetPlatformUI() { AuthenticateUIType ui = null; if (this.IsUsingNativeUI == true) { Uri uri = GetInitialUrlAsync().Result; IDictionary <string, string> query_parts = WebEx.FormDecode(uri.Query); if (query_parts.ContainsKey("redirect_uri")) { Uri redirect_uri = new Uri(query_parts["redirect_uri"]); string scheme = redirect_uri.Scheme; if (scheme.StartsWith("http", StringComparison.InvariantCultureIgnoreCase)) { StringBuilder sb = new StringBuilder(); sb.AppendLine("WARNING"); sb.AppendLine($"Scheme = {scheme}"); sb.AppendLine($"Native UI used with http[s] schema!"); sb.AppendLine($"Redirect URL will be loaded in Native UI!"); sb.AppendLine($"OAuth Data parsing might fail!"); ShowErrorForNativeUI(sb.ToString()); } } ui = GetPlatformUINative(); } else { ui = GetPlatformUIEmbeddedBrowser(); } return(ui); }
/// <summary> /// Asynchronously makes a request to the access token URL with the given parameters. /// </summary> /// <param name="queryValues">The parameters to make the request with.</param> /// <returns>The data provided in the response to the access token request.</returns> protected Task <IDictionary <string, string> > RequestAccessTokenAsync(IDictionary <string, string> queryValues) { var query = queryValues.FormEncode(); var req = WebRequest.Create(accessTokenUrl); req.Method = "POST"; var body = Encoding.UTF8.GetBytes(query); req.ContentLength = body.Length; req.ContentType = "application/x-www-form-urlencoded"; using (var s = req.GetRequestStream()) { s.Write(body, 0, body.Length); } return(req.GetResponseAsync().ContinueWith(task => { var text = task.Result.GetResponseText(); // Parse the response var data = text.Contains("{") ? WebEx.JsonDecode(text) : WebEx.FormDecode(text); if (data.ContainsKey("error")) { throw new AuthException("Error authenticating: " + data["error"]); } else if (data.ContainsKey("access_token")) { return data; } else { throw new AuthException("Expected access_token in access token response, but did not receive one."); } })); }
/// <summary> /// Method that returns the initial URL to be displayed in the web browser. /// </summary> /// <returns> /// A task that will return the initial URL. /// </returns> public override Task <Uri> GetInitialUrlAsync() { var req = OAuth1.CreateRequest( "GET", requestTokenUrl, new Dictionary <string, string>() { { "oauth_callback", callbackUrl.AbsoluteUri }, }, consumerKey, consumerSecret, ""); return(req.GetResponseAsync().ContinueWith(respTask => { var content = respTask.Result.GetResponseText(); var r = WebEx.FormDecode(content); token = r["oauth_token"]; tokenSecret = r["oauth_token_secret"]; var url = authorizeUrl.AbsoluteUri + "?oauth_token=" + Uri.EscapeDataString(token); return new Uri(url); })); }
/// <summary> /// Event handler called when a page has completed loading. /// </summary> /// <param name='url'> /// The URL of the page. /// </param> public override void OnPageLoaded(Uri url) { var query = WebEx.FormDecode(url.Query); var fragment = WebEx.FormDecode(url.Fragment); OnPageEncountered(url, query, fragment); }
/// <summary> /// Asynchronously makes a request to the access token URL with the given parameters. /// </summary> /// <param name="queryValues">The parameters to make the request with.</param> /// <returns>The data provided in the response to the access token request.</returns> protected async Task <IDictionary <string, string> > RequestAccessTokenAsync(IDictionary <string, string> queryValues) { var query = queryValues.FormEncode(); HttpClient client = new HttpClient(); //var response = await client.PostAsync(accessTokenUrl.AbsoluteUri, new StringContent(query, Encoding.UTF8, "application/x-www-form-urlencoded")); //var text = await response.Content.ReadAsStringAsync(); //// Parse the response //var data = text.Contains("{") ? WebEx.JsonDecode(text) : WebEx.FormDecode(text); //if (data.ContainsKey("error")) //{ // throw new AuthException("Error authenticating: " + data["error"]); //} //else if (data.ContainsKey("access_token")) //{ // return data; //} //else //{ // throw new AuthException("Expected access_token in access token response, but did not receive one."); //} //var query = queryValues.FormEncode(); //var req = WebRequest.Create(accessTokenUrl); //req.Method = "POST"; //var body = Encoding.UTF8.GetBytes(query); //req.ContentLength = body.Length; //req.ContentType = "application/x-www-form-urlencoded"; //using (var s = req.GetRequestStream()) //{ // s.Write(body, 0, body.Length); //} var taskPost = client.PostAsync(accessTokenUrl.AbsoluteUri, new StringContent(query, Encoding.UTF8, "application/x-www-form-urlencoded")); taskPost.Wait(); var taskReadResponse = taskPost.Result.Content.ReadAsStringAsync(); taskReadResponse.Wait(); var text = taskReadResponse.Result; // Parse the response var data = text.Contains("{") ? WebEx.JsonDecode(text) : WebEx.FormDecode(text); if (data.ContainsKey("error")) { throw new AuthException("Error authenticating: " + data["error"]); } else if (data.ContainsKey("access_token")) { return(data); } else { throw new AuthException("Expected access_token in access token response, but did not receive one."); } }
protected async Task <IDictionary <string, string> > RequestAccessTokenAsync(CancellationToken cancellationToken) { var query = FieldsToFormUrlEncodedContent(); using (var client = new HttpClient(new NativeMessageHandler())) { var response = await client.PostAsync(_accessTokenUrl, query, cancellationToken); var contentStream = await response.Content.ReadAsStringAsync(); if (!response.IsSuccessStatusCode) { if (response.Content.Headers.ContentType.MediaType.Contains("html")) { throw new AuthException($"{response.StatusCode}: {response.ReasonPhrase}"); } } var data = contentStream.Contains("{") ? WebEx.JsonDecode(contentStream) : WebEx.FormDecode(contentStream); if (data.ContainsKey("access_token") || data.ContainsKey("error")) { return(data); } throw new AuthException("Expected an access_token or error header in the response message."); } }
public override void DecidePolicy ( WKWebView webView, WKNavigationAction navigationAction, Action <WKNavigationActionPolicy> decisionHandler ) { #if DEBUG StringBuilder sb = new StringBuilder(); sb.AppendLine($"WKWebViewNavigationDelegate.DecidePolicy "); sb.AppendLine($" webView.Url.AbsoluteString = {webView.Url.AbsoluteString}"); sb.AppendLine($" navigationAction?.Request?.Url = {navigationAction?.Request?.Url}"); sb.AppendLine($" navigationAction?.NavigationType = {navigationAction?.NavigationType}"); System.Diagnostics.Debug.WriteLine(sb.ToString()); #endif Uri uri = new Uri(webView.Url.AbsoluteString); string fragment = uri.Fragment; if ( fragment.Contains("access_token") || fragment.Contains("state") || fragment.Contains("expires_in") || fragment.Contains("error") ) { IDictionary <string, string> fragments = WebEx.FormDecode(uri.Fragment); Account account = new Account ( "", new Dictionary <string, string>(fragments) ); controller.authenticator.OnSucceeded(account); } else if ( fragment.Contains("code") ) { throw new NotImplementedException("code - Explicit/Server"); } if (navigationAction.NavigationType == WKNavigationType.LinkActivated) { UIApplication.SharedApplication.OpenUrl(navigationAction.Request.Url); decisionHandler(WKNavigationActionPolicy.Cancel); return; } // Navigation Allowed? // page will not load without this one! decisionHandler(WKNavigationActionPolicy.Allow); }
/// <summary> /// Event handler called when a new page is being loaded in the web browser. /// </summary> /// <param name='url'> /// The URL of the page. /// </param> public override bool OnPageLoading(Uri url) { var query = WebEx.FormDecode(url.Query); var fragment = WebEx.FormDecode(url.Fragment); OnPageEncountered(url, query, fragment); return(true); }
Task GetAccessTokenAsync() { var requestParams = new Dictionary <string, string> { { "oauth_token", token } }; if (verifier != null) { requestParams["oauth_verifier"] = verifier; } var req = OAuth1.CreateRequest( "GET", accessTokenUrl, requestParams, consumerKey, consumerSecret, tokenSecret); if (this.HttpWebClientFrameworkType == HttpWebClientFrameworkType.WebRequest) { return(req.GetResponseAsync().ContinueWith(respTask => { var content = respTask.Result.GetResponseText(); var accountProperties = WebEx.FormDecode(content); accountProperties["oauth_consumer_key"] = consumerKey; accountProperties["oauth_consumer_secret"] = consumerSecret; if (getUsernameAsync != null) { getUsernameAsync(accountProperties).ContinueWith(uTask => { if (uTask.IsFaulted) { OnError(uTask.Exception); } else { OnSucceeded(uTask.Result, accountProperties); } }); } else { OnSucceeded("", accountProperties); } })); } else if (this.HttpWebClientFrameworkType == HttpWebClientFrameworkType.HttpClient) { throw new NotImplementedException("HttpClient implementation!"); } return(null); }
/// <summary> /// Method that returns the initial URL to be displayed in the web browser. /// </summary> /// <returns> /// A task that will return the initial URL. /// </returns> public override Task <Uri> GetInitialUrlAsync() { /* * mc++ * OriginalString property of the Uri object should be used instead of AbsoluteUri * otherwise trailing slash is added. */ string oauth_callback_uri_absolute = callbackUrl.AbsoluteUri; string oauth_callback_uri_original = callbackUrl.OriginalString; System.Diagnostics.Debug.WriteLine("GetInitialUrlAsync callbackUrl.AbsoluteUri = " + oauth_callback_uri_absolute); System.Diagnostics.Debug.WriteLine("GetInitialUrlAsync callbackUrl.OriginalString = " + oauth_callback_uri_original); string oauth_callback_uri = oauth_callback_uri_absolute; var req = OAuth1.CreateRequest ( "GET", requestTokenUrl, new Dictionary <string, string>() { { "oauth_callback", oauth_callback_uri }, }, consumerKey, consumerSecret, "" ); if (this.HttpWebClientFrameworkType == HttpWebClientFrameworkType.WebRequest) { return(req.GetResponseAsync() .ContinueWith ( respTask => { var content = respTask.Result.GetResponseText(); var r = WebEx.FormDecode(content); token = r["oauth_token"]; tokenSecret = r["oauth_token_secret"]; string paramType = authorizeUrl.AbsoluteUri.IndexOf("?") >= 0 ? "&" : "?"; var url = authorizeUrl.AbsoluteUri + paramType + "oauth_token=" + Uri.EscapeDataString(token); return new Uri(url); } )); } else if (this.HttpWebClientFrameworkType == HttpWebClientFrameworkType.HttpClient) { throw new NotImplementedException("HttpClient implementation!"); } return(null); }
/// <summary> /// Event handler that watches for the callback URL to be loaded. /// </summary> /// <param name='url'> /// The URL of the loaded page. /// </param> public override void OnPageLoaded(Uri url) { if (url.Host == callbackUrl.Host && url.AbsolutePath == callbackUrl.AbsolutePath) { var query = url.Query; var r = WebEx.FormDecode(query); verifier = r["oauth_verifier"]; GetAccessTokenAsync(); } }
/// <summary> /// Event handler called when a page has completed loading. /// </summary> /// <param name='url'> /// The URL of the page. /// </param> public override void OnPageLoaded(Uri url) { IDictionary <string, string> query = WebEx.FormDecode(url.Query); IDictionary <string, string> fragment = WebEx.FormDecode(url.Fragment); this.Query = query; this.Fragment = fragment; OnPageEncountered(url, query, fragment); return; }
/// <summary> /// Asynchronously makes a request to the access token URL with the given parameters. /// </summary> /// <param name="queryValues">The parameters to make the request with.</param> /// <returns>The data provided in the response to the access token request.</returns> public async Task <IDictionary <string, string> > RequestAccessTokenAsync(IDictionary <string, string> queryValues) { // mc++ changed protected to public for extension methods RefreshToken (Adrian Stevens) var content = new FormUrlEncodedContent(queryValues); HttpClient client = new HttpClient(); //If client secret is set, use HTTP BASIC auth to authenticate to the token endpoint if (!string.IsNullOrEmpty(this.ClientSecret)) { client.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("basic", Convert.ToBase64String(UTF8Encoding.UTF8.GetBytes($"{this.ClientId}:{this.ClientSecret}"))); } HttpResponseMessage response = await client.PostAsync(accessTokenUrl, content).ConfigureAwait(false); string text = await response.Content.ReadAsStringAsync().ConfigureAwait(false); // Parse the response var data = text.Contains("{") ? WebEx.JsonDecode(text) : WebEx.FormDecode(text); if (data.ContainsKey("error")) { throw new AuthException("Error authenticating: " + data["error"]); } #region //--------------------------------------------------------------------------------------- /// Pull Request - manually added/fixed /// OAuth2Authenticator changes to work with joind.in OAuth #91 /// https://github.com/xamarin/Xamarin.Auth/pull/91 /// //else if (data.ContainsKey("access_token")) else if (data.ContainsKey(AccessTokenName)) //--------------------------------------------------------------------------------------- #endregion { } else { #region //--------------------------------------------------------------------------------------- /// Pull Request - manually added/fixed /// OAuth2Authenticator changes to work with joind.in OAuth #91 /// https://github.com/xamarin/Xamarin.Auth/pull/91 /// //throw new AuthException ("Expected access_token in access token response, but did not receive one."); throw new AuthException("Expected " + AccessTokenName + " in access token response, but did not receive one."); //--------------------------------------------------------------------------------------- #endregion } return(data); }
/// <summary> /// Asynchronously makes a request to the access token URL with the given parameters. /// </summary> /// <param name="queryValues">The parameters to make the request with.</param> /// <returns>The data provided in the response to the access token request.</returns> public async Task <IDictionary <string, string> > RequestAccessTokenAsync(IDictionary <string, string> queryValues) { // mc++ changed protected to public for extension methods RefreshToken (Adrian Stevens) var content = new FormUrlEncodedContent(queryValues); HttpClient client = new HttpClient(); HttpRequestMessage Message = new HttpRequestMessage(HttpMethod.Post, this.accessTokenUrl); Message.Content = content; if (this.UserAgent != null) { Message.Headers.Add(@"User-Agent", this.UserAgent); } HttpResponseMessage response = await client.SendAsync(Message).ConfigureAwait(false); string text = await response.Content.ReadAsStringAsync().ConfigureAwait(false); // Parse the response var data = text.Contains("{") ? WebEx.JsonDecode(text) : WebEx.FormDecode(text); if (data.ContainsKey("error")) { throw new AuthException("Error authenticating: " + data["error"]); } #region //--------------------------------------------------------------------------------------- /// Pull Request - manually added/fixed /// OAuth2Authenticator changes to work with joind.in OAuth #91 /// https://github.com/xamarin/Xamarin.Auth/pull/91 /// //else if (data.ContainsKey("access_token")) else if (data.ContainsKey(AccessTokenName)) //--------------------------------------------------------------------------------------- #endregion { } else { #region //--------------------------------------------------------------------------------------- /// Pull Request - manually added/fixed /// OAuth2Authenticator changes to work with joind.in OAuth #91 /// https://github.com/xamarin/Xamarin.Auth/pull/91 /// //throw new AuthException ("Expected access_token in access token response, but did not receive one."); throw new AuthException("Expected " + AccessTokenName + " in access token response, but did not receive one."); //--------------------------------------------------------------------------------------- #endregion } return(data); }
/// <summary> /// Asynchronously makes a request to the access token URL with the given parameters. /// </summary> /// <param name="queryValues">The parameters to make the request with.</param> /// <returns>The data provided in the response to the access token request.</returns> public async Task <IDictionary <string, string> > CustomRequestAccessTokenAsync(IDictionary <string, string> queryValues) { // mc++ changed protected to public for extension methods RefreshToken (Adrian Stevens) var content = new FormUrlEncodedContent(queryValues); HttpClient client = new HttpClient(); HttpResponseMessage response = await client.PostAsync(_accessTokenUrl, content).ConfigureAwait(false); string text = await response.Content.ReadAsStringAsync().ConfigureAwait(false); try { if (response.StatusCode != System.Net.HttpStatusCode.OK) { LogUtils.LogMessage(LogSeverity.WARNING, "CustomOAuth2Authenticator failed to refresh token.", "Error from service: " + text); System.Diagnostics.Debug.Print("Error from service: " + text); } } catch { } // Parse the response var data = text.Contains("{") ? WebEx.JsonDecode(text) : WebEx.FormDecode(text); if (data.ContainsKey("error")) { throw new AuthException("Error authenticating: " + data["error"]); } //--------------------------------------------------------------------------------------- /// Pull Request - manually added/fixed /// OAuth2Authenticator changes to work with joind.in OAuth #91 /// https://github.com/xamarin/Xamarin.Auth/pull/91 /// else if (data.ContainsKey(AccessTokenName)) //--------------------------------------------------------------------------------------- { } else { //--------------------------------------------------------------------------------------- /// Pull Request - manually added/fixed /// OAuth2Authenticator changes to work with joind.in OAuth #91 /// https://github.com/xamarin/Xamarin.Auth/pull/91 /// //throw new AuthException ("Expected access_token in access token response, but did not receive one."); throw new AuthException("Expected " + AccessTokenName + " in access token response, but did not receive one."); //--------------------------------------------------------------------------------------- } return(data); }
/// <summary> /// Event handler that watches for the callback URL to be loaded. /// </summary> /// <param name='url'> /// The URL of the loaded page. /// </param> public override void OnPageLoaded(Uri url) { if ( url.Authority == callbackUrl.Authority //url.Host == callbackUrl.Host && url.AbsolutePath == callbackUrl.AbsolutePath ) { var query = url.Query; var r = WebEx.FormDecode(query); r.TryGetValue("oauth_verifier", out verifier); #if DEBUG StringBuilder sb = new StringBuilder(); sb.AppendLine($"OAuth1Authenticator.OnPageLoaded "); sb.AppendLine($" url = {url.AbsoluteUri}"); sb.AppendLine($" oauth_verifier = {verifier}"); System.Diagnostics.Debug.WriteLine(sb.ToString()); #endif GetAccessTokenAsync().ContinueWith(getTokenTask => { if (getTokenTask.IsCanceled) { OnCancelled(); } else if (getTokenTask.IsFaulted) { OnError(getTokenTask.Exception); } }, TaskContinuationOptions.NotOnRanToCompletion); } else { // http[s]://www.xamarin.com != http[s]://xamarin.com #if DEBUG StringBuilder sb = new StringBuilder(); sb.AppendLine($"OAuth1Authenticator.OnPageLoaded "); sb.AppendLine($" mc++ fix"); sb.AppendLine($" url = {url.AbsoluteUri}"); sb.AppendLine($" callbackUrl = {callbackUrl.AbsoluteUri}"); sb.AppendLine($" oauth_verifier = {verifier}"); System.Diagnostics.Debug.WriteLine(sb.ToString()); #endif } return; }
public static async Task <string> GetRefreshTokenAsync() { byte[] buffer = new byte[32]; Randomizer.NextBytes(buffer); var codeVerifier = Convert.ToBase64String(buffer).Replace('+', '-').Replace('/', '_').Replace("=", ""); byte[] hash = HashProvider.ComputeHash(Encoding.UTF8.GetBytes(codeVerifier)); var codeChallenge = Convert.ToBase64String(hash).Replace('+', '-').Replace('/', '_').Replace("=", ""); var redirectUri = new Uri(ProdRedirectUrl); string scope = $"{OfflineAccessScope} {WNSScope} {CCSScope} {UserNotificationsScope} {UserActivitiesScope} {DdsScope}"; var startUri = new Uri($"{ProdAuthorizeUrl}?client_id={Secrets.MSA_CLIENT_ID}&response_type=code&code_challenge_method=S256&code_challenge={codeChallenge}&redirect_uri={ProdRedirectUrl}&scope={scope}"); var webAuthenticationResult = await WebAuthenticationBroker.AuthenticateAsync( WebAuthenticationOptions.None, startUri, redirectUri); if (webAuthenticationResult.ResponseStatus == WebAuthenticationStatus.Success) { var codeResponseUri = new Uri(webAuthenticationResult.ResponseData); IDictionary <string, string> queryParams = WebEx.FormDecode(codeResponseUri.Query); if (!queryParams.ContainsKey("code")) { return(string.Empty); } string authCode = queryParams["code"]; Dictionary <string, string> refreshTokenQuery = new Dictionary <string, string> { { "client_id", Secrets.MSA_CLIENT_ID }, { "redirect_uri", redirectUri.AbsoluteUri }, { "grant_type", "authorization_code" }, { "code", authCode }, { "code_verifier", codeVerifier }, { "scope", WNSScope } }; IDictionary <string, string> refreshTokenResponse = await RequestAccessTokenAsync(ProdAccessTokenUrl, refreshTokenQuery); if (refreshTokenResponse.ContainsKey("refresh_token")) { return(refreshTokenResponse["refresh_token"]); } } return(string.Empty); }
/// <summary> /// Asynchronously makes a request to the access token URL with the given parameters. /// </summary> /// <param name="queryValues">The parameters to make the request with.</param> /// <returns>The data provided in the response to the access token request.</returns> public async Task <IDictionary <string, string> > RequestAccessTokenAsync(IDictionary <string, string> queryValues) { // mc++ changed protected to public for extension methods RefreshToken (Adrian Stevens) var content = new FormUrlEncodedContent(queryValues); HttpClient client = new HttpClient(); HttpResponseMessage response = await client.PostAsync(accessTokenUrl, content).ConfigureAwait(false); string text = await response.Content.ReadAsStringAsync().ConfigureAwait(false); // Parse the response var data = text.Contains("{") ? WebEx.JsonDecode(text) : WebEx.FormDecode(text); if (data.ContainsKey("error")) { System.Diagnostics.Debug.WriteLine($"RequestAccessTokenAsync exception {text}");//log actual response from server throw new AuthException("Error authenticating: " + data["error"]); } #region //--------------------------------------------------------------------------------------- /// Pull Request - manually added/fixed /// OAuth2Authenticator changes to work with joind.in OAuth #91 /// https://github.com/xamarin/Xamarin.Auth/pull/91 /// //else if (data.ContainsKey("access_token")) else if (data.ContainsKey(AccessTokenName)) //--------------------------------------------------------------------------------------- #endregion { } else { #region //--------------------------------------------------------------------------------------- /// Pull Request - manually added/fixed /// OAuth2Authenticator changes to work with joind.in OAuth #91 /// https://github.com/xamarin/Xamarin.Auth/pull/91 /// //throw new AuthException ("Expected access_token in access token response, but did not receive one."); throw new AuthException("Expected " + AccessTokenName + " in access token response, but did not receive one."); //--------------------------------------------------------------------------------------- #endregion } return(data); }
Task GetAccessTokenAsync() { var requestparams = new Dictionary <string, string> { { "oauth_token", token }, }; if (verifier != null) { requestparams["oauth_verifier"] = verifier; } var req = OAuth1.CreateRequest( "GET", accessTokenUrl, requestparams, consumerKey, consumerSecret, tokenSecret); return(req.GetResponseAsync().ContinueWith(respTask => { var content = respTask.Result.GetResponseText(); var accountProperties = WebEx.FormDecode(content); accountProperties["oauth_consumer_key"] = consumerKey; accountProperties["oauth_consumer_secret"] = consumerSecret; if (getUsernameAsync != null) { getUsernameAsync(accountProperties).ContinueWith(uTask => { if (uTask.IsFaulted) { OnError(uTask.Exception); } else { OnSucceeded(uTask.Result, accountProperties); } }); } else { OnSucceeded("", accountProperties); } })); }
/// <summary> /// Event handler called when a new page is being loaded in the web browser. /// </summary> /// <param name='url'> /// The URL of the page. /// </param> public override void OnPageLoading(Uri url) { #if DEBUG System.Text.StringBuilder sb = new System.Text.StringBuilder(); sb.AppendLine("WebRedirectAuthenticator OnPageLoading Called"); sb.AppendLine(" AbsoluteUri = ").AppendLine(url.AbsoluteUri); sb.AppendLine(" AbsolutePath = ").AppendLine(url.AbsolutePath); System.Diagnostics.Debug.WriteLine(sb.ToString()); #endif var query = WebEx.FormDecode(url.Query); var fragment = WebEx.FormDecode(url.Fragment); // mc++ // TODO: schemas OnPageEncountered(url, query, fragment); return; }
public virtual async void OnSsoLoginLogoutRedirectCompleted(Uri url) { Dictionary <string, string> query = (Dictionary <string, string>)WebEx.FormDecode(url.Fragment); if (CurrentAction == "Logout") { CurrentLogoutTaskCompletionSource.SetResult(null); } else { Token token = query; Account account = Token.FromTokenToAccount(token); await _accountStore.SaveAsync(account, _clientAppProfile.AppName).ConfigureAwait(false); CurrentLoginTaskCompletionSource.SetResult(query); } }
/// <summary> /// Implements: http://tools.ietf.org/html/rfc6749#section-4.1 /// </summary> /// <returns> /// The access token async. /// </returns> /// <param name='code'> /// Code. /// </param> Task <Dictionary <string, string> > RequestAccessTokenAsync(string code) { var queryValues = new Dictionary <string, string> { { "grant_type", "authorization_code" }, { "code", code }, { "redirect_uri", redirectUrl.AbsoluteUri }, { "client_id", clientId }, }; if (!string.IsNullOrEmpty(clientSecret)) { queryValues ["client_secret"] = clientSecret; } var query = queryValues.FormEncode(); var req = WebRequest.Create(accessTokenUrl); req.Method = "POST"; req.Proxy = WebAuthenticator.Proxy; var body = Encoding.UTF8.GetBytes(query); req.ContentLength = body.Length; req.ContentType = "application/x-www-form-urlencoded"; using (var s = req.GetRequestStream()) { s.Write(body, 0, body.Length); } return(req.GetResponseAsync().ContinueWith(task => { var text = task.Result.GetResponseText(); var data = WebEx.FormDecode(text); if (data.ContainsKey("error")) { throw new AuthException("Error authenticating: " + data ["error"]); } else if (data.ContainsKey("access_token")) { return data; } else { throw new AuthException("Expected access_token in access token response, but did not receive one."); } })); }
/// <summary> /// Event handler that watches for the callback URL to be loaded. /// </summary> /// <param name='url'> /// The URL of the loaded page. /// </param> public override void OnPageLoaded(Uri url) { if (url.Host == callbackUrl.Host && url.AbsolutePath == callbackUrl.AbsolutePath) { var query = url.Query; var r = WebEx.FormDecode(query); r.TryGetValue("oauth_verifier", out verifier); GetAccessTokenAsync().ContinueWith(getTokenTask => { if (getTokenTask.IsCanceled) { OnCancelled(); } else if (getTokenTask.IsFaulted) { OnError(getTokenTask.Exception); } }, TaskContinuationOptions.NotOnRanToCompletion); } }
protected override void OnRedirectPageLoaded(Uri url, IDictionary <string, string> query, IDictionary <string, string> fragment) { if (query.ContainsKey("code")) { var autorizationCode = query["code"]; var tokenUrl = GetTokenUrl(); try { using (var client = new HttpClient()) { var postBody = new Dictionary <string, string>(); postBody.Add("grant_type", "authorization_code"); postBody.Add("client_id", this.ClientId); postBody.Add("code_verifier", this.verifier); postBody.Add("redirect_uri", this.RedirectUrl.AbsoluteUri); postBody.Add("code", autorizationCode); var request = new HttpRequestMessage(HttpMethod.Post, tokenUrl); request.Content = new FormUrlEncodedContent(postBody); request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded"); var response = client.SendAsync(request).Result; OnTokenReceived(new EventArgs()); response.EnsureSuccessStatusCode(); var res = response.Content.ReadAsStringAsync().Result; var data = res.Contains("{") ? WebEx.JsonDecode(res) : WebEx.FormDecode(res); OnSucceeded(string.Empty, data); } } catch { OnError("An unexpected error occured while getting access token."); } } else { OnError("The expected authorization code not received"); } base.OnRedirectPageLoaded(url, query, fragment); }
public override void DidFailProvisionalNavigation ( WKWebView webView, WKNavigation navigation, NSError error ) { // Provisional Navigation Failed? WAT? if // loading custom url scheme will result in unsupported URL ( error.Code == -1002 || error.LocalizedDescription == "unsupported URL" ) { //custom url schema // NSUrl url_ios = webView.Url; // old URL string url_redirect = error.UserInfo[new NSString("NSErrorFailingURLKey")].ToString(); System.Uri uri = new Uri(url_redirect); IDictionary <string, string> fragment = WebEx.FormDecode(uri.Fragment); Account account = new Account ( "", new Dictionary <string, string>(fragment) ); controller.authenticator.OnSucceeded(account); } #if DEBUG StringBuilder sb = new StringBuilder(); sb.AppendLine($"WKWebViewNavigationDelegate.DidFailProvisionalNavigation "); sb.AppendLine($" error.LocalizedDescription = {error.LocalizedDescription}"); sb.AppendLine($" webView.Url.AbsoluteString = {webView.Url.AbsoluteString}"); System.Diagnostics.Debug.WriteLine(sb.ToString()); #endif return; }
public override Task <IDictionary <string, string> > GetAccessTokenAsync(Account acc, CancellationToken token) { if (string.IsNullOrEmpty(ConsumerKey) || string.IsNullOrEmpty(ConsumerSecret)) { throw new InvalidOperationException("Cannot perform Twitter Reverse Auth without ConsumerKey and ConsumerSecret set."); } return(new ReverseAuthRequest(acc, ConsumerKey, ConsumerSecret) .GetResponseAsync(token) .ContinueWith(t => { var parameters = new Dictionary <string, string> { { "x_reverse_auth_target", ConsumerKey }, { "x_reverse_auth_parameters", t.Result.GetResponseText() } }; return this.CreateRequest("POST", new Uri("https://api.twitter.com/oauth/access_token"), parameters, acc) .GetResponseAsync(token) .ContinueWith(tokenTask => { return WebEx.FormDecode(tokenTask.Result.GetResponseText()); }, token); }, token).Unwrap()); }
/// <summary> /// Method that returns the initial URL to be displayed in the web browser. /// </summary> /// <returns> /// A task that will return the initial URL. /// </returns> public override Task <Uri> GetInitialUrlAsync() { var req = OAuth1.CreateRequest( "GET", requestTokenUrl, new Dictionary <string, string>() { { "oauth_callback", callbackUrl.AbsoluteUri }, }, consumerKey, consumerSecret, ""); if (this.HttpWebClientFrameworkType == HttpWebClientFrameworkType.WebRequest) { return(req.GetResponseAsync().ContinueWith(respTask => { var content = respTask.Result.GetResponseText(); var r = WebEx.FormDecode(content); token = r["oauth_token"]; tokenSecret = r["oauth_token_secret"]; string paramType = authorizeUrl.AbsoluteUri.IndexOf("?") >= 0 ? "&" : "?"; var url = authorizeUrl.AbsoluteUri + paramType + "oauth_token=" + Uri.EscapeDataString(token); return new Uri(url); })); } else if (this.HttpWebClientFrameworkType == HttpWebClientFrameworkType.HttpClient) { throw new NotImplementedException("HttpClient implementation!"); } return(null); }