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

[Manuel de la Peña]

Adds the implementation of the keyring on windows so that we can securely store the Ubuntu SSO tokens.

[Rick McBride (rmcbride)]

I get a whole lot of errors (pasting what I have from my terminal buffer) and the build fails during NAnt.exe tests:

  [msbuild] Copying file from "obj\Debug\ServiceTestApp.pdb" to "bin\Debug\Ser
viceTestApp.pdb".
  [msbuild] Done Building Project "C:\canonical\ubuntuone-windows-installer\revi
ew.aussk\src\ServiceTestApp\ServiceTestApp.csproj" (default targets).
  [msbuild] Project "C:\canonical\ubuntuone-windows-installer\review.aussk\src\U
buntuOne.sln" (1) is building "C:\canonical\ubuntuone-windows-installer\review.a
ussk\src\UbuntuOneClient\UbuntuOneClient.csproj" (13) on node 0 (default targets
).
  [msbuild] Processing 0 EDMX files.
  [msbuild] Finished processing 0 EDMX files.
  [msbuild] PrepareForBuild:
  [msbuild] Creating directory "bin\Debug\".
  [msbuild] Creating directory "obj\Debug\".
  [msbuild] CoreResGen:
  [msbuild] Processing resource file "Properties\Resources.resx" into "obj\Deb
ug\UbuntuOneClient.Properties.Resources.resources".
  [msbuild] _CopyFilesMarkedCopyLocal:
  [msbuild] Copying file from "..\..\lib\WPFContrib\AvalonLibrary.dll" to "bin
\Debug\AvalonLibrary.dll".
  [msbuild] Copying file from "C:\canonical\ubuntuone-windows-installer\review
.aussk\src\Canonical.UbuntuOne.Client\bin\Debug\Canonical.UbuntuOne.Client.dll"
to "bin\Debug\Canonical.UbuntuOne.Client.dll".
  [msbuild] Copying file from "C:\canonical\ubuntuone-windows-installer\review
.aussk\src\Canonical.UbuntuOne.Common\bin\Debug\Canonical.UbuntuOne.Common.dll"
to "bin\Debug\Canonical.UbuntuOne.Common.dll".
  [msbuild] Copying file from "..\..\lib\Spring.Net\Common.Logging.Log4Net.dll
" to "bin\Debug\Common.Logging.Log4Net.dll".
  [msbuild] Copying file from "..\..\lib\log4net\log4net.dll" to "bin\Debug\lo
g4net.dll".
  [msbuild] Copying file from "C:\canonical\ubuntuone-windows-installer\review
.aussk\src\Canonical.UbuntuOne.Common\bin\Debug\Spring.Aop.dll" to "bin\Debug\Sp
ring.Aop.dll".
  [msbuild] Copying file from "..\..\lib\Spring.Net\Common.Logging.dll" to "bi
n\Debug\Common.Logging.dll".
  [msbuild] Copying file from "C:\canonical\ubuntuone-windows-installer\review
.aussk\src\Canonical.UbuntuOne.Common\bin\Debug\DotUpdater.dll" to "bin\Debug\Do
tUpdater.dll".
  [msbuild] Copying file from "C:\canonical\ubuntuone-windows-installer\review
.aussk\src\Canonical.UbuntuOne.Common\bin\Debug\Spring.Core.dll" to "bin\Debug\S
pring.Core.dll".
  [msbuild] Copying file from "C:\canonical\ubuntuone-windows-installer\review
.aussk\src\Canonical.UbuntuOne.Common\bin\Debug\Spring.Aop.xml" to "bin\Debug\Sp
ring.Aop.xml".
  [msbuild] Copying file from "C:\canonical\ubuntuone-windows-installer\review
.aussk\src\Canonical.UbuntuOne.Common\bin\Debug\DotUpdater.pdb" to "bin\Debug\Do
tUpdater.pdb".
  [msbuild] Copying file from "C:\canonical\ubuntuone-windows-installer\review
.aussk\src\Canonical.UbuntuOne.Common\bin\Debug\Spring.Core.xml" to "bin\Debug\S
pring.Core.xml".
  [msbuild] Copying file from "C:\canonical\ubuntuone-windows-installer\review
.aussk\src\Canonical.UbuntuOne.Client\bin\Debug\Canonical.UbuntuOne.Client.pdb"
to "bin\Debug\Canonical.UbuntuOne.Client.pdb".
  [msbuild] Copying file from "C:\canonical\ubuntuo...

[Rick McBride (rmcbride)]

See above. Looks like something is wrong.

review: Needs Fixing

[lp:~mandel/ubuntuone-windows-installer/add_ubuntu_sso_service_keyring]

62. By Manuel de la Peña on 2010-09-16

Merged with trunk.

63. By Manuel de la Peña on 2010-09-17

Re-references the NUnit dll.

[Rick McBride (rmcbride)]

+1

review: Approve

[Vincenzo Di Somma (vds)]

+1

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2010-09-08 11:23:58 +0000
+++ .bzrignore	2010-09-17 16:23:44 +0000
@@ -8,6 +8,8 @@
 src/_ReSharper.UbuntuOne
 src/Canonical.Ubuntu.SSO/bin
 src/Canonical.Ubuntu.SSO/obj
+src/Canonical.Ubuntu.SSO.Tests/bin
+src/Canonical.Ubuntu.SSO.Tests/obj
 src/Canonical.UbuntuOne.Client/bin
 src/Canonical.UbuntuOne.Client/obj
 src/Canonical.UbuntuOne.Client.Test/obj
 
=== modified file 'main.build'
--- main.build	2010-09-02 10:27:49 +0000
+++ main.build	2010-09-17 16:23:44 +0000
@@ -156,7 +156,7 @@
               program="nunit-console.exe"
               commandline="Canonical.UbuntuOne.ProcessDispatcher.Tests.dll /xml=../../../../test-results/Canonical.UbuntuOne.ProcessDispatcher.Tests-Result.xml" />
 
-		<echo>Canonical.UbuntuOne.Client.Test</echo>
+		<echo>Executing Canonical.UbuntuOne.Client.Test</echo>
 		<exec basedir="tools/NUnit"
               managed="true"
               workingdir="src/Canonical.UbuntuOne.Client.Test/bin/${enviroment}"
@@ -169,12 +169,20 @@
 		<copy file="src/Canonical.UbuntuOne.Client.Views/bin/${enviroment}/AvalonLibrary.dll"
 			  tofile="src/UbuntuOneClient.Tests/bin/${enviroment}/AvalonLibrary.dll" /> 
 			  
-		<echo>UbuntuOneClient.Tests</echo>
+		<echo>Executing UbuntuOneClient.Tests</echo>
 		<exec basedir="tools/NUnit"
               managed="true"
               workingdir="src/UbuntuOneClient.Tests/bin/${enviroment}"
               program="nunit-console.exe"
               commandline="UbuntuOneClient.Tests.dll /xml=../../../../test-results/UbuntuOneClient.Tests-Result.xml" />
+        
+        <echo>Executing Canonical.Ubuntu.SSO.Tests</echo>
+		<exec basedir="tools/NUnit"
+              managed="true"
+              workingdir="src/Canonical.Ubuntu.SSO.Tests/bin/${enviroment}"
+              program="nunit-console.exe"
+              commandline="Canonical.Ubuntu.SSO.Tests.dll /xml=../../../../test-results/Canonical.Ubuntu.SSO.Tests-Result.xml" />
+              
 	</target>
 	<target name="package_python"
             description="Creates the exe binary that embeds the python libs that will be used to perform the sync operation in the windows platform">
 
