TerribleDev/OwinOAuthProviders
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added SoundCloud middleware

Browse Source
This commit is contained in:
ByteBlast
2015-03-14 18:39:27 +00:00
parent 08ab12873c
commit b2da1acd04
10 changed files with 625 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
Owin.Security.Providers/Owin.Security.Providers.csproj
View File

@@ -189,6 +189,15 @@
<Compile Include="Salesforce\SalesforceAuthenticationHandler.cs" /> <Compile Include="Salesforce\SalesforceAuthenticationHandler.cs" />
<Compile Include="Salesforce\SalesforceAuthenticationMiddleware.cs" /> <Compile Include="Salesforce\SalesforceAuthenticationMiddleware.cs" />
<Compile Include="Salesforce\SalesforceAuthenticationOptions.cs" /> <Compile Include="Salesforce\SalesforceAuthenticationOptions.cs" />
<Compile Include="SoundCloud\Constants.cs" />
<Compile Include="SoundCloud\Provider\ISoundCloudAuthenticationProvider.cs" />
<Compile Include="SoundCloud\Provider\SoundCloudAuthenticatedContext.cs" />
<Compile Include="SoundCloud\Provider\SoundCloudAuthenticationProvider.cs" />
<Compile Include="SoundCloud\Provider\SoundCloudReturnEndpointContext.cs" />
<Compile Include="SoundCloud\SoundCloudAuthenticationExtensions.cs" />
<Compile Include="SoundCloud\SoundCloudAuthenticationHandler.cs" />
<Compile Include="SoundCloud\SoundCloudAuthenticationMiddleware.cs" />
<Compile Include="SoundCloud\SoundCloudAuthenticationOptions.cs" />
<Compile Include="StackExchange\Constants.cs" /> <Compile Include="StackExchange\Constants.cs" />
<Compile Include="StackExchange\StackExchangeAuthenticationExtensions.cs" /> <Compile Include="StackExchange\StackExchangeAuthenticationExtensions.cs" />
<Compile Include="StackExchange\StackExchangeAuthenticationHandler.cs" /> <Compile Include="StackExchange\StackExchangeAuthenticationHandler.cs" />

7
Owin.Security.Providers/SoundCloud/Constants.cs Normal file
View File

@@ -0,0 +1,7 @@
namespace Owin.Security.Providers.SoundCloud
{
public class Constants
{
public const string DefaultAuthenticationType = "SoundCloud";
}
}

29
Owin.Security.Providers/SoundCloud/Provider/ISoundCloudAuthenticationProvider.cs Normal file
View File

@@ -0,0 +1,29 @@
using System.Threading.Tasks;
namespace Owin.Security.Providers.SoundCloud.Provider
{
/// <summary>
/// Specifies callback methods which the <see cref="SoundCloudAuthenticationMiddleware"></see> invokes to enable
/// developer control over the authentication process. />
/// </summary>
public interface ISoundCloudAuthenticationProvider
{
/// <summary>
/// Invoked whenever SoundCloud succesfully authenticates a user
/// </summary>
/// <param name="context">
/// Contains information about the login session as well as the user
/// <see cref="System.Security.Claims.ClaimsIdentity" />.
/// </param>
/// <returns>A <see cref="Task" /> representing the completed operation.</returns>
Task Authenticated(SoundCloudAuthenticatedContext context);
/// <summary>
/// Invoked prior to the <see cref="System.Security.Claims.ClaimsIdentity" /> being saved in a local cookie and the
/// browser being redirected to the originally requested URL.
/// </summary>
/// <param name="context"></param>
/// <returns>A <see cref="Task" /> representing the completed operation.</returns>
Task ReturnEndpoint(SoundCloudReturnEndpointContext context);
}
}

64
Owin.Security.Providers/SoundCloud/Provider/SoundCloudAuthenticatedContext.cs Normal file
View File

