Exemplo n.º 1
0
        bool IExtensionResponse.Deserialize(IDictionary <string, string> fields, IAuthenticationResponse response, string typeUri)
        {
            if (fields == null)
            {
                return(false);
            }
            string mode;

            fields.TryGetValue("mode", out mode);
            if (mode != Mode)
            {
                return(false);
            }

            string updateUrl;

            fields.TryGetValue("update_url", out updateUrl);
            Uri updateUri;

            if (Uri.TryCreate(updateUrl, UriKind.Absolute, out updateUri))
            {
                UpdateUrl = updateUri;
            }

            foreach (var att in DeserializeAttributes(fields))
            {
                AddAttribute(att);
            }

            return(true);
        }
        private ActionResult CreateHltbsRedirectionResponse(IAuthenticationResponse response)
        {
            if (response.Status != AuthenticationStatus.Authenticated)
            {
                SiteEventSource.Log.SteamAuthenticationFailed(response.Status);
                return(CreateSiteRedirection());
            }

            long steam64Id;

            try
            {
                steam64Id = Int64.Parse(GetSteam64IdFromClaimedId(response.ClaimedIdentifier), CultureInfo.InvariantCulture);
            }
            catch (FormatException e)
            {
                SiteEventSource.Log.MalformedSteamClaimedIdProvided(response.ClaimedIdentifier, e.Message);
                return(CreateSiteRedirection());
            }
            catch (OverflowException e)
            {
                SiteEventSource.Log.MalformedSteamClaimedIdProvided(response.ClaimedIdentifier, e.Message);
                return(CreateSiteRedirection());
            }

            SiteEventSource.Log.SteamAuthenticationSucceeded(response.FriendlyIdentifierForDisplay);
            return(CreateSiteRedirection(steam64Id));
        }
		/// <summary>
		/// Processes an incoming authorization-granted message from an SP and obtains an access token.
		/// </summary>
		/// <param name="openIdAuthenticationResponse">The OpenID authentication response that may be carrying an authorized request token.</param>
		/// <returns>
		/// The access token, or null if OAuth authorization was denied by the user or service provider.
		/// </returns>
		/// <remarks>
		/// The access token, if granted, is automatically stored in the <see cref="ConsumerBase.TokenManager"/>.
		/// The token manager instance must implement <see cref="IOpenIdOAuthTokenManager"/>.
		/// </remarks>
		public AuthorizedTokenResponse ProcessUserAuthorization(IAuthenticationResponse openIdAuthenticationResponse) {
			Requires.NotNull(openIdAuthenticationResponse, "openIdAuthenticationResponse");
			Requires.ValidState(this.TokenManager is IOpenIdOAuthTokenManager);
			var openidTokenManager = this.TokenManager as IOpenIdOAuthTokenManager;
			ErrorUtilities.VerifyOperation(openidTokenManager != null, OAuthStrings.OpenIdOAuthExtensionRequiresSpecialTokenManagerInterface, typeof(IOpenIdOAuthTokenManager).FullName);

			// The OAuth extension is only expected in positive assertion responses.
			if (openIdAuthenticationResponse.Status != AuthenticationStatus.Authenticated) {
				return null;
			}

			// Retrieve the OAuth extension
			var positiveAuthorization = openIdAuthenticationResponse.GetExtension<AuthorizationApprovedResponse>();
			if (positiveAuthorization == null) {
				return null;
			}

			// Prepare a message to exchange the request token for an access token.
			// We are careful to use a v1.0 message version so that the oauth_verifier is not required.
			var requestAccess = new AuthorizedTokenRequest(this.ServiceProvider.AccessTokenEndpoint, Protocol.V10.Version) {
				RequestToken = positiveAuthorization.RequestToken,
				ConsumerKey = this.ConsumerKey,
			};

			// Retrieve the access token and store it in the token manager.
			openidTokenManager.StoreOpenIdAuthorizedRequestToken(this.ConsumerKey, positiveAuthorization);
			var grantAccess = this.Channel.Request<AuthorizedTokenResponse>(requestAccess);
			this.TokenManager.ExpireRequestTokenAndStoreNewAccessToken(this.ConsumerKey, positiveAuthorization.RequestToken, grantAccess.AccessToken, grantAccess.TokenSecret);

			// Provide the caller with the access token so it may be associated with the user
			// that is logging in.
			return grantAccess;
		}
Exemplo n.º 4
0
        private string GetFriendlyName(IAuthenticationResponse authResponse)
        {
            string friendlyName = "";

            var sregResponse = authResponse.GetExtension <ClaimsResponse>();
            var axResponse   = authResponse.GetExtension <FetchResponse>();

            if (sregResponse != null)
            {
                friendlyName =
                    sregResponse.FullName.AsNullIfEmpty() ??
                    sregResponse.Nickname.AsNullIfEmpty() ??
                    sregResponse.Email;
            }
            else if (axResponse != null)
            {
                var fullName  = axResponse.GetAttributeValue(WellKnownAttributes.Name.FullName);
                var firstName = axResponse.GetAttributeValue(WellKnownAttributes.Name.First);
                var lastName  = axResponse.GetAttributeValue(WellKnownAttributes.Name.Last);
                var email     = axResponse.GetAttributeValue(WellKnownAttributes.Contact.Email);

                friendlyName =
                    fullName.AsNullIfEmpty() ??
                    ((!string.IsNullOrEmpty(firstName) && !string.IsNullOrEmpty(lastName)) ? firstName + " " + lastName : null) ??
                    email;
            }

            if (string.IsNullOrEmpty(friendlyName))
            {
                friendlyName = authResponse.FriendlyIdentifierForDisplay;
            }

            return(friendlyName);
        }
		public override void SetUp() {
			base.SetUp();

			IndirectSignedResponse responseMessage = new IndirectSignedResponse(Protocol.Default.Version, RPUri);
			this.extensions = responseMessage.Extensions;
			this.response = new DotNetOpenAuth.OpenId.RelyingParty.PositiveAnonymousResponse(responseMessage);
		}
Exemplo n.º 6
0
        public MockRelyingParty()
        {
            var mock = new Mock <IAuthenticationResponse>();

            mock.SetupGet(r => r.Status).Returns(AuthenticationStatus.Authenticated);
            this.response = mock.Object;
        }
