Merge lp:~mandel/ubuntuone-windows-installer/refactor_sso into lp:ubuntuone-windows-installer/beta

[Manuel de la Peña]

SSO has been refactored to make it more testeable and robust.

[John Lenton (chipaca)]

review: Approve

[Rick McBride (rmcbride)]

review: Approve

=== modified file 'src/Canonical.Ubuntu.SSO.Tests/Canonical.Ubuntu.SSO.Tests.csproj'
--- src/Canonical.Ubuntu.SSO.Tests/Canonical.Ubuntu.SSO.Tests.csproj	2010-10-05 09:58:34 +0000
+++ src/Canonical.Ubuntu.SSO.Tests/Canonical.Ubuntu.SSO.Tests.csproj	2010-10-05 09:58:35 +0000
@@ -48,14 +48,21 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="ColonSeparatedSSOCredentialsEncoderFixture.cs" />
+    <Compile Include="JsonSSOCredentialsEncoderFixture.cs" />
     <Compile Include="KeyringFixture.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="SSOLoginProcessorFixture.cs" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Canonical.Ubuntu.SSO\Canonical.Ubuntu.SSO.csproj">
       <Project>{9460A771-2589-45DA-9618-9FE8BB7D16E8}</Project>
       <Name>Canonical.Ubuntu.SSO</Name>
     </ProjectReference>
+    <ProjectReference Include="..\Canonical.UbuntuOne.Common\Canonical.UbuntuOne.Common.csproj">
+      <Project>{11353FF8-8E5A-488E-9CB1-873DADD232B9}</Project>
+      <Name>Canonical.UbuntuOne.Common</Name>
+    </ProjectReference>
   </ItemGroup>
   <ItemGroup>
     <Folder Include="Service\" />

=== added file 'src/Canonical.Ubuntu.SSO.Tests/ColonSeparatedSSOCredentialsEncoderFixture.cs'
--- src/Canonical.Ubuntu.SSO.Tests/ColonSeparatedSSOCredentialsEncoderFixture.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.Ubuntu.SSO.Tests/ColonSeparatedSSOCredentialsEncoderFixture.cs	2010-10-05 09:58:35 +0000
@@ -0,0 +1,69 @@
+/* Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using NUnit.Framework;
+
+namespace Canonical.Ubuntu.SSO.Tests
+{
+    [TestFixture]
+    public class ColonSeparatedSSOCredentialsEncoderFixture
+    {
+        #region Variables
+
+        private ColonSeparatedSSOCredentialsEncoder _encoder;
+
+        #endregion
+
+        #region Setup & TearDown
+
+        [SetUp]
+        public void Setup()
+        {
+            _encoder = new ColonSeparatedSSOCredentialsEncoder();
+        }
+        #endregion
+
+        #region Tests
+
+        [TestCase("firstToken:firstTokenSecret:firstConsumer:firstConsumerSecret", "firstToken", "firstTokenSecret", "firstConsumer", "firstConsumerSecret")]
+        [TestCase("ad180jjd733klru7:hdhd0244k9j7ao03:dpf43f3p2l4k3l03:djr9rjt0jd78jf88%26", "ad180jjd733klru7", "hdhd0244k9j7ao03", "dpf43f3p2l4k3l03", "djr9rjt0jd78jf88%26")]
+        public void EncodeTest(string expected, string token, string tokenSecret, string consumerKey, string consumerSecret)
+        {
+            Assert.AreEqual(expected, _encoder.Encode(token, tokenSecret, consumerKey, consumerSecret));
+        }
+
+        [TestCase("firstToken:firstTokenSecret:firstConsumer:firstConsumerSecret", "firstToken", "firstTokenSecret", "firstConsumer", "firstConsumerSecret")]
+        [TestCase("ad180jjd733klru7:hdhd0244k9j7ao03:dpf43f3p2l4k3l03:djr9rjt0jd78jf88%26", "ad180jjd733klru7", "hdhd0244k9j7ao03", "dpf43f3p2l4k3l03", "djr9rjt0jd78jf88%26")]
+        public void DecodeTest(string secret, string expectedToken, string expectedTokenSecret, string expectedConsumerKey,
+            string expectedConsumerSecret)
+        {
+            string token;
+            string tokenSecret;
+            string consumerKey;
+            string consumerSecret;
+            _encoder.Decode(secret, out token, out tokenSecret, out consumerKey, out consumerSecret);
+            Assert.AreEqual(expectedToken, token);
+            Assert.AreEqual(expectedTokenSecret, tokenSecret);
+            Assert.AreEqual(expectedConsumerKey, consumerKey);
+            Assert.AreEqual(expectedConsumerSecret, consumerSecret);
+        }
+
+        #endregion
+
+    }
+}

=== added file 'src/Canonical.Ubuntu.SSO.Tests/JsonSSOCredentialsEncoderFixture.cs'
--- src/Canonical.Ubuntu.SSO.Tests/JsonSSOCredentialsEncoderFixture.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.Ubuntu.SSO.Tests/JsonSSOCredentialsEncoderFixture.cs	2010-10-05 09:58:35 +0000
@@ -0,0 +1,29 @@
+/* Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Canonical.Ubuntu.SSO.Tests
+{
+    class JsonSSOCredentialsEncoderFixture
+    {
+    }
+}

=== added file 'src/Canonical.Ubuntu.SSO.Tests/SSOLoginProcessorFixture.cs'
--- src/Canonical.Ubuntu.SSO.Tests/SSOLoginProcessorFixture.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.Ubuntu.SSO.Tests/SSOLoginProcessorFixture.cs	2010-10-05 09:58:35 +0000
@@ -0,0 +1,98 @@
+/* Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using Canonical.Ubuntu.SSO.Service;
+using Canonical.UbuntuOne.Common.Net;
+using NUnit.Framework;
+using Rhino.Mocks;
+
+namespace Canonical.Ubuntu.SSO.Tests
+{
+    [TestFixture]
+    public class SSOLoginProcessorFixture
+    {
+        #region Variables
+
+        private MockRepository _mocks;
+        private Authentications _auth;
+        private IKeyring _keyring;
+        private ISSOCredentialsEncoder _encode;
+        private IOAuth _oauth;
+        private IHttpWebRequestFactory _requestFactory;
+        private IHttpWebRequest _request;
+        private SSOLoginProcessor _processor;
+
+        #endregion
+
+        #region Setup
+
+        [SetUp]
+        public void Setup()
+        {
+            _mocks = new MockRepository();
+            _auth = _mocks.DynamicMock<Authentications>();
+            _keyring = _mocks.DynamicMock<IKeyring>();
+            _encode = _mocks.DynamicMock<ISSOCredentialsEncoder>();
+            _oauth = _mocks.DynamicMock<IOAuth>();
+            _requestFactory = _mocks.DynamicMock<IHttpWebRequestFactory>();
+            _request = _mocks.DynamicMock<IHttpWebRequest>();
+            _processor = new SSOLoginProcessor
+            {
+                Authentications = _auth,
+                HttpWebRequestFactory = _requestFactory,
+                Keyring = _keyring,
+                OAuth = _oauth,
+                SSOCredentialsEncoder = _encode
+            };
+        }
+
+        #endregion
+
+        #region Tests
+
+        [TestCase("[e-mail]", "Passwd", "UbuntuOne")]
+        [TestCase("[e-mail]", "Test", "Gwibber")]
+        [ExpectedException(typeof(SSOLoginException))]
+        public void LoginCredentialsExceptionTest(string email, string password, string tokenName)
+        {
+            Assert.Ignore("Not yet implemented");
+        }
+
+        [Test]
+        [ExpectedException(typeof(SSOLoginException))]
+        public void LoginPingExceptionTest()
+        {
+            Assert.Ignore("Not yet implemented");
+        }
+
+        [Test]
+        public void LoginNoSecretTest()
+        {
+            Assert.Ignore("Not yet implemented");
+        }
+
+        [Test]
+        public void LoginSecretTest()
+        {
+            Assert.Ignore("Not yet implemented");
+        }
+
+        #endregion
+
+    }
+}

=== modified file 'src/Canonical.Ubuntu.SSO/Canonical.Ubuntu.SSO.csproj'
--- src/Canonical.Ubuntu.SSO/Canonical.Ubuntu.SSO.csproj	2010-10-05 09:58:34 +0000
+++ src/Canonical.Ubuntu.SSO/Canonical.Ubuntu.SSO.csproj	2010-10-05 09:58:35 +0000
@@ -35,6 +35,10 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\lib\log4net\log4net.dll</HintPath>
     </Reference>
+    <Reference Include="Newtonsoft.Json, Version=3.5.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\JsonNet\Newtonsoft.Json.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core">
       <RequiredTargetFramework>3.5</RequiredTargetFramework>
@@ -54,6 +58,7 @@
     <Compile Include="..\Version.cs">
       <Link>Properties\Version.cs</Link>
     </Compile>
+    <Compile Include="ColonSeparatedSSOCredentialsEncoder.cs" />
     <Compile Include="CredentialsDeniedEventArgs.cs" />
     <Compile Include="CredentialsErrorEventArgs.cs" />
     <Compile Include="CredentialsFoundEventArgs.cs" />
@@ -61,11 +66,14 @@
     <Compile Include="IDataProtector.cs" />
     <Compile Include="ILoginOrRegisterView.cs" />
     <Compile Include="ILoginView.cs" />
+    <Compile Include="IOAuth.cs" />
     <Compile Include="IRegistryKey.cs" />
+    <Compile Include="ISSOCredentialsEncoder.cs" />
     <Compile Include="ISSOLoginProcessor.cs" />
+    <Compile Include="JsonSSOCredentialsEncoder.cs" />
     <Compile Include="Keyring.cs" />
     <Compile Include="LoginCredentialsEventArgs.cs" />
-    <Compile Include="OAuthBase.cs" />
+    <Compile Include="OAuth.cs" />
     <Compile Include="RegistryKeyWrapper.cs" />
     <Compile Include="Service\Account.cs" />
     <Compile Include="Service\AccountDiff.cs" />
@@ -109,6 +117,8 @@
     <Compile Include="IKeyring.cs" />
     <Compile Include="ISSOCredentialsProvider.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="SSOException.cs" />
+    <Compile Include="SSOLoginException.cs" />
     <Compile Include="SSOLoginProcessor.cs" />
   </ItemGroup>
   <ItemGroup>

=== added file 'src/Canonical.Ubuntu.SSO/ColonSeparatedSSOCredentialsEncoder.cs'
--- src/Canonical.Ubuntu.SSO/ColonSeparatedSSOCredentialsEncoder.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.Ubuntu.SSO/ColonSeparatedSSOCredentialsEncoder.cs	2010-10-05 09:58:35 +0000
@@ -0,0 +1,60 @@
+/* Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+namespace Canonical.Ubuntu.SSO
+{
+    /// <summary>
+    /// Encode implementation that encodes the oauth token using colons as separators.
+    /// </summary>
+    public class ColonSeparatedSSOCredentialsEncoder : ISSOCredentialsEncoder
+    {
+        #region Implementation of ISSOCredentialsEncoder
+
+        /// <summary>
+        /// Encodes oauth credentials so that they can be stored in a keyring.
+        /// </summary>
+        /// <param name="token">The oauth token.</param>
+        /// <param name="tokenSecret">The oauth secret.</param>
+        /// <param name="consumerKey">The oauth consumer key.</param>
+        /// <param name="consumerSecret">The oauth consumer secret.</param>
+        /// <returns>a stirng that represents the oauth token.</returns>
+        public string Encode(string token, string tokenSecret, string consumerKey, string consumerSecret)
+        {
+            return string.Format("{0}:{1}:{2}:{3}", token, tokenSecret, consumerKey, consumerSecret);
+        }
+
+        /// <summary>
+        /// Decodes the oauth credentials from a single string.
+        /// </summary>
+        /// <param name="secret">The secret that was stored in the keyring.</param>
+        /// <param name="token">Out var where the ouath token will be returned.</param>
+        /// <param name="tokenSecret">Out var where the oauth token secret will be returned.</param>
+        /// <param name="consumerKey">Out var where the oauth consumer key will be returned.</param>
+        /// <param name="consumerSecret">Out var where the oauth consumer secret will be returned.</param>
+        public void Decode(string secret, out string token, out string tokenSecret, out string consumerKey, out string consumerSecret)
+        {
+            var data = secret.Split(":".ToCharArray(),4);
+            token = data[0];
+            tokenSecret = data[1];
+            consumerKey = data[2];
+            consumerSecret = data[3];
+        }
+
+        #endregion
+    }
+}

=== modified file 'src/Canonical.Ubuntu.SSO/DPAPIDataProtector.cs'
--- src/Canonical.Ubuntu.SSO/DPAPIDataProtector.cs	2010-10-05 09:58:34 +0000
+++ src/Canonical.Ubuntu.SSO/DPAPIDataProtector.cs	2010-10-05 09:58:35 +0000
@@ -17,7 +17,6 @@
  * 
  * Authors: Manuel de la Peña <[e-mail]>
  */
