- Added authentication against Battle.net

I have added functionality for authenticating against Battle.net OAuth

Owin.Security.Providers/BattleNet/BattleNetAuthenticationExtensions.cs

@@ -0,0 +1,28 @@
+using System;
+
+namespace Owin.Security.Providers.BattleNet
+{
+	public static class BattleNetAuthenticationExtensions
+	{
+
+		public static IAppBuilder UseBattleNetAuthentication(this IAppBuilder app, BattleNetAuthenticationOptions options)
+		{
+			if (app == null)
+				throw new ArgumentException("app");
+			if (options == null)
+				throw new ArgumentException("options");
+
+			app.Use(typeof(BattleNetAuthenticationMiddleware), app, options);
+
+			return app;
+		}
+		public static IAppBuilder UseBattleNetAuthentication(this IAppBuilder app, string clientId, string clientSecret)
+		{
+			return app.UseBattleNetAuthentication(new BattleNetAuthenticationOptions
+			{
+				ClientId = clientId,
+				ClientSecret = clientSecret
+			});
+		}
+	}
+}

Owin.Security.Providers/BattleNet/BattleNetAuthenticationHandler.cs

@@ -0,0 +1,253 @@
+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;
+
+namespace Owin.Security.Providers.BattleNet
+{
+	public class BattleNetAuthenticationHandler : AuthenticationHandler<BattleNetAuthenticationOptions>
+	{
+
+		private const string XmlSchemaString = "http://www.w3.org/2001/XMLSchema#string";
+		private const string TokenEndpoint = "https://eu.battle.net/oauth/token";
+		private const string AccountUserIdEndpoint = "https://eu.api.battle.net/account/user/id";
+		private const string AccountUserBattleTagEndpoint = "https://eu.api.battle.net/account/user/battletag";
+
+		private readonly ILogger _logger;
+		private readonly HttpClient _httpClient;
+
+		public BattleNetAuthenticationHandler(HttpClient httpClient, ILogger logger)
+		{
+			_httpClient = httpClient;
+			_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;
+				}
+
+				// OAuth2 10.12 CSRF
+				if (!ValidateCorrelationId(properties, _logger))
+				{
+					return new AuthenticationTicket(null, properties);
+				}
+
+				// Check for error
+				if (Request.Query.Get("error") != null)
+					return new AuthenticationTicket(null, properties);
+
+				var requestPrefix = Request.Scheme + "://" + Request.Host;
+				var redirectUri = requestPrefix + Request.PathBase + Options.CallbackPath;
+
+				// Build up the body for the token request
+				var body = new List<KeyValuePair<string, string>>
+				{
+					new KeyValuePair<string, string>("grant_type", "authorization_code"),
+					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>("client_secret", Options.ClientSecret)
+				};
+
+				// Request the token
+				var tokenResponse = await _httpClient.PostAsync(TokenEndpoint, new FormUrlEncodedContent(body));
+				tokenResponse.EnsureSuccessStatusCode();
+				var text = await tokenResponse.Content.ReadAsStringAsync();
+
+				// Deserializes the token response
+				var response = JsonConvert.DeserializeObject<dynamic>(text);
+				var accessToken = (string)response.access_token;
+				var expires = (string)response.expires_in;
+
+				// Get WoW User Id
+				var graphResponse = await _httpClient.GetAsync(AccountUserIdEndpoint + "?access_token=" + Uri.EscapeDataString(accessToken), Request.CallCancelled);
+				graphResponse.EnsureSuccessStatusCode();
+				text = await graphResponse.Content.ReadAsStringAsync();
+				var userId = JObject.Parse(text);
+
+				// Get WoW BattleTag
+				graphResponse = await _httpClient.GetAsync(AccountUserBattleTagEndpoint + "?access_token=" + Uri.EscapeDataString(accessToken), Request.CallCancelled);
+				graphResponse.EnsureSuccessStatusCode();
+				text = await graphResponse.Content.ReadAsStringAsync();
+				var battleTag = JObject.Parse(text);
+
+
+				var context = new BattleNetAuthenticatedContext(Context, userId, battleTag, accessToken, expires)
+				{
+					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.BattleTag))
+				{
+					context.Identity.AddClaim(new Claim("urn:battlenet:battletag", context.BattleTag, XmlSchemaString, Options.AuthenticationType));
+				}
+				if (!string.IsNullOrEmpty(context.AccessToken))
+				{
+					context.Identity.AddClaim(new Claim("urn:battlenet:accesstoken", context.AccessToken, XmlSchemaString, Options.AuthenticationType));
+				}
+				context.Properties = properties;
+
+				await Options.Provider.Authenticated(context);
+
+				return new AuthenticationTicket(context.Identity, context.Properties);
+
+			}
+			catch (Exception ex)
+			{
+				_logger.WriteError(ex.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);
+
+				// comma separated
+				var scope = string.Join(" ", Options.Scope);
+
+				var state = Options.StateDataFormat.Protect(properties);
+
+				var authorizationEndpoint =
+					"https://eu.battle.net/oauth/authorize" +
+					"?response_type=code" +
+					"&client_id=" + Uri.EscapeDataString(Options.ClientId) +
+					"&redirect_uri=" + Uri.EscapeDataString(redirectUri) +
+					"&scope=" + Uri.EscapeDataString(scope) +
+					"&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 BattleNetReturnEndpointContext(Context, ticket)
+				{
+					SignInAsAuthenticationType = Options.SignInAsAuthenticationType,
+					RedirectUri = ticket.Properties.RedirectUri
+				};
+
+				await Options.Provider.ReturnEndpoint(context);
+
+				if (context.SignInAsAuthenticationType != null &&
+					context.Identity != null)
+				{
+					ClaimsIdentity 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)
+				{
+					string 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;
+		}
+	}
+}

