private async Task StartAuthorization(MobileConnectStatus response) { _state = Guid.NewGuid().ToString("N"); _nonce = Guid.NewGuid().ToString("N"); var newResponse = _mobileConnect.StartAuthorization(_discoveryResponse, response.DiscoveryResponse.ResponseData.subscriber_id, _state, _nonce, new MobileConnectRequestOptions()); await HandleResponse(newResponse); }
private void ShowIdentity(MobileConnectStatus status) { loggedPanel.Visibility = Visibility.Collapsed; identityPanel.Visibility = Visibility.Visible; var json = new Newtonsoft.Json.Linq.JRaw(status.IdentityResponse.ResponseJson); identity.Text = json.ToString(Newtonsoft.Json.Formatting.Indented); }
public void ResponseConverterShouldHandleStartDiscoveryStatus() { var status = MobileConnectStatus.StartDiscovery(); var actual = ResponseConverter.Convert(status); Assert.IsNotNull(actual); Assert.AreEqual("success", actual.Status); Assert.AreEqual("discovery", actual.Action); }
public void ResponseConverterShouldHandleTokenRevokedStatus() { var response = new RevokeTokenResponse(_responses["token-revoked"]); var status = MobileConnectStatus.TokenRevoked(response); var actual = ResponseConverter.Convert(status); Assert.IsNotNull(actual); Assert.AreEqual("success", actual.Status); Assert.AreEqual("token_revoked", actual.Action); }
public void ResponseConverterShouldHandleOperatorSelectionStatus() { var status = MobileConnectStatus.OperatorSelection(OPERATOR_SELECTION_URL); var actual = ResponseConverter.Convert(status); Assert.IsNotNull(actual); Assert.AreEqual("success", actual.Status); Assert.AreEqual("operator_selection", actual.Action); Assert.AreEqual(OPERATOR_SELECTION_URL, actual.Url); }
public void ResponseConverterShouldHandleCompleteStatus() { var response = new RequestTokenResponse(_responses["token"]); var status = MobileConnectStatus.Complete(response); var actual = ResponseConverter.Convert(status); Assert.IsNotNull(actual); Assert.AreEqual("success", actual.Status); Assert.AreEqual("complete", actual.Action); Assert.AreEqual(status.TokenResponse.ResponseData, actual.Token); }
protected IHttpActionResult GetHttpMsgWithRedirect(string url, string errMsg = null) { if (string.IsNullOrEmpty(url)) { return(CreateResponse(MobileConnectStatus.Error(ErrorCodes.InvalidArgument, errMsg, new Exception()))); } var authResponse = Request.CreateResponse(HttpStatusCode.Redirect); authResponse.Headers.Location = new Uri(url); return(new ResponseMessageResult(authResponse)); }
public void ResponseConverterShouldHandleErrorStatus() { var error = "this is the error"; var description = "this is the description"; var status = MobileConnectStatus.Error(error, description, null); var actual = ResponseConverter.Convert(status); Assert.IsNotNull(actual); Assert.AreEqual("failure", actual.Status); Assert.AreEqual("error", actual.Action); Assert.AreEqual(error, actual.Error); Assert.AreEqual(description, actual.Description); }
private IHttpActionResult CreateResponse(MobileConnectStatus status) { var response = Request.CreateResponse(HttpStatusCode.OK, ResponseConverter.Convert(status)); if (status.SetCookie != null) { foreach (var cookie in status.SetCookie) { response.Headers.Add("Set-Cookie", cookie); } } return(new ResponseMessageResult(response)); }
private void Complete(MobileConnectStatus response) { _state = null; _nonce = null; _token = response.TokenResponse.ResponseData; accessToken.Text = _token.AccessToken; idToken.Text = _token.IdToken; timeReceived.Text = _token.TimeReceived.ToString("u"); applicationName.Text = _discoveryResponse.ApplicationShortName ?? ""; validationResult.Text = response.TokenResponse.ValidationResult.ToString(); loginPanel.Visibility = Visibility.Collapsed; loggedPanel.Visibility = Visibility.Visible; }
public void ResponseConverterShouldHandleAuthenticationStatus() { var state = "qpwoeirurytalsksjdhdgf"; var nonce = "qpwowieuryrttalksjsggdfj"; var status = MobileConnectStatus.Authentication(AUTHORIZE_URL, state, nonce); var actual = ResponseConverter.Convert(status); Assert.IsNotNull(actual); Assert.AreEqual("success", actual.Status); Assert.AreEqual("authentication", actual.Action); Assert.AreEqual(AUTHORIZE_URL, actual.Url); Assert.AreEqual(state, actual.State); Assert.AreEqual(nonce, actual.Nonce); }
public void ResponseConverterShouldHandleStartAuthenticationStatus() { var session = "session"; var response = new DiscoveryResponse(_responses["authentication"]); var status = MobileConnectStatus.StartAuthentication(response); status.SDKSession = session; var actual = ResponseConverter.Convert(status); Assert.IsNotNull(actual); Assert.AreEqual("success", actual.Status); Assert.AreEqual("start_authentication", actual.Action); Assert.IsNotNull(actual.SdkSession); Assert.IsNotNull(actual.SubscriberId); }
private async Task StartAuthentication(MobileConnectStatus response) { _state = Utils.Security.GenerateSecureNonce(); _nonce = Utils.Security.GenerateSecureNonce(); _discoveryResponse = response.DiscoveryResponse; _authOptions = new MobileConnectRequestOptions { Scope = GetScope(), Context = "demo", BindingMessage = "demo auth", // Accept valid results and results indicating validation was skipped due to missing support on the provider AcceptedValidationResults = TokenValidationResult.Valid | TokenValidationResult.IdTokenValidationSkipped, }; var newResponse = _mobileConnect.StartAuthentication(_discoveryResponse, response.DiscoveryResponse.ResponseData.subscriber_id, _state, _nonce, _authOptions); await HandleResponse(newResponse); }
private async Task HandleResponse(MobileConnectStatus response) { System.Diagnostics.Debug.WriteLine(response.ResponseType); if (response.ResponseType == MobileConnectResponseType.OperatorSelection || response.ResponseType == MobileConnectResponseType.Authorization) { web.Navigate(new Uri(response.Url)); } else if (response.ResponseType == MobileConnectResponseType.StartAuthorization) { await StartAuthorization(response); } else if (response.ResponseType == MobileConnectResponseType.Complete) { System.Diagnostics.Debug.WriteLine(response.TokenResponse.ResponseData.AccessToken); Complete(response.TokenResponse.ResponseData.AccessToken); } else if (response.ResponseType == MobileConnectResponseType.Error) { HandleError(response); } }
private async Task HandleResponse(MobileConnectStatus response) { System.Diagnostics.Debug.WriteLine(response.ResponseType); switch (response.ResponseType) { case MobileConnectResponseType.Error: HandleError(response); break; case MobileConnectResponseType.OperatorSelection: case MobileConnectResponseType.Authentication: web.Navigate(new Uri(response.Url)); break; case MobileConnectResponseType.StartDiscovery: await StartDiscovery(null); break; case MobileConnectResponseType.StartAuthentication: await StartAuthentication(response); break; case MobileConnectResponseType.Complete: Complete(response); break; case MobileConnectResponseType.TokenRevoked: validationResult.Text = "Token Revoked"; identityButton.IsEnabled = false; userInfoButton.IsEnabled = false; break; case MobileConnectResponseType.UserInfo: case MobileConnectResponseType.Identity: ShowIdentity(response); break; } }
protected IHttpActionResult CreateResponse(MobileConnectStatus status) { HttpResponseMessage response; if (!string.IsNullOrEmpty(status.ErrorCode)) { response = Request.CreateResponse(HttpStatusCode.Found, ResponseConverter.Convert(status)); } else { response = Request.CreateResponse(HttpStatusCode.OK, ResponseConverter.Convert(status)); } if (status.SetCookie != null) { foreach (var cookie in status.SetCookie) { response.Headers.Add("Set-Cookie", cookie); } } return(new ResponseMessageResult(response)); }
/// <summary> /// Convert to lightweight serializable MobileConnectWebResponse /// </summary> /// <param name="status">Input status instance</param> /// <returns>Serializable response instance</returns> /// <example> /// <code language="C#" title="WebApi Controller Example"> /// <![CDATA[ /// [HttpGet] /// [Route("start_discovery")] /// public async Task<object> StartDiscovery(string msisdn = "", string mcc = "", string mnc = "") /// { /// var response = await _mobileConnect.AttemptDiscovery(Request, msisdn, mcc, mnc, true, new MobileConnectRequestOptions()); /// return ResponseConverter.Convert(response); /// } /// ]]> /// </code> /// </example> public static MobileConnectWebResponse Convert(MobileConnectStatus status) { var response = new MobileConnectWebResponse { Status = _statusDict[status.ResponseType], Action = _actionDict[status.ResponseType], Nonce = status.Nonce, State = status.State, Url = status.Url, SdkSession = status.SDKSession, SubscriberId = status.DiscoveryResponse?.ResponseData?.subscriber_id, Token = status.TokenResponse?.ResponseData, }; if (status.ResponseType == MobileConnectResponseType.Error) { response.Error = status.ErrorCode; response.Description = status.ErrorMessage; } return(response); }
protected IHttpActionResult CreateIdentityResponse(MobileConnectStatus authnStatus, MobileConnectStatus identityUserInfoStatustatus = null) { var authnResponse = Request.CreateResponse(HttpStatusCode.OK, ResponseConverter.Convert(authnStatus)); if (identityUserInfoStatustatus != null) { var response = Request.CreateResponse(HttpStatusCode.OK, ResponseConverter.Convert(identityUserInfoStatustatus)); authnResponse.Content = new StringContent(СreateNewHttpResponseMessage(authnResponse, response)); if (identityUserInfoStatustatus.SetCookie != null) { foreach (var cookie in identityUserInfoStatustatus.SetCookie) { authnResponse.Headers.Add("Set-Cookie", cookie); } } } else { authnResponse.Content = new StringContent(СreateNewHttpResponseMessage(authnResponse)); } return(new ResponseMessageResult(authnResponse)); }
/// <summary> /// Convert to lightweight serializable MobileConnectWebResponse /// </summary> /// <param name="status">Input status instance</param> /// <returns>Serializable response instance</returns> /// <example> /// <code language="C#" title="WebApi Controller Example"> /// <![CDATA[ /// [HttpGet] /// [Route("start_discovery")] /// public async Task<object> StartDiscovery(string msisdn = "", string mcc = "", string mnc = "") /// { /// var response = await _mobileConnect.AttemptDiscovery(Request, msisdn, mcc, mnc, true, new MobileConnectRequestOptions()); /// return ResponseConverter.Convert(response); /// } /// ]]> /// </code> /// </example> public static MobileConnectWebResponse Convert(MobileConnectStatus status) { var response = new MobileConnectWebResponse { Status = status.ResponseType == MobileConnectResponseType.Error ? STATUS_FAILURE : STATUS_SUCCESS, Action = _actionDict[status.ResponseType], ApplicationShortName = status.DiscoveryResponse?.ApplicationShortName, Nonce = status.Nonce, State = status.State, Url = status.Url, SdkSession = status.SDKSession, SubscriberId = status.DiscoveryResponse?.ResponseData?.subscriber_id, Token = status.TokenResponse?.ResponseData, Identity = status.IdentityResponse?.ResponseJson != null ? new Newtonsoft.Json.Linq.JRaw(status.IdentityResponse.ResponseJson) : null, }; if (status.ResponseType == MobileConnectResponseType.Error) { response.Error = status.ErrorCode; response.Description = status.ErrorMessage; } return(response); }
private void HandleError(MobileConnectStatus response) { errorText.Text = response?.ErrorMessage; progress.Visibility = Visibility.Collapsed; submit.IsEnabled = true; }
protected bool HandleErrorMsg(MobileConnectStatus status) { return(!string.IsNullOrEmpty(status.ErrorMessage)); }
public async Task <IHttpActionResult> DiscoveryCallback( string state = null, string error = null, string error_description = null, string description = null) { if (!string.IsNullOrEmpty(error)) { return(CreateResponse(MobileConnectStatus.Error(error, error_description != null ? error_description : description, new Exception()))); } var options = new MobileConnectRequestOptions { AcceptedValidationResults = Authentication.TokenValidationResult.Valid | Authentication.TokenValidationResult.IdTokenValidationSkipped, Context = ApiVersion.Equals(Utils.Constants.VERSION2_0) || ApiVersion.Equals(Utils.Constants.VERSION2_3) ? Utils.Constants.ContextBindingMsg : null, BindingMessage = ApiVersion.Equals(Utils.Constants.VERSION2_0) || ApiVersion.Equals(Utils.Constants.VERSION2_3) ? Utils.Constants.ContextBindingMsg : null, ClientName = OperatorParams.clientName, AcrValues = OperatorParams.acrValues }; Uri requestUri = Request.RequestUri; SessionData sessionData = SessionCache.Get(state); MobileConnectStatus status = await MobileConnect.HandleUrlRedirectAsync(Request, requestUri, sessionData.DiscoveryResponse, state, sessionData.Nonce, options, ApiVersion); var idTokenResponseModel = JsonConvert.DeserializeObject <IdTokenResponse>(status.TokenResponse.DecodedIdTokenPayload); MobileConnectStatus response = null; if (idTokenResponseModel.nonce.Equals(sessionData.Nonce)) { if (ApiVersion.Equals(Utils.Constants.VERSION1_1) & !string.IsNullOrEmpty(sessionData.DiscoveryResponse.OperatorUrls.UserInfoUrl)) { for (int scopeIndex = 0; scopeIndex < UserInfoScopes.Length; scopeIndex++) { if (OperatorParams.scope.Contains(UserInfoScopes[scopeIndex])) { response = await RequestUserInfo(sessionData.DiscoveryResponse, status.TokenResponse.ResponseData.AccessToken); return(CreateIdentityResponse(status, response)); } } } if ((ApiVersion.Equals(Utils.Constants.VERSION2_0) || ApiVersion.Equals(Utils.Constants.VERSION2_3)) & !string.IsNullOrEmpty(sessionData.DiscoveryResponse.OperatorUrls.PremiumInfoUrl)) { for (int scopeIndex = 0; scopeIndex < IdentityScopes.Length; scopeIndex++) { if (OperatorParams.scope.Contains(IdentityScopes[scopeIndex])) { response = await RequestPremiumInfo(sessionData.DiscoveryResponse, status.TokenResponse.ResponseData.AccessToken); return(CreateIdentityResponse(status, response)); } } } } else { response = MobileConnectStatus.Error( ErrorCodes.InvalidArgument, "nonce is incorrect", new Exception()); return(CreateResponse(response)); } // return CreateResponse(status); return(CreateIdentityResponse(status)); }
private async void SetSessionCache(MobileConnectStatus status, string msisdn, string mcc, string mnc, string sourceIp) { await SessionCache.Add(status.State, new SessionData(DiscoveryCache.Get(StringUtils.FormatKey(msisdn, mcc, mnc, sourceIp)), status.Nonce)); }
private void HandleError(MobileConnectStatus response) { errorText.Text = response.ErrorMessage; progress.Visibility = Visibility.Collapsed; }
private async void SetSessionCache(MobileConnectStatus status, DiscoveryResponse discoveryResponse, string nonce) { await SessionCache.Add(status.State, new SessionData(discoveryResponse, nonce)); }