-
 using System.Security.Cryptography;
 using System.Text;
 using log4net;

=== added file 'src/Canonical.Ubuntu.SSO/IOAuth.cs'
--- src/Canonical.Ubuntu.SSO/IOAuth.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.Ubuntu.SSO/IOAuth.cs	2010-10-05 09:58:35 +0000
@@ -0,0 +1,122 @@
+/* Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using System;
+using System.Collections.Generic;
+using System.Security.Cryptography;
+
+namespace Canonical.Ubuntu.SSO
+{
+    public interface IOAuth
+    {
+        /// <summary>
+        /// Generate the signature base that is used to produce the signature
+        /// </summary>
+        /// <param name="url">The full url that needs to be signed including its non OAuth url parameters</param>
+        /// <param name="consumerKey">The consumer key</param>        
+        /// <param name="token">The token, if available. If not available pass null or an empty string</param>
+        /// <param name="tokenSecret">The token secret, if available. If not available pass null or an empty string</param>
+        /// <param name="httpMethod">The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)</param>
+        /// <param name="nonce"></param>
+        /// <param name="signatureType">The signature type. To use the default values use <see cref="OAuth.SignatureTypes">OAuth.SignatureTypes</see>.</param>
+        /// <param name="timeStamp"></param>
+        /// <param name="normalizedUrl"></param>
+        /// <param name="normalizedRequestParameters"></param>
+        /// <returns>The signature base</returns>
+        string GenerateSignatureBase(Uri url, string consumerKey, string token, string tokenSecret, 
+            string httpMethod, string timeStamp, string nonce, string signatureType, out string normalizedUrl, 
+            out string normalizedRequestParameters);
+
+        /// <summary>
+        /// Generate the signature value based on the given signature base and hash algorithm
+        /// </summary>
+        /// <param name="signatureBase">The signature based as produced by the GenerateSignatureBase method or by any other means</param>
+        /// <param name="hash">The hash algorithm used to perform the hashing. If the hashing algorithm requires initialization or a key it should be set prior to calling this method</param>
+        /// <returns>A base64 string of the hash value</returns>
+        string GenerateSignatureUsingHash(string signatureBase, HashAlgorithm hash);
+
+        /// <summary>
+        /// Generates a signature using the HMAC-SHA1 algorithm
+        /// </summary>		
+        /// <param name="url">The full url that needs to be signed including its non OAuth url parameters</param>
+        /// <param name="consumerKey">The consumer key</param>
+        /// <param name="consumerSecret">The consumer seceret</param>
+        /// <param name="token">The token, if available. If not available pass null or an empty string</param>
+        /// <param name="tokenSecret">The token secret, if available. If not available pass null or an empty string</param>
+        /// <param name="httpMethod">The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)</param>
+        /// <param name="timeStamp"></param>
+        /// <param name="nonce"></param>
+        /// <param name="normalizedUrl"></param>
+        /// <param name="normalizedRequestParameters"></param>
+        /// <returns>A base64 string of the hash value</returns>
+        string GenerateSignature(Uri url, string consumerKey, string consumerSecret, string token, 
+            string tokenSecret, string httpMethod, string timeStamp, string nonce, out string normalizedUrl, 
+            out string normalizedRequestParameters);
+
+        /// <summary>
+        /// Generates a signature using the specified signatureType 
+        /// </summary>		
+        /// <param name="url">The full url that needs to be signed including its non OAuth url parameters</param>
+        /// <param name="consumerKey">The consumer key</param>
+        /// <param name="consumerSecret">The consumer seceret</param>
+        /// <param name="token">The token, if available. If not available pass null or an empty string</param>
+        /// <param name="tokenSecret">The token secret, if available. If not available pass null or an empty string</param>
+        /// <param name="httpMethod">The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)</param>
+        /// <param name="nonce"></param>
+        /// <param name="signatureType">The type of signature to use</param>
+        /// <param name="timeStamp"></param>
+        /// <param name="normalizedUrl"></param>
+        /// <param name="normalizedRequestParameters"></param>
+        /// <returns>A base64 string of the hash value</returns>
+        string GenerateSignature(Uri url, string consumerKey, string consumerSecret, string token, 
+            string tokenSecret, string httpMethod, string timeStamp, string nonce, 
+            OAuth.SignatureTypes signatureType, out string normalizedUrl, out string normalizedRequestParameters);
+
+        /// <summary>
+        /// Returns a key value pair that contains a hedaer that can be used to authenticate a web requet.
+        /// </summary>
+        /// <param name="url">The uri with the web resource.</param>
+        /// <param name="realm">The real that was used for the oauth.</param>
+        /// <param name="consumerKey">The oauth consumer key.</param>
+        /// <param name="consumerSecret">The oauth consumer secret.</param>
+        /// <param name="token">The oauth token.</param>
+        /// <param name="tokenSecret">The aoauth token secret.</param>
+        /// <param name="httpMethod">The http method used for the request.</param>
+        /// <param name="timeStamp">A time stamp.</param>
+        /// <param name="nonce">A once</param>
+        /// <param name="signatureType">Teht ype of signature that will be used.</param>
+        /// <param name="normUrl"></param>
+        /// <param name="normParams"></param>
+        /// <returns>A key value pair where the key is the name of the header and the value is the data of the header.</returns>
+        KeyValuePair<string, string> GenerateHeaderWithSignature(Uri url, string realm, string consumerKey, 
+            string consumerSecret, string token, string tokenSecret, string httpMethod, string timeStamp, 
+            string nonce, OAuth.SignatureTypes signatureType, out string normUrl, out string normParams);
+
+        /// <summary>
+        /// Generate the timestamp for the signature        
+        /// </summary>
+        /// <returns></returns>
+        string GenerateTimeStamp();
+
+        /// <summary>
+        /// Generate a nonce
+        /// </summary>
+        /// <returns></returns>
+        string GenerateNonce();
+    }
+}
\ No newline at end of file

=== added file 'src/Canonical.Ubuntu.SSO/ISSOCredentialsEncoder.cs'
--- src/Canonical.Ubuntu.SSO/ISSOCredentialsEncoder.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.Ubuntu.SSO/ISSOCredentialsEncoder.cs	2010-10-05 09:58:35 +0000
@@ -0,0 +1,46 @@
+/* Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+namespace Canonical.Ubuntu.SSO
+{
+    /// <summary>
+    /// Interface to be implemented by those object that know how to encode a oauth token so that it is saved as a single string.
+    /// </summary>
+    public interface ISSOCredentialsEncoder
+    {
+        /// <summary>
+        /// When implemented will encode oauth credentials so that they can be stored in a keyring.
+        /// </summary>
+        /// <param name="token">The oauth token.</param>
+        /// <param name="tokenSecret">The oauth secret.</param>
+        /// <param name="consumerKey">The oauth consumer key.</param>
+        /// <param name="consumerSecret">The oauth consumer secret.</param>
+        /// <returns>a stirng that represents the oauth token.</returns>
+        string Encode(string token, string tokenSecret, string consumerKey, string consumerSecret);
+
+        /// <summary>
+        /// When implemented decodes the oauth credentials from a single string.
+        /// </summary>
+        /// <param name="secret">The secret that was stored in the keyring.</param>
+        /// <param name="token">Out var where the ouath token will be returned.</param>
+        /// <param name="tokenSecret">Out var where the oauth token secret will be returned.</param>
+        /// <param name="consumerKey">Out var where the oauth consumer key will be returned.</param>
+        /// <param name="consumerSecret">Out var where the oauth consumer secret will be returned.</param>
+        void Decode(string secret, out string token, out string tokenSecret, out string consumerKey, out string consumerSecret);
+    }
+}

=== added file 'src/Canonical.Ubuntu.SSO/JsonSSOCredentialsEncoder.cs'
--- src/Canonical.Ubuntu.SSO/JsonSSOCredentialsEncoder.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.Ubuntu.SSO/JsonSSOCredentialsEncoder.cs	2010-10-05 09:58:35 +0000
@@ -0,0 +1,82 @@
+/* Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using System;
+using Newtonsoft.Json.Linq;
+
+namespace Canonical.Ubuntu.SSO
+{
+    public class JsonSSOCredentialsEncoder : ISSOCredentialsEncoder
+    {
+        #region Implementation of ISSOCredentialsEncoder
+
+        /// <summary>
+        /// When implemented will encode oauth credentials so that they can be stored in a keyring.
+        /// </summary>
+        /// <param name="token">The oauth token.</param>
+        /// <param name="tokenSecret">The oauth secret.</param>
+        /// <param name="consumerKey">The oauth consumer key.</param>
+        /// <param name="consumerSecret">The oauth consumer secret.</param>
+        /// <returns>a stirng that represents the oauth token.</returns>
+        public string Encode(string token, string tokenSecret, string consumerKey, string consumerSecret)
+        {
+            var jobject = new JObject();
+            jobject["consumer_key"] = "";
+            jobject["consumer_secret"] = "";
+            jobject["token"] = "";
+            jobject["token_secret"] = "";
+            return jobject.ToString();
+        }
+
+        /// <summary>
+        /// When implemented decodes the oauth credentials from a single string.
+        /// </summary>
+        /// <param name="secret">The secret that was stored in the keyring.</param>
+        /// <param name="token">Out var where the ouath token will be returned.</param>
+        /// <param name="tokenSecret">Out var where the oauth token secret will be returned.</param>
+        /// <param name="consumerKey">Out var where the oauth consumer key will be returned.</param>
+        /// <param name="consumerSecret">Out var where the oauth consumer secret will be returned.</param>
+        public void Decode(string secret, out string token, out string tokenSecret, out string consumerKey, out string consumerSecret)
+        {
+            var credentials = JObject.Parse(secret);
+            try
+            {
+                consumerKey = (string)credentials["consumer_key"];
+                consumerSecret = (string)credentials["consumer_secret"];
+                token = (string)credentials["token"];
+                tokenSecret = (string)credentials["token_secret"];
+
+            }
+            catch (InvalidCastException e)
+            {
+                // could happen when the json is not formatted as we expected.
+                throw new SSOLoginException("Error when retrieving credentials.", e);
+            }
+            if (string.IsNullOrEmpty(consumerKey)
+               || string.IsNullOrEmpty(consumerSecret)
+               || string.IsNullOrEmpty(token)
+               || string.IsNullOrEmpty(tokenSecret))
+            {
+                // none of them can be null or empty.
+                throw new SSOException("Credentials could not be parsed.");
+            }
+        }
+
+        #endregion
+    }
+}

=== added file 'src/Canonical.Ubuntu.SSO/OAuth.cs'
--- src/Canonical.Ubuntu.SSO/OAuth.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.Ubuntu.SSO/OAuth.cs	2010-10-05 09:58:35 +0000
@@ -0,0 +1,391 @@
+using System;
+using System.Security.Cryptography;
+using System.Collections.Generic;
+using System.Text;
+using System.Web;
+
+namespace Canonical.Ubuntu.SSO
+{
+    public class OAuth : IOAuth
+    {
+
+        /// <summary>
+        /// Provides a predefined set of algorithms that are supported officially by the protocol
+        /// </summary>
+        public enum SignatureTypes
+        {
+            HMACSHA1,
+            PLAINTEXT,
+            RSASHA1
+        }
+
+        /// <summary>
+        /// Provides an internal structure to sort the query parameter
+        /// </summary>
+        protected class QueryParameter
+        {
+            private readonly string _name = null;
+            private readonly string _value = null;
+
+            public QueryParameter(string name, string value)
+            {
+                _name = name;
+                _value = value;
+            }
+
+            public string Name
+            {
+                get { return _name; }
+            }
+
+            public string Value
+            {
+                get { return _value; }
+            }
+        }
+
+        /// <summary>
+        /// Comparer class used to perform the sorting of the query parameters
+        /// </summary>
+        protected class QueryParameterComparer : IComparer<QueryParameter>
+        {
+
+            #region IComparer<QueryParameter> Members
+
+            public int Compare(QueryParameter x, QueryParameter y)
+            {
+                return x.Name == y.Name ? string.Compare(x.Value, y.Value) 
+                    : string.Compare(x.Name, y.Name);
+            }
+
+            #endregion
+        }
+
+        protected const string OAuthVersion = "1.0";
+        protected const string OAuthParameterPrefix = "oauth_";
+
+        //
+        // List of know and used oauth parameters' names
+        //        
+        protected const string OAuthConsumerKeyKey = "oauth_consumer_key";
+        protected const string OAuthCallbackKey = "oauth_callback";
+        protected const string OAuthVersionKey = "oauth_version";
+        protected const string OAuthSignatureMethodKey = "oauth_signature_method";
+        protected const string OAuthSignatureKey = "oauth_signature";
+        protected const string OAuthTimestampKey = "oauth_timestamp";
+        protected const string OAuthNonceKey = "oauth_nonce";
+        protected const string OAuthTokenKey = "oauth_token";
+        protected const string OAuthTokenSecretKey = "oauth_token_secret";
+
+        protected const string HMACSHA1SignatureType = "HMAC-SHA1";
+        protected const string PlainTextSignatureType = "PLAINTEXT";
+        protected const string RSASHA1SignatureType = "RSA-SHA1";
+
+        protected Random Random = new Random();
+
+        protected string UnreservedChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.~";
+
+        /// <summary>
+        /// Helper function to compute a hash value
+        /// </summary>
+        /// <param name="hashAlgorithm">The hashing algoirhtm used. If that algorithm needs some initialization, like HMAC and its derivatives, they should be initialized prior to passing it to this function</param>
+        /// <param name="data">The data to hash</param>
+        /// <returns>a Base64 string of the hash value</returns>
+        private static string ComputeHash(HashAlgorithm hashAlgorithm, string data)
+        {
+            if (hashAlgorithm == null)
+            {
+                throw new ArgumentNullException("hashAlgorithm");
+            }
+
+            if (string.IsNullOrEmpty(data))
+            {
+                throw new ArgumentNullException("data");
+            }
+
+            var dataBuffer = Encoding.ASCII.GetBytes(data);
+            var hashBytes = hashAlgorithm.ComputeHash(dataBuffer);
+
+            return Convert.ToBase64String(hashBytes);
+        }
+
+        /// <summary>
+        /// Internal function to cut out all non oauth query string parameters (all parameters not begining with "oauth_")
+        /// </summary>
+        /// <param name="parameters">The query string part of the Url</param>
+        /// <returns>A list of QueryParameter each containing the parameter name and value</returns>
+        private static List<QueryParameter> GetQueryParameters(string parameters)
+        {
+            if (parameters.StartsWith("?"))
+            {
+                parameters = parameters.Remove(0, 1);
+            }
+
+            var result = new List<QueryParameter>();
+
+            if (!string.IsNullOrEmpty(parameters))
+            {
+                string[] p = parameters.Split('&');
+                foreach (string s in p)
+                {
+                    if (!string.IsNullOrEmpty(s) && !s.StartsWith(OAuthParameterPrefix))
+                    {
+                        if (s.IndexOf('=') > -1)
+                        {
+                            string[] temp = s.Split('=');
+                            result.Add(new QueryParameter(temp[0], temp[1]));
+                        }
+                        else
+                        {
+                            result.Add(new QueryParameter(s, string.Empty));
+                        }
+                    }
+                }
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// This is a different Url Encode implementation since the default .NET one outputs the percent encoding in lower case.
+        /// While this is not a problem with the percent encoding spec, it is used in upper case throughout OAuth
+        /// </summary>
+        /// <param name="value">The value to Url encode</param>
+        /// <returns>Returns a Url encoded string</returns>
+        protected string UrlEncode(string value)
+        {
+            var result = new StringBuilder();
+
+            foreach (char symbol in value)
+            {
+                if (UnreservedChars.IndexOf(symbol) != -1)
+                {
+                    result.Append(symbol);
+                }
+                else
+                {
+                    result.Append('%' + String.Format("{0:X2}", (int)symbol));
+                }
+            }
+
+            return result.ToString();
+        }
+
+        /// <summary>
+        /// Normalizes the request parameters according to the spec
+        /// </summary>
+        /// <param name="parameters">The list of parameters already sorted</param>
+        /// <returns>a string representing the normalized parameters</returns>
+        protected string NormalizeRequestParameters(IList<QueryParameter> parameters)
+        {
+            var sb = new StringBuilder();
+            QueryParameter p;
+            for (var i = 0; i < parameters.Count; i++)
+            {
+                p = parameters[i];
+                sb.AppendFormat("{0}={1}", p.Name, p.Value);
+
+                if (i < parameters.Count - 1)
+                {
+                    sb.Append("&");
+                }
+            }
+
+            return sb.ToString();
+        }
+
+        /// <summary>
+        /// Generate the signature base that is used to produce the signature
+        /// </summary>
+        /// <param name="url">The full url that needs to be signed including its non OAuth url parameters</param>
+        /// <param name="consumerKey">The consumer key</param>        
+        /// <param name="token">The token, if available. If not available pass null or an empty string</param>
+        /// <param name="tokenSecret">The token secret, if available. If not available pass null or an empty string</param>
+        /// <param name="httpMethod">The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)</param>
+        /// <param name="nonce"></param>
+        /// <param name="signatureType">The signature type. To use the default values use <see cref="OAuth.SignatureTypes">OAuth.SignatureTypes</see>.</param>
+        /// <param name="timeStamp"></param>
+        /// <param name="normalizedUrl"></param>
+        /// <param name="normalizedRequestParameters"></param>
+        /// <returns>The signature base</returns>
+        public string GenerateSignatureBase(Uri url, string consumerKey, string token, string tokenSecret, string httpMethod, string timeStamp, string nonce, string signatureType, out string normalizedUrl, out string normalizedRequestParameters)
+        {
+            if (token == null)
+            {
+                token = string.Empty;
+            }
+
+            if (tokenSecret == null)
+            {
+                tokenSecret = string.Empty;
+            }
+
+            if (string.IsNullOrEmpty(consumerKey))
+            {
+                throw new ArgumentNullException("consumerKey");
+            }
+
+            if (string.IsNullOrEmpty(httpMethod))
+            {
+                throw new ArgumentNullException("httpMethod");
+            }
+
+            if (string.IsNullOrEmpty(signatureType))
+            {
+                throw new ArgumentNullException("signatureType");
+            }
+
+            List<QueryParameter> parameters = GetQueryParameters(url.Query);
+            parameters.Add(new QueryParameter(OAuthVersionKey, OAuthVersion));
+            parameters.Add(new QueryParameter(OAuthNonceKey, nonce));
+            parameters.Add(new QueryParameter(OAuthTimestampKey, timeStamp));
+            parameters.Add(new QueryParameter(OAuthSignatureMethodKey, signatureType));
+            parameters.Add(new QueryParameter(OAuthConsumerKeyKey, consumerKey));
+
+            if (!string.IsNullOrEmpty(token))
+            {
+                parameters.Add(new QueryParameter(OAuthTokenKey, token));
+            }
+
+            parameters.Sort(new QueryParameterComparer());
+
+            normalizedUrl = string.Format("{0}://{1}", url.Scheme, url.Host);
+            if (!((url.Scheme == "http" && url.Port == 80) || (url.Scheme == "https" && url.Port == 443)))
+            {
+                normalizedUrl += ":" + url.Port;
+            }
+            normalizedUrl += url.AbsolutePath;
+            normalizedRequestParameters = NormalizeRequestParameters(parameters);
+
+            var signatureBase = new StringBuilder();
+            signatureBase.AppendFormat("{0}&", httpMethod.ToUpper());
+            signatureBase.AppendFormat("{0}&", UrlEncode(normalizedUrl));
+            signatureBase.AppendFormat("{0}", UrlEncode(normalizedRequestParameters));
+
+            return signatureBase.ToString();
+        }
+
+        /// <summary>
+        /// Generate the signature value based on the given signature base and hash algorithm
+        /// </summary>
+        /// <param name="signatureBase">The signature based as produced by the GenerateSignatureBase method or by any other means</param>
+        /// <param name="hash">The hash algorithm used to perform the hashing. If the hashing algorithm requires initialization or a key it should be set prior to calling this method</param>
+        /// <returns>A base64 string of the hash value</returns>
+        public string GenerateSignatureUsingHash(string signatureBase, HashAlgorithm hash)
+        {
+            return ComputeHash(hash, signatureBase);
+        }
+
+        /// <summary>
+        /// Generates a signature using the HMAC-SHA1 algorithm
+        /// </summary>		
+        /// <param name="url">The full url that needs to be signed including its non OAuth url parameters</param>
+        /// <param name="consumerKey">The consumer key</param>
+        /// <param name="consumerSecret">The consumer seceret</param>
+        /// <param name="token">The token, if available. If not available pass null or an empty string</param>
+        /// <param name="tokenSecret">The token secret, if available. If not available pass null or an empty string</param>
+        /// <param name="httpMethod">The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)</param>
+        /// <param name="timeStamp"></param>
+        /// <param name="nonce"></param>
+        /// <param name="normalizedUrl"></param>
+        /// <param name="normalizedRequestParameters"></param>
+        /// <returns>A base64 string of the hash value</returns>
+        public string GenerateSignature(Uri url, string consumerKey, string consumerSecret, string token, string tokenSecret, string httpMethod, string timeStamp, string nonce, out string normalizedUrl, out string normalizedRequestParameters)
+        {
+            return GenerateSignature(url, consumerKey, consumerSecret, token, tokenSecret, httpMethod, timeStamp, nonce, SignatureTypes.HMACSHA1, out normalizedUrl, out normalizedRequestParameters);
+        }
+
+        /// <summary>
+        /// Generates a signature using the specified signatureType 
+        /// </summary>		
+        /// <param name="url">The full url that needs to be signed including its non OAuth url parameters</param>
+        /// <param name="consumerKey">The consumer key</param>
+        /// <param name="consumerSecret">The consumer seceret</param>
+        /// <param name="token">The token, if available. If not available pass null or an empty string</param>
+        /// <param name="tokenSecret">The token secret, if available. If not available pass null or an empty string</param>
+        /// <param name="httpMethod">The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)</param>
+        /// <param name="nonce"></param>
+        /// <param name="signatureType">The type of signature to use</param>
+        /// <param name="timeStamp"></param>
+        /// <param name="normalizedUrl"></param>
+        /// <param name="normalizedRequestParameters"></param>
+        /// <returns>A base64 string of the hash value</returns>
+        public string GenerateSignature(Uri url, string consumerKey, string consumerSecret, string token, string tokenSecret, string httpMethod, string timeStamp, string nonce, SignatureTypes signatureType, out string normalizedUrl, out string normalizedRequestParameters)
+        {
+            normalizedUrl = null;
+            normalizedRequestParameters = null;
+
+            switch (signatureType)
+            {
+                case SignatureTypes.PLAINTEXT:
+                    return HttpUtility.UrlEncode(string.Format("{0}&{1}", consumerSecret, tokenSecret));
+                case SignatureTypes.HMACSHA1:
+                    var signatureBase = GenerateSignatureBase(url, consumerKey, token, tokenSecret, httpMethod, timeStamp, nonce, HMACSHA1SignatureType, out normalizedUrl, out normalizedRequestParameters);
+
+                    var hmacsha1 = new HMACSHA1();
+                    hmacsha1.Key = Encoding.ASCII.GetBytes(string.Format("{0}&{1}", UrlEncode(consumerSecret), string.IsNullOrEmpty(tokenSecret) ? "" : UrlEncode(tokenSecret)));
+
+                    return GenerateSignatureUsingHash(signatureBase, hmacsha1);
+                case SignatureTypes.RSASHA1:
+                    throw new NotImplementedException();
+                default:
+                    throw new ArgumentException("Unknown signature type", "signatureType");
+            }
+        }
+
+        /// <summary>
+        /// Returns a key value pair that contains a hedaer that can be used to authenticate a web requet.
+        /// </summary>
+        /// <param name="url">The uri with the web resource.</param>
+        /// <param name="realm">The real that was used for the oauth.</param>
+        /// <param name="consumerKey">The oauth consumer key.</param>
+        /// <param name="consumerSecret">The oauth consumer secret.</param>
+        /// <param name="token">The oauth token.</param>
+        /// <param name="tokenSecret">The aoauth token secret.</param>
+        /// <param name="httpMethod">The http method used for the request.</param>
+        /// <param name="timeStamp">A time stamp.</param>
+        /// <param name="nonce">A once</param>
+        /// <param name="signatureType">Teht ype of signature that will be used.</param>
+        /// <returns>A key value pair where the key is the name of the header and the value is the data of the header.</returns>
+        public KeyValuePair<string, string> GenerateHeaderWithSignature(Uri url, string realm, string consumerKey, 
+            string consumerSecret, string token, string tokenSecret, string httpMethod, string timeStamp, 
+            string nonce, SignatureTypes signatureType, out string normUrl, out string normParams)
+        {
+            var signature = GenerateSignature(url,
+                consumerKey, consumerSecret, token, tokenSecret,
+                httpMethod, timeStamp, nonce, SignatureTypes.HMACSHA1,
+                out normUrl, out normParams);
+
+            // Construct the OAuth header
+            var headerData = normParams + "&" + HttpUtility.UrlEncode("oauth_signature") + "=" + HttpUtility.UrlEncode(signature);
+            headerData = headerData.Replace("&", @""",");
+            headerData = headerData.Replace("=", @"=""");
+            headerData += @"""";
+            headerData = ((string.IsNullOrEmpty(realm)) ? "OAuth realm=\"\"," : 
+                string.Format("OAuth realm=\"{0}\",", realm)) + headerData;
+            return new KeyValuePair<string, string>("Authorization", headerData);
+        }
+
+        /// <summary>
+        /// Generate the timestamp for the signature        
+        /// </summary>
+        /// <returns></returns>
+        public virtual string GenerateTimeStamp()
+        {
+            // Default implementation of UNIX time of the current UTC time
+            TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
+            return Convert.ToInt64(ts.TotalSeconds).ToString();
+        }
+
+        /// <summary>
+        /// Generate a nonce
+        /// </summary>
+        /// <returns></returns>
+        public virtual string GenerateNonce()
+        {
+            // Just a simple implementation of a random number between 123400 and 9999999
+            return Random.Next(123400, 9999999).ToString();
+        }
+
+    }
+}
\ No newline at end of file

=== removed file 'src/Canonical.Ubuntu.SSO/OAuthBase.cs'
--- src/Canonical.Ubuntu.SSO/OAuthBase.cs	2010-10-05 09:58:34 +0000
+++ src/Canonical.Ubuntu.SSO/OAuthBase.cs	1970-01-01 00:00:00 +0000
@@ -1,358 +0,0 @@
-using System;
-using System.Security.Cryptography;
-using System.Collections.Generic;
-using System.Text;
-using System.Web;
-
-namespace OAuth
-{
-    public class OAuthBase
-    {
-
-        /// <summary>
-        /// Provides a predefined set of algorithms that are supported officially by the protocol
-        /// </summary>
-        public enum SignatureTypes
-        {
-            HMACSHA1,
-            PLAINTEXT,
-            RSASHA1
-        }
-
-        /// <summary>
-        /// Provides an internal structure to sort the query parameter
-        /// </summary>
-        protected class QueryParameter
-        {
-            private readonly string _name = null;
-            private readonly string _value = null;
-
-            public QueryParameter(string name, string value)
-            {
-                _name = name;
-                _value = value;
-            }
-
-            public string Name
-            {
-                get { return _name; }
-            }
-
-            public string Value
-            {
-                get { return _value; }
-            }
-        }
-
-        /// <summary>
-        /// Comparer class used to perform the sorting of the query parameters
-        /// </summary>
-        protected class QueryParameterComparer : IComparer<QueryParameter>
-        {
-
-            #region IComparer<QueryParameter> Members
-
-            public int Compare(QueryParameter x, QueryParameter y)
-            {
-                return x.Name == y.Name ? string.Compare(x.Value, y.Value) 
-                    : string.Compare(x.Name, y.Name);
-            }
-
-            #endregion
-        }
-
-        protected const string OAuthVersion = "1.0";
-        protected const string OAuthParameterPrefix = "oauth_";
-
-        //
-        // List of know and used oauth parameters' names
-        //        
-        protected const string OAuthConsumerKeyKey = "oauth_consumer_key";
-        protected const string OAuthCallbackKey = "oauth_callback";
-        protected const string OAuthVersionKey = "oauth_version";
-        protected const string OAuthSignatureMethodKey = "oauth_signature_method";
-        protected const string OAuthSignatureKey = "oauth_signature";
-        protected const string OAuthTimestampKey = "oauth_timestamp";
-        protected const string OAuthNonceKey = "oauth_nonce";
-        protected const string OAuthTokenKey = "oauth_token";
-        protected const string OAuthTokenSecretKey = "oauth_token_secret";
-
-        protected const string HMACSHA1SignatureType = "HMAC-SHA1";
-        protected const string PlainTextSignatureType = "PLAINTEXT";
-        protected const string RSASHA1SignatureType = "RSA-SHA1";
-
-        protected Random Random = new Random();
-
-        protected string UnreservedChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_.~";
-
-        /// <summary>
-        /// Helper function to compute a hash value
-        /// </summary>
-        /// <param name="hashAlgorithm">The hashing algoirhtm used. If that algorithm needs some initialization, like HMAC and its derivatives, they should be initialized prior to passing it to this function</param>
-        /// <param name="data">The data to hash</param>
-        /// <returns>a Base64 string of the hash value</returns>
-        private static string ComputeHash(HashAlgorithm hashAlgorithm, string data)
-        {
-            if (hashAlgorithm == null)
-            {
-                throw new ArgumentNullException("hashAlgorithm");
-            }
-
-            if (string.IsNullOrEmpty(data))
-            {
-                throw new ArgumentNullException("data");
-            }
-
-            var dataBuffer = Encoding.ASCII.GetBytes(data);
-            var hashBytes = hashAlgorithm.ComputeHash(dataBuffer);
-
-            return Convert.ToBase64String(hashBytes);
-        }
-
-        /// <summary>
-        /// Internal function to cut out all non oauth query string parameters (all parameters not begining with "oauth_")
-        /// </summary>
-        /// <param name="parameters">The query string part of the Url</param>
-        /// <returns>A list of QueryParameter each containing the parameter name and value</returns>
-        private static List<QueryParameter> GetQueryParameters(string parameters)
-        {
-            if (parameters.StartsWith("?"))
-            {
-                parameters = parameters.Remove(0, 1);
-            }
-
-            var result = new List<QueryParameter>();
-
-            if (!string.IsNullOrEmpty(parameters))
-            {
-                string[] p = parameters.Split('&');
-                foreach (string s in p)
-                {
-                    if (!string.IsNullOrEmpty(s) && !s.StartsWith(OAuthParameterPrefix))
-                    {
-                        if (s.IndexOf('=') > -1)
-                        {
-                            string[] temp = s.Split('=');
-                            result.Add(new QueryParameter(temp[0], temp[1]));
-                        }
-                        else
-                        {
-                            result.Add(new QueryParameter(s, string.Empty));
-                        }
-                    }
-                }
-            }
-
-            return result;
-        }
-
-        /// <summary>
-        /// This is a different Url Encode implementation since the default .NET one outputs the percent encoding in lower case.
-        /// While this is not a problem with the percent encoding spec, it is used in upper case throughout OAuth
-        /// </summary>
-        /// <param name="value">The value to Url encode</param>
-        /// <returns>Returns a Url encoded string</returns>
-        protected string UrlEncode(string value)
-        {
-            var result = new StringBuilder();
-
-            foreach (char symbol in value)
-            {
-                if (UnreservedChars.IndexOf(symbol) != -1)
-                {
-                    result.Append(symbol);
-                }
-                else
-                {
-                    result.Append('%' + String.Format("{0:X2}", (int)symbol));
-                }
-            }
-
-            return result.ToString();
-        }
-
-        /// <summary>
-        /// Normalizes the request parameters according to the spec
-        /// </summary>
-        /// <param name="parameters">The list of parameters already sorted</param>
-        /// <returns>a string representing the normalized parameters</returns>
-        protected string NormalizeRequestParameters(IList<QueryParameter> parameters)
-        {
-            var sb = new StringBuilder();
-            QueryParameter p;
-            for (var i = 0; i < parameters.Count; i++)
-            {
-                p = parameters[i];
-                sb.AppendFormat("{0}={1}", p.Name, p.Value);
-
-                if (i < parameters.Count - 1)
-                {
-                    sb.Append("&");
-                }
-            }
-
-            return sb.ToString();
-        }
-
-        /// <summary>
-        /// Generate the signature base that is used to produce the signature
-        /// </summary>
-        /// <param name="url">The full url that needs to be signed including its non OAuth url parameters</param>
-        /// <param name="consumerKey">The consumer key</param>        
-        /// <param name="token">The token, if available. If not available pass null or an empty string</param>
-        /// <param name="tokenSecret">The token secret, if available. If not available pass null or an empty string</param>
-        /// <param name="httpMethod">The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)</param>
-        /// <param name="nonce"></param>
-        /// <param name="signatureType">The signature type. To use the default values use <see cref="OAuthBase.SignatureTypes">OAuthBase.SignatureTypes</see>.</param>
-        /// <param name="timeStamp"></param>
-        /// <param name="normalizedUrl"></param>
-        /// <param name="normalizedRequestParameters"></param>
-        /// <returns>The signature base</returns>
-        public string GenerateSignatureBase(Uri url, string consumerKey, string token, string tokenSecret, string httpMethod, string timeStamp, string nonce, string signatureType, out string normalizedUrl, out string normalizedRequestParameters)
-        {
-            if (token == null)
-            {
-                token = string.Empty;
-            }
-
-            if (tokenSecret == null)
-            {
-                tokenSecret = string.Empty;
-            }
-
-            if (string.IsNullOrEmpty(consumerKey))
-            {
-                throw new ArgumentNullException("consumerKey");
-            }
-
-            if (string.IsNullOrEmpty(httpMethod))
-            {
-                throw new ArgumentNullException("httpMethod");
-            }
-
-            if (string.IsNullOrEmpty(signatureType))
-            {
-                throw new ArgumentNullException("signatureType");
-            }
-
-            List<QueryParameter> parameters = GetQueryParameters(url.Query);
-            parameters.Add(new QueryParameter(OAuthVersionKey, OAuthVersion));
-            parameters.Add(new QueryParameter(OAuthNonceKey, nonce));
-            parameters.Add(new QueryParameter(OAuthTimestampKey, timeStamp));
-            parameters.Add(new QueryParameter(OAuthSignatureMethodKey, signatureType));
-            parameters.Add(new QueryParameter(OAuthConsumerKeyKey, consumerKey));
-
-            if (!string.IsNullOrEmpty(token))
-            {
-                parameters.Add(new QueryParameter(OAuthTokenKey, token));
-            }
-
-            parameters.Sort(new QueryParameterComparer());
-
-            normalizedUrl = string.Format("{0}://{1}", url.Scheme, url.Host);
-            if (!((url.Scheme == "http" && url.Port == 80) || (url.Scheme == "https" && url.Port == 443)))
-            {
-                normalizedUrl += ":" + url.Port;
-            }
-            normalizedUrl += url.AbsolutePath;
-            normalizedRequestParameters = NormalizeRequestParameters(parameters);
-
-            var signatureBase = new StringBuilder();
-            signatureBase.AppendFormat("{0}&", httpMethod.ToUpper());
-            signatureBase.AppendFormat("{0}&", UrlEncode(normalizedUrl));
-            signatureBase.AppendFormat("{0}", UrlEncode(normalizedRequestParameters));
-
-            return signatureBase.ToString();
-        }
-
-        /// <summary>
-        /// Generate the signature value based on the given signature base and hash algorithm
-        /// </summary>
-        /// <param name="signatureBase">The signature based as produced by the GenerateSignatureBase method or by any other means</param>
-        /// <param name="hash">The hash algorithm used to perform the hashing. If the hashing algorithm requires initialization or a key it should be set prior to calling this method</param>
-        /// <returns>A base64 string of the hash value</returns>
-        public string GenerateSignatureUsingHash(string signatureBase, HashAlgorithm hash)
-        {
-            return ComputeHash(hash, signatureBase);
-        }
-
-        /// <summary>
-        /// Generates a signature using the HMAC-SHA1 algorithm
-        /// </summary>		
-        /// <param name="url">The full url that needs to be signed including its non OAuth url parameters</param>
-        /// <param name="consumerKey">The consumer key</param>
-        /// <param name="consumerSecret">The consumer seceret</param>
-        /// <param name="token">The token, if available. If not available pass null or an empty string</param>
-        /// <param name="tokenSecret">The token secret, if available. If not available pass null or an empty string</param>
-        /// <param name="httpMethod">The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)</param>
-        /// <param name="timeStamp"></param>
-        /// <param name="nonce"></param>
-        /// <param name="normalizedUrl"></param>
-        /// <param name="normalizedRequestParameters"></param>
-        /// <returns>A base64 string of the hash value</returns>
-        public string GenerateSignature(Uri url, string consumerKey, string consumerSecret, string token, string tokenSecret, string httpMethod, string timeStamp, string nonce, out string normalizedUrl, out string normalizedRequestParameters)
-        {
-            return GenerateSignature(url, consumerKey, consumerSecret, token, tokenSecret, httpMethod, timeStamp, nonce, SignatureTypes.HMACSHA1, out normalizedUrl, out normalizedRequestParameters);
-        }
-
-        /// <summary>
-        /// Generates a signature using the specified signatureType 
-        /// </summary>		
-        /// <param name="url">The full url that needs to be signed including its non OAuth url parameters</param>
-        /// <param name="consumerKey">The consumer key</param>
-        /// <param name="consumerSecret">The consumer seceret</param>
-        /// <param name="token">The token, if available. If not available pass null or an empty string</param>
-        /// <param name="tokenSecret">The token secret, if available. If not available pass null or an empty string</param>
-        /// <param name="httpMethod">The http method used. Must be a valid HTTP method verb (POST,GET,PUT, etc)</param>
-        /// <param name="nonce"></param>
-        /// <param name="signatureType">The type of signature to use</param>
-        /// <param name="timeStamp"></param>
-        /// <param name="normalizedUrl"></param>
-        /// <param name="normalizedRequestParameters"></param>
-        /// <returns>A base64 string of the hash value</returns>
-        public string GenerateSignature(Uri url, string consumerKey, string consumerSecret, string token, string tokenSecret, string httpMethod, string timeStamp, string nonce, SignatureTypes signatureType, out string normalizedUrl, out string normalizedRequestParameters)
-        {
-            normalizedUrl = null;
-            normalizedRequestParameters = null;
-
-            switch (signatureType)
-            {
-                case SignatureTypes.PLAINTEXT:
-                    return HttpUtility.UrlEncode(string.Format("{0}&{1}", consumerSecret, tokenSecret));
-                case SignatureTypes.HMACSHA1:
-                    var signatureBase = GenerateSignatureBase(url, consumerKey, token, tokenSecret, httpMethod, timeStamp, nonce, HMACSHA1SignatureType, out normalizedUrl, out normalizedRequestParameters);
-
-                    var hmacsha1 = new HMACSHA1();
-                    hmacsha1.Key = Encoding.ASCII.GetBytes(string.Format("{0}&{1}", UrlEncode(consumerSecret), string.IsNullOrEmpty(tokenSecret) ? "" : UrlEncode(tokenSecret)));
-
-                    return GenerateSignatureUsingHash(signatureBase, hmacsha1);
-                case SignatureTypes.RSASHA1:
-                    throw new NotImplementedException();
-                default:
-                    throw new ArgumentException("Unknown signature type", "signatureType");
-            }
-        }
-
-        /// <summary>
-        /// Generate the timestamp for the signature        
-        /// </summary>
-        /// <returns></returns>
-        public virtual string GenerateTimeStamp()
-        {
-            // Default implementation of UNIX time of the current UTC time
-            TimeSpan ts = DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0);
-            return Convert.ToInt64(ts.TotalSeconds).ToString();
-        }
-
-        /// <summary>
-        /// Generate a nonce
-        /// </summary>
-        /// <returns></returns>
-        public virtual string GenerateNonce()
-        {
-            // Just a simple implementation of a random number between 123400 and 9999999
-            return Random.Next(123400, 9999999).ToString();
-        }
-
-    }
-}
\ No newline at end of file

=== added file 'src/Canonical.Ubuntu.SSO/SSOException.cs'
--- src/Canonical.Ubuntu.SSO/SSOException.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.Ubuntu.SSO/SSOException.cs	2010-10-05 09:58:35 +0000
@@ -0,0 +1,57 @@
+/* Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using System;
+
+namespace Canonical.Ubuntu.SSO
+{
+    /// <summary>
+    /// Root exception class for all those SSO problems.
+    /// </summary>
+    public class SSOException : Exception
+    {
+        /// <summary>
+        /// Creates a new instance of the class with no message or inner exception.
+        /// </summary>
+        public SSOException()
+        {
+
+        }
+
+        /// <summary>
+        /// Creates a new instance of the class with the given message.
+        /// </summary>
+        /// <param name="message">The message to be carried by the exception.</param>
+        public SSOException(string message)
+            : base(message)
+        {
+
+        }
+
+        /// <summary>
+        /// Creates a new instance of the class with the given message and inner exception.
+        /// </summary>
+        /// <param name="message">The message to be carried by the exception.</param>
+        /// <param name="e">The inner exception.</param>
+        public SSOException(string message, Exception e)
+            : base(message, e)
+        {
+
+        }
+    }
+}

=== added file 'src/Canonical.Ubuntu.SSO/SSOLoginException.cs'
--- src/Canonical.Ubuntu.SSO/SSOLoginException.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.Ubuntu.SSO/SSOLoginException.cs	2010-10-05 09:58:35 +0000
@@ -0,0 +1,57 @@
+/* Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using System;
+
+namespace Canonical.Ubuntu.SSO
+{
+    /// <summary>
+    /// Exception thrown when there are errors during a login.
+    /// </summary>
+    public class SSOLoginException : SSOException
+    {
+        /// <summary>
+        /// Creates a new instance of the class with no message or inner exception.
+        /// </summary>
+        public SSOLoginException()
+        {
+
+        }
+
+        /// <summary>
+        /// Creates a new instance of the class with the given message.
+        /// </summary>
+        /// <param name="message">The message to be carried by the exception.</param>
+        public SSOLoginException(string message)
+            : base(message)
+        {
+
+        }
+
+        /// <summary>
+        /// Creates a new instance of the class with the given message and inner exception.
+        /// </summary>
+        /// <param name="message">The message to be carried by the exception.</param>
+        /// <param name="e">The inner exception.</param>
+        public SSOLoginException(string message, Exception e)
+            : base(message, e)
+        {
+
+        }
+    }
+}

=== modified file 'src/Canonical.Ubuntu.SSO/SSOLoginProcessor.cs'
--- src/Canonical.Ubuntu.SSO/SSOLoginProcessor.cs	2010-09-20 11:21:19 +0000
+++ src/Canonical.Ubuntu.SSO/SSOLoginProcessor.cs	2010-10-05 09:58:35 +0000
@@ -18,6 +18,10 @@
  * Authors: Manuel de la Peña <[e-mail]>
  */
 using System;