Owin.Security.Providers/BattleNet/BattleNetAuthenticationMiddleware.cs

@@ -0,0 +1,84 @@
+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;
+
+namespace Owin.Security.Providers.BattleNet
+{
+	public class BattleNetAuthenticationMiddleware : AuthenticationMiddleware<BattleNetAuthenticationOptions>
+	{
+		private readonly HttpClient _httpClient;
+		private readonly ILogger _logger;
+
+		public BattleNetAuthenticationMiddleware(OwinMiddleware next, IAppBuilder app, BattleNetAuthenticationOptions 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<BattleNetAuthenticationMiddleware>();
+
+			if (Options.Provider == null)
+				Options.Provider = new BattleNetAuthenticationProvider();
+
+			if (Options.StateDataFormat == null)
+			{
+				var dataProtector = app.CreateDataProtector(
+					typeof(BattleNetAuthenticationMiddleware).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
+			};
+		}
+
+		/// <summary>
+		///     Provides the <see cref="T:Microsoft.Owin.Security.Infrastructure.AuthenticationHandler" /> object for processing
+		///     authentication-related requests.
+		/// </summary>
+		/// <returns>
+		///     An <see cref="T:Microsoft.Owin.Security.Infrastructure.AuthenticationHandler" /> configured with the
+		///     <see cref="T:Owin.Security.Providers.BattleNet.BattleNetAuthenticationOptions" /> supplied to the constructor.
+		/// </returns>
+		protected override AuthenticationHandler<BattleNetAuthenticationOptions> CreateHandler()
+		{
+			return new BattleNetAuthenticationHandler(_httpClient, _logger);
+		}
+
+		private static HttpMessageHandler ResolveHttpMessageHandler(BattleNetAuthenticationOptions options)
+		{
+			HttpMessageHandler 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;
+		}
+	}
+}

Owin.Security.Providers/BattleNet/BattleNetAuthenticationOptions.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using Microsoft.Owin;
+using Microsoft.Owin.Security;
+
+namespace Owin.Security.Providers.BattleNet
+{
+	public class BattleNetAuthenticationOptions : AuthenticationOptions
+	{
+		/// <summary>
+		///     Initializes a new <see cref="BattleNetAuthenticationOptions" />.
+		///		By default the scope is only wow.profile but there is also the scope for sc2.profile
+		/// </summary>
+		public BattleNetAuthenticationOptions()
+			: base("BattleNet")
+		{
+			Caption = Constants.DefaultAuthenticationType;
+			CallbackPath = new PathString("/signin-battlenet");
+			AuthenticationMode = AuthenticationMode.Passive;
+			Scope = new List<string>
+            {
+                "wow.profile"
+            };
+			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 Battle.net.
+		/// </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 Battle.net.
+		///     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 Battle.net.
+		/// </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-battlenet".
+		/// </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 Battle.net supplied Client Id
+		/// </summary>
+		public string ClientId { get; set; }
+
+		/// <summary>
+		///     Gets or sets the Battle.net supplied Client Secret
+		/// </summary>
+		public string ClientSecret { get; set; }
+
+		/// <summary>
+		///     Gets or sets the <see cref="IBattleNetAuthenticationProvider" /> used in the authentication events
+		/// </summary>
+		public IBattleNetAuthenticationProvider Provider { get; set; }
+
+		/// <summary>
+		/// A list of permissions to request.
+		/// </summary>
+		public IList<string> Scope { get; private 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; }
+
+	}
+}

Owin.Security.Providers/BattleNet/Constants.cs

@@ -0,0 +1,8 @@
+
+namespace Owin.Security.Providers.BattleNet
+{
+	internal static class Constants
+	{
+		internal const string DefaultAuthenticationType = "BattleNet";
+	}
+}

Owin.Security.Providers/BattleNet/Provider/BattleNetAuthenticatedContext.cs

@@ -0,0 +1,97 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+using System;
+using System.Globalization;
+using System.Security.Claims;
+using Microsoft.Owin;
+using Microsoft.Owin.Security;
+using Microsoft.Owin.Security.Provider;
+using Newtonsoft.Json.Linq;
+
+namespace Owin.Security.Providers.BattleNet
+{
+	/// <summary>
+	/// Contains information about the login session as well as the user <see cref="System.Security.Claims.ClaimsIdentity"/>.
+	/// </summary>
+	public class BattleNetAuthenticatedContext : BaseContext
+	{
+		/// <summary>
+		/// Initializes a <see cref="BattleNetAuthenticatedContext"/>
+		/// </summary>
+		/// <param name="context">The OWIN environment</param>
+		/// <param name="userId">The JSON-serialized userId</param>
+		/// <param name="battleTag">The JSON-serialized battleTag</param>
+		/// <param name="accessToken">Battle.net Access token</param>
+		/// <param name="expires">Seconds until expiration</param>
+		public BattleNetAuthenticatedContext(IOwinContext context, JObject userId, JObject battleTag, string accessToken, string expires)
+			: base(context)
+		{
+			JsonUserId = userId;
+			JsonBattleTag = battleTag;
+			AccessToken = accessToken;
+
+			int expiresValue;
+			if (Int32.TryParse(expires, NumberStyles.Integer, CultureInfo.InvariantCulture, out expiresValue))
+			{
+				ExpiresIn = TimeSpan.FromSeconds(expiresValue);
+			}
+
+			Id = TryGetValue(userId, "id");
+			BattleTag = TryGetValue(battleTag, "battletag");
+
+		}
+
+		/// <summary>
+		/// Gets the JSON-serialized user ID
+		/// </summary>
+		/// <remarks>
+		/// Contains the Battle.net user ID obtained from the endpoint https://eu.api.battle.net/account/user/id
+		/// </remarks>
+		public JObject JsonUserId { get; private set; }
+
+		/// <summary>
+		/// Gets the JSON-serialized BattleTag
+		/// </summary>
+		/// <remarks>
+		/// Contains the Battle.net battle tag obtained from the endpoint https://eu.api.battle.net/account/user/battletag.  For more information
+		/// see https://dev.battle.net/io-docs
+		/// </remarks>
+		public JObject JsonBattleTag { get; private set; }
+
+		/// <summary>
+		/// Gets the Battle.net OAuth access token
+		/// </summary>
+		public string AccessToken { get; private set; }
+
+		/// <summary>
+		/// Gets the Battle.net access token expiration time
+		/// </summary>
+		public TimeSpan? ExpiresIn { get; set; }
+
+		/// <summary>
+		/// Gets the Battle.net user ID
+		/// </summary>
+		public string Id { get; private set; }
+
+		/// <summary>
+		/// Get Wow users battle tag
+		/// </summary>
+		public string BattleTag { get; private 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;
+		}
+	}
+}

Owin.Security.Providers/BattleNet/Provider/BattleNetAuthenticationProvider.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Threading.Tasks;
+
+
+namespace Owin.Security.Providers.BattleNet
+{
+	/// <summary>
+	/// Default <see cref="IBattleNetAuthenticationProvider"/> implementation.
+	/// </summary>
+	public class BattleNetAuthenticationProvider : IBattleNetAuthenticationProvider
+	{
+		/// <summary>
+		/// Initializes a <see cref="BattleNetAuthenticationProvider"/>
+		/// </summary>
+		public BattleNetAuthenticationProvider()
+		{
+			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<BattleNetAuthenticatedContext, Task> OnAuthenticated { get; set; }
+
+		/// <summary>
+		/// Gets or sets the function that is invoked when the ReturnEndpoint method is invoked.
+		/// </summary>
+		public Func<BattleNetReturnEndpointContext, Task> OnReturnEndpoint { get; set; }
+
+		/// <summary>
+		/// Invoked whenever Battle.net successfully 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 Task Authenticated(BattleNetAuthenticatedContext 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(BattleNetReturnEndpointContext context)
+		{
+			return OnReturnEndpoint(context);
+		}
+	}
+}

Owin.Security.Providers/BattleNet/Provider/BattleNetReturnEndpointContext.cs

@@ -0,0 +1,26 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved. See License.txt in the project root for license information.
+
+using Microsoft.Owin;
+using Microsoft.Owin.Security;
+using Microsoft.Owin.Security.Provider;
+
+namespace Owin.Security.Providers.BattleNet
+{
+	/// <summary>
+	/// Provides context information to middleware providers.
+	/// </summary>
+	public class BattleNetReturnEndpointContext : ReturnEndpointContext
+	{
+		/// <summary>
+		/// 
+		/// </summary>
+		/// <param name="context">OWIN environment</param>
+		/// <param name="ticket">The authentication ticket</param>
+		public BattleNetReturnEndpointContext(
+			IOwinContext context,
+			AuthenticationTicket ticket)
+			: base(context, ticket)
+		{
+		}
+	}
+}

Owin.Security.Providers/BattleNet/Provider/IBattleNetAuthenticationProvider.cs

@@ -0,0 +1,21 @@
+using System.Threading.Tasks;
+
+namespace Owin.Security.Providers.BattleNet
+{
+	public interface IBattleNetAuthenticationProvider
+	{
+		/// <summary>
+		/// Invoked whenever Battle.net 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(BattleNetAuthenticatedContext 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(BattleNetReturnEndpointContext context);
+	}
+}

Owin.Security.Providers/Owin.Security.Providers.csproj

@@ -67,6 +67,14 @@
     <Compile Include="ArcGISOnline\Provider\ArcGISOnlineReturnEndpointContext.cs" />
     <Compile Include="ArcGISOnline\Provider\ArcGISOnlineUser.cs" />
     <Compile Include="ArcGISOnline\Provider\IArcGISOnlineAuthenticationProvider.cs" />
+    <Compile Include="BattleNet\BattleNetAuthenticationExtensions.cs" />
+    <Compile Include="BattleNet\BattleNetAuthenticationHandler.cs" />
+    <Compile Include="BattleNet\BattleNetAuthenticationMiddleware.cs" />
+    <Compile Include="BattleNet\BattleNetAuthenticationOptions.cs" />
+    <Compile Include="BattleNet\Provider\BattleNetAuthenticatedContext.cs" />
+    <Compile Include="BattleNet\Provider\BattleNetAuthenticationProvider.cs" />
+    <Compile Include="BattleNet\Provider\BattleNetReturnEndpointContext.cs" />
+    <Compile Include="BattleNet\Provider\IBattleNetAuthenticationProvider.cs" />
     <Compile Include="Buffer\BufferAuthenticationExtensions.cs" />
     <Compile Include="Buffer\BufferAuthenticationHandler.cs" />
     <Compile Include="Buffer\BufferAuthenticationMiddleware.cs" />
@@ -76,6 +84,7 @@
     <Compile Include="Buffer\Provider\BufferAuthenticationProvider.cs" />
     <Compile Include="Buffer\Provider\BufferReturnEndpointContext.cs" />
     <Compile Include="Buffer\Provider\IBufferAuthenticationProvider.cs" />
+    <Compile Include="BattleNet\Constants.cs" />
     <Compile Include="Dropbox\DropboxAuthenticationExtensions.cs" />
     <Compile Include="Dropbox\DropboxAuthenticationHandler.cs" />
     <Compile Include="Dropbox\DropboxAuthenticationMiddleware.cs" />

Owin.Security.Providers/Owin.Security.Providers.csproj.DotSettings

@@ -1,4 +1,5 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=BattleNet_005CProvider/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=Buffer_005CProvider/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=DropBox_005CProvider/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=Dropbox_005CProvider/@EntryIndexedValue">True</s:Boolean>

README.md

@@ -8,6 +8,7 @@ Provides a set of extra authentication providers for OWIN ([Project Katana](http
   - GitHub
   - Instagram
   - StackExchange
+  - Battle.net
 - OpenID
   - Generic OpenID 2.0 provider
   - Steam