=== added directory 'src/Canonical.Ubuntu.SSO.Tests'
=== added file 'src/Canonical.Ubuntu.SSO.Tests/Canonical.Ubuntu.SSO.Tests.csproj'
--- src/Canonical.Ubuntu.SSO.Tests/Canonical.Ubuntu.SSO.Tests.csproj	1970-01-01 00:00:00 +0000
+++ src/Canonical.Ubuntu.SSO.Tests/Canonical.Ubuntu.SSO.Tests.csproj	2010-09-17 16:23:44 +0000
@@ -0,0 +1,74 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.21022</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{17BBBEC2-0F4F-48CE-A585-07AA33B6B2B3}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>Canonical.Ubuntu.SSO.Tests</RootNamespace>
+    <AssemblyName>Canonical.Ubuntu.SSO.Tests</AssemblyName>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="nunit.framework, Version=2.5.5.10112, Culture=neutral, PublicKeyToken=96d09a1eb7f44a77, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\Nunit\nunit.framework.dll</HintPath>
+    </Reference>
+    <Reference Include="Rhino.Mocks, Version=3.6.0.0, Culture=neutral, PublicKeyToken=0b3305902db7183f, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\RhinoMocks\Rhino.Mocks.dll</HintPath>
+    </Reference>
+    <Reference Include="System" />
+    <Reference Include="System.Core">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Security" />
+    <Reference Include="System.Xml.Linq">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data.DataSetExtensions">
+      <RequiredTargetFramework>3.5</RequiredTargetFramework>
+    </Reference>
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="KeyringFixture.cs" />
+    <Compile Include="Properties\AssemblyInfo.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>
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>
 \ No newline at end of file
 