Exemplo n.º 7
0
        public async Task UnsolicitedAssertion()
        {
            var opStore = new MemoryCryptoKeyAndNonceStore();

            Handle(RPUri).By(
                async req => {
                var rp = new OpenIdRelyingParty(new MemoryCryptoKeyAndNonceStore(), this.HostFactories);
                IAuthenticationResponse response = await rp.GetResponseAsync(req);
                Assert.That(response, Is.Not.Null);
                Assert.AreEqual(AuthenticationStatus.Authenticated, response.Status);
                return(new HttpResponseMessage());
            });
            Handle(OPUri).By(
                async(req, ct) => {
                var op = new OpenIdProvider(opStore, this.HostFactories);
                return(await this.AutoProviderActionAsync(op, req, ct));
            });
            this.RegisterMockRPDiscovery(ssl: false);

            {
                var        op        = new OpenIdProvider(opStore, this.HostFactories);
                Identifier id        = GetMockIdentifier(ProtocolVersion.V20);
                var        assertion = await op.PrepareUnsolicitedAssertionAsync(OPUri, RPRealmUri, id, OPLocalIdentifiers[0]);

                using (var httpClient = this.HostFactories.CreateHttpClient()) {
                    using (var response = await httpClient.GetAsync(assertion.Headers.Location)) {
                        response.EnsureSuccessStatusCode();
                    }
                }
            }
        }
Exemplo n.º 8
0
        /// <summary>
        /// Check if authentication succeeded after user is redirected back from the service provider.
        /// </summary>
        /// <param name="context">
        /// The context of the current request.
        /// </param>
        /// <returns>
        /// An instance of <see cref="AuthenticationResult"/> containing authentication result.
        /// </returns>
        public virtual AuthenticationResult VerifyAuthentication(HttpContextBase context)
        {
            IAuthenticationResponse response = RelyingParty.GetResponse();

            if (response == null)
            {
                throw new InvalidOperationException(WebResources.OpenIDFailedToGetResponse);
            }

            if (response.Status == AuthenticationStatus.Authenticated)
            {
                string id = response.ClaimedIdentifier;
                string username;

                Dictionary <string, string> extraData = this.GetExtraData(response) ?? new Dictionary <string, string>();

                // try to look up username from the 'username' or 'email' property. If not found, fall back to 'friendly id'
                if (!extraData.TryGetValue("username", out username) && !extraData.TryGetValue("email", out username))
                {
                    username = response.FriendlyIdentifierForDisplay;
                }

                return(new AuthenticationResult(true, this.ProviderName, id, username, extraData));
            }

            return(AuthenticationResult.Failed);
        }
Exemplo n.º 9
0
        public ActionResult LogOn()
        {
            var openid = new OpenIdRelyingParty();
            IAuthenticationResponse response = openid.GetResponse();

            if (response != null)
            {
                switch (response.Status)
                {
                case AuthenticationStatus.Authenticated:
                    var user = _userRepo.FindUserByClaimedIdentifier(response.ClaimedIdentifier);
                    if (null == user)
                    {
                        user = CreateUserFromOpenIDResponse(response);
                    }
                    FormsAuthentication.RedirectFromLoginPage(user.FriendlyIdentifier, false);
                    break;

                case AuthenticationStatus.Canceled:
                    ModelState.AddModelError("loginIdentifier",
                                             "Login was cancelled at the provider");
                    break;

                case AuthenticationStatus.Failed:
                    ModelState.AddModelError("loginIdentifier",
                                             "Login failed using the provided OpenID identifier");
                    break;
                }
            }

            return(View());
        }
Exemplo n.º 10
0
        public ActionResult Login()
        {
            var openid = new OpenIdRelyingParty();
            IAuthenticationResponse response = openid.GetResponse();

            if (response != null)
            {
                switch (response.Status)
                {
                case AuthenticationStatus.Authenticated:
                    var user = EnsureUserExists(response);
                    FormsAuthentication.RedirectFromLoginPage(
                        user.email, false);
                    break;

                case AuthenticationStatus.Canceled:
                    ModelState.AddModelError("loginIdentifier",
                                             "Login was cancelled at the provider");
                    break;

                case AuthenticationStatus.Failed:
                    ModelState.AddModelError("loginIdentifier",
                                             "Login failed using the provided OpenID identifier");
                    break;
                }
            }

            return(View());
        }
 private void SetUserInformationGeneric(IAuthenticationResponse response)
 {
     var userdata = response.GetExtension<ClaimsResponse>();
     var email = userdata.Email;
     FullName = userdata.FullName;
     Email = email;
 }
Exemplo n.º 12
0
        /// <summary>
        /// The PreparePolicyInfo
        /// </summary>
        /// <param name="authenticationResponse">The verifyFactorsList<see cref="IAuthenticationResponse"/></param>
        private PolicyInfo PreparePolicyInfo(IAuthenticationResponse authenticationResponse)
        {
            var        policyResponse = JsonConvert.SerializeObject(authenticationResponse.Embedded["policy"]);
            PolicyInfo policyObj      = JsonConvert.DeserializeObject <PolicyInfo>(policyResponse);

            return(policyObj);
        }
Exemplo n.º 13
0
        public ActionResult OpenIdLogin(IAuthenticationResponse response)
        {
            switch (response.Status)
            {
            case AuthenticationStatus.Authenticated:
                var claimsResponse = response.GetExtension <ClaimsResponse>();
                if (claimsResponse.Email == _adminEmail)
                {
                    FormsAuthentication.SetAuthCookie(response.ClaimedIdentifier, false);
                    return(RedirectToAction("Index", "Dashboard", new { area = "Admin" }));
                }
                break;

            case AuthenticationStatus.Canceled:
                ModelState.AddModelError("loginIdentifier",
                                         "Login was cancelled at the provider");
                break;

            case AuthenticationStatus.Failed:
                ModelState.AddModelError("loginIdentifier",
                                         "Login failed using the provided OpenID identifier");
                break;
            }

            return(new EmptyResult());
        }
Exemplo n.º 14
0
        private List <IEnrollFactor> PrepareEnrollFactors(IAuthenticationResponse authenticationResponse)
        {
            List <IEnrollFactor> enrollFactorsList = new List <IEnrollFactor>();

            if (authenticationResponse.Embedded.GetData().ContainsKey("factors"))
            {
                string        stringResponse = JsonConvert.SerializeObject(authenticationResponse.Embedded.GetData()["factors"]);
                List <object> factorsList    = JsonConvert.DeserializeObject <List <object> >(stringResponse);
                this.OktaFactorCount = factorsList.Count;
                foreach (var factor in factorsList)
                {
                    string     factorStringResponse   = JsonConvert.SerializeObject(factor);
                    FactorInfo factorObj              = JsonConvert.DeserializeObject <FactorInfo>(factorStringResponse);
                    string     factorKey              = GetFactorKey(factorObj);
                    string     isFactorRequired       = IsFactorRequired(factorObj);
                    string     factorEnrollmentStatus = GetFactorEnrollStatus(factorObj);
                    string     factorId = GetEnrollFactorId(factorObj.FactorType);
                    factorObj.FactorKey = factorKey;
                    string[] supportedFactors = { "sms:OKTA" };
                    if (supportedFactors.Contains(factorKey) && isFactorRequired == "REQUIRED" && factorEnrollmentStatus == "NOT_SETUP")
                    {
                        IEnrollFactor enrollFactor = this.CreateEnrollFactorObject(factorObj);
                        enrollFactorsList.Add(enrollFactor);
                    }
                }
            }

            return(enrollFactorsList);
        }