@@ -0,0 +1,64 @@
using System.Security.Claims;
using Microsoft.Owin;
using Microsoft.Owin.Security;
using Microsoft.Owin.Security.Provider;
using Newtonsoft.Json.Linq;
namespace Owin.Security.Providers.SoundCloud.Provider
{
/// <summary>
/// Contains information about the login session as well as the user
/// <see cref="System.Security.Claims.ClaimsIdentity" />.
/// </summary>
public class SoundCloudAuthenticatedContext : BaseContext
{
public SoundCloudAuthenticatedContext(IOwinContext context, JObject user, string accessToken)
: base(context)
{
User = user;
AccessToken = accessToken;
Id = TryGetValue(user, "id");
UserName = TryGetValue(user, "username");
}
/// <summary>
/// Gets the JSON-serialized user
/// </summary>
/// <remarks>
/// Contains the SoundCloud user obtained from the endpoint https://api.soundcloud.com/me
/// </remarks>
public JObject User { get; private set; }
/// <summary>
/// Gets the SoundCloud access token
/// </summary>
public string AccessToken { get; private set; }
/// <summary>
/// Gets the SoundCloud user ID
/// </summary>
public string Id { get; set; }
/// <summary>
/// Gets the SoundCloud username
/// </summary>
public string UserName { get; set; }
/// <summary>
/// Gets the <see cref="ClaimsIdentity" /> representing the user
/// </summary>
public ClaimsIdentity Identity { get; set; }
/// <summary>
/// Gets or sets a property bag for common authentication properties
/// </summary>
public AuthenticationProperties Properties { get; set; }
private static string TryGetValue(JObject user, string propertyName)
{
JToken value;
return user.TryGetValue(propertyName, out value) ? value.ToString() : null;
}
}
}

54
Owin.Security.Providers/SoundCloud/Provider/SoundCloudAuthenticationProvider.cs Normal file
View File

@@ -0,0 +1,54 @@
using System;
using System.Threading.Tasks;
namespace Owin.Security.Providers.SoundCloud.Provider
{
/// <summary>
/// Default <see cref="ISoundCloudAuthenticationProvider" /> implementation.
/// </summary>
public class SoundCloudAuthenticationProvider : ISoundCloudAuthenticationProvider
{
/// <summary>
/// Initializes a <see cref="SoundCloudAuthenticationProvider" />
/// </summary>
public SoundCloudAuthenticationProvider()
{
OnAuthenticated = context => Task.FromResult<object>(null);
OnReturnEndpoint = context => Task.FromResult<object>(null);
}
/// <summary>
/// Gets or sets the function that is invoked when the Authenticated method is invoked.
/// </summary>
public Func<SoundCloudAuthenticatedContext, Task> OnAuthenticated { get; set; }
/// <summary>
/// Gets or sets the function that is invoked when the ReturnEndpoint method is invoked.
/// </summary>
public Func<SoundCloudReturnEndpointContext, Task> OnReturnEndpoint { get; set; }
/// <summary>
/// Invoked whenever SoundCloud succesfully authenticates a user
/// </summary>
/// <param name="context">
/// Contains information about the login session as well as the user
/// <see cref="System.Security.Claims.ClaimsIdentity" />.
/// </param>
/// <returns>A <see cref="Task" /> representing the completed operation.</returns>
public virtual Task Authenticated(SoundCloudAuthenticatedContext context)
{
return OnAuthenticated(context);
}
/// <summary>
/// Invoked prior to the <see cref="System.Security.Claims.ClaimsIdentity" /> being saved in a local cookie and the
/// browser being redirected to the originally requested URL.
/// </summary>
/// <param name="context"></param>
/// <returns>A <see cref="Task" /> representing the completed operation.</returns>
public Task ReturnEndpoint(SoundCloudReturnEndpointContext context)
{
return OnReturnEndpoint(context);
}
}
}

21
Owin.Security.Providers/SoundCloud/Provider/SoundCloudReturnEndpointContext.cs Normal file
View File

@@ -0,0 +1,21 @@
using Microsoft.Owin;
using Microsoft.Owin.Security;
using Microsoft.Owin.Security.Provider;
namespace Owin.Security.Providers.SoundCloud.Provider
{
/// <summary>
/// Provides context information to middleware providers.
/// </summary>
public class SoundCloudReturnEndpointContext : ReturnEndpointContext
{
/// <summary>
/// </summary>
/// <param name="context">OWIN environment</param>
/// <param name="ticket">The authentication ticket</param>
public SoundCloudReturnEndpointContext(IOwinContext context, AuthenticationTicket ticket)
: base(context, ticket)
{
}
}
}

29
Owin.Security.Providers/SoundCloud/SoundCloudAuthenticationExtensions.cs Normal file
View File

@@ -0,0 +1,29 @@
using System;
namespace Owin.Security.Providers.SoundCloud
{
public static class SoundCloudAuthenticationExtensions
{
public static IAppBuilder UseSoundCloudAuthentication(this IAppBuilder app,
SoundCloudAuthenticationOptions options)
{
if (app == null)
throw new ArgumentNullException("app");
if (options == null)
throw new ArgumentNullException("options");
app.Use(typeof (SoundCloudAuthenticationMiddleware), app, options);
return app;
}
public static IAppBuilder UseSoundCloudAuthentication(this IAppBuilder app, string clientId, string clientSecret)
{
return app.UseSoundCloudAuthentication(new SoundCloudAuthenticationOptions
{
ClientId = clientId,
ClientSecret = clientSecret
});
}
}
}