=== added file 'src/Canonical.Ubuntu.SSO.Tests/KeyringFixture.cs'
--- src/Canonical.Ubuntu.SSO.Tests/KeyringFixture.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.Ubuntu.SSO.Tests/KeyringFixture.cs	2010-09-17 16:23:44 +0000
@@ -0,0 +1,409 @@
+/*
+ * 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.Linq;
+using System.Security.Cryptography;
+using System.Text;
+using NUnit.Framework;
+using Rhino.Mocks;
+
+namespace Canonical.Ubuntu.SSO.Tests
+{
+    [TestFixture]
+    public class KeyringFixture
+    {
+        #region Variables
+
+        private MockRepository _mocks;
+        private IRegistryKey _userRegistry;
+        private IRegistryKey _keyringsRoot;
+        private IRegistryKey _keyringKey;
+        private IDataProtector _dataProtector;
+        private Keyring _keyring;
+
+        #endregion
+
+        #region Setup & TearDown
+
+        [SetUp]
+        public void Setup()
+        {
+            _mocks = new MockRepository();
+            _userRegistry = _mocks.StrictMock<IRegistryKey>();
+            _keyringsRoot = _mocks.StrictMock<IRegistryKey>();
+            _keyringKey = _mocks.StrictMock<IRegistryKey>();
+            _dataProtector = _mocks.StrictMock<IDataProtector>();
+            _keyring = new Keyring(_userRegistry) { DataProtector = _dataProtector };
+        }
+
+        #endregion
+
+        #region Tests
+
+        [Test]
+        public void DisposeTest()
+        {
+            using (_mocks.Record())
+            {
+                Expect.Call(() => _userRegistry.Dispose())
+                    .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                // we ensure that we always dispose the registry key to ensure no 
+                // memory leaks.
+                _keyring.Dispose();
+            }
+        }
+
+        [TestCase("Default", "UbuntuOne", "myPassword")]
+        [TestCase("Default", "Mandel", "Secret")]
+        [TestCase("Test", "Leo", "MySecret")]
+        public void CreateSecretNoRootPathPresentTest(string keyringName, string applicationName, string secret)
+        {
+            using (_mocks.Record())
+            {
+                using (_mocks.Ordered())
+                {
+                    Expect.Call(_userRegistry.GetSubKeyNames())
+                        .Return(new[] {"Blah", "BlahBlah"})
+                        .Repeat.Twice();
+
+                    Expect.Call(_userRegistry.CreateSubKey(Keyring.RootPath))
+                        .Return(_keyringsRoot)
+                        .Repeat.Once();
+
+                    Expect.Call(_keyringsRoot.CreateSubKey(keyringName))
+                        .Return(_keyringKey)
+                        .Repeat.Once();
+
+                    Expect.Call(() => _keyringKey.Dispose())
+                        .Repeat.Any();
+
+                    Expect.Call(() => _keyringsRoot.Dispose())
+                        .Repeat.Any();
+
+                    Expect.Call(_userRegistry.OpenSubKey(Keyring.RootPath))
+                        .Return(_keyringsRoot)
+                        .Repeat.Once();
+
+                    Expect.Call(_keyringsRoot.OpenSubKey(keyringName))
+                        .Return(_keyringKey)
+                        .Repeat.Once();
+
+                    Expect.Call(_dataProtector.Protect(secret,
+                        Encoding.UTF8.GetBytes(Keyring.Entropy), DataProtectionScope.CurrentUser))
+                        .Return(secret)
+                        .Repeat.Once();
+
+                    Expect.Call(() => _keyringKey.SetValue(applicationName, secret))
+                        .Repeat.Once();
+
+                }
+
+            }
+            using (_mocks.Playback())
+            {
+                _keyring.CreateSecret(keyringName, applicationName, secret);
+            }
+        }
+
+        [TestCase("Default", "UbuntuOne", "myPassword")]
+        [TestCase("Default", "Mandel", "Secret")]
+        [TestCase("Test", "Leo", "MySecret")]
+        public void CreateSecretNoKeyringPresentTest(string keyringName, string applicationName, string secret)
+        {
+            using (_mocks.Record())
+            {
+                using(_mocks.Ordered())
+                {
+                    Expect.Call(_userRegistry.GetSubKeyNames())
+                        .Return(new[] { "Blah", "BlahBlah", Keyring.RootPath})
+                        .Repeat.Once();
+
+                    Expect.Call(() => _keyringsRoot.Dispose())
+                        .Repeat.Any();
+
+                    Expect.Call(_userRegistry.OpenSubKey(Keyring.RootPath))
+                        .Return(_keyringsRoot)
+                        .Repeat.Once();
+
+                    Expect.Call(_keyringsRoot.GetSubKeyNames())
+                        .Return(new string[] { })
+                        .Repeat.Once();
+
+                    Expect.Call(_userRegistry.OpenSubKey(Keyring.RootPath))
+                        .Return(_keyringsRoot)
+                        .Repeat.Once();
+
+                    Expect.Call(_keyringsRoot.CreateSubKey(keyringName))
+                        .Return(_keyringKey)
+                        .Repeat.Once();
+
+                    Expect.Call(() => _keyringKey.Dispose())
+                        .Repeat.Any();
+
+                    Expect.Call(_userRegistry.OpenSubKey(Keyring.RootPath))
+                        .Return(_keyringsRoot)
+                        .Repeat.Once();
+
+                    Expect.Call(_keyringsRoot.OpenSubKey(keyringName))
+                        .Return(_keyringKey)
+                        .Repeat.Once();
+
+                    Expect.Call(_dataProtector.Protect(secret,
+                        Encoding.UTF8.GetBytes(Keyring.Entropy), DataProtectionScope.CurrentUser))
+                        .Return(secret)
+                        .Repeat.Once();
+
+                    Expect.Call(() => _keyringKey.SetValue(applicationName, secret))
+                        .Repeat.Once();
+
+                }
+            }
+            using (_mocks.Playback())
+            {
+                _keyring.CreateSecret(keyringName, applicationName, secret);
+            }
+        }
+
+        [TestCase("Default", "UbuntuOne", "myPassword")]
+        [TestCase("Default", "Mandel", "Secret")]
+        [TestCase("Test", "Leo", "MySecret")]
+        public void CreateSecretPresentKeyringTest(string keyringName, string applicationName, string secret)
+        {
+            using(_mocks.Record())
+            {
+                using(_mocks.Ordered())
+                {
+                    Expect.Call(_userRegistry.GetSubKeyNames())
+                        .Return(new[] { "Blah", "BlahBlah", Keyring.RootPath })
+                        .Repeat.Once();
+
+                    Expect.Call(() => _keyringsRoot.Dispose())
+                        .Repeat.Any();
+
+                    Expect.Call(_userRegistry.OpenSubKey(Keyring.RootPath))
+                        .Return(_keyringsRoot)
+                        .Repeat.Once();
+
+                    Expect.Call(_keyringsRoot.GetSubKeyNames())
+                        .Return(new[] { keyringName})
+                        .Repeat.Once();
+
+                    Expect.Call(() => _keyringKey.Dispose())
+                        .Repeat.Any();
+
+                    Expect.Call(_userRegistry.OpenSubKey(Keyring.RootPath))
+                        .Return(_keyringsRoot)
+                        .Repeat.Once();
+
+                    Expect.Call(_keyringsRoot.OpenSubKey(keyringName))
+                        .Return(_keyringKey)
+                        .Repeat.Once();
+
+                    Expect.Call(_dataProtector.Protect(secret,
+                        Encoding.UTF8.GetBytes(Keyring.Entropy), DataProtectionScope.CurrentUser))
+                        .Return(secret)
+                        .Repeat.Once();
+
+                    Expect.Call(() => _keyringKey.SetValue(applicationName, secret))
+                        .Repeat.Once();
+                }
+            }
+            using(_mocks.Playback())
+            {
+                _keyring.CreateSecret(keyringName, applicationName, secret);
+            }
+        }
+
+        [TestCase("Default", "UbuntuOne")]
+        [TestCase("Keyring", "AppNAme")]
+        public void GetSecretByNameNotKeyringTest(string keyringName, string applicationName)
+        {
+            using(_mocks.Record())
+            {
+                Expect.Call(_userRegistry.GetSubKeyNames())
+                        .Return(new[] { "Blah", "BlahBlah" })
+                        .Repeat.Once();
+            }
+            using(_mocks.Playback())
+            {
+                var secret = _keyring.GetSecretByName(keyringName, applicationName);
+                Assert.IsEmpty(secret);
+            }
+        }
+
+        [TestCase("Default", "UbuntuOne")]
+        [TestCase("Keyring", "AppNAme")]
+        public void GetSecretByNameKeyringExistsTest(string keyringName, string applicationName)
+        {
+            using (_mocks.Record())
+            {
+                using (_mocks.Ordered())
+                {
+                    Expect.Call(_userRegistry.GetSubKeyNames())
+                        .Return(new[] { "Blah", "BlahBlah", Keyring.RootPath })
+                        .Repeat.Once();
+
+                    Expect.Call(() => _keyringsRoot.Dispose())
+                        .Repeat.Any();
+
+                    Expect.Call(_userRegistry.OpenSubKey(Keyring.RootPath))
+                        .Return(_keyringsRoot)
+                        .Repeat.Once();
+
+                    Expect.Call(_keyringsRoot.GetSubKeyNames())
+                        .Return(new[] { keyringName })
+                        .Repeat.Once();
+
+                    Expect.Call(() => _keyringKey.Dispose())
+                        .Repeat.Any();
+
+                    Expect.Call(_userRegistry.OpenSubKey(Keyring.RootPath))
+                        .Return(_keyringsRoot)
+                        .Repeat.Once();
+
+                    Expect.Call(_keyringsRoot.OpenSubKey(keyringName))
+                        .Return(_keyringKey)
+                        .Repeat.Once();
+
+                    Expect.Call(_keyringKey.GetValue(applicationName))
+                        .Return(applicationName)
+                        .Repeat.Once();
+
+                    Expect.Call(_dataProtector.Unprotect("",
+                        Encoding.UTF8.GetBytes(Keyring.Entropy), DataProtectionScope.CurrentUser))
+                        .IgnoreArguments()
+                        .Return(applicationName)
+                        .Repeat.Once();
+
+                }
+            }
+            using (_mocks.Playback())
+            {
+                var secret = _keyring.GetSecretByName(keyringName, applicationName);
+                Assert.AreEqual(applicationName, secret);
+            }
+        }
+
+        [Test]
+        public void GetKeyringsTest()
+        {
+            var keyrings = new[] {"Default", "Test", "Test1"};
+
+            using(_mocks.Record())
+            {
+                // make it such that the root is present
+                Expect.Call(_userRegistry.GetSubKeyNames())
+                        .Return(new[] { "Blah", "BlahBlah", Keyring.RootPath })
+                        .Repeat.Once();
+
+                Expect.Call(() => _keyringsRoot.Dispose())
+                    .Repeat.Any();
+
+                Expect.Call(_userRegistry.OpenSubKey(Keyring.RootPath))
+                    .Return(_keyringsRoot)
+                    .Repeat.Once();
+
+                Expect.Call(_keyringsRoot.GetSubKeyNames())
+                    .Return(keyrings)
+                    .Repeat.Once();
+
+            }
+            using(_mocks.Playback())
+            {
+                Assert.AreSame(_keyring.GetKeyrings(), keyrings);
+            }
+        }
+
+        [Test]
+        public void GetKeyringsNotRootTest()
+        {
+            using (_mocks.Record())
+            {
+                // make it such that the root is present
+                Expect.Call(_userRegistry.GetSubKeyNames())
+                        .Return(new[] { "Blah", "BlahBlah"})
+                        .Repeat.Once();
+            }
+            using (_mocks.Playback())
+            {
+                Assert.AreEqual(0, _keyring.GetKeyrings().Count());
+            }
+        }
+
+        [TestCase("Default")]
+        [TestCase("Test")]
+        public void GetApplicationsTest(string keyringName)
+        {
+            var applications = new[] {"Ubuntu One", "Test", "Default"};
+            using(_mocks.Record())
+            {
+                Expect.Call(_userRegistry.GetSubKeyNames())
+                        .Return(new[] { "Blah", "BlahBlah", Keyring.RootPath })
+                        .Repeat.Once();
+
+                Expect.Call(() => _keyringsRoot.Dispose())
+                    .Repeat.Any();
+
+                Expect.Call(_userRegistry.OpenSubKey(Keyring.RootPath))
+                    .Return(_keyringsRoot)
+                    .Repeat.Twice();
+
+                Expect.Call(_keyringsRoot.GetSubKeyNames())
+                    .Return(new[] { keyringName })
+                    .Repeat.Once();
+
+                Expect.Call(_keyringsRoot.OpenSubKey(keyringName))
+                    .Return(_keyringKey)
+                    .Repeat.Once();
+
+                Expect.Call(_keyringKey.GetSubKeyNames())
+                    .Return(applications)
+                    .Repeat.Once();
+
+                Expect.Call(() => _keyringKey.Dispose())
+                    .Repeat.Any();
+            }
+            using(_mocks.Playback())
+            {
+                Assert.AreSame(applications, _keyring.GetApplications(keyringName));
+            }
+        }
+
+        [Test]
+        public void GetApplicationNotKeyringTest()
+        {
+            using (_mocks.Record())
+            {
+                // make it such that the root is present
+                Expect.Call(_userRegistry.GetSubKeyNames())
+                        .Return(new[] { "Blah", "BlahBlah" })
+                        .Repeat.Once();
+            }
+            using(_mocks.Playback())
+            {
+                Assert.AreEqual(0, _keyring.GetApplications("Test").Count());
+            }
+        }
+
+        #endregion
+    }
+}
 
=== added directory 'src/Canonical.Ubuntu.SSO.Tests/Properties'
=== added file 'src/Canonical.Ubuntu.SSO.Tests/Properties/AssemblyInfo.cs'
--- src/Canonical.Ubuntu.SSO.Tests/Properties/AssemblyInfo.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.Ubuntu.SSO.Tests/Properties/AssemblyInfo.cs	2010-09-17 16:23:44 +0000
@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Canonical.Ubuntu.SSO.Tests")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Canonical.Ubuntu.SSO.Tests")]
+[assembly: AssemblyCopyright("Copyright ©  2010")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("055a2726-2682-4018-8c48-e1795da59ab2")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
 
=== modified file 'src/Canonical.Ubuntu.SSO/Canonical.Ubuntu.SSO.csproj'
--- src/Canonical.Ubuntu.SSO/Canonical.Ubuntu.SSO.csproj	2010-09-08 11:23:58 +0000
+++ src/Canonical.Ubuntu.SSO/Canonical.Ubuntu.SSO.csproj	2010-09-17 16:23:44 +0000
@@ -31,10 +31,15 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="log4net, Version=1.2.10.0, Culture=neutral, PublicKeyToken=1b44e1d426115821, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\lib\log4net\log4net.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core">
       <RequiredTargetFramework>3.5</RequiredTargetFramework>
     </Reference>
+    <Reference Include="System.Security" />
     <Reference Include="System.Xml.Linq">
       <RequiredTargetFramework>3.5</RequiredTargetFramework>
     </Reference>
@@ -45,17 +50,31 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="..\Version.cs">
+      <Link>Properties\Version.cs</Link>
+    </Compile>
     <Compile Include="CredentialsDeniedEventArgs.cs" />
     <Compile Include="CredentialsErrorEventArgs.cs" />
     <Compile Include="CredentialsFoundEventArgs.cs" />
+    <Compile Include="DPAPIDataProtector.cs" />
+    <Compile Include="IDataProtector.cs" />
     <Compile Include="ILoginOrRegisterView.cs" />
     <Compile Include="ILoginView.cs" />
+    <Compile Include="IRegistryKey.cs" />
+    <Compile Include="Keyring.cs" />
     <Compile Include="LoginCredentialsEventArgs.cs" />
+    <Compile Include="RegistryKeyWrapper.cs" />
     <Compile Include="SSOCredentialsProvider.cs" />
     <Compile Include="IKeyring.cs" />
     <Compile Include="ISSOCredentialsProvider.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\Canonical.UbuntuOne.Common\Canonical.UbuntuOne.Common.csproj">
+      <Project>{11353FF8-8E5A-488E-9CB1-873DADD232B9}</Project>
+      <Name>Canonical.UbuntuOne.Common</Name>
+    </ProjectReference>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
 
=== added file 'src/Canonical.Ubuntu.SSO/DPAPIDataProtector.cs'
--- src/Canonical.Ubuntu.SSO/DPAPIDataProtector.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.Ubuntu.SSO/DPAPIDataProtector.cs	2010-09-17 16:23:44 +0000
@@ -0,0 +1,65 @@
+/*
+ * 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.Security.Cryptography;
+using System.Text;
+
+namespace Canonical.Ubuntu.SSO
+{
+    /// <summary>
+    /// Implementation of the IDataProtector that uses the DAPI api to perform the protection.
+    /// </summary>
+    public class DPAPIDataProtector : IDataProtector
+    {
+        #region Implementation of IDataProtector
+
+        /// <summary>
+        /// Protects the userData parameter and returns a string.
+        /// </summary>
+        /// <param name="userData">A string containing data to protect. </param>
+        /// <param name="optionalEntropy">An additional byte array used to encrypt the data. </param>
+        /// <param name="scope">One of the DataProtectionScope values.</param>
+        /// <returns>A string representing the encrypted data.</returns>
+        public string Protect(string userData, byte[] optionalEntropy, DataProtectionScope scope)
+        {
+            var userDataBytes = Encoding.UTF8.GetBytes(userData);
+            var encryptedBytes = ProtectedData.Protect(userDataBytes, optionalEntropy, scope);
+            var enc = new UTF8Encoding(false);
+            return enc.GetString(encryptedBytes);
+        }
+
+        /// <summary>
+        /// Unprotects the encryptedData parameter and returns a string.
+        /// </summary>
+        /// <param name="encryptedData">A string containing data encrypted using the Protect method.</param>
+        /// <param name="optionalEntropy">An additional byte array used to encrypt the data.</param>
+        /// <param name="scope">One of the DataProtectionScope values. </param>
+        /// <returns>A string representing the unprotected data.</returns>
+        public string Unprotect(string encryptedData, byte[] optionalEntropy, DataProtectionScope scope)
+        {
+            var encryptedDataBytes = Encoding.UTF8.GetBytes(encryptedData);
+            var userDataBytes = ProtectedData.Unprotect(encryptedDataBytes, optionalEntropy, scope);
+            var enc = new UTF8Encoding(false);
+            return enc.GetString(userDataBytes);
+        }
+
+        #endregion
+    }
+}
 
=== added file 'src/Canonical.Ubuntu.SSO/IDataProtector.cs'
--- src/Canonical.Ubuntu.SSO/IDataProtector.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.Ubuntu.SSO/IDataProtector.cs	2010-09-17 16:23:44 +0000
@@ -0,0 +1,48 @@
+/*
+ * 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.Security.Cryptography;
+
+namespace Canonical.Ubuntu.SSO
+{
+    /// <summary>
+    /// Interface to be implemented by those objects that are able to encryp and decrypt users
+    /// data to protect it.
+    /// </summary>
+    public interface IDataProtector
+    {
+        /// <summary>
+        /// Protects the userData parameter and returns a string.
+        /// </summary>
+        /// <param name="userData">A string containing data to protect. </param>
+        /// <param name="optionalEntropy">An additional byte array used to encrypt the data. </param>
+        /// <param name="scope">One of the DataProtectionScope values.</param>
+        /// <returns>A string representing the encrypted data.</returns>
+        string Protect(string userData, byte[] optionalEntropy, DataProtectionScope scope);
+
+        /// <summary>
+        /// Unprotects the encryptedData parameter and returns a string.
+        /// </summary>
+        /// <param name="encryptedData">A string containing data encrypted using the Protect method.</param>
+        /// <param name="optionalEntropy">An additional byte array used to encrypt the data.</param>
+        /// <param name="scope">One of the DataProtectionScope values. </param>
+        /// <returns>A string representing the unprotected data.</returns>
+        string Unprotect(string encryptedData, byte[] optionalEntropy, DataProtectionScope scope);
+    }
+}
 
=== modified file 'src/Canonical.Ubuntu.SSO/IKeyring.cs'
--- src/Canonical.Ubuntu.SSO/IKeyring.cs	2010-09-09 09:11:07 +0000
+++ src/Canonical.Ubuntu.SSO/IKeyring.cs	2010-09-17 16:23:44 +0000
@@ -17,6 +17,7 @@
  * 
  * Authors: Manuel de la Peña <[e-mail]>
  */