Exemplo n.º 15
0
        /// <summary>
        /// Initializes a new instance of the <see cref="OpenIdEventArgs"/> class
        /// with information on a completed authentication attempt
        /// (whether that attempt was successful or not).
        /// </summary>
        /// <param name="response">The incoming authentication response.</param>
        internal OpenIdEventArgs(IAuthenticationResponse response)
        {
            ErrorUtilities.VerifyArgumentNotNull(response, "response");

            this.Response          = response;
            this.ClaimedIdentifier = response.ClaimedIdentifier;
        }
Exemplo n.º 16
0
        /// <summary>
        /// Gets the extra data obtained from the response message when authentication is successful.
        /// </summary>
        /// <param name="response">
        /// The response message.
        /// </param>
        /// <returns>A dictionary of profile data; or null if no data is available.</returns>
        protected override Dictionary <string, string> GetExtraData(IAuthenticationResponse response)
        {
            FetchResponse fetchResponse = response.GetExtension <FetchResponse>();

            if (fetchResponse != null)
            {
                var extraData = new Dictionary <string, string>();
                extraData.Add("email", fetchResponse.GetAttributeValue(WellKnownAttributes.Contact.Email));
                extraData.Add("country", fetchResponse.GetAttributeValue(WellKnownAttributes.Contact.HomeAddress.Country));
                extraData.Add("firstName", fetchResponse.GetAttributeValue(WellKnownAttributes.Name.First));
                extraData.Add("lastName", fetchResponse.GetAttributeValue(WellKnownAttributes.Name.Last));
                //extraData.Add("city", fetchResponse.GetAttributeValue(WellKnownAttributes.Contact.HomeAddress.City));
                //extraData.Add("postalcode", fetchResponse.GetAttributeValue(WellKnownAttributes.Contact.HomeAddress.PostalCode));
                //extraData.Add("state", fetchResponse.GetAttributeValue(WellKnownAttributes.Contact.HomeAddress.State));
                //extraData.Add("addressone", fetchResponse.GetAttributeValue(WellKnownAttributes.Contact.HomeAddress.StreetAddressLine1));
                //extraData.Add("addresstwo", fetchResponse.GetAttributeValue(WellKnownAttributes.Contact.HomeAddress.StreetAddressLine2));
                //extraData.Add("birthdate", fetchResponse.GetAttributeValue(WellKnownAttributes.BirthDate.WholeBirthDate));
                //extraData.Add("companyname", fetchResponse.GetAttributeValue(WellKnownAttributes.Company.CompanyName));
                //extraData.Add("jobtitle", fetchResponse.GetAttributeValue(WellKnownAttributes.Company.JobTitle));
                //extraData.Add("gender", fetchResponse.GetAttributeValue(WellKnownAttributes.Person.Gender));
                //extraData.Add("fullname", fetchResponse.GetAttributeValue(WellKnownAttributes.Name.FullName));
                //extraData.Add("mobile", fetchResponse.GetAttributeValue(WellKnownAttributes.Contact.Phone.Mobile));
                //extraData.Add("homepage", fetchResponse.GetAttributeValue(WellKnownAttributes.Contact.Web.Homepage));
                return(extraData);
            }
            return(null);
        }
Exemplo n.º 17
0
        public async Task <IAuthenticationResponse> LogIn(object userData, string key)
        {
            var authData = JsonConvert.DeserializeObject <AuthData>(userData.ToString());

            //if (authData.SystemCode == 0) throw new Exception("Código do sistema não informado");
            if (authData.UserIdentity == null)
            {
                throw new ArgumentNullException(nameof(IAuthData.UserIdentity));
            }
            if (authData.KeyContent == null)
            {
                throw new ArgumentNullException(nameof(IAuthData.KeyContent));
            }

            IAuthenticationResponse response = null;

            IAuthData data = null;

            switch (authData.LoginType)
            {
            default:
            case enumLoginType.PassPhrase:
                data     = JsonConvert.DeserializeObject <AuthDataFromPassPhrase>(userData.ToString());
                response = await AuthWithLogin(data, key);

                break;
            }

            return(response);
        }
Exemplo n.º 18
0
        public static UserToken Login(IAuthenticationResponse resp)
        {
            if (resp == null)
            {
                return(null);
            }

            UserToken token = null;

            if (resp.Status == AuthenticationStatus.Authenticated)
            {
                ClaimsResponse ProfileFields = resp.GetExtension <ClaimsResponse>();

                User user = GetUserByOpenIDIdentifier(resp.ClaimedIdentifier);

                if (user != null && user.Active)
                {
                    token = user.ToToken();
                }
            }

            Login(token, resp.ClaimedIdentifier);

            return(token);
        }
Exemplo n.º 19
0
        private static void SetCommenterValuesFromOpenIdResponse(IAuthenticationResponse response, Commenter commenter)
        {
            var claimsResponse = response.GetExtension<ClaimsResponse>();
            if (claimsResponse != null)
            {
                if (string.IsNullOrWhiteSpace(commenter.Name) && string.IsNullOrWhiteSpace(claimsResponse.Nickname) == false)
                    commenter.Name = claimsResponse.Nickname;
                else if (string.IsNullOrWhiteSpace(commenter.Name) && string.IsNullOrWhiteSpace(claimsResponse.FullName) == false)
                    commenter.Name = claimsResponse.FullName;
                if (string.IsNullOrWhiteSpace(commenter.Email) && string.IsNullOrWhiteSpace(claimsResponse.Email) == false)
                    commenter.Email = claimsResponse.Email;
            }
            var fetchResponse = response.GetExtension<FetchResponse>();
            if (fetchResponse != null) // let us try from the attributes
            {
                if (string.IsNullOrWhiteSpace(commenter.Email))
                    commenter.Email = fetchResponse.GetAttributeValue(WellKnownAttributes.Contact.Email);
                if (string.IsNullOrWhiteSpace(commenter.Name))
                {
                    commenter.Name = fetchResponse.GetAttributeValue(WellKnownAttributes.Name.FullName) ??
                                     fetchResponse.GetAttributeValue(WellKnownAttributes.Name.First) + " " +
                                     fetchResponse.GetAttributeValue(WellKnownAttributes.Name.Last);
                }

                if (string.IsNullOrWhiteSpace(commenter.Url))
                {
                    commenter.Url = fetchResponse.GetAttributeValue(WellKnownAttributes.Contact.Web.Blog) ??
                                fetchResponse.GetAttributeValue(WellKnownAttributes.Contact.Web.Homepage);
                }
            }
        }
