public void UnifyExtensionsAsSregNoExtensions()
{
var sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg(this.response, true);
Assert.IsNotNull(sreg);
Assert.IsNull(sreg.Nickname);
}
private async Task ParameterizedAXTestAsync(AXAttributeFormats format)
{
var axInjected = new FetchRequest();
axInjected.Attributes.AddOptional(ExtensionsInteropHelper.TransformAXFormatTestHook(WellKnownAttributes.Name.Alias, format));
axInjected.Attributes.AddRequired(ExtensionsInteropHelper.TransformAXFormatTestHook(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 = sreg.CreateResponse();
sregResponse.Nickname = "andy";
this.request.AddResponseExtension(sregResponse);
await ExtensionsInteropHelper.ConvertSregToMatchRequestAsync(this.request, CancellationToken.None);
var extensions = await this.GetResponseExtensionsAsync();
var axResponse = extensions.OfType <FetchResponse>().Single();
Assert.AreEqual("andy", axResponse.GetAttributeValue(ExtensionsInteropHelper.TransformAXFormatTestHook(WellKnownAttributes.Name.Alias, format)));
}
public void UnifyExtensionsAsSregWithBothSregAndAX()
{
var sregInjected = new ClaimsRequest(DotNetOpenAuth.OpenId.Extensions.SimpleRegistration.Constants.TypeUris.Standard)
{
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 = sreg.CreateResponse();
sregResponseInjected.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));
}
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 void UnifyExtensionsasSregFromSchemaOpenIdNet()
{
var axInjected = new FetchResponse();
axInjected.Attributes.Add(ExtensionsInteropProviderHelper.TransformAXFormatTestHook(WellKnownAttributes.Name.Alias, AXAttributeFormats.SchemaOpenIdNet), "nate");
this.extensions.Add(axInjected);
var sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg(this.response, true);
Assert.AreEqual("nate", sreg.Nickname);
}
public void UnifyExtensionsAsSregFromAXSchemaOrg()
{
var axInjected = new FetchResponse();
axInjected.Attributes.Add(WellKnownAttributes.Name.Alias, "nate");
this.extensions.Add(axInjected);
var sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg(this.response, true);
Assert.AreEqual("nate", sreg.Nickname);
}
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);
}
public void UnifyExtensionsAsSregWithSreg()
{
var sregInjected = new ClaimsResponse {
Nickname = "andy",
};
var axInjected = new FetchResponse();
axInjected.Attributes.Add(WellKnownAttributes.Name.Alias, "nate");
this.extensions.Add(sregInjected);
this.extensions.Add(axInjected);
var sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg(this.response, true);
Assert.AreSame(sregInjected, sreg);
Assert.AreEqual("andy", sreg.Nickname);
}
public void NoRequestedExtensions()
{
var sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg(this.request);
Assert.IsNull(sreg);
// Make sure we're still able to send an sreg response.
var sregResponse = new ClaimsResponse();
this.request.AddResponseExtension(sregResponse);
ExtensionsInteropHelper.ConvertSregToMatchRequest(this.request);
var extensions = this.GetResponseExtensions();
Assert.AreSame(sregResponse, extensions.Single());
}
/// <summary>
/// Gets an authentication response from a Provider.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>
/// The processed authentication response if there is any; <c>null</c> otherwise.
/// </returns>
/// <remarks>
/// Requires an <see cref="HttpContext.Current">HttpContext.Current</see> context.
/// </remarks>
public async Task <IAuthenticationResponse> GetResponseAsync_ccp(IProtocolMessage msg, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
var message = await this.Channel.ReadFromRequestAsync_ccp(msg, cancellationToken);
PositiveAssertionResponse positiveAssertion;
NegativeAssertionResponse negativeAssertion;
IndirectSignedResponse positiveExtensionOnly;
if ((positiveAssertion = message as PositiveAssertionResponse) != null)
{
// We need to make sure that this assertion is coming from an endpoint
// that the host deems acceptable.
var providerEndpoint = new SimpleXrdsProviderEndpoint(positiveAssertion);
ErrorUtilities.VerifyProtocol(
this.FilterEndpoint(providerEndpoint),
OpenIdStrings.PositiveAssertionFromNonQualifiedProvider,
providerEndpoint.Uri);
var response = await PositiveAuthenticationResponse.CreateAsync_ccp(positiveAssertion, this, cancellationToken);
foreach (var behavior in this.Behaviors)
{
behavior.OnIncomingPositiveAssertion(response);
}
var sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg(response, true);
Debug.Assert(sreg.Email != null, "No email field!");
return(response);
}
else if ((positiveExtensionOnly = message as IndirectSignedResponse) != null)
{
return(new PositiveAnonymousResponse(positiveExtensionOnly));
}
else if ((negativeAssertion = message as NegativeAssertionResponse) != null)
{
return(new NegativeAuthenticationResponse(negativeAssertion));
}
return(null);
}
catch (ProtocolException ex)
{
return(new FailedAuthenticationResponse(ex));
}
}
public void NoRequestedExtensions()
{
var sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg(this.request);
Assert.IsNull(sreg);
// Make sure we're still able to send an sreg response.
// (not really a valid scenario, since OPs don't have public access
// to directly create a response without a request.
var sregResponse = new ClaimsResponse();
this.request.AddResponseExtension(sregResponse);
ExtensionsInteropHelper.ConvertSregToMatchRequest(this.request);
var extensions = this.GetResponseExtensions();
Assert.AreSame(sregResponse, extensions.Single());
}
public void UnifyExtensionsAsSregWithSreg()
{
var sregInjected = new ClaimsRequest {
Nickname = DemandLevel.Request,
};
this.extensions.Add(sregInjected);
var sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg(this.request);
Assert.AreSame(sregInjected, sreg);
Assert.AreEqual(DemandLevel.Request, sreg.Nickname);
Assert.AreEqual(DemandLevel.NoRequest, sreg.FullName);
var sregResponse = new ClaimsResponse();
this.request.AddResponseExtension(sregResponse);
ExtensionsInteropHelper.ConvertSregToMatchRequest(this.request);
var extensions = this.GetResponseExtensions();
Assert.AreSame(sregResponse, extensions.Single());
}
public void UnifyExtensionsAsSregWithSreg()
{
var sregInjected = new ClaimsRequest(DotNetOpenAuth.OpenId.Extensions.SimpleRegistration.Constants.TypeUris.Standard)
{
Nickname = DemandLevel.Request,
};
this.extensions.Add(sregInjected);
var sreg = ExtensionsInteropHelper.UnifyExtensionsAsSreg(this.request);
Assert.AreSame(sregInjected, sreg);
Assert.AreEqual(DemandLevel.Request, sreg.Nickname);
Assert.AreEqual(DemandLevel.NoRequest, sreg.FullName);
var sregResponse = sreg.CreateResponse();
this.request.AddResponseExtension(sregResponse);
ExtensionsInteropHelper.ConvertSregToMatchRequest(this.request);
var extensions = this.GetResponseExtensions();
Assert.AreSame(sregResponse, extensions.Single());
}