+using System;
 using System.Collections.Generic;
 
 namespace Canonical.Ubuntu.SSO
@@ -25,7 +26,7 @@
     /// Interface to be implemented by a class that allows to store data in the registry of the 
     /// current user and makes the class behave like a keyring.
     /// </summary>
-    public interface IKeyring
+    public interface IKeyring : IDisposable
     {
         /// <summary>
         /// Creates a new secret in the the keyring with the given name for a given applciation.
@@ -36,11 +37,11 @@
         void CreateSecret(string keyringName, string applicationName, string secret);
 
         /// <summary>
-        /// 
+        /// Gets the secret froma keyring using the name of the application that stored it.
         /// </summary>
-        /// <param name="keyringName"></param>
-        /// <param name="applicationName"></param>
-        /// <returns></returns>
+        /// <param name="keyringName">The name of the keyring where the secret was stored.</param>
+        /// <param name="applicationName">the name of the application that stored the secret.</param>
+        /// <returns>An empty string if the secret does not exist, the secret otherwhise.</returns>
         string GetSecretByName(string keyringName, string applicationName);
 
         /// <summary>
@@ -52,8 +53,8 @@
         /// <summary>
         /// Gets a list with all the applications in a keyring.
         /// </summary>
-        /// <param name="keyring">The name of the keyring that is queried.</param>
+        /// <param name="keyringName">The name of the keyring that is queried.</param>
         /// <returns>An enumerable with all the applications in the keyring.</returns>
-        IEnumerable<string> GetApplications(string keyring);
+        IEnumerable<string> GetApplications(string keyringName);
     }
 }
 
