public OpenIdMembershipUser(
string providerName,
Identifier openId,
string name,
object providerUserKey,
string email,
string passwordQuestion,
string comment,
bool isApproved,
bool isLockedOut,
DateTime creationDate,
DateTime lastLoginDate,
DateTime lastActivityDate,
DateTime lastPasswordChangedDate,
DateTime lastLockoutDate)
: base(providerName,
name,
providerUserKey,
email,
passwordQuestion,
comment,
isApproved,
isLockedOut,
creationDate,
lastLoginDate,
lastActivityDate,
lastPasswordChangedDate,
lastLockoutDate)
{
OpenId = openId;
}
public static void CreateDatabase(Identifier claimedId, string friendlyId, string databaseName)
{
const string SqlFormat = @"
{0}
GO
EXEC [dbo].[AddUser] 'admin', 'admin', '{1}', '{2}'
GO
";
var removeSnippets = new string[] { @"
IF IS_SRVROLEMEMBER(N'sysadmin') = 1
BEGIN
IF EXISTS (SELECT 1
FROM [master].[dbo].[sysdatabases]
WHERE [name] = N'$(DatabaseName)')
BEGIN
EXECUTE sp_executesql N'ALTER DATABASE [$(DatabaseName)]
SET HONOR_BROKER_PRIORITY OFF
WITH ROLLBACK IMMEDIATE';
END
END
ELSE
BEGIN
PRINT N'The database settings cannot be modified. You must be a SysAdmin to apply these settings.';
END
GO" };
string databasePath = HttpContext.Current.Server.MapPath("~/App_Data/" + databaseName + ".mdf");
StringBuilder schemaSqlBuilder = new StringBuilder();
using (var sr = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream(DefaultNamespace + ".CreateDatabase.sql")))
{
schemaSqlBuilder.Append(sr.ReadToEnd());
}
foreach (string remove in removeSnippets)
{
schemaSqlBuilder.Replace(remove, string.Empty);
}
schemaSqlBuilder.Replace("$(Path1)", HttpContext.Current.Server.MapPath("~/App_Data/"));
schemaSqlBuilder.Replace("WEBROOT", databasePath);
schemaSqlBuilder.Replace("$(DatabaseName)", databaseName);
string sql = string.Format(CultureInfo.InvariantCulture, SqlFormat, schemaSqlBuilder, claimedId, "Admin");
var serverConnection = new ServerConnection(".\\sqlexpress");
try
{
serverConnection.ExecuteNonQuery(sql);
}
finally
{
try
{
var server = new Server(serverConnection);
server.DetachDatabase(databaseName, true);
}
catch (FailedOperationException)
{
}
serverConnection.Disconnect();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="OpenIdClient"/> class.
/// </summary>
/// <param name="providerName">
/// Name of the provider.
/// </param>
/// <param name="providerIdentifier">
/// The provider identifier, which is the usually the login url of the specified provider.
/// </param>
public OpenIdClient(string providerName, Identifier providerIdentifier) {
Requires.NotNullOrEmpty(providerName, "providerName");
Requires.NotNull(providerIdentifier, "providerIdentifier");
this.providerName = providerName;
this.providerIdentifier = providerIdentifier;
}
private ActionResult LogOn(Identifier identifier)
{
//Remove the unnecessary portion of the identifier
string steamIDString = identifier.ToString().Replace("http://steamcommunity.com/openid/id/", "");
long steamId64 = long.Parse(steamIDString);
using (var db = new SprayContext())
{
var user = db.Users.FirstOrDefault(x => x.SteamId == steamId64);
SteamWebAPI.SteamAPISession session = new SteamWebAPI.SteamAPISession();
session.accessToken = ""; /* CHANGEME - Steam Web API access token */
var userInfo = session.GetUserInfo(steamId64.ToString());
if (user == null)
{
//Add the user if they're new
user = CreateUser(steamId64, db, userInfo);
}
else
{
// Or update the relevant information
user.AvatarURI = userInfo.avatarUrl;
user.NickName = userInfo.nickname;
user.LastUpdated = DateTime.Now;
}
int recordsAffected = db.SaveChanges();
FormsAuthentication.SetAuthCookie(steamId64.ToString(), true);
}
return RedirectToAction("Index", "Home");
}
public IEnumerable<IAuthenticationRequest> CreateRequests(Identifier userSuppliedIdentifier, Realm realm, Uri returnTo, Uri privacyPolicy) {
if (userSuppliedIdentifier == null) {
throw new ArgumentNullException("userSuppliedIdentifier");
}
if (realm == null) {
throw new ArgumentNullException("realm");
}
if (returnTo == null) {
throw new ArgumentNullException("returnTo");
}
var requests = relyingParty.CreateRequests(userSuppliedIdentifier, realm, returnTo);
foreach (IAuthenticationRequest request in requests) {
// Ask for the user's email, not because we necessarily need it to do our work,
// but so we can display something meaningful to the user as their "username"
// when they log in with a PPID from Google, for example.
request.AddExtension(new ClaimsRequest {
Email = DemandLevel.Require,
FullName = DemandLevel.Request,
PolicyUrl = privacyPolicy,
});
yield return request;
}
}
/// <summary>
/// Creates the open id request.
/// </summary>
/// <param name="identifier">The identifier.</param>
/// <returns></returns>
private IAuthenticationRequest CreateOpenIdRequest(Identifier identifier)
{
var request = openId.CreateRequest(identifier);
var fetchRequest = CreateFetchRequest();
request.AddExtension(fetchRequest);
return request;
}
/// <summary>
/// Performs discovery on the specified identifier.
/// </summary>
/// <param name="identifier">The identifier to discover services for.</param>
/// <returns>A non-null sequence of services discovered for the identifier.</returns>
public IEnumerable<IdentifierDiscoveryResult> Discover(Identifier identifier) {
Requires.NotNull(identifier, "identifier");
IEnumerable<IdentifierDiscoveryResult> results = Enumerable.Empty<IdentifierDiscoveryResult>();
foreach (var discoverer in this.DiscoveryServices) {
bool abortDiscoveryChain;
var discoveryResults = discoverer.Discover(identifier, this.host.WebRequestHandler, out abortDiscoveryChain).CacheGeneratedResults();
results = results.Concat(discoveryResults);
if (abortDiscoveryChain) {
Logger.OpenId.InfoFormat("Further discovery on '{0}' was stopped by the {1} discovery service.", identifier, discoverer.GetType().Name);
break;
}
}
// If any OP Identifier service elements were found, we must not proceed
// to use any Claimed Identifier services, per OpenID 2.0 sections 7.3.2.2 and 11.2.
// For a discussion on this topic, see
// http://groups.google.com/group/dotnetopenid/browse_thread/thread/4b5a8c6b2210f387/5e25910e4d2252c8
// Sometimes the IIdentifierDiscoveryService will automatically filter this for us, but
// just to be sure, we'll do it here as well.
if (!this.host.SecuritySettings.AllowDualPurposeIdentifiers) {
results = results.CacheGeneratedResults(); // avoid performing discovery repeatedly
var opIdentifiers = results.Where(result => result.ClaimedIdentifier == result.Protocol.ClaimedIdentifierForOPIdentifier);
var claimedIdentifiers = results.Where(result => result.ClaimedIdentifier != result.Protocol.ClaimedIdentifierForOPIdentifier);
results = opIdentifiers.Any() ? opIdentifiers : claimedIdentifiers;
}
return results;
}
/// <summary>
/// Initializes a new instance of the <see cref="NoDiscoveryIdentifier"/> class.
/// </summary>
/// <param name="wrappedIdentifier">The ordinary Identifier whose discovery is being masked.</param>
/// <param name="claimSsl">Whether this Identifier should claim to be SSL-secure, although no discovery will never generate service endpoints anyway.</param>
internal NoDiscoveryIdentifier(Identifier wrappedIdentifier, bool claimSsl)
: base(wrappedIdentifier.OriginalString, claimSsl)
{
Contract.Requires(wrappedIdentifier != null);
ErrorUtilities.VerifyArgumentNotNull(wrappedIdentifier, "wrappedIdentifier");
this.wrappedIdentifier = wrappedIdentifier;
}
internal override bool TryRequireSsl(out Identifier secureIdentifier) {
// We take special care to make our wrapped identifier secure, but still
// return a mocked (secure) identifier.
Identifier secureWrappedIdentifier;
bool result = this.wrappedIdentifier.TryRequireSsl(out secureWrappedIdentifier);
secureIdentifier = new MockIdentifier(secureWrappedIdentifier, this.mockHttpRequest, this.endpoints);
return result;
}
/// <summary>
/// Performs discovery on the specified identifier.
/// </summary>
/// <param name="identifier">The identifier to perform discovery on.</param>
/// <param name="requestHandler">The means to place outgoing HTTP requests.</param>
/// <param name="abortDiscoveryChain">if set to <c>true</c>, no further discovery services will be called for this identifier.</param>
/// <returns>
/// A sequence of service endpoints yielded by discovery. Must not be null, but may be empty.
/// </returns>
public IEnumerable<IdentifierDiscoveryResult> Discover(Identifier identifier, IDirectWebRequestHandler requestHandler, out bool abortDiscoveryChain) {
abortDiscoveryChain = false;
var xriIdentifier = identifier as XriIdentifier;
if (xriIdentifier == null) {
return Enumerable.Empty<IdentifierDiscoveryResult>();
}
return DownloadXrds(xriIdentifier, requestHandler).XrdElements.CreateServiceEndpoints(xriIdentifier);
}
/// <summary>
/// Generates OpenID Providers that can authenticate using directed identity.
/// </summary>
/// <param name="xrds">The XrdsDocument instance to use in this process.</param>
/// <param name="opIdentifier">The OP Identifier entered (and resolved) by the user. Essentially the user-supplied identifier.</param>
/// <returns>A sequence of the providers that can offer directed identity services.</returns>
private static IEnumerable<IdentifierDiscoveryResult> GenerateOPIdentifierServiceEndpoints(this IEnumerable<XrdElement> xrds, Identifier opIdentifier) {
Requires.NotNull(xrds, "xrds");
Requires.NotNull(opIdentifier, "opIdentifier");
return from service in xrds.FindOPIdentifierServices()
from uri in service.UriElements
let protocol = Protocol.FindBestVersion(p => p.OPIdentifierServiceTypeURI, service.TypeElementUris)
let providerDescription = new ProviderEndpointDescription(uri.Uri, service.TypeElementUris)
select IdentifierDiscoveryResult.CreateForProviderIdentifier(opIdentifier, providerDescription, service.Priority, uri.Priority);
}
/// <summary>
/// Performs discovery on the specified identifier.
/// </summary>
/// <param name="identifier">The identifier to perform discovery on.</param>
/// <param name="requestHandler">The means to place outgoing HTTP requests.</param>
/// <param name="abortDiscoveryChain">if set to <c>true</c>, no further discovery services will be called for this identifier.</param>
/// <returns>
/// A sequence of service endpoints yielded by discovery. Must not be null, but may be empty.
/// </returns>
public IEnumerable<IdentifierDiscoveryResult> Discover(Identifier identifier, IDirectWebRequestHandler requestHandler, out bool abortDiscoveryChain) {
var mockIdentifier = identifier as MockIdentifier;
if (mockIdentifier == null) {
abortDiscoveryChain = false;
return Enumerable.Empty<IdentifierDiscoveryResult>();
}
abortDiscoveryChain = true;
return mockIdentifier.DiscoveryEndpoints;
}
public static ActionResult SendRequest(OpenIdRelyingParty openid, Identifier openIdIdentifier)
{
Logger.Info("Sending request to the open id provider");
var req = openid.CreateRequest(openIdIdentifier);
var fetch = new FetchRequest();
fetch.Attributes.Add(new AttributeRequest(WellKnownAttributes.Contact.Email, true));
fetch.Attributes.Add(new AttributeRequest(WellKnownAttributes.Name.Alias, true));
req.AddExtension(fetch);
return req.RedirectingResponse.AsActionResult();
}
/// <summary>
/// Performs discovery on the specified identifier.
/// </summary>
/// <param name="identifier">The identifier to perform discovery on.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>
/// A sequence of service endpoints yielded by discovery. Must not be null, but may be empty.
/// </returns>
public async Task<IdentifierDiscoveryServiceResult> DiscoverAsync(Identifier identifier, CancellationToken cancellationToken) {
Requires.NotNull(identifier, "identifier");
Verify.Operation(this.HostFactories != null, Strings.HostFactoriesRequired);
cancellationToken.ThrowIfCancellationRequested();
var uriIdentifier = identifier as UriIdentifier;
if (uriIdentifier == null) {
return new IdentifierDiscoveryServiceResult(Enumerable.Empty<IdentifierDiscoveryResult>());
}
var endpoints = new List<IdentifierDiscoveryResult>();
// Attempt YADIS discovery
DiscoveryResult yadisResult = await Yadis.DiscoverAsync(this.HostFactories, uriIdentifier, identifier.IsDiscoverySecureEndToEnd, cancellationToken);
cancellationToken.ThrowIfCancellationRequested();
if (yadisResult != null) {
if (yadisResult.IsXrds) {
try {
XrdsDocument xrds = new XrdsDocument(yadisResult.ResponseText);
var xrdsEndpoints = xrds.XrdElements.CreateServiceEndpoints(yadisResult.NormalizedUri, uriIdentifier);
// Filter out insecure endpoints if high security is required.
if (uriIdentifier.IsDiscoverySecureEndToEnd) {
xrdsEndpoints = xrdsEndpoints.Where(se => se.ProviderEndpoint.IsTransportSecure());
}
endpoints.AddRange(xrdsEndpoints);
} catch (XmlException ex) {
Logger.Yadis.Error("Error while parsing the XRDS document. Falling back to HTML discovery.", ex);
}
}
// Failing YADIS discovery of an XRDS document, we try HTML discovery.
if (endpoints.Count == 0) {
await yadisResult.TryRevertToHtmlResponseAsync();
var htmlEndpoints = new List<IdentifierDiscoveryResult>(DiscoverFromHtml(yadisResult.NormalizedUri, uriIdentifier, yadisResult.ResponseText));
if (htmlEndpoints.Any()) {
Logger.Yadis.DebugFormat("Total services discovered in HTML: {0}", htmlEndpoints.Count);
Logger.Yadis.Debug(htmlEndpoints.ToStringDeferred(true));
endpoints.AddRange(htmlEndpoints.Where(ep => !uriIdentifier.IsDiscoverySecureEndToEnd || ep.ProviderEndpoint.IsTransportSecure()));
if (endpoints.Count == 0) {
Logger.Yadis.Info("No HTML discovered endpoints met the security requirements.");
}
} else {
Logger.Yadis.Debug("HTML discovery failed to find any endpoints.");
}
} else {
Logger.Yadis.Debug("Skipping HTML discovery because XRDS contained service endpoints.");
}
}
return new IdentifierDiscoveryServiceResult(endpoints);
}
/// <summary>
/// Performs discovery on the specified identifier.
/// </summary>
/// <param name="identifier">The identifier to perform discovery on.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>
/// A sequence of service endpoints yielded by discovery. Must not be null, but may be empty.
/// </returns>
public async Task<IdentifierDiscoveryServiceResult> DiscoverAsync(Identifier identifier, CancellationToken cancellationToken) {
Requires.NotNull(identifier, "identifier");
Verify.Operation(this.HostFactories != null, Strings.HostFactoriesRequired);
var xriIdentifier = identifier as XriIdentifier;
if (xriIdentifier == null) {
return new IdentifierDiscoveryServiceResult(Enumerable.Empty<IdentifierDiscoveryResult>());
}
var xrds = await DownloadXrdsAsync(xriIdentifier, this.HostFactories, cancellationToken);
var endpoints = xrds.XrdElements.CreateServiceEndpoints(xriIdentifier);
return new IdentifierDiscoveryServiceResult(endpoints);
}
public MockIdentifier(Identifier wrappedIdentifier, MockHttpRequest mockHttpRequest, IEnumerable<IdentifierDiscoveryResult> endpoints)
: base(wrappedIdentifier.OriginalString, false) {
Requires.NotNull(wrappedIdentifier, "wrappedIdentifier");
Requires.NotNull(mockHttpRequest, "mockHttpRequest");
Requires.NotNull(endpoints, "endpoints");
this.wrappedIdentifier = wrappedIdentifier;
this.endpoints = endpoints;
this.mockHttpRequest = mockHttpRequest;
// Register a mock HTTP response to enable discovery of this identifier within the RP
// without having to host an ASP.NET site within the test.
mockHttpRequest.RegisterMockXrdsResponse(new Uri(wrappedIdentifier.ToString()), endpoints);
}
/// <summary>
/// Gets the salt to use for generating an anonymous identifier for a given OP local identifier.
/// </summary>
/// <param name="localIdentifier">The OP local identifier.</param>
/// <returns>The salt to use in the hash.</returns>
/// <remarks>
/// It is important that this method always return the same value for a given
/// <paramref name="localIdentifier"/>.
/// New salts can be generated for local identifiers without previously assigned salt
/// values by calling <see cref="CreateSalt"/> or by a custom method.
/// </remarks>
protected override byte[] GetHashSaltForLocalIdentifier(Identifier localIdentifier) {
// This is just a sample with no database... a real web app MUST return
// a reasonable salt here and have that salt be persistent for each user.
var membership = (ReadOnlyXmlMembershipProvider)Membership.Provider;
string username = User.GetUserFromClaimedIdentifier(new Uri(localIdentifier));
string salt = membership.GetSalt(username);
return Convert.FromBase64String(salt);
// If users were encountered without a salt, one could be generated like this,
// and would also need to be saved to the user's account.
//// var newSalt = AnonymousIdentifierProviderBase.GetNewSalt(5);
//// user.Salt = newSalt;
//// return newSalt;
}
public MockIdentifier(Identifier wrappedIdentifier, MockHttpRequest mockHttpRequest, IEnumerable<IdentifierDiscoveryResult> endpoints)
: base(wrappedIdentifier.OriginalString, false) {
Contract.Requires<ArgumentNullException>(wrappedIdentifier != null);
Contract.Requires<ArgumentNullException>(mockHttpRequest != null);
Contract.Requires<ArgumentNullException>(endpoints != null);
this.wrappedIdentifier = wrappedIdentifier;
this.endpoints = endpoints;
this.mockHttpRequest = mockHttpRequest;
// Register a mock HTTP response to enable discovery of this identifier within the RP
// without having to host an ASP.NET site within the test.
mockHttpRequest.RegisterMockXrdsResponse(new Uri(wrappedIdentifier.ToString()), endpoints);
}
public MockIdentifier(Identifier wrappedIdentifier, MockHttpRequest mockHttpRequest, IEnumerable<ServiceEndpoint> endpoints)
: base(false)
{
ErrorUtilities.VerifyArgumentNotNull(wrappedIdentifier, "wrappedIdentifier");
ErrorUtilities.VerifyArgumentNotNull(mockHttpRequest, "mockHttpRequest");
ErrorUtilities.VerifyArgumentNotNull(endpoints, "endpoints");
this.wrappedIdentifier = wrappedIdentifier;
this.endpoints = endpoints;
this.mockHttpRequest = mockHttpRequest;
// Register a mock HTTP response to enable discovery of this identifier within the RP
// without having to host an ASP.NET site within the test.
mockHttpRequest.RegisterMockXrdsResponse(new Uri(wrappedIdentifier.ToString()), endpoints);
}
/// <summary>
/// Performs discovery on the specified identifier.
/// </summary>
/// <param name="identifier">The identifier to perform discovery on.</param>
/// <param name="requestHandler">The means to place outgoing HTTP requests.</param>
/// <param name="abortDiscoveryChain">if set to <c>true</c>, no further discovery services will be called for this identifier.</param>
/// <returns>
/// A sequence of service endpoints yielded by discovery. Must not be null, but may be empty.
/// </returns>
public IEnumerable<IdentifierDiscoveryResult> Discover(Identifier identifier, IDirectWebRequestHandler requestHandler, out bool abortDiscoveryChain) {
abortDiscoveryChain = false;
var uriIdentifier = identifier as UriIdentifier;
if (uriIdentifier == null) {
return Enumerable.Empty<IdentifierDiscoveryResult>();
}
var endpoints = new List<IdentifierDiscoveryResult>();
// Attempt YADIS discovery
DiscoveryResult yadisResult = Yadis.Discover(requestHandler, uriIdentifier, identifier.IsDiscoverySecureEndToEnd);
if (yadisResult != null) {
if (yadisResult.IsXrds) {
try {
XrdsDocument xrds = new XrdsDocument(yadisResult.ResponseText);
var xrdsEndpoints = xrds.XrdElements.CreateServiceEndpoints(yadisResult.NormalizedUri, uriIdentifier);
// Filter out insecure endpoints if high security is required.
if (uriIdentifier.IsDiscoverySecureEndToEnd) {
xrdsEndpoints = xrdsEndpoints.Where(se => se.ProviderEndpoint.IsTransportSecure());
}
endpoints.AddRange(xrdsEndpoints);
} catch (XmlException ex) {
Logger.Yadis.Error("Error while parsing the XRDS document. Falling back to HTML discovery.", ex);
}
}
// Failing YADIS discovery of an XRDS document, we try HTML discovery.
if (endpoints.Count == 0) {
yadisResult.TryRevertToHtmlResponse();
var htmlEndpoints = new List<IdentifierDiscoveryResult>(DiscoverFromHtml(yadisResult.NormalizedUri, uriIdentifier, yadisResult.ResponseText));
if (htmlEndpoints.Any()) {
Logger.Yadis.DebugFormat("Total services discovered in HTML: {0}", htmlEndpoints.Count);
Logger.Yadis.Debug(htmlEndpoints.ToStringDeferred(true));
endpoints.AddRange(htmlEndpoints.Where(ep => !uriIdentifier.IsDiscoverySecureEndToEnd || ep.ProviderEndpoint.IsTransportSecure()));
if (endpoints.Count == 0) {
Logger.Yadis.Info("No HTML discovered endpoints met the security requirements.");
}
} else {
Logger.Yadis.Debug("HTML discovery failed to find any endpoints.");
}
} else {
Logger.Yadis.Debug("Skipping HTML discovery because XRDS contained service endpoints.");
}
}
return endpoints;
}
public async Task<IEnumerable<IAuthenticationRequest>> CreateRequestsAsync(Identifier userSuppliedIdentifier, Realm realm, Uri returnTo, Uri privacyPolicy, CancellationToken cancellationToken = default(CancellationToken)) {
Requires.NotNull(userSuppliedIdentifier, "userSuppliedIdentifier");
Requires.NotNull(realm, "realm");
Requires.NotNull(returnTo, "returnTo");
var requests = (await relyingParty.CreateRequestsAsync(userSuppliedIdentifier, realm, returnTo, cancellationToken)).ToList();
foreach (IAuthenticationRequest request in requests) {
// Ask for the user's email, not because we necessarily need it to do our work,
// but so we can display something meaningful to the user as their "username"
// when they log in with a PPID from Google, for example.
request.AddExtension(new ClaimsRequest {
Email = DemandLevel.Require,
FullName = DemandLevel.Request,
PolicyUrl = privacyPolicy,
});
}
return requests;
}
public static IAuthenticationRequest GetRedirectActionRequest(Identifier provider)
{
var openid = new OpenIdRelyingParty();
var request = openid.CreateRequest(Identifier.Parse(provider));
var fr = new FetchRequest();
fr.Attributes.AddRequired(WellKnownAttributes.Contact.Email);
fr.Attributes.AddRequired(WellKnownAttributes.Name.First);
fr.Attributes.AddRequired(WellKnownAttributes.Name.Last);
request.AddExtension(fr);
// Require some additional data
request.AddExtension(new ClaimsRequest
{
Email = DemandLevel.Require,
FullName = DemandLevel.Require,
Nickname = DemandLevel.Require
});
return request;
}
public IAuthenticationRequest CreateRequest(Identifier userSuppliedIdentifier, Realm realm, Uri returnTo, Uri privacyPolicy)
{
return this.CreateRequests(userSuppliedIdentifier, realm, returnTo, privacyPolicy).First();
}
internal Task<IEnumerable<IdentifierDiscoveryResult>> DiscoverAsync(Identifier identifier, CancellationToken cancellationToken = default(CancellationToken)) {
var rp = this.CreateRelyingParty(true);
return rp.DiscoverAsync(identifier, cancellationToken);
}
internal IEnumerable<IdentifierDiscoveryResult> Discover(Identifier identifier) {
var rp = this.CreateRelyingParty(true);
rp.Channel.WebRequestHandler = this.RequestHandler;
return rp.Discover(identifier);
}
public ActionResult AjaxDiscovery(Identifier userSuppliedIdentifier, Realm realm, Uri returnTo, Uri privacyPolicy)
{
return relyingParty.AsAjaxDiscoveryResult(
this.CreateRequests(userSuppliedIdentifier, realm, returnTo, privacyPolicy)).AsActionResult();
}
private void DiscoverHtml(string page, ProtocolVersion version, Identifier expectedLocalId, string providerEndpoint, bool useRedirect) {
this.Discover("/Discovery/htmldiscovery/" + page, version, expectedLocalId, providerEndpoint, false, useRedirect);
}
private void DiscoverHtml(string scenario, ProtocolVersion version, Identifier expectedLocalId, string providerEndpoint) {
string page = scenario + ".html";
this.DiscoverHtml(page, version, expectedLocalId, providerEndpoint, false);
this.DiscoverHtml(page, version, expectedLocalId, providerEndpoint, true);
}
private void DiscoverXrds(string page, ProtocolVersion version, Identifier expectedLocalId, string providerEndpoint, WebHeaderCollection headers) {
if (!page.Contains(".")) {
page += ".xml";
}
this.Discover("/Discovery/xrdsdiscovery/" + page, version, expectedLocalId, providerEndpoint, true, false, headers);
this.Discover("/Discovery/xrdsdiscovery/" + page, version, expectedLocalId, providerEndpoint, true, true, headers);
}
private void DiscoverXrds(string page, ProtocolVersion version, Identifier expectedLocalId, string providerEndpoint) {
this.DiscoverXrds(page, version, expectedLocalId, providerEndpoint, null);
}
/// <summary>
/// Performs discovery on the specified identifier.
/// </summary>
/// <param name="identifier">The identifier to perform discovery on.</param>
/// <param name="requestHandler">The means to place outgoing HTTP requests.</param>
/// <param name="abortDiscoveryChain">if set to <c>true</c>, no further discovery services will be called for this identifier.</param>
/// <returns>
/// A sequence of service endpoints yielded by discovery. Must not be null, but may be empty.
/// </returns>
public IEnumerable <IdentifierDiscoveryResult> Discover(Identifier identifier, IDirectWebRequestHandler requestHandler, out bool abortDiscoveryChain)
{
abortDiscoveryChain = false;
var uriIdentifier = identifier as UriIdentifier;
if (uriIdentifier == null)
{
return(Enumerable.Empty <IdentifierDiscoveryResult>());
}
var endpoints = new List <IdentifierDiscoveryResult>();
// Attempt YADIS discovery
DiscoveryResult yadisResult = Yadis.Discover(requestHandler, uriIdentifier, identifier.IsDiscoverySecureEndToEnd);
if (yadisResult != null)
{
if (yadisResult.IsXrds)
{
try {
XrdsDocument xrds = new XrdsDocument(yadisResult.ResponseText);
var xrdsEndpoints = xrds.XrdElements.CreateServiceEndpoints(yadisResult.NormalizedUri, uriIdentifier);
// Filter out insecure endpoints if high security is required.
if (uriIdentifier.IsDiscoverySecureEndToEnd)
{
xrdsEndpoints = xrdsEndpoints.Where(se => se.ProviderEndpoint.IsTransportSecure());
}
endpoints.AddRange(xrdsEndpoints);
} catch (XmlException ex) {
Logger.Yadis.Error("Error while parsing the XRDS document. Falling back to HTML discovery.", ex);
}
}
// Failing YADIS discovery of an XRDS document, we try HTML discovery.
if (endpoints.Count == 0)
{
yadisResult.TryRevertToHtmlResponse();
var htmlEndpoints = new List <IdentifierDiscoveryResult>(DiscoverFromHtml(yadisResult.NormalizedUri, uriIdentifier, yadisResult.ResponseText));
if (htmlEndpoints.Any())
{
Logger.Yadis.DebugFormat("Total services discovered in HTML: {0}", htmlEndpoints.Count);
Logger.Yadis.Debug(htmlEndpoints.ToStringDeferred(true));
endpoints.AddRange(htmlEndpoints.Where(ep => !uriIdentifier.IsDiscoverySecureEndToEnd || ep.ProviderEndpoint.IsTransportSecure()));
if (endpoints.Count == 0)
{
Logger.Yadis.Info("No HTML discovered endpoints met the security requirements.");
}
}
else
{
Logger.Yadis.Debug("HTML discovery failed to find any endpoints.");
}
}
else
{
Logger.Yadis.Debug("Skipping HTML discovery because XRDS contained service endpoints.");
}
}
return(endpoints);
}
/// <summary> /// Converts a given identifier to its secure equivalent. /// UriIdentifiers originally created with an implied HTTP scheme change to HTTPS. /// Discovery is made to require SSL for the entire resolution process. /// </summary> /// <param name="secureIdentifier"> /// The newly created secure identifier. /// If the conversion fails, <paramref name="secureIdentifier"/> retains /// <i>this</i> identifiers identity, but will never discover any endpoints. /// </param> /// <returns> /// True if the secure conversion was successful. /// False if the Identifier was originally created with an explicit HTTP scheme. /// </returns> internal abstract bool TryRequireSsl(out Identifier secureIdentifier);
[ContractVerification(false)] // bugs/limitations in CC static analysis
internal override bool TryRequireSsl(out Identifier secureIdentifier)
{
secureIdentifier = IsDiscoverySecureEndToEnd ? this : new XriIdentifier(this, true);
return(true);
}