Exemplo n.º 20
0
        /// <summary>
        /// Initializes a new instance of the <see cref="OpenIdEventArgs"/> class
        /// with information on a completed authentication attempt
        /// (whether that attempt was successful or not).
        /// </summary>
        /// <param name="response">The incoming authentication response.</param>
        internal OpenIdEventArgs(IAuthenticationResponse response)
        {
            Requires.NotNull(response, "response");

            this.Response          = response;
            this.ClaimedIdentifier = response.ClaimedIdentifier;
        }
Exemplo n.º 21
0
        /// <summary>
        /// Initializes a new instance of the <see cref="OpenIdEventArgs"/> class
        /// with information on a completed authentication attempt
        /// (whether that attempt was successful or not).
        /// </summary>
        /// <param name="response">The incoming authentication response.</param>
        internal OpenIdEventArgs(IAuthenticationResponse response)
        {
            Contract.Requires <ArgumentNullException>(response != null);

            this.Response          = response;
            this.ClaimedIdentifier = response.ClaimedIdentifier;
        }
Exemplo n.º 22
0
        public virtual UserClaim GetUserClaim(IAuthenticationResponse response)
        {
            if (response == null) return null;

            switch (response.Status) {
                case AuthenticationStatus.Authenticated:
                    var claimsResponse = response.GetExtension<ClaimsResponse>();

                    if (claimsResponse != null) {
                        return new UserClaim {
                            Username = claimsResponse.Nickname,
                            Email = claimsResponse.Email,
                            Name = claimsResponse.FullName,
                            Identifier = response.FriendlyIdentifierForDisplay
                        };
                    }

                    return null;
                case AuthenticationStatus.Canceled:
                case AuthenticationStatus.Failed:
                    return null;
            }

            return null;
        }
Exemplo n.º 23
0
 private void ProcessOpenIdResponse(IAuthenticationResponse response)
 {
     switch (response.Status)
     {
     case AuthenticationStatus.Authenticated:
         string openId = response.ClaimedIdentifier;
         int    userId;
         string userName;
         GetUserByOpenId(openId, out userId, out userName);
         //int userId = BusinessLayer.User.GetUserIDByOpenIdUsername(response.ClaimedIdentifier);
         if (userId != 0)
         {
             Utils.User.Login(userId, userName);
             Response.Redirect("default.aspx");
         }
         else                         //we have to add a new user
         {
             Session["OpenIdUserName"] = openId;
             divLogin.Visible          = false;
             divPickLogin.Visible      = true;
             lblOpenId.Text            = openId;
             lblOpenId2.Text           = openId;
         }
         break;
     }
 }
Exemplo n.º 24
0
        /// <summary>
        /// The PrepareVerifyFactors
        /// </summary>
        /// <param name="authenticationResponse">The authenticationResponse<see cref="IAuthenticationResponse"/></param>
        /// <returns>The <see cref="List{IVerifyFactor}"/></returns>
        private List <IVerifyFactor> PrepareVerifyFactors(IAuthenticationResponse authenticationResponse)
        {
            List <IVerifyFactor> verifyFactorsList = new List <IVerifyFactor>();

            //this.logger.Debug("ProcessAuthnResponse stateToken: " + authenticationResponse.StateToken);
            if (authenticationResponse.Embedded.GetData().ContainsKey("factors"))
            {
                string        stringResponse = JsonConvert.SerializeObject(authenticationResponse.Embedded.GetData()["factors"]);
                List <object> factorsList    = JsonConvert.DeserializeObject <List <object> >(stringResponse);
                this.OktaFactorCount = factorsList.Count;
                foreach (var factor in factorsList)
                {
                    string     factorStringResponse = JsonConvert.SerializeObject(factor);
                    FactorInfo factorObj            = JsonConvert.DeserializeObject <FactorInfo>(factorStringResponse);
                    string     factorKey            = GetFactorKey(factorObj);
                    factorObj.FactorKey = factorKey;
                    string[] supportedFactors = { "sms:OKTA", "email:OKTA" };
                    if (supportedFactors.Contains(factorKey))
                    {
                        IVerifyFactor verifyFactor = this.CreateFactorObject(factorObj);
                        verifyFactorsList.Add(verifyFactor);
                    }
                    else
                    {
                        this.OktaFactorCount -= 1;
                    }
                }
            }

            return(verifyFactorsList);
        }
Exemplo n.º 25
0
        private ActionResult OpenIdResponse(IAuthenticationResponse response)
        {
            Logger.Trace("Received response from open id provider");

            // Step 2: OpenID Provider sending assertion response
            switch (response.Status)
            {
            case AuthenticationStatus.Authenticated:
                Logger.Info("User succesfully authenticated");

                var userId      = OpenIdService.ParseResponse(response);
                var loginResult = this.PerformLoginProcedure(userId);
                if (!loginResult)
                {
                    this.ViewBag.Error = "Authentication failed";
                    return(this.View("Login"));
                }

                Logger.Info("Authentication procedure succesfull redirecting to Home/Index");
                return(this.RedirectToAction("Index", "Home"));

            case AuthenticationStatus.Canceled:
            case AuthenticationStatus.Failed:
                Logger.Error("Authentication failed : {0}", response.Exception.Message);
                this.ViewBag.Error = "Authentication failed";
                return(this.View("Login"));
            }

            return(new EmptyResult());
        }
		/// <summary>
		/// Processes an incoming authorization-granted message from an SP and obtains an access token.
		/// </summary>
		/// <param name="openIdAuthenticationResponse">The OpenID authentication response that may be carrying an authorized request token.</param>
		/// <param name="cancellationToken">The cancellation token.</param>
		/// <returns>
		/// The access token, or null if OAuth authorization was denied by the user or service provider.
		/// </returns>
		/// <remarks>
		/// The access token, if granted, is automatically stored in the <see cref="ConsumerBase.TokenManager" />.
		/// The token manager instance must implement <see cref="IOpenIdOAuthTokenManager" />.
		/// </remarks>
		public async Task<AccessTokenResponse> ProcessUserAuthorizationAsync(IAuthenticationResponse openIdAuthenticationResponse, CancellationToken cancellationToken = default(CancellationToken)) {
			Requires.NotNull(openIdAuthenticationResponse, "openIdAuthenticationResponse");

			// The OAuth extension is only expected in positive assertion responses.
			if (openIdAuthenticationResponse.Status != AuthenticationStatus.Authenticated) {
				return null;
			}

			// Retrieve the OAuth extension
			var positiveAuthorization = openIdAuthenticationResponse.GetExtension<AuthorizationApprovedResponse>();
			if (positiveAuthorization == null) {
				return null;
			}

			using (var client = this.CreateHttpClient(new AccessToken(positiveAuthorization.RequestToken, string.Empty))) {
				var request = new HttpRequestMessage(this.ServiceProvider.TokenRequestEndpointMethod, this.ServiceProvider.TokenRequestEndpoint);
				using (var response = await client.SendAsync(request, cancellationToken)) {
					response.EnsureSuccessStatusCode();

					// Parse the response and ensure that it meets the requirements of the OAuth 1.0 spec.
					string content = await response.Content.ReadAsStringAsync();
					var responseData = HttpUtility.ParseQueryString(content);
					string accessToken = responseData[Protocol.TokenParameter];
					string tokenSecret = responseData[Protocol.TokenSecretParameter];
					ErrorUtilities.VerifyProtocol(!string.IsNullOrEmpty(accessToken), MessagingStrings.RequiredParametersMissing, typeof(AuthorizedTokenResponse).Name, Protocol.TokenParameter);
					ErrorUtilities.VerifyProtocol(tokenSecret != null, MessagingStrings.RequiredParametersMissing, typeof(AuthorizedTokenResponse).Name, Protocol.TokenSecretParameter);

					responseData.Remove(Protocol.TokenParameter);
					responseData.Remove(Protocol.TokenSecretParameter);
					return new AccessTokenResponse(accessToken, tokenSecret, responseData);
				}
			}
		}
 /// <summary>
 /// Initializes a new instance of the <see cref="AuthenticationResponseShim"/> class.
 /// </summary>
 /// <param name="response">The response.</param>
 internal AuthenticationResponseShim(IAuthenticationResponse response)
 {
     if (response == null)
     {
         throw new ArgumentNullException("response");
     }
     this.response = response;
 }
 private void SetUserInformationFromGoogle(IAuthenticationResponse response)
 {
     var userdata = response.GetExtension<FetchResponse>();
     var firstname = userdata.GetAttributeValue(WellKnownAttributes.Name.First);
     var lastname = userdata.GetAttributeValue(WellKnownAttributes.Name.Last);
     FullName = firstname + " " + lastname;
     Email = userdata.GetAttributeValue(WellKnownAttributes.Contact.Email);
 }
Exemplo n.º 29
0
 /// <summary>
 /// Called when an incoming positive assertion is received.
 /// </summary>
 /// <param name="assertion">The positive assertion.</param>
 void IRelyingPartyBehavior.OnIncomingPositiveAssertion(IAuthenticationResponse assertion)
 {
     if (assertion.GetExtension <ClaimsResponse>() == null)
     {
         ClaimsResponse sreg = assertion.UnifyExtensionsAsSreg(true);
         ((PositiveAnonymousResponse)assertion).Response.Extensions.Add(sreg);
     }
 }
Exemplo n.º 30
0
 protected override string HandleUnknownUser(IAuthenticationResponse response)
 {
     string username = response.ClaimedIdentifier.ToString();
     string email = response.ClaimedIdentifier.ToString();
     string comment = null;
     var sreg = response.GetExtension<DotNetOpenAuth.OpenId.Extensions.SimpleRegistration.ClaimsResponse>();
     if (sreg != null)
     {
         if (sreg.Nickname != null)
         {
             comment = sreg.Nickname;
         }
         if (sreg.Email != null)
         {
             email = sreg.Email;
         }
     }
     var ax = response.GetExtension<DotNetOpenAuth.OpenId.Extensions.AttributeExchange.FetchResponse>();
     if (ax != null)
     {
         if (ax.Attributes.Contains(WellKnownAttributes.Contact.Email))
         {
             IList<string> emailAddresses = ax.Attributes[WellKnownAttributes.Contact.Email].Values;
             email = emailAddresses.Count > 0 ? emailAddresses[0] : email;
         }
         if (ax.Attributes.Contains(WellKnownAttributes.Name.Alias))
         {
             IList<string> aliasNames = ax.Attributes[WellKnownAttributes.Name.Alias].Values;
             comment = aliasNames.Count > 0 ? aliasNames[0] : comment;
         }
     }
     try
     {
         var user = Membership.CreateUser(username, Guid.NewGuid().ToString(), email);
         NHOpenIDMembershipProvider idprov = Provider as NHOpenIDMembershipProvider;
         MembershipCreateStatus status;
         idprov.AddIdToUser(user, response.ClaimedIdentifier, out status);
         if (status == MembershipCreateStatus.Success)
         {
             if (String.IsNullOrEmpty(comment)) {
               user.Comment = email;
             } else {
               user.Comment = comment;
             }
             Provider.UpdateUser(user);
             return user.UserName;
         }
         else
         {
             Provider.DeleteUser(user.UserName, true);
         }
     }
     catch (MembershipCreateUserException)
     {
         return null;
     }
     return null;
 }
Exemplo n.º 31
0
        internal static string SignIn(Guid userDetailsPageId)
        {
            string errorMessage = string.Empty;

            using (var openid = new OpenIdRelyingParty())
            {
                //fix wrong URI, add PathInfo
                HttpContext.Current.RewritePath(HttpContext.Current.Request.RawUrl);
                IAuthenticationResponse response = openid.GetResponse();
                if (response == null)
                {
                    //request
                    string openIDIdentifier = HttpContext.Current.Request.Form["openid_identifier"];

                    if (!string.IsNullOrEmpty(openIDIdentifier))
                    {
                        IAuthenticationRequest request = openid.CreateRequest(openIDIdentifier);
                        var claims = new ClaimsRequest();
                        claims.Email    = DemandLevel.Require;
                        claims.Nickname = DemandLevel.Require;
                        claims.FullName = DemandLevel.Require;
                        claims.Country  = DemandLevel.Require;
                        request.AddExtension(claims);

                        //small fix for request.RedirectToProvider();
                        string location = request.RedirectingResponse.Headers["Location"];
                        HttpContext.Current.Response.Redirect(location, false);
                    }
                }
                else
                {
                    //response
                    switch (response.Status)
                    {
                    case AuthenticationStatus.Authenticated:
                        HandleSuccessfulSignIn(response, userDetailsPageId);
                        break;

                    case AuthenticationStatus.Canceled:
                        errorMessage = "Login was cancelled at the provider.";
                        break;

                    case AuthenticationStatus.Failed:
                        errorMessage = "Login failed at the provider.";
                        break;

                    case AuthenticationStatus.SetupRequired:
                        errorMessage = "The provider requires setup.";
                        break;

                    default:
                        errorMessage = "Login failed.";
                        break;
                    }
                }
            }
            return(errorMessage);
        }
Exemplo n.º 32
0
 public override bool TryGetOpenIdResponse(out IAuthenticationResponse openIdResponse)
 {
     openIdResponse = openIdRelyingParty.GetResponse();
     if (openIdResponse.IsNull())
     {
         return false;
     }
     return true;
 }