+using System.Net;
+using Canonical.Ubuntu.SSO.Service;
+using Canonical.UbuntuOne.Common.Net;
+using Newtonsoft.Json.Linq;
 
 namespace Canonical.Ubuntu.SSO
 {
@@ -27,6 +31,126 @@
     /// </summary>
     public class SSOLoginProcessor : ISSOLoginProcessor
     {
+        private const string ApplicationTokenName = "Ubuntu One @ {0} (Windows)";
+        internal const string KeyringName = "Default";
+        internal const string ApplicationName = "UbuntuOne";
+
+        #region DI properties
+
+        /// <summary>
+        /// Gets and sets the Authentications rest service that is used to authenticate the user.
+        /// </summary>
+        public Authentications Authentications { get; set; }
+
+        /// <summary>
+        /// Gets and sets the keyring that will be used to store the secrets.
+        /// </summary>
+        public IKeyring Keyring { get; set; }
+
+        /// <summary>
+        /// Gets and sets the credential encoder that will be used to encode the oauth credentials 
+        /// before they are saved in the keyring.
+        /// </summary>
+        public ISSOCredentialsEncoder SSOCredentialsEncoder { get; set; }
+
+        /// <summary>
+        /// Gets and sets the object that will take care of the oauth operations.
+        /// </summary>
+        public IOAuth OAuth { get; set; }
+
+        public IHttpWebRequestFactory HttpWebRequestFactory { get; set; }
+
+        #endregion
+
+        #region Helper methods}
+
+        /// <summary>
+        /// Creates an oauth request that can access a protected web resource.
+        /// </summary>
+        /// <param name="uri">The uri where the resource is found.</param>
+        /// <param name="httpMethod">The request berb to be used.</param>
+        /// <param name="consumerKey">Consumer key from oauth.</param>
+        /// <param name="consumerSecret">Consumer secret from oauth.</param>
+        /// <param name="token">Token from oauth.</param>
+        /// <param name="tokenSecret">Token secret from oauth.</param>
+        /// <returns>A webrequest that can be used to access the resource.</returns>
+        public IHttpWebRequest MakeRequest(string uri, string httpMethod, string consumerKey, string consumerSecret, string token, string tokenSecret)
+        {
+            // Form the full REST request url
+            var url = new Uri(uri);
+            string normUrl;
+            string normParams;
+
+            // get oauth header
+            var authHeader = OAuth.GenerateHeaderWithSignature(url, string.Empty, consumerKey, consumerSecret,
+                token, tokenSecret, httpMethod, OAuth.GenerateTimeStamp(), OAuth.GenerateNonce(), SSO.OAuth.SignatureTypes.HMACSHA1,
+                out normUrl, out normParams);
+
+            var request = HttpWebRequestFactory.Create(url);
+            request.Headers.Add(authHeader.Key, authHeader.Value);
+            return request;
+        }
+
+        /// <summary>
+        /// Pings the Ubuntu One server so that the SSO tokens are added to them and they know how to identify the user.
+        /// </summary>
+        /// <param name="email">The email used by the user to register to u1.</param>
+        /// <param name="consumerKey">The oauth consumer key.</param>
+        /// <param name="consumerSecret">The oauth consumer secret.</param>
+        /// <param name="token">The oauth token.</param>
+        /// <param name="tokenSecret">The oauth secret.</param>
+        private void PingUbuntuOneServer(string email, string consumerKey, string consumerSecret, string token, string tokenSecret)
+        {
+            // ping the service to make it download the tokens
+            var pingRequest = MakeRequest(Constants.PingUrl + email, "GET", consumerKey, consumerSecret,
+                                          token, tokenSecret);
+            try
+            {
+                pingRequest.GetResponse();
+            }
+            catch (Exception e)
+            {
+                throw new SSOException("Credentials could not be sent to Ubuntu One servers", e);
+            }
+        }
+
+        /// <summary>
+        /// Allows to parse the json that is returned by the rest service to extract that credentials.
+        /// </summary>
+        /// <param name="credentialsJson">Json that contains the credentials info.</param>
+        /// <param name="consumerKey">Out var where the oauth consumer key will be returned.</param>
+        /// <param name="consumerSecret">Out var where the oauth consumer secret will be returned.</param>
+        /// <param name="token">Out var where the oauth token secret will be returned.</param>
+        /// <param name="tokenSecret">Out var where the oauth token secret will be returned.</param>
+        private static void ParseCredentials(string credentialsJson, out string consumerKey, out string consumerSecret, out string token,
+            out string tokenSecret)
+        {
+            var credentials = JObject.Parse(credentialsJson);
+            try
+            {
+                consumerKey = (string)credentials["consumer_key"];
+                consumerSecret = (string)credentials["consumer_secret"];
+                token = (string)credentials["token"];
+                tokenSecret = (string)credentials["token_secret"];
+
+            }
+            catch (InvalidCastException e)
+            {
+                // could happen when the json is not formatted as we expected.
+                throw new SSOLoginException("Error when retrieving credentials.", e);
+            }
+            if (string.IsNullOrEmpty(consumerKey)
+               || string.IsNullOrEmpty(consumerSecret)
+               || string.IsNullOrEmpty(token)
+               || string.IsNullOrEmpty(tokenSecret))
+            {
+                // none of them can be null or empty.
+                throw new SSOLoginException("Credentials have missing values..");
+            }
+
+        }
+        #endregion
+
         #region Implementation of ISSOLoginProcessor
 
         /// <summary>
@@ -61,7 +185,36 @@
         /// <returns>A string with the sso credentials.</returns>
         public string Login(string email, string password, string tokenName)
         {
-            throw new NotImplementedException();
+            var secret = Keyring.GetSecretByName(KeyringName, ApplicationName);
+            if (secret == null)
+            {
+                try
+                {
+                    // credentials are not present in the keyring, therefore we will have to get them from the 
+                    // rest service
+                    string token;
+                    string tokenSecret;
+                    string consumerKey;
+                    string consumerSecret;
+
+                    // the rest server returns json, we need to parse it.
+                    ParseCredentials(Authentications.Authenticate(email, password, tokenName),
+                        out consumerKey, out consumerSecret, out token, out tokenSecret);
+                    secret = SSOCredentialsEncoder.Encode(token, tokenSecret, consumerKey, consumerSecret);
+                    // ping the service to make it download the tokens
+                    PingUbuntuOneServer(email, consumerKey, consumerKey, token, tokenSecret);
+                    Keyring.CreateSecret(KeyringName, ApplicationName, secret);
+                }
+                catch (WebException e)
+                {
+                    throw new SSOLoginException("Unable to login", e);
+                }
+                catch (Exception e)
+                {
+                    throw new SSOLoginException("Unable to login", e);
+                }
+            }
+            return secret;
         }
 
         /// <summary>

=== modified file 'src/Canonical.UbuntuOne.Client/Notification/NotificationIconPresenter.cs'
--- src/Canonical.UbuntuOne.Client/Notification/NotificationIconPresenter.cs	2010-10-05 09:58:34 +0000
+++ src/Canonical.UbuntuOne.Client/Notification/NotificationIconPresenter.cs	2010-10-05 09:58:35 +0000
@@ -1,25 +1,25 @@
-// Copyright 2010 Canonical Ltd.
-// 
-// This file is part of UbuntuOne on Windows.
-// 
-// UbuntuOne on Windows is free software: you can redistribute it and/or modify		
-// it under the terms of the GNU Lesser General Public License version 		
-// as published by the Free Software Foundation.		
-//		
-// Ubuntu One on Windows is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
-// GNU Lesser General Public License for more details.	
-//
-// You should have received a copy of the GNU Lesser General Public License	
-// along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
-// 
-// Authors: Manuel de la Peña <[e-mail]>
+/* Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
 using System;
 using System.Diagnostics;
 using System.IO;
 using System.Net;
-using System.Web;
 using System.Windows;
 using Canonical.Ubuntu.SSO;
 using Canonical.Ubuntu.SSO.Service;
@@ -29,7 +29,6 @@
 using Canonical.UbuntuOne.Common.Utils;
 using log4net;
 using Newtonsoft.Json.Linq;
-using OAuth;
 
 namespace Canonical.UbuntuOne.Client.Notification
 {
@@ -148,33 +147,23 @@
 
         #region Helper methods
 
-        public HttpWebRequest MakeRequest(string uri, string consumerKey, string consumerSecret, string toke, string tokenSecret)
+        public HttpWebRequest MakeRequest(string uri, string consumerKey, string consumerSecret, string token, string tokenSecret)
         {
             // Form the full REST request url
             Uri url = new Uri(uri);
 
             // Instantiate OAuthBase and declare variables
-            var oAuth = new OAuthBase();
-            var nonce = oAuth.GenerateNonce();
-            var timeStamp = oAuth.GenerateTimeStamp();
+            var oAuth = new OAuth();
+            
             var normUrl = string.Empty;
             var normParams = string.Empty;
-            var strRequest = string.Empty;
 
-            // Create an OAuth signature
-            string signature = oAuth.GenerateSignature(url,
-                consumerKey, consumerSecret, toke, tokenSecret,
-                "GET", timeStamp, nonce, OAuthBase.SignatureTypes.HMACSHA1,
+            var authHeader = oAuth.GenerateHeaderWithSignature(url, string.Empty, consumerKey, consumerSecret,
+                token, tokenSecret, "GET", oAuth.GenerateTimeStamp(), oAuth.GenerateNonce(), OAuth.SignatureTypes.HMACSHA1,
                 out normUrl, out normParams);
-
-            // Construct the OAuth authenticated REST url
-            strRequest = normParams + "&" + HttpUtility.UrlEncode("oauth_signature") + "=" + HttpUtility.UrlEncode(signature);
-            strRequest = strRequest.Replace("&", @""",");
-            strRequest = strRequest.Replace("=", @"=""");
-            strRequest += @"""";
-            strRequest = @"OAuth realm=""""," + strRequest;
+            
             var request = WebRequest.Create(normUrl) as HttpWebRequest;
-            request.Headers.Add("Authorization", strRequest);
+            request.Headers.Add(authHeader.Key, authHeader.Value);
             return request;
         }
 

=== modified file 'src/Canonical.UbuntuOne.Common/Canonical.UbuntuOne.Common.csproj'
--- src/Canonical.UbuntuOne.Common/Canonical.UbuntuOne.Common.csproj	2010-08-30 17:30:31 +0000
+++ src/Canonical.UbuntuOne.Common/Canonical.UbuntuOne.Common.csproj	2010-10-05 09:58:35 +0000
@@ -57,6 +57,10 @@
     <Compile Include="Container\ObjectsContainer.cs" />
     <Compile Include="Container\SpringContainer.cs" />
     <Compile Include="Container\UnsatisfiedDependencyException.cs" />
+    <Compile Include="Net\HttpWebRequest.cs" />
+    <Compile Include="Net\HttpWebRequestFactory.cs" />
+    <Compile Include="Net\IHttpWebRequestFactory.cs" />
+    <Compile Include="Net\IHttpWebRequest.cs" />
     <Compile Include="OperationContracts\IEventNotifier.cs" />
     <Compile Include="Security\IAuthentication.cs" />
     <Compile Include="Threading\IDispatcher.cs" />

=== added directory 'src/Canonical.UbuntuOne.Common/Net'
=== added file 'src/Canonical.UbuntuOne.Common/Net/HttpWebRequest.cs'
--- src/Canonical.UbuntuOne.Common/Net/HttpWebRequest.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.Common/Net/HttpWebRequest.cs	2010-10-05 09:58:35 +0000
@@ -0,0 +1,505 @@
+/*
+ * Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using System;
+using System.IO;
+using System.Net;
+using System.Net.Cache;
+using System.Net.Security;
+using System.Security.Cryptography.X509Certificates;
+using System.Security.Principal;
+using RealHttpRequest = System.Net.HttpWebRequest;
+
+namespace Canonical.UbuntuOne.Common.Net
+{
+    /// <summary>
+    /// Wrapper around the System.Net.HttpWebRequest.
+    /// </summary>
+    internal class HttpWebRequest : IHttpWebRequest
+    {
+        #region Variables
+
+        private RealHttpRequest _request;
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Internal constructor that can only be used by a httpweb request factory.
+        /// </summary>
+        /// <param name="httpWebRequest"></param>
+        internal HttpWebRequest(RealHttpRequest httpWebRequest)
+        {
+            _request = httpWebRequest;
+        }
+
+        #endregion
+
+        #region Implementation of IHttpWebRequest
+
+        /// <summary>
+        /// Gets and sets value of the Accept HTTP header. The default value is null.
+        /// </summary>
+        public string Accept
+        {
+            get { return _request.Accept; }
+            set { _request.Accept = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets the uri that responds to the request.
+        /// </summary>
+        public Uri Address
+        {
+            get { return _request.Address; }
+        }
+
+        /// <summary>
+        /// Gets and sets if the request should automatically follow redirection responses
+        /// </summary>
+        public bool AllowAutoRedirect
+        {
+            get { return _request.AllowAutoRedirect; }
+            set { _request.AllowAutoRedirect = value; }
+        }
+
+        /// <summary>
+        /// Enables buffering of the data sent to the Internet resource
+        /// </summary>
+        public bool AllowWriteStreamBuffering
+        {
+            get { return _request.AllowWriteStreamBuffering; }
+            set { _request.AllowWriteStreamBuffering = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets the auhentication lavel used.
+        /// </summary>
+        public AuthenticationLevel AuthenticationLevel
+        {
+            get { return _request.AuthenticationLevel; }
+            set { _request.AuthenticationLevel = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets the type of decompression that is used. 
+        /// </summary>
+        public DecompressionMethods AutomaticDecompression
+        {
+            get { return _request.AutomaticDecompression; }
+            set { _request.AutomaticDecompression = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the cache policy used by the request.
+        /// </summary>
+        public RequestCachePolicy CachePolicy
+        {
+            get { return _request.CachePolicy; }
+            set { _request.CachePolicy = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets the certificates used by the request.
+        /// </summary>
+        public X509CertificateCollection ClientCertificates
+        {
+            get { return _request.ClientCertificates; }
+            set { _request.ClientCertificates = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets the Connection HTTP header
+        /// </summary>
+        public string Connection
+        {
+            get { return _request.Connection; }
+            set { _request.Connection = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets the name of the connection group for this request
+        /// </summary>
+        public string ConnectionGroupName
+        {
+            get { return _request.ConnectionGroupName; }
+            set { _request.ConnectionGroupName = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets the number of bytes of data to send to the Internet resource.
+        /// </summary>
+        public long ContentLength
+        {
+            get { return _request.ContentLength; }
+            set { _request.ContentLength = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets the content type of the request.
+        /// </summary>
+        public string ContentType
+        {
+            get { return _request.ContentType; }
+            set { _request.ContentType = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets the delegate that implements the callback method that 
+        /// executes when an HTTP Continue response is returned from the Internet resource.
+        /// </summary>
+        public HttpContinueDelegate ContinueDelegate
+        {
+            get { return _request.ContinueDelegate; }
+            set { _request.ContinueDelegate = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets cookies container associated with this request.
+        /// </summary>
+        public CookieContainer CookieContainer
+        {
+            get { return _request.CookieContainer; }
+            set { _request.CookieContainer = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets the credentials used with the request.
+        /// </summary>
+        public ICredentials Credentials
+        {
+            get { return _request.Credentials; }
+            set { _request.Credentials = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets the data header of the request.
+        /// </summary>
+        public DateTime Date
+        {
+            get { throw new NotImplementedException(); }
+            set { throw new NotImplementedException(); }
+        }
+
+        /// <summary>
+        /// Gets and sets the Expect HTTP header. 
+        /// </summary>
+        public string Expect
+        {
+            get { return _request.Expect; }
+            set { _request.Expect = value; }
+        }
+
+        /// <summary>
+        /// Gets  if a response has been received.
+        /// </summary>
+        public bool HaveResponse
+        {
+            get { return _request.HaveResponse; }
+        }
+
+        /// <summary>
+        /// Gets and sets the headers of the request,
+        /// </summary>
+        public WebHeaderCollection Headers
+        {
+            get { return _request.Headers; }
+            set { _request.Headers = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets the Host header.
+        /// </summary>
+        public string Host
+        {
+            get { throw new NotImplementedException(); }
+            set { throw new NotImplementedException(); }
+        }
+
+        /// <summary>
+        /// A DateTime that contains the contents of the If-Modified-Since HTTP header.
+        /// </summary>
+        public DateTime IfModifiedSince
+        {
+            get { return _request.IfModifiedSince; }
+            set { _request.IfModifiedSince = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets the the impersonation level.
+        /// </summary>
+        public TokenImpersonationLevel ImpersonationLevel
+        {
+            get { return _request.ImpersonationLevel; }
+            set { _request.ImpersonationLevel = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets if the request should have a Connection HTTP header.
+        /// </summary>
+        public bool KeepAlive
+        {
+            get { return _request.KeepAlive; }
+            set { _request.KeepAlive = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets the max number of redirections.
+        /// </summary>
+        public int MaximumAutomaticRedirections
+        {
+            get { return _request.MaximumAutomaticRedirections; }
+            set { _request.MaximumAutomaticRedirections = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets The length, in kilobytes (1024 bytes), of the response headers.
+        /// </summary>
+        public int MaximumResponseHeadersLength
+        {
+            get { return _request.MaximumResponseHeadersLength; }
+            set { _request.MaximumResponseHeadersLength = value; }
+        }
+
+        /// <summary>
+        /// The media type of the request. 
+        /// </summary>
+        public string MediaType
+        {
+            get { return _request.MediaType; }
+            set { _request.MediaType = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets the request method.
+        /// </summary>
+        public string Method
+        {
+            get { return _request.Method; }
+            set { _request.Method = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets if the request should be pipelined
+        /// </summary>
+        public bool Pipelined
+        {
+            get { return _request.Pipelined; }
+            set { _request.Pipelined = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets if an HTTP Authorization header with requests after authentication has taken place;
+        /// </summary>
+        public bool PreAuthenticate
+        {
+            get { return _request.PreAuthenticate; }
+            set { _request.PreAuthenticate = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets the protol version used.
+        /// </summary>
+        public Version ProtocolVersion
+        {
+            get { return _request.ProtocolVersion; }
+            set { _request.ProtocolVersion = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets the proxy information.
+        /// </summary>
+        public IWebProxy Proxy
+        {
+            get { return _request.Proxy; }
+            set { _request.Proxy = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets the number of milliseconds before the writing or reading times out..
+        /// </summary>
+        public int ReadWriteTimeout
+        {
+            get { return _request.ReadWriteTimeout; }
+            set { _request.ReadWriteTimeout = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets the Referer HTTP header.
+        /// </summary>
+        public string Referer
+        {
+            get { return _request.Referer; }
+            set { _request.Referer = value; }
+        }
+
+        /// <summary>
+        /// Gets the resource uri used by the request.
+        /// </summary>
+        public Uri RequestUri
+        {
+            get { return _request.RequestUri; }
+        }
+
+        /// <summary>
+        /// Ges and sets if the request should be sent in chuckes.
+        /// </summary>
+        public bool SendChunked
+        {
+            get { return _request.SendChunked; }
+            set { _request.SendChunked = value; }
+        }
+
+        /// <summary>
+        /// Gets the service point that represents the internet resource.
+        /// </summary>
+        public ServicePoint ServicePoint
+        {
+            get { return _request.ServicePoint; }
+        }
+
+        /// <summary>
+        /// Gets and sets the number of milliseconds to wait before the request times out.
+        /// </summary>
+        public int Timeout
+        {
+            get { return _request.Timeout; }
+            set { _request.Timeout = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets the Transfer-encoding HTTP header.
+        /// </summary>
+        public string TransferEncoding
+        {
+            get { return _request.TransferEncoding; }
+            set { _request.TransferEncoding = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets if the authenticated connection is kept opened.
+        /// </summary>
+        public bool UnsafeAuthenticatedConnectionSharing
+        {
+            get { return _request.UnsafeAuthenticatedConnectionSharing; }
+            set { _request.UnsafeAuthenticatedConnectionSharing = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets if the default credentials are used.
+        /// </summary>
+        public bool UseDefaultCredentials
+        {
+            get { return _request.UseDefaultCredentials; }
+            set { _request.UseDefaultCredentials = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the User-agent HTTP header;
+        /// </summary>
+        public string UserAgent
+        {
+            get { return _request.UserAgent; }
+            set { _request.UserAgent = value; }
+        }
+
+        /// <summary>
+        /// Cancels a request to a resource
+        /// </summary>
+        public void Abort()
+        {
+            _request.Abort();
+        }
+
+        /// <summary>
+        /// Begins an asynchronous request for a Stream object to use to write data.
+        /// </summary>
+        /// <param name="callback">The delegate to execute.</param>
+        /// <param name="state">Teh state object of the request. </param>
+        /// <returns>An async result.</returns>
+        public IAsyncResult BeginGetRequestStream(AsyncCallback callback, object state)
+        {
+            return _request.BeginGetRequestStream(callback, state);
+        }
+
+        /// <summary>
+        /// Begins an asynchronous request to an Internet resource.
+        /// </summary>
+        /// <param name="callback">Teh deleaget.</param>
+        /// <param name="state">Teh state object fo the response.</param>
+        /// <returns>an asyn result.</returns>
+        public IAsyncResult BeginGetResponse(AsyncCallback callback, object state)
+        {
+            return _request.BeginGetResponse(callback, state);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous request for a Stream object to use to write data.
+        /// </summary>
+        /// <param name="asyncResult">The result from the async request.</param>
+        /// <returns>Teh stream from teh request.</returns>
+        public Stream EndGetRequestStream(IAsyncResult asyncResult)
+        {
+            return EndGetRequestStream(asyncResult);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous request for a Stream object to use to write data and outputs
+        ///  the TransportContext associated with the stream.
+        /// </summary>
+        /// <param name="asyncResult">The async result from the request stream.</param>
+        /// <param name="context">The context of the request.</param>
+        /// <returns>The request stream.</returns>
+        public Stream EndGetRequestStream(IAsyncResult asyncResult, out TransportContext context)
+        {
+            return _request.EndGetRequestStream(asyncResult, out context);
+        }
+
+        /// <summary>
+        /// Ends an asynchronous request to an Internet resource.
+        /// </summary>
+        /// <param name="asyncResult">The async result from the asyn response.</param>
+        /// <returns>Teh response frm the internet resource.</returns>
+        public WebResponse EndGetResponse(IAsyncResult asyncResult)
+        {
+            return _request.EndGetResponse(asyncResult);
+        }
+
+        /// <summary>
+        /// Gets a Stream object to use to write request data.
+        /// </summary>
+        /// <returns>Teh stream to which write the request.</returns>
+        public Stream GetRequestStream()
+        {
+            return _request.GetRequestStream();
+        }
+
+        /// <summary>
+        /// Returns a response from an Internet resource.
+        /// </summary>
+        /// <returns>Teh response from the resource.</returns>
+        public WebResponse GetResponse()
+        {
+            return _request.GetResponse();
+        }
+
+        #endregion
+    }
+}

=== added file 'src/Canonical.UbuntuOne.Common/Net/HttpWebRequestFactory.cs'
--- src/Canonical.UbuntuOne.Common/Net/HttpWebRequestFactory.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.Common/Net/HttpWebRequestFactory.cs	2010-10-05 09:58:35 +0000
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using System;
+using System.Net;
+using RealHttpRequest = System.Net.HttpWebRequest;
+
+namespace Canonical.UbuntuOne.Common.Net
+{
+    /// <summary>
+    /// Class that creates IHttpWebRequest that can be used to request an internet resource.
+    /// </summary>
+    internal class HttpWebRequestFactory : IHttpWebRequestFactory
+    {
+        #region Implementation of IHttpWebRequestFactory
+
+        /// <summary>
+        /// Creates a new webrequest that will be used to request an internet resource that is identified
+        /// by the given uri.
+        /// </summary>
+        /// <param name="uri">A string with the uri that identifies the internet resource.</param>
+        /// <returns>An IHttpWebRequest that can be used to request an internet resource.</returns>
+        public IHttpWebRequest Create(string uri)
+        {
+            var realRequest = WebRequest.Create(uri) as RealHttpRequest;
+            return new HttpWebRequest(realRequest);
+        }
+
+        /// <summary>
+        /// Creates a webrequest that will be used to request an internet resource that is identified by
+        /// the given uri.
+        /// </summary>
+        /// <param name="uri">An object that identifies the web request.</param>
+        /// <returns>An HttpWebRequest that can be used to request an internet resource.</returns>
+        public IHttpWebRequest Create(Uri uri)
+        {
+            var realRequest = WebRequest.Create(uri) as RealHttpRequest;
+            return new HttpWebRequest(realRequest);
+        }
+
+        #endregion
+    }
+}

=== added file 'src/Canonical.UbuntuOne.Common/Net/IHttpWebRequest.cs'
--- src/Canonical.UbuntuOne.Common/Net/IHttpWebRequest.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.Common/Net/IHttpWebRequest.cs	2010-10-05 09:58:35 +0000
@@ -0,0 +1,297 @@
+/*
+ * Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using System;
+using System.IO;
+using System.Net;
+using System.Net.Cache;
+using System.Net.Security;
+using System.Security.Cryptography.X509Certificates;
+using System.Security.Principal;
+
+namespace Canonical.UbuntuOne.Common.Net
+{
+    /// <summary>
+    /// Helper interface that wrapps the HttpWebRequest class from System.Net
+    /// </summary>
+    public interface IHttpWebRequest
+    {
+        /// <summary>
+        /// Gets and sets value of the Accept HTTP header. The default value is null.
+        /// </summary>
+        string Accept { get; set; }
+
+        /// <summary>
+        /// Gets and sets the uri that responds to the request.
+        /// </summary>
+        Uri Address { get; }
+
+        /// <summary>
+        /// Gets and sets if the request should automatically follow redirection responses
+        /// </summary>
+        bool AllowAutoRedirect { get; set; }
+
+        /// <summary>
+        /// Enables buffering of the data sent to the Internet resource
+        /// </summary>
+        bool AllowWriteStreamBuffering { get; set; }
+
+        /// <summary>
+        /// Gets and sets the auhentication lavel used.
+        /// </summary>
+        AuthenticationLevel AuthenticationLevel { get; set; }
+
+        /// <summary>
+        /// Gets and sets the type of decompression that is used. 
+        /// </summary>
+        DecompressionMethods AutomaticDecompression { get; set; }
+
+        /// <summary>
+        /// Gets or sets the cache policy used by the request.
+        /// </summary>
+        RequestCachePolicy CachePolicy { get; set; }
+
+        /// <summary>
+        /// Gets and sets the certificates used by the request.
+        /// </summary>
+        X509CertificateCollection ClientCertificates { get; set; }
+
+        /// <summary>
+        /// Gets and sets the Connection HTTP header
+        /// </summary>
+        string Connection { get; set; }
+
+        /// <summary>
+        /// Gets and sets the name of the connection group for this request
+        /// </summary>
+        string ConnectionGroupName { get; set; }
+
+        /// <summary>
+        /// Gets and sets the number of bytes of data to send to the Internet resource.
+        /// </summary>
+        long ContentLength { get; set; }
+
+        /// <summary>
+        /// Gets and sets the content type of the request.
+        /// </summary>
+        string ContentType { get; set; }
+
+        /// <summary>
+        /// Gets and sets the delegate that implements the callback method that 
+        /// executes when an HTTP Continue response is returned from the Internet resource.
+        /// </summary>
+        HttpContinueDelegate ContinueDelegate { get; set; }
+
+        /// <summary>
+        /// Gets and sets cookies container associated with this request.
+        /// </summary>
+        CookieContainer CookieContainer { get; set; }
+
+        /// <summary>
+        /// Gets and sets the credentials used with the request.
+        /// </summary>
+        ICredentials Credentials { get; set; }
+
+        /// <summary>
+        /// Gets and sets the data header of the request.
+        /// </summary>
+        DateTime Date { get; set; }
+
+        /// <summary>
+        /// Gets and sets the Expect HTTP header. 
+        /// </summary>
+        string Expect { get; set; }
+
+        /// <summary>
+        /// Gets  if a response has been received.
+        /// </summary>
+        bool HaveResponse { get; }
+
+        /// <summary>
+        /// Gets and sets the headers of the request,
+        /// </summary>
+        WebHeaderCollection Headers { get; set; }
+
+        /// <summary>
+        /// Gets and sets the Host header.
+        /// </summary>
+        string Host { get; set; }
+
+        /// <summary>
+        /// A DateTime that contains the contents of the If-Modified-Since HTTP header.
+        /// </summary>
+        DateTime IfModifiedSince { get; set; }
+
+        /// <summary>
+        /// Gets and sets the the impersonation level.
+        /// </summary>
+        TokenImpersonationLevel ImpersonationLevel { get; set; }
+
+        /// <summary>
+        /// Gets and sets if the request should have a Connection HTTP header.
+        /// </summary>
+        bool KeepAlive { get; set; }
+
+        /// <summary>
+        /// Gets and sets the max number of redirections.
+        /// </summary>
+        int MaximumAutomaticRedirections { get; set; }
+
+        /// <summary>
+        /// Gets and sets The length, in kilobytes (1024 bytes), of the response headers.
+        /// </summary>
+        int MaximumResponseHeadersLength { get; set; }
+
+        /// <summary>
+        /// The media type of the request. 
+        /// </summary>
+        string MediaType { get; set; }
+
+        /// <summary>
+        /// Gets and sets the request method.
+        /// </summary>
+        string Method { get; set; }
+
+        /// <summary>
+        /// Gets and sets if the request should be pipelined
+        /// </summary>
+        bool Pipelined { get; set; }
+
+        /// <summary>
+        /// Gets and sets if an HTTP Authorization header with requests after authentication has taken place;
+        /// </summary>
+        bool PreAuthenticate { get; set; }
+
+        /// <summary>
+        /// Gets and sets the protol version used.
+        /// </summary>
+        Version ProtocolVersion { get; set; }
+
+        /// <summary>
+        /// Gets and sets the proxy information.
+        /// </summary>
+        IWebProxy Proxy { get; set; }
+
+        /// <summary>
+        /// Gets and sets the number of milliseconds before the writing or reading times out..
+        /// </summary>
+        int ReadWriteTimeout { get; set; }
+
+        /// <summary>
+        /// Gets and sets the Referer HTTP header.
+        /// </summary>
+        string Referer { get; set; }
+
+        /// <summary>
+        /// Gets the resource uri used by the request.
+        /// </summary>
+        Uri RequestUri { get; }
+
+        /// <summary>
+        /// Ges and sets if the request should be sent in chuckes.
+        /// </summary>
+        bool SendChunked { get; set; }
+
+        /// <summary>
+        /// Gets the service point that represents the internet resource.
+        /// </summary>
+        ServicePoint ServicePoint { get; }
+
+        /// <summary>
+        /// Gets and sets the number of milliseconds to wait before the request times out.
+        /// </summary>
+        int Timeout { get; set; }
+
+        /// <summary>
+        /// Gets and sets the Transfer-encoding HTTP header.
+        /// </summary>
+        string TransferEncoding { get; set; }
+
+        /// <summary>
+        /// Gets and sets if the authenticated connection is kept opened.
+        /// </summary>
+        bool UnsafeAuthenticatedConnectionSharing { get; set; }
+
+        /// <summary>
+        /// Gets and sets if the default credentials are used.
+        /// </summary>
+        bool UseDefaultCredentials { get; set; }
+
+        /// <summary>
+        /// Gets or sets the User-agent HTTP header;
+        /// </summary>
+        string UserAgent { get; set; }
+
+        /// <summary>
+        /// Cancels a request to a resource
+        /// </summary>
+        void Abort();
+
+        /// <summary>
+        /// Begins an asynchronous request for a Stream object to use to write data.
+        /// </summary>
+        /// <param name="callback">The delegate to execute.</param>
+        /// <param name="state">Teh state object of the request. </param>
+        /// <returns>An async result.</returns>
+        IAsyncResult BeginGetRequestStream(AsyncCallback callback,Object state);
+
+        /// <summary>
+        /// Begins an asynchronous request to an Internet resource.
+        /// </summary>
+        /// <param name="callback">Teh deleaget.</param>
+        /// <param name="state">Teh state object fo the response.</param>
+        /// <returns>an asyn result.</returns>
+        IAsyncResult BeginGetResponse(AsyncCallback callback,Object state);
+
+        /// <summary>
+        /// Ends an asynchronous request for a Stream object to use to write data.
+        /// </summary>
+        /// <param name="asyncResult">The result from the async request.</param>
+        /// <returns>Teh stream from teh request.</returns>
+        Stream EndGetRequestStream(IAsyncResult asyncResult);
+
+        /// <summary>
+        /// Ends an asynchronous request for a Stream object to use to write data and outputs
+        ///  the TransportContext associated with the stream.
+        /// </summary>
+        /// <param name="asyncResult">The async result from the request stream.</param>
+        /// <param name="context">The context of the request.</param>
+        /// <returns>The request stream.</returns>
+        Stream EndGetRequestStream(IAsyncResult asyncResult,out TransportContext context);
+
+        /// <summary>
+        /// Ends an asynchronous request to an Internet resource.
+        /// </summary>
+        /// <param name="asyncResult">The async result from the asyn response.</param>
+        /// <returns>Teh response frm the internet resource.</returns>
+        WebResponse EndGetResponse(IAsyncResult asyncResult);
+
+        /// <summary>
+        /// Gets a Stream object to use to write request data.
+        /// </summary>
+        /// <returns>Teh stream to which write the request.</returns>
+        Stream GetRequestStream();
+
+        /// <summary>
+        /// Returns a response from an Internet resource.
+        /// </summary>
+        /// <returns>Teh response from the resource.</returns>
+        WebResponse GetResponse();
+    }
+}

=== added file 'src/Canonical.UbuntuOne.Common/Net/IHttpWebRequestFactory.cs'
--- src/Canonical.UbuntuOne.Common/Net/IHttpWebRequestFactory.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.UbuntuOne.Common/Net/IHttpWebRequestFactory.cs	2010-10-05 09:58:35 +0000
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2010 Canonical Ltd.
+ * 
+ * This file is part of UbuntuOne on Windows.
+ * 
+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify		
+ * it under the terms of the GNU Lesser General Public License version 		
+ * as published by the Free Software Foundation.		
+ *		
+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	
+ * GNU Lesser General Public License for more details.	
+ *
+ * You should have received a copy of the GNU Lesser General Public License	
+ * along with UbuntuOne for Windows.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ * Authors: Manuel de la Peña <[e-mail]>
+ */
+using System;
+
+namespace Canonical.UbuntuOne.Common.Net
+{
+    /// <summary>
+    /// Simple interface to be implemented by those objects that are able to create web requests.
+    /// </summary>
+    public interface IHttpWebRequestFactory
+    {
+        /// <summary>
+        /// Creates a new webrequest that will be used to request an internet resource that is identified
+        /// by the given uri.
+        /// </summary>
+        /// <param name="uri">A string with the uri that identifies the internet resource.</param>
+        /// <returns>An IHttpWebRequest that can be used to request an internet resource.</returns>
+        IHttpWebRequest Create(string uri);
+
+        /// <summary>
+        /// Creates a webrequest that will be used to request an internet resource that is identified by
+        /// the given uri.
+        /// </summary>
+        /// <param name="uri">An object that identifies the web request.</param>
+        /// <returns>An HttpWebRequest that can be used to request an internet resource.</returns>
+        IHttpWebRequest Create(Uri uri);
+    }
+}