=== added file 'src/Canonical.Ubuntu.SSO/IRegistryKey.cs'
--- src/Canonical.Ubuntu.SSO/IRegistryKey.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.Ubuntu.SSO/IRegistryKey.cs	2010-09-17 16:23:44 +0000
@@ -0,0 +1,171 @@
+/*
+ * 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 Microsoft.Win32;
+
+namespace Canonical.Ubuntu.SSO
+{
+    /// <summary>
+    /// Interface that represents a class that allows to perform the access to 
+    /// the registry keys of the machine.
+    /// </summary>
+    public interface IRegistryKey : IDisposable
+    {
+        #region Properties
+
+        /// <summary>
+        /// Retrieves the name of the key.
+        /// </summary>
+        string Name { get; }
+
+        /// <summary>
+        /// Retrieves the count of subkeys of the current key.
+        /// </summary>
+        int SubKeyCount { get; }
+
+        /// <summary>
+        /// Retrieves the count of values in the key.
+        /// </summary>
+        int ValueCount { get; }
+
+        #endregion
+
+        #region Methods
+
+        /// <summary>
+        /// Closes the key and flushes it to disk if its contents have been modified.
+        /// </summary>
+        void Close();
+
+        /// <summary>
+        /// Creates a new subkey or opens an existing subkey for write access. 
+        /// The string subkey is not case-sensitive.
+        /// </summary>
+        /// <param name="name">The name or path of the subkey to create or open. </param>
+        /// <returns>A sub key to work with.</returns>
+        IRegistryKey CreateSubKey(string name);
+
+        /// <summary>
+        /// Creates a new subkey or opens an existing subkey for write access, using the specified 
+        /// permission check option. The string subkey is not case-sensitive.
+        /// </summary>
+        /// <param name="subkey">The name or path of the subkey to create or open.</param>
+        /// <param name="permissionCheck">One of the RegistryKeyPermissionCheck values that 
+        /// specifies whether the key is opened for read or read/write access.</param>
+        /// <returns>A subkey to work with.</returns>
+        IRegistryKey CreateSubKey(string subkey, RegistryKeyPermissionCheck permissionCheck);
+        
+        /// <summary>
+        /// Deletes the specified subkey. The string subkey is not case-sensitive.
+        /// </summary>
+        /// <param name="subkey">The name of the subkey to delete. </param>
+        void DeleteSubKey(string subkey);
+
+        /// <summary>
+        /// Deletes the specified value from this key.
+        /// </summary>
+        /// <param name="name">The name of the value to delete.</param>
+        void DeleteValue(string name);
+
+        /// <summary>
+        /// Writes all the attributes of the specified open registry 
+        /// key into the registry.
+        /// </summary>
+        void Flush();
+
+        /// <summary>
+        /// Retrieves an array of strings that contains all the subkey names.
+        /// </summary>
+        /// <returns>An array of strings that contains the names of the 
+        /// subkeys for the current key.</returns>
+        string[] GetSubKeyNames();
+
+        /// <summary>
+        /// Retrieves the value associated with the specified name. 
+        /// Returns null if the name/value pair does not exist in the registry.
+        /// </summary>
+        /// <param name="name">The name of the value to retrieve. </param>
+        /// <returns>The value associated with name, or null if name is not found.</returns>
+        object GetValue(string name);
+
+        /// <summary>
+        /// Retrieves the value associated with the specified name. 
+        /// If the name is not found, returns the default value that you provide.
+        /// </summary>
+        /// <param name="name">The name of the value to retrieve.</param>
+        /// <param name="defaultValue">The value to return if name does not exist.</param>
+        /// <returns>The value associated with name, with any embedded 
+        /// environment variables left unexpanded, or defaultValue if name is not found.</returns>
+        object GetValue(string name, object defaultValue);
+
+        /// <summary>
+        /// Retrieves the registry data type of the value associated with the specified name.
+        /// </summary>
+        /// <param name="name">The name of the value whose registry data type is to be retrieved. </param>
+        /// <returns>A RegistryValueKind value representing the registry 
+        /// data type of the value associated with name.</returns>
+        RegistryValueKind GetValueKind(string name);
+
+        /// <summary>
+        /// Retrieves an array of strings that contains all the 
+        /// value names associated with this key.
+        /// </summary>
+        /// <returns>An array of strings that contains 
+        /// the value names for the current key.</returns>
+        string[] GetValueNames();
+
+        /// <summary>
+        /// Retrieves a subkey as read-only.
+        /// </summary>
+        /// <param name="name">The name or path of the subkey to open read-only. </param>
+        /// <returns>The subkey requested, or null if the operation failed.</returns>
+        IRegistryKey OpenSubKey(string name);
+
+        /// <summary>
+        /// Retrieves the specified subkey for read or read/write access.
+        /// </summary>
+        /// <param name="name">The name or path of the subkey to create or open.</param>
+        /// <param name="permissionCheck">One of the RegistryKeyPermissionCheck values 
+        /// that specifies whether the key is opened for read or read/write access.</param>
+        /// <returns></returns>
+        IRegistryKey OpenSubKey(string name, RegistryKeyPermissionCheck permissionCheck);
+
+        /// <summary>
+        /// Sets the specified name/value pair.
+        /// </summary>
+        /// <param name="name">The name of the value to store. </param>
+        /// <param name="value">The data to be stored.</param>
+        void SetValue(string name, Object value);
+
+        /// <summary>
+        /// Sets the value of a name/value pair in the registry key, using the specified registry data type.
+        /// </summary>
+        /// <param name="name">The name of the value to be stored. </param>
+        /// <param name="value">The data to be stored. </param>
+        /// <param name="valueKind">The registry data type to use when storing the data</param>
+        void SetValue(string name, Object value, RegistryValueKind valueKind);
+
+        #endregion
+
+
+
+    }
+}
 
=== added file 'src/Canonical.Ubuntu.SSO/Keyring.cs'
--- src/Canonical.Ubuntu.SSO/Keyring.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.Ubuntu.SSO/Keyring.cs	2010-09-17 16:23:44 +0000
@@ -0,0 +1,282 @@
+/*
+ * 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.Collections.Generic;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Text;
+using Canonical.UbuntuOne.Common.Validation;
+using log4net;
+
+namespace Canonical.Ubuntu.SSO
+{
+    /// <summary>
+    /// Implementation of the IKeyring interface that will store encripted secrets in the users current keyring.
+    /// </summary>
+    public class Keyring : IKeyring
+    {
+        #region Variables
+
+        internal const string RootPath = "Canonical\\Keyrings";
+        internal const string Entropy = "bdc97980-bbfa-11df-851a-0800200c9a66";
+        private const int KeyringMaxNameLength = 255;
+        private ILog _logger;
+        private readonly object _loggerLock = new object();
+        private bool _keyringsRootExists = false;
+
+        #endregion
+
+        #region DI properties
+
+        /// <summary>
+        /// Gets and sets the users registry key.
+        /// </summary>
+        public IRegistryKey UserRegistry { get; set; }
+
+        /// <summary>
+        /// Gets and sets the data protector to secure the data in the registry.
+        /// </summary>
+        public IDataProtector DataProtector { get; set; }
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Gets and sets the logger that will be used to log the operation of the
+        /// class.
+        /// </summary>
+        public ILog Logger
+        {
+            get
+            {
+                if (_logger == null)
+                {
+                    lock (_loggerLock)
+                    {
+                        _logger = LogManager.GetLogger(typeof(Keyring));
+                    }
+                }
+                return _logger;
+            }
+            set
+            {
+                _logger = value;
+            }
+        }
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Creates a new instance of the class that will be using the users registry to store the data.
+        /// </summary>
+        public Keyring()
+            : this(new RegistryKeyWrapper())
+        {
+            
+        }
+
+        /// <summary>
+        /// Creates a new instance of the class that will be storing the keyring in the provided registry key.
+        /// </summary>
+        /// <param name="key"></param>
+        public Keyring(IRegistryKey key)
+        {
+            UserRegistry = key;
+        }
+
+        #endregion
+
+        #region Helpers
+
+        private bool KeyringsRootExists()
+        {
+            if (!_keyringsRootExists)
+            {
+                var rootKey = from key in UserRegistry.GetSubKeyNames()
+                              where key == RootPath
+                              select key;
+                _keyringsRootExists = rootKey.Count() == 1;
+            }
+            return _keyringsRootExists;
+        }
+
+        private bool KeyringExist(string keyring)
+        {
+            // open the root keyring and then the subkeyring to ensure that the
+            // length of the string is not over 255 chars
+            if (!KeyringsRootExists())
+                return false;
+
+            using (var rootKeyring = UserRegistry.OpenSubKey(RootPath))
+            {
+                var presentKeyrings = from key in rootKeyring.GetSubKeyNames()
+                                      where key == keyring
+                                      select key;
+                return presentKeyrings.Count() == 1;
+            }
+        }
+
+        private IRegistryKey CreateKeyringRootPath()
+        {
+            // create a key with the root path to be used
+            return UserRegistry.CreateSubKey(RootPath);
+        }
+
+        private void CreateKeyring(string keyring)
+        {
+            using(var rootKey = (KeyringsRootExists())?
+                UserRegistry.OpenSubKey(RootPath) : CreateKeyringRootPath())
+            {
+                var subkey = rootKey.CreateSubKey(keyring);
+                subkey.Dispose();
+            }
+        }
+
+        private IRegistryKey OpenKeyring(string keyring)
+        {
+            using(var rootKey = UserRegistry.OpenSubKey(RootPath))
+            {
+                return rootKey.OpenSubKey(keyring);
+            }
+        }
+
+        private void SaveValue(string keyringName, string applicationName, string secret)
+        {
+            using(var keyring = OpenKeyring(keyringName))
+            {
+                var encryptedSecret = DataProtector.Protect(secret, Encoding.UTF8.GetBytes(Entropy),
+                    DataProtectionScope.CurrentUser);
+                keyring.SetValue(applicationName, encryptedSecret);
+            }
+        }
+
+        private string GetValue(string keyringName, string applicationName)
+        {
+            using (var keyring = OpenKeyring(keyringName))
+            {
+                var secret = keyring.GetValue(applicationName) as string;
+                return DataProtector.Unprotect(secret, Encoding.UTF8.GetBytes(Entropy), DataProtectionScope.CurrentUser);
+            }    
+        }
+
+
+        #endregion
+
+        #region Implementation of IKeyring
+
+        /// <summary>
+        /// Creates a new secret in the the keyring with the given name for a given applciation.
+        /// </summary>
+        /// <param name="keyringName">The name of the keyring where the secret will be stored.</param>
+        /// <param name="applicationName">The name of the application whose secret will be stored.</param>
+        /// <param name="secret">The secret to store in the keyring.</param>
+        public void CreateSecret(string keyringName, string applicationName, string secret)
+        {
+            ValidateArgs.Begin()
+                .IsNotNullOrEmpty(keyringName, "keyringName")
+                .IsShorterThan(keyringName, KeyringMaxNameLength, "keyringName")
+                .IsNotNullOrEmpty(applicationName, "applicationName")
+                .IsNotNullOrEmpty(secret, "secret")
+                .Check();
+
+            if (!KeyringExist(keyringName))
+            {
+                CreateKeyring(keyringName);
+                Logger.InfoFormat("Creating keyring with name {0}", keyringName);
+            }
+            SaveValue(keyringName, applicationName, secret);
+        }
+
+        /// <summary>
+        /// Gets the secret froma keyring using the name of the application that stored it.
+        /// </summary>
+        /// <param name="keyringName">The name of the keyring where the secret was stored.</param>
+        /// <param name="applicationName">the name of the application that stored the secret.</param>
+        /// <returns>An empty string if the secret does not exist, the secret otherwhise.</returns>
+        public string GetSecretByName(string keyringName, string applicationName)
+        {
+            ValidateArgs.Begin()
+                .IsNotNullOrEmpty(keyringName, "keyringName")
+                .IsShorterThan(keyringName, KeyringMaxNameLength, "keyringName")
+                .IsNotNullOrEmpty(applicationName, "applicationName")
+                .Check();
+
+            return KeyringExist(keyringName) ? GetValue(keyringName, applicationName) : string.Empty;
+        }
+
+        /// <summary>
+        /// Gets a lists with all the names of the available keyrings.
+        /// </summary>
+        /// <returns>An enumerable with all the names of the different keyrings.</returns>
+        public IEnumerable<string> GetKeyrings()
+        {
+            if(KeyringsRootExists())
+            {
+                using(var keyringRoot =  UserRegistry.OpenSubKey(RootPath))
+                {
+                    return keyringRoot.GetSubKeyNames();
+                }
+            }
+            return new string[0];
+        }
+
+        /// <summary>
+        /// Gets a list with all the applications in a keyring.
+        /// </summary>
+        /// <param name="keyringName">The name of the keyring that is queried.</param>
+        /// <returns>An enumerable with all the applications in the keyring.</returns>
+        public IEnumerable<string> GetApplications(string keyringName)
+        {
+            ValidateArgs.Begin()
+                .IsNotNullOrEmpty(keyringName, "keyring")
+                .IsShorterThan(keyringName, KeyringMaxNameLength, "keyring")
+                .Check();
+            if(KeyringExist(keyringName))
+            {
+                using(var keyringRoot = UserRegistry.OpenSubKey(RootPath))
+                {
+                    using(var keyring = keyringRoot.OpenSubKey(keyringName))
+                    {
+                        return keyring.GetSubKeyNames();
+                    }
+                }
+            }
+            return new string[0];
+        }
+
+        #endregion
+
+        #region Implementation of IDisposable
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+        /// </summary>
+        /// <filterpriority>2</filterpriority>
+        public void Dispose()
+        {
+            if (UserRegistry != null)
+                UserRegistry.Dispose();
+        }
+
+        #endregion
+    }
+}
 
=== modified file 'src/Canonical.Ubuntu.SSO/Properties/AssemblyInfo.cs'
--- src/Canonical.Ubuntu.SSO/Properties/AssemblyInfo.cs	2010-09-08 11:23:58 +0000
+++ src/Canonical.Ubuntu.SSO/Properties/AssemblyInfo.cs	2010-09-17 16:23:44 +0000
@@ -32,5 +32,4 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.0.0.0")]
-[assembly: AssemblyFileVersion("1.0.0.0")]
+[assembly: InternalsVisibleTo("Canonical.Ubuntu.SSO.Tests")]
 
=== added file 'src/Canonical.Ubuntu.SSO/RegistryKeyWrapper.cs'
--- src/Canonical.Ubuntu.SSO/RegistryKeyWrapper.cs	1970-01-01 00:00:00 +0000
+++ src/Canonical.Ubuntu.SSO/RegistryKeyWrapper.cs	2010-09-17 16:23:44 +0000
@@ -0,0 +1,261 @@
+/*
+ * 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 Microsoft.Win32;
+
+namespace Canonical.Ubuntu.SSO
+{
+    /// <summary>
+    /// Simple wrapper around the registry class that allows the class to be mocked for testing 
+    /// purposes
+    /// </summary>
+    public class RegistryKeyWrapper : IRegistryKey
+    {
+        #region Variables
+
+        private readonly RegistryKey _key;
+
+        #endregion
+
+        #region Constructors
+
+        /// <summary>
+        /// Creates a new registry key that contains information about the default user configuration.
+        /// </summary>
+        public RegistryKeyWrapper()
+            : this(Registry.Users)
+        {
+
+        }
+
+        /// <summary>
+        /// Creates a new registry key wrapper with the given key.
+        /// </summary>
+        /// <param name="key">The key to be wrapped.</param>
+        public RegistryKeyWrapper(RegistryKey key)
+        {
+            _key = key;
+        }
+
+        #endregion
+
+        #region Implementation of IDisposable
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, 
+        /// or resetting unmanaged resources.
+        /// </summary>
+        /// <filterpriority>2</filterpriority>
+        public void Dispose()
+        {
+            var disposable = (IDisposable)_key;
+            disposable.Dispose();
+        }
+
+        #endregion
+
+        #region Implementation of IRegistryKey
+
+        /// <summary>
+        /// Retrieves the name of the key.
+        /// </summary>
+        public string Name
+        {
+            get { return _key.Name; }
+        }
+
+        /// <summary>
+        /// Retrieves the count of subkeys of the current key.
+        /// </summary>
+        public int SubKeyCount
+        {
+            get { return _key.SubKeyCount; }
+        }
+
+        /// <summary>
+        /// Retrieves the count of values in the key.
+        /// </summary>
+        public int ValueCount
+        {
+            get { return _key.ValueCount; }
+        }
+
+        /// <summary>
+        /// Closes the key and flushes it to disk if its contents have been modified.
+        /// </summary>
+        public void Close()
+        {
+            _key.Close();
+        }
+
+        /// <summary>
+        /// Creates a new subkey or opens an existing subkey for write access. 
+        /// The string subkey is not case-sensitive.
+        /// </summary>
+        /// <param name="name">The name or path of the subkey to create or open. </param>
+        /// <returns>A sub key to work with.</returns>
+        public IRegistryKey CreateSubKey(string name)
+        {
+            return new RegistryKeyWrapper(_key.CreateSubKey(name));
+        }
+
+        /// <summary>
+        /// Creates a new subkey or opens an existing subkey for write access, using the specified 
+        /// permission check option. The string subkey is not case-sensitive.
+        /// </summary>
+        /// <param name="subkey">The name or path of the subkey to create or open.</param>
+        /// <param name="permissionCheck">One of the RegistryKeyPermissionCheck values that 
+        /// specifies whether the key is opened for read or read/write access.</param>
+        /// <returns>A subkey to work with.</returns>
+        public IRegistryKey CreateSubKey(string subkey, RegistryKeyPermissionCheck permissionCheck)
+        {
+            return new RegistryKeyWrapper(_key.CreateSubKey(subkey, permissionCheck));
+        }
+
+        /// <summary>
+        /// Deletes the specified subkey. The string subkey is not case-sensitive.
+        /// </summary>
+        /// <param name="subkey">The name of the subkey to delete. </param>
+        public void DeleteSubKey(string subkey)
+        {
+            _key.DeleteSubKey(subkey);
+        }
+
+        /// <summary>
+        /// Deletes the specified value from this key.
+        /// </summary>
+        /// <param name="name">The name of the value to delete.</param>
+        public void DeleteValue(string name)
+        {
+            _key.DeleteValue(name);
+        }
+
+        /// <summary>
+        /// Writes all the attributes of the specified open registry 
+        /// key into the registry.
+        /// </summary>
+        public void Flush()
+        {
+            _key.Flush();
+        }
+
+        /// <summary>
+        /// Retrieves an array of strings that contains all the subkey names.
+        /// </summary>
+        /// <returns>An array of strings that contains the names of the 
+        /// subkeys for the current key.</returns>
+        public string[] GetSubKeyNames()
+        {
+            return _key.GetSubKeyNames();
+        }
+
+        /// <summary>
+        /// Retrieves the value associated with the specified name. 
+        /// Returns null if the name/value pair does not exist in the registry.
+        /// </summary>
+        /// <param name="name">The name of the value to retrieve. </param>
+        /// <returns>The value associated with name, or null if name is not found.</returns>
+        public object GetValue(string name)
+        {
+            return _key.GetValue(name);
+        }
+
+        /// <summary>
+        /// Retrieves the value associated with the specified name. 
+        /// If the name is not found, returns the default value that you provide.
+        /// </summary>
+        /// <param name="name">The name of the value to retrieve.</param>
+        /// <param name="defaultValue">The value to return if name does not exist.</param>
+        /// <returns>The value associated with name, with any embedded 
+        /// environment variables left unexpanded, or defaultValue if name is not found.</returns>
+        public object GetValue(string name, object defaultValue)
+        {
+            return _key.GetValue(name, defaultValue);
+        }
+
+        /// <summary>
+        /// Retrieves the registry data type of the value associated with the specified name.
+        /// </summary>
+        /// <param name="name">The name of the value whose registry data type is to be retrieved. </param>
+        /// <returns>A RegistryValueKind value representing the registry 
+        /// data type of the value associated with name.</returns>
+        public RegistryValueKind GetValueKind(string name)
+        {
+            return _key.GetValueKind(name);
+        }
+
+        /// <summary>
+        /// Retrieves an array of strings that contains all the 
+        /// value names associated with this key.
+        /// </summary>
+        /// <returns>An array of strings that contains 
+        /// the value names for the current key.</returns>
+        public string[] GetValueNames()
+        {
+            return _key.GetValueNames();
+        }
+
+        /// <summary>
+        /// Retrieves a subkey as read-only.
+        /// </summary>
+        /// <param name="name">The name or path of the subkey to open read-only. </param>
+        /// <returns>The subkey requested, or null if the operation failed.</returns>
+        public IRegistryKey OpenSubKey(string name)
+        {
+            return new RegistryKeyWrapper(_key.OpenSubKey(name));
+        }
+
+        /// <summary>
+        /// Retrieves the specified subkey for read or read/write access.
+        /// </summary>
+        /// <param name="name">The name or path of the subkey to create or open.</param>
+        /// <param name="permissionCheck">One of the RegistryKeyPermissionCheck values 
+        /// that specifies whether the key is opened for read or read/write access.</param>
+        /// <returns></returns>
+        public IRegistryKey OpenSubKey(string name, RegistryKeyPermissionCheck permissionCheck)
+        {
+            return new RegistryKeyWrapper(_key.OpenSubKey(name, permissionCheck));
+        }
+
+        /// <summary>
+        /// Sets the specified name/value pair.
+        /// </summary>
+        /// <param name="name">The name of the value to store. </param>
+        /// <param name="value">The data to be stored.</param>
+        public void SetValue(string name, object value)
+        {
+            _key.SetValue(name, value);
+        }
+
+        /// <summary>
+        /// Sets the value of a name/value pair in the registry key, using the specified registry data type.
+        /// </summary>
+        /// <param name="name">The name of the value to be stored. </param>
+        /// <param name="value">The data to be stored. </param>
+        /// <param name="valueKind">The registry data type to use when storing the data</param>
+        public void SetValue(string name, object value, RegistryValueKind valueKind)
+        {
+            _key.SetValue(name, value, valueKind);
+        }
+
+        #endregion
+    }
+}
 
=== modified file 'src/Canonical.UbuntuOne.Common.Tests/Validation/EqualityExtensionsValidation.cs'
--- src/Canonical.UbuntuOne.Common.Tests/Validation/EqualityExtensionsValidation.cs	2010-07-23 15:50:15 +0000
+++ src/Canonical.UbuntuOne.Common.Tests/Validation/EqualityExtensionsValidation.cs	2010-09-17 16:23:44 +0000
@@ -236,6 +236,44 @@
                 .Check();
         }
 
+        [TestCase("Robert", 255)]
+        [TestCase("true", 5)]
+        public void IsShorterThanTest(string value, int length)
+        {
+            ValidateArgs.Begin()
+                .IsShorterThan(value, length, "")
+                .Check();
+        }
+
+
+        [TestCase("Robert", 2)]
+        [TestCase("true", 1)]
+        [ExpectedException(typeof(ValidationException))]
+        public void IsShorterThanFailTest(string value, int length)
+        {
+            ValidateArgs.Begin()
+                .IsShorterThan(value, length, "")
+                .Check();
+        }
+
+        [TestCase("true", 4)]
+        [TestCase("Robert", 255)]
+        public void IsShorterOrEqualToTest(string value, int length)
+        {
+            ValidateArgs.Begin()
+                .IsShorterOrEqualTo(value, length, "")
+                .Check();
+        }
+
+        [TestCase("Robert", 2)]
+        [TestCase("true", 1)]
+        [ExpectedException(typeof(ValidationException))]
+        public void IsShorterOrEqualToFailTest(string value, int length)
+        {
+            ValidateArgs.Begin()
+                .IsShorterOrEqualTo(value, length, "")
+                .Check();
+        }
         #endregion
 
     }
 
=== modified file 'src/Canonical.UbuntuOne.Common/Validation/EqualityValidationExtensions.cs'
--- src/Canonical.UbuntuOne.Common/Validation/EqualityValidationExtensions.cs	2010-08-11 08:05:19 +0000
+++ src/Canonical.UbuntuOne.Common/Validation/EqualityValidationExtensions.cs	2010-09-17 16:23:44 +0000
@@ -242,5 +242,55 @@
                 (argumentValidation ?? new ArgumentValidation()).AddException(new ArgumentException(
                     string.Format("'{0}' cannot be null or empty.", parameterName)));
         }
+
+        /// <summary>
+        /// Ensures that the string that was passed as argument is not too long.
+        /// </summary>
+        /// <param name="argumentValidation">
+        /// A <see cref="ArgumentValidation"/> with the current result of the validations.
+        /// </param>
+        /// <param name="value">
+        /// A <see cref="System.String"/> with the argument to validate.
+        /// </param>
+        /// <param name="length">
+        /// An int with the length not to be excided by the string.
+        /// </param>
+        /// <param name="parameterName">The name of the parameter under test.</param>
+        /// <returns>
+        /// A <see cref="ArgumentValidation"/> the result of the validation.
+        /// </returns>
+        public static ArgumentValidation IsShorterThan(this ArgumentValidation argumentValidation, string value,
+            int length, string parameterName)
+        {
+            return (value.Length < length)
+                ? argumentValidation :
+                (argumentValidation ?? new ArgumentValidation()).AddException(new ArgumentException(
+                    string.Format("'{0}' has to be smaller than {1} chars.",parameterName, length)));
+        }
+
+        /// <summary>
+        /// Ensures that the string that was passed as argument is not too long.
+        /// </summary>
+        /// <param name="argumentValidation">
+        /// A <see cref="ArgumentValidation"/> with the current result of the validations.
+        /// </param>
+        /// <param name="value">
+        /// A <see cref="System.String"/> with the argument to validate.
+        /// </param>
+        /// <param name="length">
+        /// An int with the length not to be excided by the string.
+        /// </param>
+        /// <param name="parameterName">The name of the parameter under test.</param>
+        /// <returns>
+        /// A <see cref="ArgumentValidation"/> the result of the validation.
+        /// </returns>
+        public static ArgumentValidation IsShorterOrEqualTo(this ArgumentValidation argumentValidation, string value,
+            int length, string parameterName)
+        {
+            return (value.Length <= length)
+                ? argumentValidation :
+                (argumentValidation ?? new ArgumentValidation()).AddException(new ArgumentException(
+                    string.Format("'{0}' has to be smaller or equalt to {1} chars.", parameterName, length)));
+        }
     }
 }
 
=== modified file 'src/UbuntuOne.sln'
--- src/UbuntuOne.sln	2010-09-08 11:23:58 +0000
+++ src/UbuntuOne.sln	2010-09-17 16:23:44 +0000
@@ -25,6 +25,8 @@
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Canonical.Ubuntu.SSO", "Canonical.Ubuntu.SSO\Canonical.Ubuntu.SSO.csproj", "{9460A771-2589-45DA-9618-9FE8BB7D16E8}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Canonical.Ubuntu.SSO.Tests", "Canonical.Ubuntu.SSO.Tests\Canonical.Ubuntu.SSO.Tests.csproj", "{17BBBEC2-0F4F-48CE-A585-07AA33B6B2B3}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -155,6 +157,16 @@
 		{9460A771-2589-45DA-9618-9FE8BB7D16E8}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
 		{9460A771-2589-45DA-9618-9FE8BB7D16E8}.Release|Mixed Platforms.Build.0 = Release|Any CPU
 		{9460A771-2589-45DA-9618-9FE8BB7D16E8}.Release|x86.ActiveCfg = Release|Any CPU
+		{17BBBEC2-0F4F-48CE-A585-07AA33B6B2B3}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{17BBBEC2-0F4F-48CE-A585-07AA33B6B2B3}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{17BBBEC2-0F4F-48CE-A585-07AA33B6B2B3}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU
+		{17BBBEC2-0F4F-48CE-A585-07AA33B6B2B3}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU
+		{17BBBEC2-0F4F-48CE-A585-07AA33B6B2B3}.Debug|x86.ActiveCfg = Debug|Any CPU
+		{17BBBEC2-0F4F-48CE-A585-07AA33B6B2B3}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{17BBBEC2-0F4F-48CE-A585-07AA33B6B2B3}.Release|Any CPU.Build.0 = Release|Any CPU
+		{17BBBEC2-0F4F-48CE-A585-07AA33B6B2B3}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU
+		{17BBBEC2-0F4F-48CE-A585-07AA33B6B2B3}.Release|Mixed Platforms.Build.0 = Release|Any CPU
+		{17BBBEC2-0F4F-48CE-A585-07AA33B6B2B3}.Release|x86.ActiveCfg = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE