Merge branch 'splitDlls'.

DNOA now builds and (in some cases) ships as many distinct assemblies.

10 files changed, 974 insertions, 0 deletions

diff --git a/src/DotNetOpenAuth.OAuth.Consumer/DotNetOpenAuth.OAuth.Consumer.csproj b/src/DotNetOpenAuth.OAuth.Consumer/DotNetOpenAuth.OAuth.Consumer.csproj
new file mode 100644
index 0000000..2478187
--- /dev/null
+++ b/src/DotNetOpenAuth.OAuth.Consumer/DotNetOpenAuth.OAuth.Consumer.csproj
@@ -0,0 +1,50 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildProjectDirectory), EnlistmentInfo.props))\EnlistmentInfo.props" Condition=" '$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildProjectDirectory), EnlistmentInfo.props))' != '' " />
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+  </PropertyGroup>
+  <Import Project="$(ProjectRoot)tools\DotNetOpenAuth.props" />
+  <PropertyGroup>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{B202E40D-4663-4A2B-ACDA-865F88FF7CAA}</ProjectGuid>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <AssemblyName>DotNetOpenAuth.OAuth.Consumer</AssemblyName>
+  </PropertyGroup>
+  <Import Project="$(ProjectRoot)tools\DotNetOpenAuth.Product.props" />
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="OAuth\ChannelElements\IConsumerTokenManager.cs" />
+    <Compile Include="OAuth\ChannelElements\OAuthConsumerChannel.cs" />
+    <Compile Include="OAuth\ChannelElements\OAuthConsumerMessageFactory.cs" />
+    <Compile Include="OAuth\ChannelElements\RsaSha1ConsumerSigningBindingElement.cs" />
+    <Compile Include="OAuth\ConsumerBase.cs" />
+    <Compile Include="OAuth\DesktopConsumer.cs" />
+    <Compile Include="OAuth\WebConsumer.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs">
+      <SubType>
+      </SubType>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\DotNetOpenAuth.Core\DotNetOpenAuth.Core.csproj">
+      <Project>{60426312-6AE5-4835-8667-37EDEA670222}</Project>
+      <Name>DotNetOpenAuth.Core</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\DotNetOpenAuth.OAuth\DotNetOpenAuth.OAuth.csproj">
+      <Project>{A288FCC8-6FCF-46DA-A45E-5F9281556361}</Project>
+      <Name>DotNetOpenAuth.OAuth</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\DotNetOpenAuth.OpenId\DotNetOpenAuth.OpenId.csproj">
+      <Project>{3896A32A-E876-4C23-B9B8-78E17D134CD3}</Project>
+      <Name>DotNetOpenAuth.OpenId</Name>
+    </ProjectReference>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <Import Project="$(ProjectRoot)tools\DotNetOpenAuth.targets" />
+  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildProjectDirectory), EnlistmentInfo.targets))\EnlistmentInfo.targets" Condition=" '$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildProjectDirectory), EnlistmentInfo.targets))' != '' " />
+</Project>
\ No newline at end of file
diff --git a/src/DotNetOpenAuth.OAuth.Consumer/OAuth/ChannelElements/IConsumerTokenManager.cs b/src/DotNetOpenAuth.OAuth.Consumer/OAuth/ChannelElements/IConsumerTokenManager.cs
new file mode 100644
index 0000000..f16be64
--- /dev/null
+++ b/src/DotNetOpenAuth.OAuth.Consumer/OAuth/ChannelElements/IConsumerTokenManager.cs
@@ -0,0 +1,25 @@
+//-----------------------------------------------------------------------
+// <copyright file="IConsumerTokenManager.cs" company="Andrew Arnott">
+//     Copyright (c) Andrew Arnott. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace DotNetOpenAuth.OAuth.ChannelElements {
+	/// <summary>
+	/// A token manager for use by a web site in its role as a consumer of
+	/// an individual ServiceProvider.
+	/// </summary>
+	public interface IConsumerTokenManager : ITokenManager {
+		/// <summary>
+		/// Gets the consumer key.
+		/// </summary>
+		/// <value>The consumer key.</value>
+		string ConsumerKey { get; }
+
+		/// <summary>
+		/// Gets the consumer secret.
+		/// </summary>
+		/// <value>The consumer secret.</value>
+		string ConsumerSecret { get; }
+	}
+}
diff --git a/src/DotNetOpenAuth.OAuth.Consumer/OAuth/ChannelElements/OAuthConsumerChannel.cs b/src/DotNetOpenAuth.OAuth.Consumer/OAuth/ChannelElements/OAuthConsumerChannel.cs
new file mode 100644
index 0000000..553d6c6
--- /dev/null
+++ b/src/DotNetOpenAuth.OAuth.Consumer/OAuth/ChannelElements/OAuthConsumerChannel.cs
@@ -0,0 +1,70 @@
+//-----------------------------------------------------------------------
+// <copyright file="OAuthConsumerChannel.cs" company="Andrew Arnott">
+//     Copyright (c) Andrew Arnott. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace DotNetOpenAuth.OAuth.ChannelElements {
+	using System;
+	using System.Collections.Generic;
+	using System.Diagnostics.CodeAnalysis;
+	using System.Diagnostics.Contracts;
+	using System.Linq;
+	using System.Text;
+	using DotNetOpenAuth.Messaging;
+	using DotNetOpenAuth.Messaging.Bindings;
+
+	/// <summary>
+	/// The messaging channel for OAuth 1.0(a) Consumers.
+	/// </summary>
+	internal class OAuthConsumerChannel : OAuthChannel {
+		/// <summary>
+		/// Initializes a new instance of the <see cref="OAuthConsumerChannel"/> class.
+		/// </summary>
+		/// <param name="signingBindingElement">The binding element to use for signing.</param>
+		/// <param name="store">The web application store to use for nonces.</param>
+		/// <param name="tokenManager">The token manager instance to use.</param>
+		/// <param name="securitySettings">The security settings.</param>
+		/// <param name="messageFactory">The message factory.</param>
+		[SuppressMessage("Microsoft.Globalization", "CA1303:Do not pass literals as localized parameters", MessageId = "System.Diagnostics.Contracts.__ContractsRuntime.Requires<System.ArgumentNullException>(System.Boolean,System.String,System.String)", Justification = "Code contracts"), SuppressMessage("Microsoft.Naming", "CA2204:Literals should be spelled correctly", MessageId = "securitySettings", Justification = "Code contracts")]
+		internal OAuthConsumerChannel(ITamperProtectionChannelBindingElement signingBindingElement, INonceStore store, IConsumerTokenManager tokenManager, ConsumerSecuritySettings securitySettings, IMessageFactory messageFactory = null)
+			: base(
+			signingBindingElement,
+			store,
+			tokenManager,
+			securitySettings,
+			messageFactory ?? new OAuthConsumerMessageFactory(),
+			InitializeBindingElements(signingBindingElement, store, tokenManager, securitySettings)) {
+			Requires.NotNull(tokenManager, "tokenManager");
+			Requires.NotNull(securitySettings, "securitySettings");
+			Requires.NotNull(signingBindingElement, "signingBindingElement");
+		}
+
+		/// <summary>
+		/// Gets the consumer secret for a given consumer key.
+		/// </summary>
+		/// <param name="consumerKey">The consumer key.</param>
+		/// <returns>The consumer secret.</returns>
+		protected override string GetConsumerSecret(string consumerKey) {
+			var consumerTokenManager = (IConsumerTokenManager)this.TokenManager;
+			ErrorUtilities.VerifyInternal(consumerKey == consumerTokenManager.ConsumerKey, "The token manager consumer key and the consumer key set earlier do not match!");
+			return consumerTokenManager.ConsumerSecret;
+		}
+
+		/// <summary>
+		/// Initializes the binding elements for the OAuth channel.
+		/// </summary>
+		/// <param name="signingBindingElement">The signing binding element.</param>
+		/// <param name="store">The nonce store.</param>
+		/// <param name="tokenManager">The token manager.</param>
+		/// <param name="securitySettings">The security settings.</param>
+		/// <returns>
+		/// An array of binding elements used to initialize the channel.
+		/// </returns>
+		private static new IChannelBindingElement[] InitializeBindingElements(ITamperProtectionChannelBindingElement signingBindingElement, INonceStore store, ITokenManager tokenManager, SecuritySettings securitySettings) {
+			Contract.Requires(securitySettings != null);
+
+			return OAuthChannel.InitializeBindingElements(signingBindingElement, store, tokenManager, securitySettings).ToArray();
+		}
+	}
+}
diff --git a/src/DotNetOpenAuth.OAuth.Consumer/OAuth/ChannelElements/OAuthConsumerMessageFactory.cs b/src/DotNetOpenAuth.OAuth.Consumer/OAuth/ChannelElements/OAuthConsumerMessageFactory.cs
new file mode 100644
index 0000000..327b923
--- /dev/null
+++ b/src/DotNetOpenAuth.OAuth.Consumer/OAuth/ChannelElements/OAuthConsumerMessageFactory.cs
@@ -0,0 +1,109 @@
+//-----------------------------------------------------------------------
+// <copyright file="OAuthConsumerMessageFactory.cs" company="Andrew Arnott">
+//     Copyright (c) Andrew Arnott. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace DotNetOpenAuth.OAuth.ChannelElements {
+	using System;
+	using System.Collections.Generic;
+	using System.Diagnostics.Contracts;
+	using DotNetOpenAuth.Messaging;
+	using DotNetOpenAuth.OAuth.Messages;
+
+	/// <summary>
+	/// An OAuth-protocol specific implementation of the <see cref="IMessageFactory"/>
+	/// interface.
+	/// </summary>
+	public class OAuthConsumerMessageFactory : IMessageFactory {
+		/// <summary>
+		/// Initializes a new instance of the <see cref="OAuthConsumerMessageFactory"/> class.
+		/// </summary>
+		protected internal OAuthConsumerMessageFactory() {
+		}
+
+		#region IMessageFactory Members
+
+		/// <summary>
+		/// Analyzes an incoming request message payload to discover what kind of
+		/// message is embedded in it and returns the type, or null if no match is found.
+		/// </summary>
+		/// <param name="recipient">The intended or actual recipient of the request message.</param>
+		/// <param name="fields">The name/value pairs that make up the message payload.</param>
+		/// <returns>
+		/// A newly instantiated <see cref="IProtocolMessage"/>-derived object that this message can
+		/// deserialize to.  Null if the request isn't recognized as a valid protocol message.
+		/// </returns>
+		/// <remarks>
+		/// The request messages are:
+		/// UserAuthorizationResponse
+		/// </remarks>
+		public virtual IDirectedProtocolMessage GetNewRequestMessage(MessageReceivingEndpoint recipient, IDictionary<string, string> fields) {
+			MessageBase message = null;
+
+			if (fields.ContainsKey("oauth_token")) {
+				Protocol protocol = fields.ContainsKey("oauth_verifier") ? Protocol.V10a : Protocol.V10;
+				message = new UserAuthorizationResponse(recipient.Location, protocol.Version);
+			}
+
+			if (message != null) {
+				message.SetAsIncoming();
+			}
+
+			return message;
+		}
+
+		/// <summary>
+		/// Analyzes an incoming request message payload to discover what kind of 
+		/// message is embedded in it and returns the type, or null if no match is found.
+		/// </summary>
+		/// <param name="request">
+		/// The message that was sent as a request that resulted in the response.
+		/// Null on a Consumer site that is receiving an indirect message from the Service Provider.
+		/// </param>
+		/// <param name="fields">The name/value pairs that make up the message payload.</param>
+		/// <returns>
+		/// A newly instantiated <see cref="IProtocolMessage"/>-derived object that this message can
+		/// deserialize to.  Null if the request isn't recognized as a valid protocol message.
+		/// </returns>
+		/// <remarks>
+		/// The response messages are:
+		/// UnauthorizedTokenResponse
+		/// AuthorizedTokenResponse
+		/// </remarks>
+		public virtual IDirectResponseProtocolMessage GetNewResponseMessage(IDirectedProtocolMessage request, IDictionary<string, string> fields) {
+			MessageBase message = null;
+
+			// All response messages have the oauth_token field.
+			if (!fields.ContainsKey("oauth_token")) {
+				return null;
+			}
+
+			// All direct message responses should have the oauth_token_secret field.
+			if (!fields.ContainsKey("oauth_token_secret")) {
+				Logger.OAuth.Error("An OAuth message was expected to contain an oauth_token_secret but didn't.");
+				return null;
+			}
+
+			var unauthorizedTokenRequest = request as UnauthorizedTokenRequest;
+			var authorizedTokenRequest = request as AuthorizedTokenRequest;
+			if (unauthorizedTokenRequest != null) {
+				Protocol protocol = fields.ContainsKey("oauth_callback_confirmed") ? Protocol.V10a : Protocol.V10;
+				message = new UnauthorizedTokenResponse(unauthorizedTokenRequest, protocol.Version);
+			} else if (authorizedTokenRequest != null) {
+				message = new AuthorizedTokenResponse(authorizedTokenRequest);
+			} else {
+				Logger.OAuth.ErrorFormat("Unexpected response message given the request type {0}", request.GetType().Name);
+				throw new ProtocolException(OAuthStrings.InvalidIncomingMessage);
+			}
+
+			if (message != null) {
+				message.SetAsIncoming();
+			}
+
+			return message;
+		}
+
+		#endregion
+	}
+}
diff --git a/src/DotNetOpenAuth.OAuth.Consumer/OAuth/ChannelElements/RsaSha1ConsumerSigningBindingElement.cs b/src/DotNetOpenAuth.OAuth.Consumer/OAuth/ChannelElements/RsaSha1ConsumerSigningBindingElement.cs
new file mode 100644
index 0000000..7a7998e
--- /dev/null
+++ b/src/DotNetOpenAuth.OAuth.Consumer/OAuth/ChannelElements/RsaSha1ConsumerSigningBindingElement.cs
@@ -0,0 +1,74 @@
+//-----------------------------------------------------------------------
+// <copyright file="RsaSha1ConsumerSigningBindingElement.cs" company="Andrew Arnott">
+//     Copyright (c) Andrew Arnott. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace DotNetOpenAuth.OAuth.ChannelElements {
+	using System;
+	using System.Diagnostics.Contracts;
+	using System.Security.Cryptography;
+	using System.Security.Cryptography.X509Certificates;
+	using System.Text;
+	using DotNetOpenAuth.Messaging;
+
+	/// <summary>
+	/// A binding element that signs outgoing messages and verifies the signature on incoming messages.
+	/// </summary>
+	public class RsaSha1ConsumerSigningBindingElement : RsaSha1SigningBindingElement {
+		/// <summary>
+		/// Initializes a new instance of the <see cref="RsaSha1ConsumerSigningBindingElement"/> class.
+		/// </summary>
+		/// <param name="signingCertificate">The certificate used to sign outgoing messages.</param>
+		public RsaSha1ConsumerSigningBindingElement(X509Certificate2 signingCertificate) {
+			Requires.NotNull(signingCertificate, "signingCertificate");
+
+			this.SigningCertificate = signingCertificate;
+		}
+
+		/// <summary>
+		/// Gets or sets the certificate used to sign outgoing messages.  Used only by Consumers.
+		/// </summary>
+		public X509Certificate2 SigningCertificate { get; set; }
+
+		/// <summary>
+		/// Determines whether the signature on some message is valid.
+		/// </summary>
+		/// <param name="message">The message to check the signature on.</param>
+		/// <returns>
+		///   <c>true</c> if the signature on the message is valid; otherwise, <c>false</c>.
+		/// </returns>
+		protected override bool IsSignatureValid(ITamperResistantOAuthMessage message) {
+			throw new NotImplementedException();
+		}
+
+		/// <summary>
+		/// Calculates a signature for a given message.
+		/// </summary>
+		/// <param name="message">The message to sign.</param>
+		/// <returns>The signature for the message.</returns>
+		/// <remarks>
+		/// This method signs the message per OAuth 1.0 section 9.3.
+		/// </remarks>
+		protected override string GetSignature(ITamperResistantOAuthMessage message) {
+			ErrorUtilities.VerifyOperation(this.SigningCertificate != null, OAuthStrings.X509CertificateNotProvidedForSigning);
+
+			string signatureBaseString = ConstructSignatureBaseString(message, this.Channel.MessageDescriptions.GetAccessor(message));
+			byte[] data = Encoding.ASCII.GetBytes(signatureBaseString);
+			var provider = (RSACryptoServiceProvider)this.SigningCertificate.PrivateKey;
+			byte[] binarySignature = provider.SignData(data, "SHA1");
+			string base64Signature = Convert.ToBase64String(binarySignature);
+			return base64Signature;
+		}
+
+		/// <summary>
+		/// Creates a new object that is a copy of the current instance.
+		/// </summary>
+		/// <returns>
+		/// A new object that is a copy of this instance.
+		/// </returns>
+		protected override ITamperProtectionChannelBindingElement Clone() {
+			return new RsaSha1ConsumerSigningBindingElement(this.SigningCertificate);
+		}
+	}
+}
diff --git a/src/DotNetOpenAuth.OAuth.Consumer/OAuth/ConsumerBase.cs b/src/DotNetOpenAuth.OAuth.Consumer/OAuth/ConsumerBase.cs
new file mode 100644
index 0000000..89f5a5f
--- /dev/null
+++ b/src/DotNetOpenAuth.OAuth.Consumer/OAuth/ConsumerBase.cs
@@ -0,0 +1,302 @@
+//-----------------------------------------------------------------------
+// <copyright file="ConsumerBase.cs" company="Andrew Arnott">
+//     Copyright (c) Andrew Arnott. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace DotNetOpenAuth.OAuth {
+	using System;
+	using System.Collections.Generic;
+	using System.Diagnostics.CodeAnalysis;
+	using System.Diagnostics.Contracts;
+	using System.Linq;
+	using System.Net;
+	using DotNetOpenAuth.Configuration;
+	using DotNetOpenAuth.Messaging;
+	using DotNetOpenAuth.Messaging.Bindings;
+	using DotNetOpenAuth.OAuth.ChannelElements;
+	using DotNetOpenAuth.OAuth.Messages;
+
+	/// <summary>
+	/// Base class for <see cref="WebConsumer"/> and <see cref="DesktopConsumer"/> types.
+	/// </summary>
+	public class ConsumerBase : IDisposable {
+		/// <summary>
+		/// Initializes a new instance of the <see cref="ConsumerBase"/> class.
+		/// </summary>
+		/// <param name="serviceDescription">The endpoints and behavior of the Service Provider.</param>
+		/// <param name="tokenManager">The host's method of storing and recalling tokens and secrets.</param>
+		protected ConsumerBase(ServiceProviderDescription serviceDescription, IConsumerTokenManager tokenManager) {
+			Requires.NotNull(serviceDescription, "serviceDescription");
+			Requires.NotNull(tokenManager, "tokenManager");
+
+			ITamperProtectionChannelBindingElement signingElement = serviceDescription.CreateTamperProtectionElement();
+			INonceStore store = new NonceMemoryStore(StandardExpirationBindingElement.MaximumMessageAge);
+			this.SecuritySettings = OAuthElement.Configuration.Consumer.SecuritySettings.CreateSecuritySettings();
+			this.OAuthChannel = new OAuthConsumerChannel(signingElement, store, tokenManager, this.SecuritySettings);
+			this.ServiceProvider = serviceDescription;
+
+			OAuthReporting.RecordFeatureAndDependencyUse(this, serviceDescription, tokenManager, null);
+		}
+
+		/// <summary>
+		/// Gets the Consumer Key used to communicate with the Service Provider.
+		/// </summary>
+		public string ConsumerKey {
+			get { return this.TokenManager.ConsumerKey; }
+		}
+
+		/// <summary>
+		/// Gets the Service Provider that will be accessed.
+		/// </summary>
+		public ServiceProviderDescription ServiceProvider { get; private set; }
+
+		/// <summary>
+		/// Gets the persistence store for tokens and secrets.
+		/// </summary>
+		public IConsumerTokenManager TokenManager {
+			get { return (IConsumerTokenManager)this.OAuthChannel.TokenManager; }
+		}
+
+		/// <summary>
+		/// Gets the channel to use for sending/receiving messages.
+		/// </summary>
+		public Channel Channel {
+			get { return this.OAuthChannel; }
+		}
+
+		/// <summary>
+		/// Gets the security settings for this consumer.
+		/// </summary>
+		internal ConsumerSecuritySettings SecuritySettings { get; private set; }
+
+		/// <summary>
+		/// Gets or sets the channel to use for sending/receiving messages.
+		/// </summary>
+		internal OAuthChannel OAuthChannel { get; set; }
+
+		/// <summary>
+		/// Obtains an access token for a new account at the Service Provider via 2-legged OAuth.
+		/// </summary>
+		/// <param name="requestParameters">Any applicable parameters to include in the query string of the token request.</param>
+		/// <returns>The access token.</returns>
+		/// <remarks>
+		/// The token secret is stored in the <see cref="TokenManager"/>.
+		/// </remarks>
+		public string RequestNewClientAccount(IDictionary<string, string> requestParameters = null) {
+			// Obtain an unauthorized request token.  Assume the OAuth version given in the service description.
+			var token = new UnauthorizedTokenRequest(this.ServiceProvider.RequestTokenEndpoint, this.ServiceProvider.Version) {
+				ConsumerKey = this.ConsumerKey,
+			};
+			var tokenAccessor = this.Channel.MessageDescriptions.GetAccessor(token);
+			tokenAccessor.AddExtraParameters(requestParameters);
+			var requestTokenResponse = this.Channel.Request<UnauthorizedTokenResponse>(token);
+			this.TokenManager.StoreNewRequestToken(token, requestTokenResponse);
+
+			var requestAccess = new AuthorizedTokenRequest(this.ServiceProvider.AccessTokenEndpoint, this.ServiceProvider.Version) {
+				RequestToken = requestTokenResponse.RequestToken,
+				ConsumerKey = this.ConsumerKey,
+			};
+			var grantAccess = this.Channel.Request<AuthorizedTokenResponse>(requestAccess);
+			this.TokenManager.ExpireRequestTokenAndStoreNewAccessToken(this.ConsumerKey, requestTokenResponse.RequestToken, grantAccess.AccessToken, grantAccess.TokenSecret);
+			return grantAccess.AccessToken;
+		}
+
+		/// <summary>
+		/// Creates a web request prepared with OAuth authorization 
+		/// that may be further tailored by adding parameters by the caller.
+		/// </summary>
+		/// <param name="endpoint">The URL and method on the Service Provider to send the request to.</param>
+		/// <param name="accessToken">The access token that permits access to the protected resource.</param>
+		/// <returns>The initialized WebRequest object.</returns>
+		public HttpWebRequest PrepareAuthorizedRequest(MessageReceivingEndpoint endpoint, string accessToken) {
+			Requires.NotNull(endpoint, "endpoint");
+			Requires.NotNullOrEmpty(accessToken, "accessToken");
+
+			return this.PrepareAuthorizedRequest(endpoint, accessToken, EmptyDictionary<string, string>.Instance);
+		}
+
+		/// <summary>
+		/// Creates a web request prepared with OAuth authorization
+		/// that may be further tailored by adding parameters by the caller.
+		/// </summary>
+		/// <param name="endpoint">The URL and method on the Service Provider to send the request to.</param>
+		/// <param name="accessToken">The access token that permits access to the protected resource.</param>
+		/// <param name="extraData">Extra parameters to include in the message.  Must not be null, but may be empty.</param>
+		/// <returns>The initialized WebRequest object.</returns>
+		public HttpWebRequest PrepareAuthorizedRequest(MessageReceivingEndpoint endpoint, string accessToken, IDictionary<string, string> extraData) {
+			Requires.NotNull(endpoint, "endpoint");
+			Requires.NotNullOrEmpty(accessToken, "accessToken");
+			Requires.NotNull(extraData, "extraData");
+
+			IDirectedProtocolMessage message = this.CreateAuthorizingMessage(endpoint, accessToken);
+			foreach (var pair in extraData) {
+				message.ExtraData.Add(pair);
+			}
+
+			HttpWebRequest wr = this.OAuthChannel.InitializeRequest(message);
+			return wr;
+		}
+
+		/// <summary>
+		/// Prepares an authorized request that carries an HTTP multi-part POST, allowing for binary data.
+		/// </summary>
+		/// <param name="endpoint">The URL and method on the Service Provider to send the request to.</param>
+		/// <param name="accessToken">The access token that permits access to the protected resource.</param>
+		/// <param name="binaryData">Extra parameters to include in the message.  Must not be null, but may be empty.</param>
+		/// <returns>The initialized WebRequest object.</returns>
+		public HttpWebRequest PrepareAuthorizedRequest(MessageReceivingEndpoint endpoint, string accessToken, IEnumerable<MultipartPostPart> binaryData) {
+			Requires.NotNull(endpoint, "endpoint");
+			Requires.NotNullOrEmpty(accessToken, "accessToken");
+			Requires.NotNull(binaryData, "binaryData");
+
+			AccessProtectedResourceRequest message = this.CreateAuthorizingMessage(endpoint, accessToken);
+			foreach (MultipartPostPart part in binaryData) {
+				message.BinaryData.Add(part);
+			}
+
+			HttpWebRequest wr = this.OAuthChannel.InitializeRequest(message);
+			return wr;
+		}
+
+		/// <summary>
+		/// Prepares an HTTP request that has OAuth authorization already attached to it.
+		/// </summary>
+		/// <param name="message">The OAuth authorization message to attach to the HTTP request.</param>
+		/// <returns>
+		/// The HttpWebRequest that can be used to send the HTTP request to the remote service provider.
+		/// </returns>
+		/// <remarks>
+		/// If <see cref="IDirectedProtocolMessage.HttpMethods"/> property on the
+		/// <paramref name="message"/> has the
+		/// <see cref="HttpDeliveryMethods.AuthorizationHeaderRequest"/> flag set and
+		/// <see cref="ITamperResistantOAuthMessage.HttpMethod"/> is set to an HTTP method
+		/// that includes an entity body, the request stream is automatically sent
+		/// if and only if the <see cref="IMessage.ExtraData"/> dictionary is non-empty.
+		/// </remarks>
+		[SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Type of parameter forces the method to apply only to specific scenario.")]
+		public HttpWebRequest PrepareAuthorizedRequest(AccessProtectedResourceRequest message) {
+			Requires.NotNull(message, "message");
+			return this.OAuthChannel.InitializeRequest(message);
+		}
+
+		/// <summary>
+		/// Creates a web request prepared with OAuth authorization 
+		/// that may be further tailored by adding parameters by the caller.
+		/// </summary>
+		/// <param name="endpoint">The URL and method on the Service Provider to send the request to.</param>
+		/// <param name="accessToken">The access token that permits access to the protected resource.</param>
+		/// <returns>The initialized WebRequest object.</returns>
+		/// <exception cref="WebException">Thrown if the request fails for any reason after it is sent to the Service Provider.</exception>
+		public IncomingWebResponse PrepareAuthorizedRequestAndSend(MessageReceivingEndpoint endpoint, string accessToken) {
+			IDirectedProtocolMessage message = this.CreateAuthorizingMessage(endpoint, accessToken);
+			HttpWebRequest wr = this.OAuthChannel.InitializeRequest(message);
+			return this.Channel.WebRequestHandler.GetResponse(wr);
+		}
+
+		#region IDisposable Members
+
+		/// <summary>
+		/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+		/// </summary>
+		public void Dispose() {
+			this.Dispose(true);
+			GC.SuppressFinalize(this);
+		}
+
+		#endregion
+
+		/// <summary>
+		/// Creates a web request prepared with OAuth authorization 
+		/// that may be further tailored by adding parameters by the caller.
+		/// </summary>
+		/// <param name="endpoint">The URL and method on the Service Provider to send the request to.</param>
+		/// <param name="accessToken">The access token that permits access to the protected resource.</param>
+		/// <returns>The initialized WebRequest object.</returns>
+		protected internal AccessProtectedResourceRequest CreateAuthorizingMessage(MessageReceivingEndpoint endpoint, string accessToken) {
+			Requires.NotNull(endpoint, "endpoint");
+			Requires.NotNullOrEmpty(accessToken, "accessToken");
+
+			AccessProtectedResourceRequest message = new AccessProtectedResourceRequest(endpoint, this.ServiceProvider.Version) {
+				AccessToken = accessToken,
+				ConsumerKey = this.ConsumerKey,
+			};
+
+			return message;
+		}
+
+		/// <summary>
+		/// Prepares an OAuth message that begins an authorization request that will 
+		/// redirect the user to the Service Provider to provide that authorization.
+		/// </summary>
+		/// <param name="callback">
+		/// An optional Consumer URL that the Service Provider should redirect the 
+		/// User Agent to upon successful authorization.
+		/// </param>
+		/// <param name="requestParameters">Extra parameters to add to the request token message.  Optional.</param>
+		/// <param name="redirectParameters">Extra parameters to add to the redirect to Service Provider message.  Optional.</param>
+		/// <param name="requestToken">The request token that must be exchanged for an access token after the user has provided authorization.</param>
+		/// <returns>The pending user agent redirect based message to be sent as an HttpResponse.</returns>
+		[SuppressMessage("Microsoft.Design", "CA1021:AvoidOutParameters", MessageId = "3#", Justification = "Two results")]
+		protected internal UserAuthorizationRequest PrepareRequestUserAuthorization(Uri callback, IDictionary<string, string> requestParameters, IDictionary<string, string> redirectParameters, out string requestToken) {
+			// Obtain an unauthorized request token.  Assume the OAuth version given in the service description.
+			var token = new UnauthorizedTokenRequest(this.ServiceProvider.RequestTokenEndpoint, this.ServiceProvider.Version) {
+				ConsumerKey = this.ConsumerKey,
+				Callback = callback,
+			};
+			var tokenAccessor = this.Channel.MessageDescriptions.GetAccessor(token);
+			tokenAccessor.AddExtraParameters(requestParameters);
+			var requestTokenResponse = this.Channel.Request<UnauthorizedTokenResponse>(token);
+			this.TokenManager.StoreNewRequestToken(token, requestTokenResponse);
+
+			// Fine-tune our understanding of the SP's supported OAuth version if it's wrong.
+			if (this.ServiceProvider.Version != requestTokenResponse.Version) {
+				Logger.OAuth.WarnFormat("Expected OAuth service provider at endpoint {0} to use OAuth {1} but {2} was detected.  Adjusting service description to new version.", this.ServiceProvider.RequestTokenEndpoint.Location, this.ServiceProvider.Version, requestTokenResponse.Version);
+				this.ServiceProvider.ProtocolVersion = Protocol.Lookup(requestTokenResponse.Version).ProtocolVersion;
+			}
+
+			// Request user authorization.  The OAuth version will automatically include 
+			// or drop the callback that we're setting here.
+			ITokenContainingMessage assignedRequestToken = requestTokenResponse;
+			var requestAuthorization = new UserAuthorizationRequest(this.ServiceProvider.UserAuthorizationEndpoint, assignedRequestToken.Token, requestTokenResponse.Version) {
+				Callback = callback,
+			};
+			var requestAuthorizationAccessor = this.Channel.MessageDescriptions.GetAccessor(requestAuthorization);
+			requestAuthorizationAccessor.AddExtraParameters(redirectParameters);
+			requestToken = requestAuthorization.RequestToken;
+			return requestAuthorization;
+		}
+
+		/// <summary>
+		/// Exchanges a given request token for access token.
+		/// </summary>
+		/// <param name="requestToken">The request token that the user has authorized.</param>
+		/// <param name="verifier">The verifier code.</param>
+		/// <returns>
+		/// The access token assigned by the Service Provider.
+		/// </returns>
+		protected AuthorizedTokenResponse ProcessUserAuthorization(string requestToken, string verifier) {
+			Requires.NotNullOrEmpty(requestToken, "requestToken");
+			Contract.Ensures(Contract.Result<AuthorizedTokenResponse>() != null);
+
+			var requestAccess = new AuthorizedTokenRequest(this.ServiceProvider.AccessTokenEndpoint, this.ServiceProvider.Version) {
+				RequestToken = requestToken,
+				VerificationCode = verifier,
+				ConsumerKey = this.ConsumerKey,
+			};
+			var grantAccess = this.Channel.Request<AuthorizedTokenResponse>(requestAccess);
+			this.TokenManager.ExpireRequestTokenAndStoreNewAccessToken(this.ConsumerKey, requestToken, grantAccess.AccessToken, grantAccess.TokenSecret);
+			return grantAccess;
+		}
+
+		/// <summary>
+		/// Releases unmanaged and - optionally - managed resources
+		/// </summary>
+		/// <param name="disposing"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+		protected virtual void Dispose(bool disposing) {
+			if (disposing) {
+				this.Channel.Dispose();
+			}
+		}
+	}
+}
diff --git a/src/DotNetOpenAuth.OAuth.Consumer/OAuth/DesktopConsumer.cs b/src/DotNetOpenAuth.OAuth.Consumer/OAuth/DesktopConsumer.cs
new file mode 100644
index 0000000..f9c1a94
--- /dev/null
+++ b/src/DotNetOpenAuth.OAuth.Consumer/OAuth/DesktopConsumer.cs
@@ -0,0 +1,73 @@
+//-----------------------------------------------------------------------
+// <copyright file="DesktopConsumer.cs" company="Andrew Arnott">
+//     Copyright (c) Andrew Arnott. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace DotNetOpenAuth.OAuth {
+	using System;
+	using System.Collections.Generic;
+	using System.Diagnostics.CodeAnalysis;
+	using DotNetOpenAuth.Messaging;
+	using DotNetOpenAuth.OAuth;
+	using DotNetOpenAuth.OAuth.ChannelElements;
+	using DotNetOpenAuth.OAuth.Messages;
+
+	/// <summary>
+	/// Used by a desktop application to use OAuth to access the Service Provider on behalf of the User.
+	/// </summary>
+	/// <remarks>
+	/// The methods on this class are thread-safe.  Provided the properties are set and not changed
+	/// afterward, a single instance of this class may be used by an entire desktop application safely.
+	/// </remarks>
+	public class DesktopConsumer : ConsumerBase {
+		/// <summary>
+		/// Initializes a new instance of the <see cref="DesktopConsumer"/> class.
+		/// </summary>
+		/// <param name="serviceDescription">The endpoints and behavior of the Service Provider.</param>
+		/// <param name="tokenManager">The host's method of storing and recalling tokens and secrets.</param>
+		public DesktopConsumer(ServiceProviderDescription serviceDescription, IConsumerTokenManager tokenManager)
+			: base(serviceDescription, tokenManager) {
+		}
+
+		/// <summary>
+		/// Begins an OAuth authorization request.
+		/// </summary>
+		/// <param name="requestParameters">Extra parameters to add to the request token message.  Optional.</param>
+		/// <param name="redirectParameters">Extra parameters to add to the redirect to Service Provider message.  Optional.</param>
+		/// <param name="requestToken">The request token that must be exchanged for an access token after the user has provided authorization.</param>
+		/// <returns>The URL to open a browser window to allow the user to provide authorization.</returns>
+		[SuppressMessage("Microsoft.Design", "CA1021:AvoidOutParameters", MessageId = "2#", Justification = "Two results")]
+		public Uri RequestUserAuthorization(IDictionary<string, string> requestParameters, IDictionary<string, string> redirectParameters, out string requestToken) {
+			var message = this.PrepareRequestUserAuthorization(null, requestParameters, redirectParameters, out requestToken);
+			OutgoingWebResponse response = this.Channel.PrepareResponse(message);
+			return response.GetDirectUriRequest(this.Channel);
+		}
+
+		/// <summary>
+		/// Exchanges a given request token for access token.
+		/// </summary>
+		/// <param name="requestToken">The request token that the user has authorized.</param>
+		/// <returns>The access token assigned by the Service Provider.</returns>
+		[Obsolete("Use the ProcessUserAuthorization method that takes a verifier parameter instead.")]
+		public AuthorizedTokenResponse ProcessUserAuthorization(string requestToken) {
+			return this.ProcessUserAuthorization(requestToken, null);
+		}
+
+		/// <summary>
+		/// Exchanges a given request token for access token.
+		/// </summary>
+		/// <param name="requestToken">The request token that the user has authorized.</param>
+		/// <param name="verifier">The verifier code typed in by the user.  Must not be <c>Null</c> for OAuth 1.0a service providers and later.</param>
+		/// <returns>
+		/// The access token assigned by the Service Provider.
+		/// </returns>
+		public new AuthorizedTokenResponse ProcessUserAuthorization(string requestToken, string verifier) {
+			if (this.ServiceProvider.Version >= Protocol.V10a.Version) {
+				ErrorUtilities.VerifyNonZeroLength(verifier, "verifier");
+			}
+
+			return base.ProcessUserAuthorization(requestToken, verifier);
+		}
+	}
+}
diff --git a/src/DotNetOpenAuth.OAuth.Consumer/OAuth/WebConsumer.cs b/src/DotNetOpenAuth.OAuth.Consumer/OAuth/WebConsumer.cs
new file mode 100644
index 0000000..e7d7f4f
--- /dev/null
+++ b/src/DotNetOpenAuth.OAuth.Consumer/OAuth/WebConsumer.cs
@@ -0,0 +1,155 @@
+//-----------------------------------------------------------------------
+// <copyright file="WebConsumer.cs" company="Andrew Arnott">
+//     Copyright (c) Andrew Arnott. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+namespace DotNetOpenAuth.OAuth {
+	using System;
+	using System.Collections.Generic;
+	using System.Diagnostics.Contracts;
+	using System.Web;
+	using DotNetOpenAuth.Messaging;
+	using DotNetOpenAuth.OAuth.ChannelElements;
+	using DotNetOpenAuth.OAuth.Messages;
+	using DotNetOpenAuth.OpenId.Extensions.OAuth;
+	using DotNetOpenAuth.OpenId.RelyingParty;
+
+	/// <summary>
+	/// A website or application that uses OAuth to access the Service Provider on behalf of the User.
+	/// </summary>
+	/// <remarks>
+	/// The methods on this class are thread-safe.  Provided the properties are set and not changed
+	/// afterward, a single instance of this class may be used by an entire web application safely.
+	/// </remarks>
+	public class WebConsumer : ConsumerBase {
+		/// <summary>
+		/// Initializes a new instance of the <see cref="WebConsumer"/> class.
+		/// </summary>
+		/// <param name="serviceDescription">The endpoints and behavior of the Service Provider.</param>
+		/// <param name="tokenManager">The host's method of storing and recalling tokens and secrets.</param>
+		public WebConsumer(ServiceProviderDescription serviceDescription, IConsumerTokenManager tokenManager)
+			: base(serviceDescription, tokenManager) {
+		}
+
+		/// <summary>
+		/// Begins an OAuth authorization request and redirects the user to the Service Provider
+		/// to provide that authorization.  Upon successful authorization, the user is redirected
+		/// back to the current page.
+		/// </summary>
+		/// <returns>The pending user agent redirect based message to be sent as an HttpResponse.</returns>
+		/// <remarks>
+		/// Requires HttpContext.Current.
+		/// </remarks>
+		public UserAuthorizationRequest PrepareRequestUserAuthorization() {
+			Uri callback = this.Channel.GetRequestFromContext().UrlBeforeRewriting.StripQueryArgumentsWithPrefix(Protocol.ParameterPrefix);
+			return this.PrepareRequestUserAuthorization(callback, null, null);
+		}
+
+		/// <summary>
+		/// Prepares an OAuth message that begins an authorization request that will 
+		/// redirect the user to the Service Provider to provide that authorization.
+		/// </summary>
+		/// <param name="callback">
+		/// An optional Consumer URL that the Service Provider should redirect the 
+		/// User Agent to upon successful authorization.
+		/// </param>
+		/// <param name="requestParameters">Extra parameters to add to the request token message.  Optional.</param>
+		/// <param name="redirectParameters">Extra parameters to add to the redirect to Service Provider message.  Optional.</param>
+		/// <returns>The pending user agent redirect based message to be sent as an HttpResponse.</returns>
+		public UserAuthorizationRequest PrepareRequestUserAuthorization(Uri callback, IDictionary<string, string> requestParameters, IDictionary<string, string> redirectParameters) {
+			string token;
+			return this.PrepareRequestUserAuthorization(callback, requestParameters, redirectParameters, out token);
+		}
+
+		/// <summary>
+		/// Processes an incoming authorization-granted message from an SP and obtains an access token.
+		/// </summary>
+		/// <returns>The access token, or null if no incoming authorization message was recognized.</returns>
+		/// <remarks>
+		/// Requires HttpContext.Current.
+		/// </remarks>
+		public AuthorizedTokenResponse ProcessUserAuthorization() {
+			return this.ProcessUserAuthorization(this.Channel.GetRequestFromContext());
+		}
+
+		/// <summary>
+		/// Attaches an OAuth authorization request to an outgoing OpenID authentication request.
+		/// </summary>
+		/// <param name="openIdAuthenticationRequest">The OpenID authentication request.</param>
+		/// <param name="scope">The scope of access that is requested of the service provider.</param>
+		public void AttachAuthorizationRequest(IAuthenticationRequest openIdAuthenticationRequest, string scope) {
+			Requires.NotNull(openIdAuthenticationRequest, "openIdAuthenticationRequest");
+
+			var authorizationRequest = new AuthorizationRequest {
+				Consumer = this.ConsumerKey,
+				Scope = scope,
+			};
+
+			openIdAuthenticationRequest.AddExtension(authorizationRequest);
+		}
+
+		/// <summary>
+		/// Processes an incoming authorization-granted message from an SP and obtains an access token.
+		/// </summary>
+		/// <param name="openIdAuthenticationResponse">The OpenID authentication response that may be carrying an authorized request token.</param>
+		/// <returns>
+		/// The access token, or null if OAuth authorization was denied by the user or service provider.
+		/// </returns>
+		/// <remarks>
+		/// The access token, if granted, is automatically stored in the <see cref="ConsumerBase.TokenManager"/>.
+		/// The token manager instance must implement <see cref="IOpenIdOAuthTokenManager"/>.
+		/// </remarks>
+		public AuthorizedTokenResponse ProcessUserAuthorization(IAuthenticationResponse openIdAuthenticationResponse) {
+			Requires.NotNull(openIdAuthenticationResponse, "openIdAuthenticationResponse");
+			Requires.ValidState(this.TokenManager is IOpenIdOAuthTokenManager);
+			var openidTokenManager = this.TokenManager as IOpenIdOAuthTokenManager;
+			ErrorUtilities.VerifyOperation(openidTokenManager != null, OAuthStrings.OpenIdOAuthExtensionRequiresSpecialTokenManagerInterface, typeof(IOpenIdOAuthTokenManager).FullName);
+
+			// The OAuth extension is only expected in positive assertion responses.
+			if (openIdAuthenticationResponse.Status != AuthenticationStatus.Authenticated) {
+				return null;
+			}
+
+			// Retrieve the OAuth extension
+			var positiveAuthorization = openIdAuthenticationResponse.GetExtension<AuthorizationApprovedResponse>();
+			if (positiveAuthorization == null) {
+				return null;
+			}
+
+			// Prepare a message to exchange the request token for an access token.
+			// We are careful to use a v1.0 message version so that the oauth_verifier is not required.
+			var requestAccess = new AuthorizedTokenRequest(this.ServiceProvider.AccessTokenEndpoint, Protocol.V10.Version) {
+				RequestToken = positiveAuthorization.RequestToken,
+				ConsumerKey = this.ConsumerKey,
+			};
+
+			// Retrieve the access token and store it in the token manager.
+			openidTokenManager.StoreOpenIdAuthorizedRequestToken(this.ConsumerKey, positiveAuthorization);
+			var grantAccess = this.Channel.Request<AuthorizedTokenResponse>(requestAccess);
+			this.TokenManager.ExpireRequestTokenAndStoreNewAccessToken(this.ConsumerKey, positiveAuthorization.RequestToken, grantAccess.AccessToken, grantAccess.TokenSecret);
+
+			// Provide the caller with the access token so it may be associated with the user
+			// that is logging in.
+			return grantAccess;
+		}
+
+		/// <summary>
+		/// Processes an incoming authorization-granted message from an SP and obtains an access token.
+		/// </summary>
+		/// <param name="request">The incoming HTTP request.</param>
+		/// <returns>The access token, or null if no incoming authorization message was recognized.</returns>
+		public AuthorizedTokenResponse ProcessUserAuthorization(HttpRequestInfo request) {
+			Requires.NotNull(request, "request");
+
+			UserAuthorizationResponse authorizationMessage;
+			if (this.Channel.TryReadFromRequest<UserAuthorizationResponse>(request, out authorizationMessage)) {
+				string requestToken = authorizationMessage.RequestToken;
+				string verifier = authorizationMessage.VerificationCode;
+				return this.ProcessUserAuthorization(requestToken, verifier);
+			} else {
+				return null;
+			}
+		}
+	}
+}
diff --git a/src/DotNetOpenAuth.OAuth.Consumer/Properties/AssemblyInfo.cs b/src/DotNetOpenAuth.OAuth.Consumer/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..fd29585
--- /dev/null
+++ b/src/DotNetOpenAuth.OAuth.Consumer/Properties/AssemblyInfo.cs
@@ -0,0 +1,58 @@
+//-----------------------------------------------------------------------
+// <copyright file="AssemblyInfo.cs" company="Andrew Arnott">
+//     Copyright (c) Andrew Arnott. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+// We DON'T put an AssemblyVersionAttribute in here because it is generated in the build.
+
+using System;
+using System.Diagnostics.Contracts;
+using System.Net;
+using System.Reflection;
+using System.Resources;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Security.Permissions;
+using System.Web.UI;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("DotNetOpenAuth OAuth")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("DotNetOpenAuth")]
+[assembly: AssemblyCopyright("Copyright ©  2008")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+[assembly: NeutralResourcesLanguage("en-US")]
+[assembly: CLSCompliant(true)]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("7d73990c-47c0-4256-9f20-a893add9e289")]
+
+[assembly: ContractVerification(true)]
+
+#if StrongNameSigned
+// See comment at top of this file.  We need this so that strong-naming doesn't
+// keep this assembly from being useful to shared host (medium trust) web sites.
+[assembly: AllowPartiallyTrustedCallers]
+
+[assembly: InternalsVisibleTo("DotNetOpenAuth.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100AD093C3765257C89A7010E853F2C7C741FF92FA8ACE06D7B8254702CAD5CF99104447F63AB05F8BB6F51CE0D81C8C93D2FCE8C20AAFF7042E721CBA16EAAE98778611DED11C0ABC8900DC5667F99B50A9DADEC24DBD8F2C91E3E8AD300EF64F1B4B9536CEB16FB440AF939F57624A9B486F867807C649AE4830EAB88C6C03998")]
+[assembly: InternalsVisibleTo("DotNetOpenAuth.OAuth2, PublicKey=0024000004800000940000000602000000240000525341310004000001000100AD093C3765257C89A7010E853F2C7C741FF92FA8ACE06D7B8254702CAD5CF99104447F63AB05F8BB6F51CE0D81C8C93D2FCE8C20AAFF7042E721CBA16EAAE98778611DED11C0ABC8900DC5667F99B50A9DADEC24DBD8F2C91E3E8AD300EF64F1B4B9536CEB16FB440AF939F57624A9B486F867807C649AE4830EAB88C6C03998")]
+[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2, PublicKey=0024000004800000940000000602000000240000525341310004000001000100c547cac37abd99c8db225ef2f6c8a3602f3b3606cc9891605d02baa56104f4cfc0734aa39b93bf7852f7d9266654753cc297e7d2edfe0bac1cdcf9f717241550e0a7b191195b7667bb4f64bcb8e2121380fd1d9d46ad2d92d2d15605093924cceaf74c4861eff62abf69b9291ed0a340e113be11e6a7d3113e92484cf7045cc7")]
+#else
+[assembly: InternalsVisibleTo("DotNetOpenAuth.Test")]
+[assembly: InternalsVisibleTo("DotNetOpenAuth.OAuth.Consumer")]
+[assembly: InternalsVisibleTo("DotNetOpenAuth.OAuth.ServiceProvider")]
+[assembly: InternalsVisibleTo("DotNetOpenAuth.OAuth2")]
+[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]
+#endif
diff --git a/src/DotNetOpenAuth.OAuth.Consumer/Properties/Properties/AssemblyInfo.cs b/src/DotNetOpenAuth.OAuth.Consumer/Properties/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..d402b02
--- /dev/null
+++ b/src/DotNetOpenAuth.OAuth.Consumer/Properties/Properties/AssemblyInfo.cs
@@ -0,0 +1,58 @@
+//-----------------------------------------------------------------------
+// <copyright file="AssemblyInfo.cs" company="Andrew Arnott">
+//     Copyright (c) Andrew Arnott. All rights reserved.
+// </copyright>
+//-----------------------------------------------------------------------
+
+// We DON'T put an AssemblyVersionAttribute in here because it is generated in the build.
+
+using System;
+using System.Diagnostics.Contracts;
+using System.Net;
+using System.Reflection;
+using System.Resources;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security;
+using System.Security.Permissions;
+using System.Web.UI;
+
+[assembly: TagPrefix("DotNetOpenAuth.OAuth", "oauth")]
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("DotNetOpenAuth OAuth")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("DotNetOpenAuth")]
+[assembly: AssemblyCopyright("Copyright ©  2008")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+[assembly: NeutralResourcesLanguage("en-US")]
+[assembly: CLSCompliant(true)]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("7d73990c-47c0-4256-9f20-a893add9e289")]
+
+[assembly: ContractVerification(true)]
+
+#if StrongNameSigned
+// See comment at top of this file.  We need this so that strong-naming doesn't
+// keep this assembly from being useful to shared host (medium trust) web sites.
+[assembly: AllowPartiallyTrustedCallers]
+
+[assembly: InternalsVisibleTo("DotNetOpenAuth.Test, PublicKey=0024000004800000940000000602000000240000525341310004000001000100AD093C3765257C89A7010E853F2C7C741FF92FA8ACE06D7B8254702CAD5CF99104447F63AB05F8BB6F51CE0D81C8C93D2FCE8C20AAFF7042E721CBA16EAAE98778611DED11C0ABC8900DC5667F99B50A9DADEC24DBD8F2C91E3E8AD300EF64F1B4B9536CEB16FB440AF939F57624A9B486F867807C649AE4830EAB88C6C03998")]
+[assembly: InternalsVisibleTo("DotNetOpenAuth.OAuth2, PublicKey=0024000004800000940000000602000000240000525341310004000001000100AD093C3765257C89A7010E853F2C7C741FF92FA8ACE06D7B8254702CAD5CF99104447F63AB05F8BB6F51CE0D81C8C93D2FCE8C20AAFF7042E721CBA16EAAE98778611DED11C0ABC8900DC5667F99B50A9DADEC24DBD8F2C91E3E8AD300EF64F1B4B9536CEB16FB440AF939F57624A9B486F867807C649AE4830EAB88C6C03998")]
+[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2, PublicKey=0024000004800000940000000602000000240000525341310004000001000100c547cac37abd99c8db225ef2f6c8a3602f3b3606cc9891605d02baa56104f4cfc0734aa39b93bf7852f7d9266654753cc297e7d2edfe0bac1cdcf9f717241550e0a7b191195b7667bb4f64bcb8e2121380fd1d9d46ad2d92d2d15605093924cceaf74c4861eff62abf69b9291ed0a340e113be11e6a7d3113e92484cf7045cc7")]
+#else
+[assembly: InternalsVisibleTo("DotNetOpenAuth.Test")]
+[assembly: InternalsVisibleTo("DotNetOpenAuth.OAuth2")]
+[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]
+#endif