238
Owin.Security.Providers/SoundCloud/SoundCloudAuthenticationHandler.cs Normal file
View File

@@ -0,0 +1,238 @@
using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.Owin.Infrastructure;
using Microsoft.Owin.Logging;
using Microsoft.Owin.Security;
using Microsoft.Owin.Security.Infrastructure;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Owin.Security.Providers.SoundCloud.Provider;
namespace Owin.Security.Providers.SoundCloud
{
public class SoundCloudAuthenticationHandler : AuthenticationHandler<SoundCloudAuthenticationOptions>
{
private const string XmlSchemaString = "http://www.w3.org/2001/XMLSchema#string";
private const string TokenEndpoint = "https://api.soundcloud.com/oauth2/token";
private const string ConnectEndpoint = "https://soundcloud.com/connect";
private const string UserInfoEndpoint = "https://api.soundcloud.com/me.json";
private readonly HttpClient httpClient;
private readonly ILogger logger;
public SoundCloudAuthenticationHandler(HttpClient httpClient, ILogger logger)
{
this.httpClient = httpClient;
this.logger = logger;
}
protected override async Task<AuthenticationTicket> AuthenticateCoreAsync()
{
AuthenticationProperties properties = null;
try
{
string code = null;
string state = null;
var query = Request.Query;
var values = query.GetValues("code");
if (values != null && values.Count == 1)
{
code = values[0];
}
values = query.GetValues("state");
if (values != null && values.Count == 1)
{
state = values[0];
}
properties = Options.StateDataFormat.Unprotect(state);
if (properties == null)
{
return null;
}
if (!ValidateCorrelationId(properties, logger))
{
return new AuthenticationTicket(null, properties);
}
var requestPrefix = Request.Scheme + "://" + Request.Host;
var redirectUri = requestPrefix + Request.PathBase + Options.CallbackPath;
var body = new List<KeyValuePair<string, string>>
{
new KeyValuePair<string, string>("code", code),
new KeyValuePair<string, string>("redirect_uri", redirectUri),
new KeyValuePair<string, string>("client_id", Options.ClientId),
new KeyValuePair<string, string>("grant_type", "authorization_code"),
new KeyValuePair<string, string>("client_secret", Options.ClientSecret)
};
var tokenResponse = await httpClient.PostAsync(TokenEndpoint, new FormUrlEncodedContent(body));
tokenResponse.EnsureSuccessStatusCode();
var text = await tokenResponse.Content.ReadAsStringAsync();
dynamic response = JsonConvert.DeserializeObject<dynamic>(text);
var accessToken = (string) response.access_token;
var userRequest = new HttpRequestMessage(
HttpMethod.Get,
UserInfoEndpoint + "?oauth_token=" + Uri.EscapeDataString(accessToken));
var userResponse = await httpClient.SendAsync(userRequest, Request.CallCancelled);
userResponse.EnsureSuccessStatusCode();
text = await userResponse.Content.ReadAsStringAsync();
var user = JObject.Parse(text);
var context = new SoundCloudAuthenticatedContext(Context, user, accessToken)
{
Identity = new ClaimsIdentity(
Options.AuthenticationType,
ClaimsIdentity.DefaultNameClaimType,
ClaimsIdentity.DefaultRoleClaimType)
};
if (!string.IsNullOrEmpty(context.Id))
{
context.Identity.AddClaim(new Claim(
ClaimTypes.NameIdentifier,
context.Id,
XmlSchemaString,
Options.AuthenticationType));
}
if (!string.IsNullOrEmpty(context.UserName))
{
context.Identity.AddClaim(new Claim(
ClaimsIdentity.DefaultNameClaimType,
context.UserName,
XmlSchemaString,
Options.AuthenticationType));
}
context.Properties = properties;
await Options.Provider.Authenticated(context);
return new AuthenticationTicket(context.Identity, context.Properties);
}
catch (Exception exception)
{
logger.WriteError(exception.Message);
}
return new AuthenticationTicket(null, properties);
}
protected override Task ApplyResponseChallengeAsync()
{
if (Response.StatusCode != 401)
{
return Task.FromResult<object>(null);
}
var challenge = Helper.LookupChallenge(Options.AuthenticationType, Options.AuthenticationMode);
if (challenge != null)
{
var baseUri =
Request.Scheme +
Uri.SchemeDelimiter +
Request.Host +
Request.PathBase;
var currentUri =
baseUri +
Request.Path +
Request.QueryString;
var redirectUri =
baseUri +
Options.CallbackPath;
var properties = challenge.Properties;
if (string.IsNullOrEmpty(properties.RedirectUri))
{
properties.RedirectUri = currentUri;
}
// OAuth2 10.12 CSRF
GenerateCorrelationId(properties);
var state = Options.StateDataFormat.Protect(properties);
var authorizationEndpoint =
ConnectEndpoint
+ "?client_id=" + Uri.EscapeDataString(Options.ClientId)
+ "&redirect_uri=" + Uri.EscapeDataString(redirectUri)
+ "&response_type=" + "code"
+ "&scope=" + "non-expiring"
+ "&display=" + "popup"
+ "&state=" + Uri.EscapeDataString(state);
Response.Redirect(authorizationEndpoint);
}
return Task.FromResult<object>(null);
}
public override async Task<bool> InvokeAsync()
{
return await InvokeReplyPathAsync();
}
private async Task<bool> InvokeReplyPathAsync()
{
if (Options.CallbackPath.HasValue && Options.CallbackPath == Request.Path)
{
// TODO: error responses
var ticket = await AuthenticateAsync();
if (ticket == null)
{
logger.WriteWarning("Invalid return state, unable to redirect.");
Response.StatusCode = 500;
return true;
}
var context = new SoundCloudReturnEndpointContext(Context, ticket)
{
SignInAsAuthenticationType = Options.SignInAsAuthenticationType,
RedirectUri = ticket.Properties.RedirectUri
};
await Options.Provider.ReturnEndpoint(context);
if (context.SignInAsAuthenticationType != null && context.Identity != null)
{
var grantIdentity = context.Identity;
if (!string.Equals(
grantIdentity.AuthenticationType,
context.SignInAsAuthenticationType,
StringComparison.Ordinal))
{
grantIdentity = new ClaimsIdentity(
grantIdentity.Claims,
context.SignInAsAuthenticationType,
grantIdentity.NameClaimType,
grantIdentity.RoleClaimType);
}
Context.Authentication.SignIn(context.Properties, grantIdentity);
}
if (!context.IsRequestCompleted && context.RedirectUri != null)
{
var redirectUri = context.RedirectUri;
if (context.Identity == null)
{
// add a redirect hint that sign-in failed in some way
redirectUri = WebUtilities.AddQueryString(redirectUri, "error", "access_denied");
}
Response.Redirect(redirectUri);
context.RequestCompleted();
}
return context.IsRequestCompleted;
}
return false;
}
}
}

