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); }
private void ParameterizedAXTest(AXAttributeFormats format) { var axInjected = new FetchRequest(); axInjected.Attributes.AddOptional(ExtensionsInteropHelper_Accessor.TransformAXFormat(WellKnownAttributes.Name.Alias, format)); axInjected.Attributes.AddRequired(ExtensionsInteropHelper_Accessor.TransformAXFormat(WellKnownAttributes.Name.FullName, format)); this.extensions.Add(axInjected); var sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg(this.request); Assert.AreSame(sreg, this.request.GetExtension <ClaimsRequest>()); Assert.AreEqual(DemandLevel.Request, sreg.Nickname); Assert.AreEqual(DemandLevel.Require, sreg.FullName); Assert.AreEqual(DemandLevel.NoRequest, sreg.Language); var sregResponse = new ClaimsResponse { Nickname = "andy", }; this.request.AddResponseExtension(sregResponse); ExtensionsInteropHelper.ConvertSregToMatchRequest(this.request); var extensions = this.GetResponseExtensions(); var axResponse = extensions.OfType <FetchResponse>().Single(); Assert.AreEqual("andy", axResponse.GetAttributeValue(ExtensionsInteropHelper_Accessor.TransformAXFormat(WellKnownAttributes.Name.Alias, format))); }
public static Dictionary <string, string> ToDictionary(this ClaimsResponse response) { var map = new Dictionary <string, string>(); if (response == null) { return(map); } if (response.BirthDate.HasValue) { map["BirthDate"] = response.BirthDate.Value.ToJsv(); } if (!response.BirthDateRaw.IsNullOrEmpty()) { map["BirthDateRaw"] = response.BirthDateRaw; } if (!response.Country.IsNullOrEmpty()) { map["Country"] = response.Country; } if (response.Culture != null) { map["Culture"] = response.Culture.TwoLetterISOLanguageName; } if (!response.Email.IsNullOrEmpty()) { map["Email"] = response.Email; } if (!response.FullName.IsNullOrEmpty()) { map["FullName"] = response.FullName; } if (response.Gender.HasValue) { map["Gender"] = response.Gender.Value.ToString(); } if (!response.Language.IsNullOrEmpty()) { map["Language"] = response.Language; } if (response.MailAddress != null) { map["MailAddress"] = response.MailAddress.ToJsv(); } if (!response.Nickname.IsNullOrEmpty()) { map["Nickname"] = response.Nickname; } if (!response.PostalCode.IsNullOrEmpty()) { map["PostalCode"] = response.PostalCode; } if (!response.TimeZone.IsNullOrEmpty()) { map["TimeZone"] = response.TimeZone; } return(map); }
public void UnifyExtensionsAsSregWithBothSregAndAX() { var sregInjected = new ClaimsRequest { Nickname = DemandLevel.Request, }; this.extensions.Add(sregInjected); var axInjected = new FetchRequest(); axInjected.Attributes.AddOptional(WellKnownAttributes.Contact.Email); this.extensions.Add(axInjected); var sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg(this.request); Assert.AreSame(sregInjected, sreg); Assert.AreEqual(DemandLevel.Request, sreg.Nickname); Assert.AreEqual(DemandLevel.NoRequest, sreg.Email); var sregResponseInjected = new ClaimsResponse { Nickname = "andy", }; this.request.AddResponseExtension(sregResponseInjected); var axResponseInjected = new FetchResponse(); axResponseInjected.Attributes.Add(WellKnownAttributes.Contact.Email, "*****@*****.**"); this.request.AddResponseExtension(axResponseInjected); ExtensionsInteropHelper.ConvertSregToMatchRequest(this.request); var extensions = this.GetResponseExtensions(); var sregResponse = extensions.OfType <ClaimsResponse>().Single(); Assert.AreEqual("andy", sregResponse.Nickname); var axResponse = extensions.OfType <FetchResponse>().Single(); Assert.AreEqual("*****@*****.**", axResponse.GetAttributeValue(WellKnownAttributes.Contact.Email)); }
public void EmptyMailAddress() { ClaimsResponse response = new ClaimsResponse(Constants.sreg_ns); response.Email = string.Empty; Assert.IsNull(response.MailAddress); }
private bool IsValidForUserCreation(OpenIdEventArgs e, ClaimsResponse claim) { bool result = true; if (claim == null) { return(false); } if (String.IsNullOrEmpty(claim.Email)) { return(false); } if (String.IsNullOrEmpty(claim.FullName)) { return(false); } if (!Email.IsValidEmailAddressSyntax(claim.Email)) { return(false); } mojoProfileConfiguration profileConfig = mojoProfileConfiguration.GetConfig(); if (profileConfig.HasRequiredCustomProperties()) { result = false; } return(result); }
public async Task <ClaimsResponse> GetClaimListByPaging(ListDTO listDTO) { ClaimsResponse claimsResponse = new ClaimsResponse(); var lst = (from a in Context.Set <Claims>() select new ClaimsRow() { Id = a.Id, ActionName = a.ActionName, ActionTitleEn = a.ActionTitleEn, ActionTitleFr = a.ActionTitleFr, ControlleEnTitile = a.ControlleEnTitile, ControlleFaTitile = a.ControlleFaTitile, ControllerEntityID = a.ControllerEntityID, ControllerName = a.ControllerName }).AsQueryable(); if (listDTO.Filter != null && listDTO.Filter.Trim().Length != 0) { lst = new LinqSearch().ApplyFilter(lst, listDTO.Filter); } if (listDTO.IsRequestCount) { claimsResponse.LstCount = await lst.CountAsync(); } else { claimsResponse.Claims = await lst.Skip((listDTO.PageNum - 1) *listDTO.PageSize).Take(listDTO.PageSize).ToListAsync(); } return(claimsResponse); }
public void Birthdates() { var response = new ClaimsResponse(); // Verify that they both start out as null Assert.IsNull(response.BirthDateRaw); Assert.IsFalse(response.BirthDate.HasValue); // Verify that null can be set. response.BirthDate = null; response.BirthDateRaw = null; Assert.IsNull(response.BirthDateRaw); Assert.IsFalse(response.BirthDate.HasValue); // Verify that the strong-typed BirthDate property can be set and that it affects the raw property. response.BirthDate = DateTime.Parse("April 4, 1984"); Assert.AreEqual(4, response.BirthDate.Value.Month); Assert.AreEqual("1984-04-04", response.BirthDateRaw); // Verify that the raw property can be set with a complete birthdate and that it affects the strong-typed property. response.BirthDateRaw = "1998-05-08"; Assert.AreEqual("1998-05-08", response.BirthDateRaw); Assert.AreEqual(DateTime.Parse("May 8, 1998", CultureInfo.InvariantCulture), response.BirthDate); // Verify that an partial raw birthdate works, and sets the strong-typed property to null since it cannot be represented. response.BirthDateRaw = "2000-00-00"; Assert.AreEqual("2000-00-00", response.BirthDateRaw); Assert.IsFalse(response.BirthDate.HasValue); }
protected void Yes_Click(Object sender, EventArgs e) { var sregRequest = ProviderEndpoint.PendingAuthenticationRequest.GetExtension <ClaimsRequest>(); ClaimsResponse sregResponse = null; if (sregRequest != null) { sregResponse = profileFields.GetOpenIdProfileFields(sregRequest); ProviderEndpoint.PendingAuthenticationRequest.AddResponseExtension(sregResponse); } var papeRequest = ProviderEndpoint.PendingAuthenticationRequest.GetExtension <PolicyRequest>(); PolicyResponse papeResponse = null; if (papeRequest != null) { papeResponse = new PolicyResponse(); papeResponse.NistAssuranceLevel = NistAssuranceLevel.InsufficientForLevel1; ProviderEndpoint.PendingAuthenticationRequest.AddResponseExtension(papeResponse); } ProviderEndpoint.PendingAuthenticationRequest.IsAuthenticated = true; Debug.Assert(ProviderEndpoint.PendingAuthenticationRequest.IsResponseReady); ProviderEndpoint.PendingAuthenticationRequest.Response.Send(); ProviderEndpoint.PendingAuthenticationRequest = null; }
public void EmptyMailAddress() { ClaimsResponse response = new ClaimsResponse(Constants.TypeUris.Standard); response.Email = string.Empty; Assert.IsNull(response.MailAddress); }
public async Task <ClaimsResponse> GetClaimsByRole(string roleId) { try { ClaimsResponse claimsResponse = new ClaimsResponse(); claimsResponse.Claims = new List <ClaimsRow>(); var claimsIds = await Context.RoleClaims.Where(a => a.RoleId == roleId).Select(a => int.Parse(a.ClaimValue)).ToListAsync(); var _claims = await Context.Claims.Where(a => claimsIds.Contains(a.Id)).Select(a => a).ToListAsync(); foreach (var item in _claims) { ClaimsRow claimsRow = new ClaimsRow(); item.CopyPropertiesTo(claimsRow); claimsResponse.Claims.Add(claimsRow); } claimsResponse.LstCount = claimsResponse.Claims.Count(); claimsResponse.ToSuccess <ClaimsResponse>(); return(claimsResponse); } catch (Exception ex) { throw new Exception(ex.Message); } }
private void ParameterizedTypeUriPreservedTest(string typeUri) { ClaimsRequest request = new ClaimsRequest(typeUri); ClaimsResponse response = request.CreateResponse(); Assert.AreEqual(typeUri, ((IOpenIdMessageExtension)response).TypeUri); }
internal static UniversalProfile ProfileFromOpenId(ClaimsResponse spprofile, FetchResponse fetchprofile, string claimedId) { var profile = new UniversalProfile { Link = claimedId, Id = claimedId, Provider = "openid", }; if (spprofile != null) { //Fill profile.BirthDay = spprofile.BirthDateRaw; profile.DisplayName = spprofile.FullName; profile.EMail = spprofile.Email; profile.Name = spprofile.Nickname; profile.Gender = spprofile.Gender.HasValue ? spprofile.Gender.Value.ToString() : ""; profile.TimeZone = spprofile.TimeZone; profile.Locale = spprofile.Language; } if (fetchprofile != null) { profile.Name = fetchprofile.GetAttributeValue(WellKnownAttributes.Name.Alias); profile.LastName = fetchprofile.GetAttributeValue(WellKnownAttributes.Name.Last); profile.FirstName = fetchprofile.GetAttributeValue(WellKnownAttributes.Name.First); profile.DisplayName = fetchprofile.GetAttributeValue(WellKnownAttributes.Name.FullName); profile.MiddleName = fetchprofile.GetAttributeValue(WellKnownAttributes.Name.Middle); profile.Salutation = fetchprofile.GetAttributeValue(WellKnownAttributes.Name.Prefix); profile.Avatar = fetchprofile.GetAttributeValue(WellKnownAttributes.Media.Images.Default); profile.EMail = fetchprofile.GetAttributeValue(WellKnownAttributes.Contact.Email); profile.Gender = fetchprofile.GetAttributeValue(WellKnownAttributes.Person.Gender); profile.BirthDay = fetchprofile.GetAttributeValue(WellKnownAttributes.BirthDate.WholeBirthDate); } return(profile); }
/// <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); } }
/// <summary> /// Correctly calculate the unclaimed GAS from a claim response /// </summary> /// <param name="claims">The claim response object</param> /// <returns>A proper decimal GAS amount</returns> public static decimal GetUnclaimedGas(this ClaimsResponse claims) { if (claims == null || claims.TotalUnspentClaim == 0) { return(0); } return((decimal)claims.TotalUnspentClaim / 100000000); }
private void addClaimInfo(ClaimsResponse claim, string identifier) { Email = claim.Email; FullName = claim.FullName; Nickname = claim.Nickname ?? claim.Email; IsSignedByProvider = claim.IsSignedByProvider; ClaimedIdentifier = identifier; }
public async Task DualIdentifierNoMatchInAssertionVerificationByDefault() { PositiveAssertionResponse assertion = this.GetPositiveAssertion(true); ClaimsResponse extension = new ClaimsResponse(); assertion.Extensions.Add(extension); var rp = CreateRelyingParty(); await PositiveAuthenticationResponse.CreateAsync(assertion, rp, CancellationToken.None); // this will throw if it fails to find a match }
public IActionResult Index() { ViewBag.lang = langcode; var _paidclaims = GetPaidClaimsById(); var claimsResponse = new ClaimsResponse(); claimsResponse.PaidClaims = _paidclaims.OrderByDescending(c => c.POLICY_INC).ToList(); return(View(claimsResponse)); }
public IActionResult GetOSClaims() { ViewBag.lang = langcode; var _osClaims = GetOSClaimsById(); var claimsResponse = new ClaimsResponse(); claimsResponse.OSClaims = _osClaims.OrderByDescending(c => c.POLICY_INC).ToList(); return(View(claimsResponse)); }
protected void Yes_Click(object sender, EventArgs e) { this.RegisterAsyncTask( new PageAsyncTask( async ct => { if (!Page.IsValid || ProviderEndpoint.PendingRequest == null) { return; } if (this.OAuthPanel.Visible) { string grantedScope = null; if (this.oauthPermission.Checked) { // This SIMPLE sample merely uses the realm as the consumerKey, // but in a real app this will probably involve a database lookup to translate // the realm to a known consumerKey. grantedScope = string.Empty; // we don't scope individual access rights on this sample } OAuthHybrid.ServiceProvider.AttachAuthorizationResponse(ProviderEndpoint.PendingRequest, grantedScope); } var sregRequest = ProviderEndpoint.PendingRequest.GetExtension <ClaimsRequest>(); ClaimsResponse sregResponse = null; if (sregRequest != null) { sregResponse = this.profileFields.GetOpenIdProfileFields(sregRequest); ProviderEndpoint.PendingRequest.AddResponseExtension(sregResponse); } var papeRequest = ProviderEndpoint.PendingRequest.GetExtension <PolicyRequest>(); PolicyResponse papeResponse = null; if (papeRequest != null) { papeResponse = new PolicyResponse(); papeResponse.NistAssuranceLevel = NistAssuranceLevel.InsufficientForLevel1; ProviderEndpoint.PendingRequest.AddResponseExtension(papeResponse); } if (ProviderEndpoint.PendingAuthenticationRequest != null) { ProviderEndpoint.PendingAuthenticationRequest.IsAuthenticated = true; } else { ProviderEndpoint.PendingAnonymousRequest.IsApproved = true; } Debug.Assert( ProviderEndpoint.PendingRequest.IsResponseReady, "Setting authentication should be all that's necessary."); var provider = new ProviderEndpoint(); var response = await provider.PrepareResponseAsync(); await response.SendAsync(); })); }
public void DualIdentifierNoMatchInAssertionVerificationByDefault() { PositiveAssertionResponse assertion = this.GetPositiveAssertion(true); ClaimsResponse extension = new ClaimsResponse(); assertion.Extensions.Add(extension); var rp = CreateRelyingParty(); new PositiveAuthenticationResponse(assertion, rp); // this will throw if it fails to find a match }
public async Task DualIdentifierMatchesInAssertionVerification() { PositiveAssertionResponse assertion = this.GetPositiveAssertion(true); ClaimsResponse extension = new ClaimsResponse(); assertion.Extensions.Add(extension); var rp = CreateRelyingParty(); rp.SecuritySettings.AllowDualPurposeIdentifiers = true; await PositiveAuthenticationResponse.CreateAsync(assertion, rp, CancellationToken.None); // this will throw if it fails to find a match }
public void ResponseAlternateTypeUriTests() { var request = new ClaimsRequest(Constants.TypeUris.Variant10); request.Email = DemandLevel.Require; var response = new ClaimsResponse(Constants.TypeUris.Variant10); response.Email = "*****@*****.**"; ExtensionTestUtilities.Roundtrip(Protocol.Default, new[] { request }, new[] { response }); }
public async Task ResponseAlternateTypeUriTests() { var request = new ClaimsRequest(Constants.TypeUris.Variant10); request.Email = DemandLevel.Require; var response = new ClaimsResponse(Constants.TypeUris.Variant10); response.Email = "*****@*****.**"; await this.RoundtripAsync(Protocol.Default, new[] { request }, new[] { response }); }
void parameterizedPreserveVersionFromRequest(string versionTypeUri) { Dictionary <string, string> fields = new Dictionary <string, string> { { "optional", "nickname" }, }; var req = new ClaimsRequest(); Assert.IsTrue(((IExtensionRequest)req).Deserialize(fields, null, versionTypeUri)); Assert.AreEqual(DemandLevel.Request, req.Nickname); ClaimsResponse resp = req.CreateResponse(); Assert.AreEqual(versionTypeUri, ((IExtensionResponse)resp).TypeUri); }
public void XmlSerialization() { ClaimsResponse fields = this.GetFilledData(); MemoryStream ms = new MemoryStream(); XmlSerializer xs = new XmlSerializer(typeof(ClaimsResponse)); xs.Serialize(ms, fields); ms.Position = 0; ClaimsResponse fields2 = (ClaimsResponse)xs.Deserialize(ms); Assert.AreEqual(fields, fields2); }
public void BinarySerialization() { ClaimsResponse fields = this.GetFilledData(); MemoryStream ms = new MemoryStream(); IFormatter formatter = new BinaryFormatter(); formatter.Serialize(ms, fields); ms.Position = 0; ClaimsResponse fields2 = (ClaimsResponse)formatter.Deserialize(ms); Assert.AreEqual(fields, fields2); }
static void Main() { init(); //initialization GlobalState.is_positive_assertion = new PositiveAssertionResponse(); result = c.PrepareResponseAsync_CCP(Auth_resp); //Check for extensions ClaimsResponse sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg((IAuthenticationResponse)result, true); GlobalState.actualExt = sreg; //signature coverage -- returnTo and ClaimedIdentifier are protected by the signature Contract.Assume(Auth_resp.ClaimedIdentifier == SignIn_req.ClaimedIdentifier); //signature coverage -- returnTo and ClaimedIdentifier are protected by the signature Contract.Assume(SignIn_req.ReturnTo == Auth_resp.ReturnTo); CancellationToken x = default(CancellationToken); result1 = rp.GetResponseAsync_ccp(SignIn_req, x); sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg(result1, true); GlobalState.claimedExt = sreg; //signature coverage if (identity == Identity.Email) { Contract.Assume(GlobalState.actualExt.Email != null && GlobalState.claimedExt.Email == GlobalState.actualExt.Email); } //RP check: Does the final returnTo field match our origin? //This is supplied by the developer of the convincee Contract.Assert(Auth_resp.ReturnTo == HttpContext.Current.Request.Url); //check for extension if (identity == Identity.Email) { Contract.Assert(GlobalState.actualExt.Email != null && GlobalState.claimedExt.Email == GlobalState.actualExt.Email); } else if (identity == Identity.ClaimedId) { Contract.Assert(Auth_resp.ClaimedIdentifier == SignIn_req.ClaimedIdentifier); } //RP check: verify claimed id resolves to the correct endpoint Contract.Assert(GlobalState.is_positive_assertion == null || GlobalState.claimedEndPoint == GlobalState.actualEndPoint); //shuo's assertion Contract.Assert(Get_ID_Assertion(auth_req_sessionID, auth_req_realm).ClaimedIdentifier == SignIn_req.ClaimedIdentifier); Contract.Assert(Get_ID_Assertion(auth_req_sessionID, auth_req_realm).ReturnTo == HttpContext.Current.Request.Url); Contract.Assert(Get_ID_Assertion(auth_req_sessionID, auth_req_realm).Recipient.Authority == HttpContext.Current.Request.Url.Authority); }
private void LogUser(string openId, ClaimsResponse profileFields) { //recupero l'utente da db, oppure lo creo al volo se non esiste MTBUser user = DBHelper.LoadUser(openId); //non esiste? allora lo creo e lo metto nella sessione come NewUser, quindi //rimando alla pagina User che, solo dopo aver inserito i dati obblicatori, lo metterà //finalmente in sessione come User if (user == null) { user = new MTBUser(); user.OpenId = openId; user.Surname = ""; if (profileFields != null) { user.Name = profileFields.FullName; user.EMail = profileFields.Email; user.Nickname = profileFields.Nickname; if (profileFields.Gender != null) { switch (profileFields.Gender.Value) { case Gender.Male: user.Gender = MTBUser.GenderType.Male; break; case Gender.Female: user.Gender = MTBUser.GenderType.Female; break; default: break; } } if (profileFields.BirthDate != null) { user.BirthDate = profileFields.BirthDate.Value; } } LoginState.NewUser = user; Response.Redirect("User.aspx"); } else { LoginState.User = user; FormsAuthentication.RedirectFromLoginPage("", false); } }
public async Task <ClaimsResponse> GetListAsync(ListDTO listDTO) { var response = new ClaimsResponse(); try { response = await _claimsRepository.GetClaimListByPaging(listDTO); return(response.ToSuccess <ClaimsResponse>()); } catch (Exception e) { throw new Exception(e.Message); } }