Exemplo n.º 33
0
        private PolicyComplexity PreparePolicyComplexityObject(IAuthenticationResponse authenticationResponse)
        {
            var              policyResponseObject     = JsonConvert.SerializeObject(authenticationResponse.Embedded["policy"]);
            dynamic          policyComplexityObj      = JsonConvert.DeserializeObject <dynamic>(policyResponseObject).complexity;
            string           passwordComplexityString = JsonConvert.SerializeObject(policyComplexityObj);
            PolicyComplexity passwordComplexityObj    = JsonConvert.DeserializeObject <PolicyComplexity>(passwordComplexityString);

            return(passwordComplexityObj);
        }
Exemplo n.º 34
0
        private PolicyAge PreparePolicyAgeObject(IAuthenticationResponse authenticationResponse)
        {
            var       policyResponseObject = JsonConvert.SerializeObject(authenticationResponse.Embedded["policy"]);
            dynamic   policyAgeObj         = JsonConvert.DeserializeObject <dynamic>(policyResponseObject).age;
            string    policyAgeString      = JsonConvert.SerializeObject(policyAgeObj);
            PolicyAge policyAge            = JsonConvert.DeserializeObject <PolicyAge>(policyAgeString);

            return(policyAge);
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="AuthenticationResponseSnapshot"/> class.
        /// </summary>
        /// <param name="copyFrom">The authentication response to copy from.</param>
        internal AuthenticationResponseSnapshot(IAuthenticationResponse copyFrom)
        {
            ErrorUtilities.VerifyArgumentNotNull(copyFrom, "copyFrom");

            this.ClaimedIdentifier            = copyFrom.ClaimedIdentifier;
            this.FriendlyIdentifierForDisplay = copyFrom.FriendlyIdentifierForDisplay;
            this.Status            = copyFrom.Status;
            this.callbackArguments = copyFrom.GetCallbackArguments();
        }
Exemplo n.º 36
0
        private PolicyExpiration PreparePolicyExpirationObject(IAuthenticationResponse authenticationResponse)
        {
            var              policyResponseObject   = JsonConvert.SerializeObject(authenticationResponse.Embedded["policy"]);
            dynamic          policyExpirationObj    = JsonConvert.DeserializeObject <dynamic>(policyResponseObject).expiration;
            string           policyExpirationString = JsonConvert.SerializeObject(policyExpirationObj);
            PolicyExpiration policyExpiration       = JsonConvert.DeserializeObject <PolicyExpiration>(policyExpirationString);

            return(policyExpiration);
        }
		/// <summary>
		/// Initializes a new instance of the <see cref="AuthenticationResponseShim"/> class.
		/// </summary>
		/// <param name="response">The response.</param>
		internal AuthenticationResponseShim(IAuthenticationResponse response) {
			Requires.NotNull(response, "response");

			this.response = response;
			var claimsResponse = this.response.GetExtension<ClaimsResponse>();
			if (claimsResponse != null) {
				this.ClaimsResponse = new ClaimsResponseShim(claimsResponse);
			}
		}
		/// <summary>
		/// Initializes a new instance of the <see cref="AuthenticationResponseShim"/> class.
		/// </summary>
		/// <param name="response">The response.</param>
		internal AuthenticationResponseShim(IAuthenticationResponse response) {
			Contract.Requires<ArgumentNullException>(response != null);

			this.response = response;
			var claimsResponse = this.response.GetExtension<ClaimsResponse>();
			if (claimsResponse != null) {
				this.ClaimsResponse = new ClaimsResponseShim(claimsResponse);
			}
		}
Exemplo n.º 39
0
        public override void SetUp()
        {
            base.SetUp();

            IndirectSignedResponse responseMessage = new IndirectSignedResponse(Protocol.Default.Version, RPUri);

            this.extensions = responseMessage.Extensions;
            this.response   = new DotNetOpenAuth.OpenId.RelyingParty.PositiveAnonymousResponse(responseMessage);
        }
Exemplo n.º 40
0
        /// <summary>
        /// Adds authentication cancellation behavior to display a message to the user.
        /// </summary>
        /// <param name="response">The response.</param>
        protected override void OnCanceled(IAuthenticationResponse response)
        {
            base.OnCanceled(response);

            if (!string.IsNullOrEmpty(this.CanceledText))
            {
                this.errorLabel.Text    = this.CanceledText;
                this.errorLabel.Visible = true;
            }
        }
Exemplo n.º 41
0
        /// <summary>
        /// Adds failure handling to display an error message to the user.
        /// </summary>
        /// <param name="response">The response.</param>
        protected override void OnFailed(IAuthenticationResponse response)
        {
            base.OnFailed(response);

            if (!string.IsNullOrEmpty(this.FailedMessageText))
            {
                this.errorLabel.Text    = string.Format(CultureInfo.CurrentCulture, this.FailedMessageText, response.Exception.ToStringDescriptive());
                this.errorLabel.Visible = true;
            }
        }
        /// <summary>
        /// Initializes a new instance of the <see cref="AuthenticationResponseShim"/> class.
        /// </summary>
        /// <param name="response">The response.</param>
        internal AuthenticationResponseShim(IAuthenticationResponse response)
        {
            Contract.Requires(response != null);
            ErrorUtilities.VerifyArgumentNotNull(response, "response");

            this.response = response;
            var claimsResponse = this.response.GetExtension<ClaimsResponse>();
            if (claimsResponse != null) {
                this.ClaimsResponse = new ClaimsResponseShim(claimsResponse);
            }
        }
Exemplo n.º 43
0
        public OpenIdentity ProcessOpenId(string openId)
        {
            _response = _openIdRelyingParty.GetResponse();

            if (_response == null)
            {
                Authenticate(openId);
                return null;
            }

              return Verify();
        }
Exemplo n.º 44
0
        protected override Dictionary<string, string> GetExtraData(IAuthenticationResponse response)
        {
            var fetchResponse = response.GetExtension<FetchResponse>();
            if (fetchResponse != null)
            {
                var extraData = new Dictionary<string, string>();
                extraData.AddItemIfNotEmpty(ClaimTypes.IsPersistent, fetchResponse.GetAttributeValue(ClaimTypes.IsPersistent));

                return extraData;
            }
            return null;
        }
Exemplo n.º 45
0
   /// <summary>
   /// This authenticates a user based on a response from an openid provider.
   /// </summary>
   /// <param name="response"></param>
   private void AuthenticateUser(IAuthenticationResponse response)
   {
      if (response.Status != AuthenticationStatus.Authenticated)
         throw new ArgumentException("The response status must be 'Authenticated'. (" + response.Status.ToString() + ")", "response");

      Identifier identifier = response.ClaimedIdentifier;

      if (identifier == null)
      {
         lblError.Text = "Oops! We lost the ID you tried to log in with. Can you try again?";
      }
      else
      {
         using (SqlConnection cn = new SqlConnection(Database.TadMapConnection))
         {
            cn.Open();
            using (SqlCommand cm = cn.CreateCommand())
            {
               cm.CommandType = CommandType.StoredProcedure;
               cm.CommandText = "GetUserId";
               cm.Parameters.AddWithValue("@OpenIdUrl", identifier.ToString());

               using (SqlDataReader dr = cm.ExecuteReader())
               {
                  if (dr.Read())
                  {
                     // a record was found so the user already exists
                     // in the future we can use this to populate the identity
                     // with display name and image...
                  }
                  else
                  {
                     // no user was found so we create it now.
                     CreateNewUser(identifier.ToString());
                  }
               }
            }
         }

         // somehow we need to put the response.FriendlyIdentifierForDisplay
         // into the identity/principal

         if (Request.QueryString["ReturnUrl"] != null)
         {
            FormsAuthentication.RedirectFromLoginPage(identifier.ToString(), false);
         }
         else
         {
            FormsAuthentication.SetAuthCookie(identifier.ToString(), false);
            Response.Redirect("MyImages.aspx", false);
         }
      }
   }
Exemplo n.º 46
0
		/// <summary>
		/// Gets the extra data obtained from the response message when authentication is successful.
		/// </summary>
		/// <param name="response">
		/// The response message. 
		/// </param>
		/// <returns>
		/// </returns>
		protected override Dictionary<string, string> GetExtraData(IAuthenticationResponse response) {
			FetchResponse fetchResponse = response.GetExtension<FetchResponse>();
			if (fetchResponse != null) {
				var extraData = new Dictionary<string, string>();
				extraData.AddItemIfNotEmpty("email", fetchResponse.GetAttributeValue(WellKnownAttributes.Contact.Email));
				extraData.AddItemIfNotEmpty("fullName", fetchResponse.GetAttributeValue(WellKnownAttributes.Name.FullName));

				return extraData;
			}

			return null;
		}
Exemplo n.º 47
0
 protected override Dictionary<string, string> GetExtraData(IAuthenticationResponse response)
 {
     FetchResponse extension = response.GetExtension<FetchResponse>();
     if (extension != null)
     {
         Dictionary<string, string> dictionary = new Dictionary<string, string>();
         dictionary.Add("email", extension.GetAttributeValue("http://axschema.org/contact/email"));
         dictionary.Add("name", extension.GetAttributeValue("http://axschema.org/namePerson/first") + " " + extension.GetAttributeValue("http://axschema.org/namePerson/last"));
         return dictionary;
     }
     return null;
 }
Exemplo n.º 48
0
 public static string GetFriendlyOpenId(IAuthenticationResponse response, string email)
 {
     if (response.ClaimedIdentifier.ToString().Contains(WellKnownProviders.Google))
     {
         return "Google(" + email + ")";
     }
     if (response.ClaimedIdentifier.ToString().Contains(WellKnownProviders.Yahoo))
     {
         return "Yahoo(" + email + ")";
     }
     return response.FriendlyIdentifierForDisplay;
 }
        internal AuthenticationResult ProcessOpenIdResponse(IAuthenticationResponse response)
        {
            switch (response.Status)
            {
                default:
                {
                    return AbortedAuthentication(Common.Resources.Authentication.InvalidOpenAuthenticationStatus);
                }
                case AuthenticationStatus.Canceled:
                {
                    return AbortedAuthentication(Common.Resources.Authentication.CanceledAtProvider, ConnectionStatus.Canceled);
                }
                case AuthenticationStatus.Failed:
                {
                    return AuthenticationException(response.Exception);
                }
                case AuthenticationStatus.Authenticated:
                {
                    string openId = response.ClaimedIdentifier;
                    User user = userService.GetByOpenId(openId);
                    bool isNewUser = false;
                    bool isNewConnection = false;
                    if (user == null)
                    {
                        isNewConnection = true;

                        string email = null;
                        string displayName = null;
                        var fetch = response.GetExtension<FetchResponse>();
                        if (fetch != null)
                        {
                            email = fetch.GetAttributeValue(WellKnownAttributes.Contact.Email);
                            displayName = fetch.GetAttributeValue(WellKnownAttributes.Name.FullName);
                        }
                        if (!email.NullOrEmpty()) // maybe they already have an account.
                        {
                            user = userService.GetByEmail(email);
                        }
                        if (user == null) // create a brand new account.
                        {
                            user = userService.CreateWithOpenId(openId, email, displayName);
                            isNewUser = true;
                        }
                        else // just connect the existing account to their OpenId account.
                        {
                            userService.AddOpenIdConnection(user, openId);
                        }
                    }
                    return SuccessfulAuthentication(user, isNewUser, isNewConnection);
                }
            }
        }
 public UserInformation(IAuthenticationResponse response)
 {
     Response = response;
     ClaimedIdentifier = response.ClaimedIdentifier.ToString();
     if (response.Provider.Uri.Host == OpenIdHelper.Google)
     {
         SetUserInformationFromGoogle(response);
     }
     else
     {
         SetUserInformationGeneric(response);
     }
 }
Exemplo n.º 51
0
        private Interfaces.IAuthenticationResponse GetUserIdentity(IAuthenticationResponse response)
        {
            var identifier = response.ClaimedIdentifier;
            var fetch = response.GetExtension<FetchResponse>();
            Interfaces.IUserIdentity userIdentity = (fetch == null)
                ? null
                : Factory.GetUserIdentity(response.ClaimedIdentifier.ToString(),
                    fetch.GetAttributeValue(WellKnownAttributes.Name.First),
                    fetch.GetAttributeValue(WellKnownAttributes.Name.Last),
                    fetch.GetAttributeValue(WellKnownAttributes.Contact.Email));

            return Factory.AuthenticationResponse(userIdentity);
        }
Exemplo n.º 52
0
		/// <summary>
		/// Gets the extra data obtained from the response message when authentication is successful.
		/// </summary>
		/// <param name="response">
		/// The response message. 
		/// </param>
		/// <returns>A dictionary of profile data; or null if no data is available.</returns>
		protected override NameValueCollection GetExtraData(IAuthenticationResponse response) {
			FetchResponse fetchResponse = response.GetExtension<FetchResponse>();
			if (fetchResponse != null) {
				var extraData = new NameValueCollection();
				extraData.AddItemIfNotEmpty("email", fetchResponse.GetAttributeValue(WellKnownAttributes.Contact.Email));
				extraData.AddItemIfNotEmpty("country", fetchResponse.GetAttributeValue(WellKnownAttributes.Contact.HomeAddress.Country));
				extraData.AddItemIfNotEmpty("firstName", fetchResponse.GetAttributeValue(WellKnownAttributes.Name.First));
				extraData.AddItemIfNotEmpty("lastName", fetchResponse.GetAttributeValue(WellKnownAttributes.Name.Last));

				return extraData;
			}

			return null;
		}
        /// <summary>
        /// Log member in from response informations.
        /// </summary>
        /// <param name="response">A successfull response from the relying party</param>
        public void LogInMember(IAuthenticationResponse response)
        {
            var fetch = response.GetExtension(typeof(ClaimsResponse)) as ClaimsResponse;
            string email = null;
            if (fetch != null)
            {
                email = fetch.Email;
            }
            Member connectedMember = email == null
                                         ? _membershipService.LogIn(response.ClaimedIdentifier.ToString())
                                         : _membershipService.LogIn(response.ClaimedIdentifier.ToString(), email);

            _sessionRegistry.MemberInformations.UserName = connectedMember.UserName;
            _sessionRegistry.MemberInformations.OpenId = response.ClaimedIdentifier.ToString();
        }
Exemplo n.º 54
0
        public OpenIdUser ResponseIntoUser(IAuthenticationResponse response)
        {
            var claimResponseUntrusted = response.GetUntrustedExtension<ClaimsResponse>();
            var claimResponse = response.GetExtension<ClaimsResponse>();

            if (claimResponse != null)
            {
                return new OpenIdUser(claimResponse, response.ClaimedIdentifier);
            }
            if (claimResponseUntrusted != null)
            {
                return new OpenIdUser(claimResponseUntrusted, response.ClaimedIdentifier);
            }

            return null;
        }
        public OpenIdAuthenticationParameters(IAuthenticationResponse authenticationResponse)
        {
            ExternalIdentifier = authenticationResponse.ClaimedIdentifier;
            ExternalDisplayIdentifier = authenticationResponse.FriendlyIdentifierForDisplay;

            _claims = new List<UserClaims>();
            var claimsResponseTranslator = new OpenIdClaimsResponseClaimsTranslator();
            var claims1 = claimsResponseTranslator.Translate(authenticationResponse.GetExtension<ClaimsResponse>());
            if (claims1 != null)
                UserClaims.Add(claims1);

            var fetchResponseTranslator = new OpenIdFetchResponseClaimsTranslator();
            var claims2 = fetchResponseTranslator.Translate(authenticationResponse.GetExtension<FetchResponse>());
            if (claims2 != null)
                UserClaims.Add(claims2);
        }
        private OpenIdUser ResponseIntoUser(IAuthenticationResponse response)
        {
            OpenIdUser user = null;
            var claimResponseUntrusted = response.GetUntrustedExtension<FetchResponse>();
            var claimResponse = response.GetExtension<FetchResponse>();

            if (claimResponse != null)
            {
                user = new OpenIdUser(claimResponse, response.ClaimedIdentifier);
            }
            else if (claimResponseUntrusted != null)
            {
                user = new OpenIdUser(claimResponseUntrusted, response.ClaimedIdentifier);
            }

            return user;
        }
        private static string FetchEmail(IAuthenticationResponse response)
        {
            var fetch = response.GetExtension<FetchResponse>();

            string email = string.Empty;
            if (fetch != null)
            {
                email = fetch.GetAttributeValue(WellKnownAttributes.Contact.Email);
            }

            if (string.IsNullOrEmpty(email))
            {
                throw new InvalidOperationException("Email is required, but was not supplied by the OpenID provider.");
            }

            return email;
        }
Exemplo n.º 58
0
 public override OpenIdData ParseOpenIdResponse(IAuthenticationResponse openIdResponse)
 {
     if (openIdResponse.IsNull())
     {
         throw new ArgumentException("Invalid open id response");
     }
     //Let us check the response
     switch (openIdResponse.Status)
     {
         case AuthenticationStatus.Authenticated:
             var openId = openIdResponse.ClaimedIdentifier;
             var friendlyName = openIdResponse.FriendlyIdentifierForDisplay;
             return new OpenIdData() {FriendlyName = friendlyName, OpenId = openId};
             break;
         default:
             throw new ArgumentException("Invalid open id");
     }
 }
Exemplo n.º 59
0
        protected override Dictionary<string, string> GetExtraData(IAuthenticationResponse response)
        {
            var fetchResponse = response.GetExtension<FetchResponse>();
            if (fetchResponse != null)
            {
                var extraData = new Dictionary<string, string>
                    {
                        {"email", fetchResponse.GetAttributeValue(WellKnownAttributes.Contact.Email)},
                        {"country", fetchResponse.GetAttributeValue(WellKnownAttributes.Contact.HomeAddress.Country)},
                        {"firstName", fetchResponse.GetAttributeValue(WellKnownAttributes.Name.First)},
                        {"lastName", fetchResponse.GetAttributeValue(WellKnownAttributes.Name.Last)}
                    };

                return extraData;
            }

            return null;
        }
        /// <summary>
        /// Extracts an Attribute Exchange response, if one exists
        /// </summary>
        private Dictionary<string, string> GetAttributeEx(IAuthenticationResponse response)
        {
            var ret = new Dictionary<string, string>();

            var fetchResponse = response.GetExtension<FetchResponse>();

            if (fetchResponse == null) return ret;

            var names = new List<string>();
            var emails = new List<string>();

            if (fetchResponse.Attributes.Contains("http://schema.openid.net/namePerson"))
                names.AddRange(fetchResponse.Attributes["http://schema.openid.net/namePerson"].Values);

            if (fetchResponse.Attributes.Contains(WellKnownAttributes.Name.FullName))
                names.AddRange(fetchResponse.Attributes[WellKnownAttributes.Name.FullName].Values);

            if (fetchResponse.Attributes.Contains(WellKnownAttributes.Name.Alias))
                names.AddRange(fetchResponse.Attributes[WellKnownAttributes.Name.Alias].Values);

            if (fetchResponse.Attributes.Contains(WellKnownAttributes.Name.First))
                names.AddRange(fetchResponse.Attributes[WellKnownAttributes.Name.First].Values);

            if (fetchResponse.Attributes.Contains(WellKnownAttributes.Name.Last))
                names.AddRange(fetchResponse.Attributes[WellKnownAttributes.Name.Last].Values);

            if (fetchResponse.Attributes.Contains("http://schema.openid.net/contact/email"))
                emails.AddRange(fetchResponse.Attributes["http://schema.openid.net/contact/email"].Values);

            if (fetchResponse.Attributes.Contains(WellKnownAttributes.Contact.Email))
                emails.AddRange(fetchResponse.Attributes[WellKnownAttributes.Contact.Email].Values);

            if (names.Count > 0)
                ret["FullName"] = names[0];

            if (emails.Count > 0)
                ret["Email"] = emails[0];

            return ret;
        }