81
Owin.Security.Providers/SoundCloud/SoundCloudAuthenticationMiddleware.cs Normal file
View File

@@ -0,0 +1,81 @@
using System;
using System.Globalization;
using System.Net.Http;
using Microsoft.Owin;
using Microsoft.Owin.Logging;
using Microsoft.Owin.Security;
using Microsoft.Owin.Security.DataHandler;
using Microsoft.Owin.Security.DataProtection;
using Microsoft.Owin.Security.Infrastructure;
using Owin.Security.Providers.Properties;
using Owin.Security.Providers.SoundCloud.Provider;
namespace Owin.Security.Providers.SoundCloud
{
public class SoundCloudAuthenticationMiddleware : AuthenticationMiddleware<SoundCloudAuthenticationOptions>
{
private readonly HttpClient httpClient;
private readonly ILogger logger;
public SoundCloudAuthenticationMiddleware(
OwinMiddleware next,
IAppBuilder app,
SoundCloudAuthenticationOptions options) : base(next, options)
{
if (String.IsNullOrWhiteSpace(Options.ClientId))
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,
Resources.Exception_OptionMustBeProvided, "ClientId"));
if (String.IsNullOrWhiteSpace(Options.ClientSecret))
throw new ArgumentException(String.Format(CultureInfo.CurrentCulture,
Resources.Exception_OptionMustBeProvided, "ClientSecret"));
logger = app.CreateLogger<SoundCloudAuthenticationProvider>();
if (Options.Provider == null)
Options.Provider = new SoundCloudAuthenticationProvider();
if (Options.StateDataFormat == null)
{
var dataProtector = app.CreateDataProtector(
typeof (SoundCloudAuthenticationMiddleware).FullName,
Options.AuthenticationType, "v1");
Options.StateDataFormat = new PropertiesDataFormat(dataProtector);
}
if (String.IsNullOrEmpty(Options.SignInAsAuthenticationType))
Options.SignInAsAuthenticationType = app.GetDefaultSignInAsAuthenticationType();
httpClient = new HttpClient(ResolveHttpMessageHandler(Options))
{
Timeout = Options.BackchannelTimeout,
MaxResponseContentBufferSize = 1024*1024*10
};
httpClient.DefaultRequestHeaders.UserAgent.ParseAdd("Microsoft Owin SoundCloud middleware");
httpClient.DefaultRequestHeaders.ExpectContinue = false;
}
protected override AuthenticationHandler<SoundCloudAuthenticationOptions> CreateHandler()
{
return new SoundCloudAuthenticationHandler(httpClient, logger);
}
private HttpMessageHandler ResolveHttpMessageHandler(SoundCloudAuthenticationOptions options)
{
var handler = options.BackchannelHttpHandler ?? new WebRequestHandler();
// If they provided a validator, apply it or fail.
if (options.BackchannelCertificateValidator != null)
{
// Set the cert validate callback
var webRequestHandler = handler as WebRequestHandler;
if (webRequestHandler == null)
{
throw new InvalidOperationException(Resources.Exception_ValidatorHandlerMismatch);
}
webRequestHandler.ServerCertificateValidationCallback = options.BackchannelCertificateValidator.Validate;
}
return handler;
}
}
}

93
Owin.Security.Providers/SoundCloud/SoundCloudAuthenticationOptions.cs Normal file
View File

@@ -0,0 +1,93 @@
using System;
using System.Net.Http;
using Microsoft.Owin;
using Microsoft.Owin.Security;
using Owin.Security.Providers.SoundCloud.Provider;
namespace Owin.Security.Providers.SoundCloud
{
public class SoundCloudAuthenticationOptions : AuthenticationOptions
{
/// <summary>
/// Initializes a new <see cref="SoundCloudAuthenticationOptions" />
/// </summary>
public SoundCloudAuthenticationOptions()
: base("SoundCloud")
{
Caption = Constants.DefaultAuthenticationType;
CallbackPath = new PathString("/signin-soundcloud");
AuthenticationMode = AuthenticationMode.Passive;
BackchannelTimeout = TimeSpan.FromSeconds(60);
}
/// <summary>
/// Gets or sets the a pinned certificate validator to use to validate the endpoints used
/// in back channel communications belong to SoundCloud.
/// </summary>
/// <value>
/// The pinned certificate validator.
/// </value>
/// <remarks>
/// If this property is null then the default certificate checks are performed,
/// validating the subject name and if the signing chain is a trusted party.
/// </remarks>
public ICertificateValidator BackchannelCertificateValidator { get; set; }
/// <summary>
/// The HttpMessageHandler used to communicate with SoundCloud.
/// This cannot be set at the same time as BackchannelCertificateValidator unless the value
/// can be downcast to a WebRequestHandler.
/// </summary>
public HttpMessageHandler BackchannelHttpHandler { get; set; }
/// <summary>
/// Gets or sets timeout value in milliseconds for back channel communications with SoundCloud.
/// </summary>
/// <value>
/// The back channel timeout in milliseconds.
/// </value>
public TimeSpan BackchannelTimeout { get; set; }
/// <summary>
/// The request path within the application's base path where the user-agent will be returned.
/// The middleware will process this request when it arrives.
/// Default value is "/signin-soundcloud".
/// </summary>
public PathString CallbackPath { get; set; }
/// <summary>
/// Get or sets the text that the user can display on a sign in user interface.
/// </summary>
public string Caption
{
get { return Description.Caption; }
set { Description.Caption = value; }
}
/// <summary>
/// Gets or sets the SoundCloud supplied Client ID
/// </summary>
public string ClientId { get; set; }
/// <summary>
/// Gets or sets the SoundCloud supplied Client Secret
/// </summary>
public string ClientSecret { get; set; }
/// <summary>
/// Gets or sets the <see cref="ISoundCloudAuthenticationProvider" /> used in the authentication events
/// </summary>
public ISoundCloudAuthenticationProvider Provider { get; set; }
/// <summary>
/// Gets or sets the name of another authentication middleware which will be responsible for actually issuing a user
/// <see cref="System.Security.Claims.ClaimsIdentity" />.
/// </summary>
public string SignInAsAuthenticationType { get; set; }
/// <summary>
/// Gets or sets the type used to secure data handled by the middleware.
/// </summary>
public ISecureDataFormat<AuthenticationProperties> StateDataFormat { get; set; }
}
}