github · jcansdale · Nov 21, 2017 · Aug 25, 2017 · Aug 25, 2017 · Aug 25, 2017
diff --git a/src/CredentialManagement/Credential.cs b/src/CredentialManagement/Credential.cs
@@ -60,6 +60,28 @@ public Credential(
             _lastWriteTime = DateTime.MinValue;
         }
 
+        public static Credential Load(string key)
+        {
+            var result = new Credential();
+            result.Target = key;
+            result.Type = CredentialType.Generic;
+            return result.Load() ? result : null;
+        }
+
+        public static void Save(string key, string username, string password)
+        {
+            var result = new Credential(username, password, key);
+            result.Save();
+        }
+
+        public static void Delete(string key)
+        {
+            var result = new Credential();
+            result.Target = key;
+            result.Type = CredentialType.Generic;
+            result.Delete();
+        }
+
         bool disposed;
         void Dispose(bool disposing)
         {

diff --git a/src/GitHub.Api/GitHub.Api.csproj b/src/GitHub.Api/GitHub.Api.csproj
@@ -62,12 +62,12 @@
       <Link>ApiClientConfiguration_User.cs</Link>
     </Compile>
     <Compile Include="ApiClientConfiguration_User.cs" Condition="$(Buildtype) != 'Internal'" />
-    <Compile Include="ILoginCache.cs" />
+    <Compile Include="IKeychain.cs" />
     <Compile Include="ILoginManager.cs" />
     <Compile Include="ITwoFactorChallengeHandler.cs" />
     <Compile Include="LoginManager.cs" />
-    <Compile Include="SimpleCredentialStore.cs" />
-    <Compile Include="WindowsLoginCache.cs" />
+    <Compile Include="KeychainCredentialStore.cs" />
+    <Compile Include="WindowsKeychain.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="..\common\SolutionInfo.cs">
       <Link>Properties\SolutionInfo.cs</Link>

diff --git a/src/GitHub.Api/IKeychain.cs b/src/GitHub.Api/IKeychain.cs
@@ -0,0 +1,38 @@
+using System;
+using System.Threading.Tasks;
+using GitHub.Primitives;
+
+namespace GitHub.Api
+{
+    /// <summary>
+    /// Represents a keychain used to store credentials.
+    /// </summary>
+    public interface IKeychain
+    {
+        /// <summary>
+        /// Loads the credentials for the specified host address.
+        /// </summary>
+        /// <param name="address">The host address.</param>
+        /// <returns>
+        /// A task returning a tuple consisting of the retrieved username and password or null
+        /// if the credentials were not found.
+        /// </returns>
+        Task<Tuple<string, string>> Load(HostAddress address);
+
+        /// <summary>
+        /// Saves the credentials for the specified host address.
+        /// </summary>
+        /// <param name="userName">The username.</param>
+        /// <param name="password">The password.</param>
+        /// <param name="address">The host address.</param>
+        /// <returns>A task tracking the operation.</returns>
+        Task Save(string userName, string password, HostAddress address);
+
+        /// <summary>
+        /// Deletes the login details for the specified host address.
+        /// </summary>
+        /// <param name="address"></param>
+        /// <returns>A task tracking the operation.</returns>
+        Task Delete(HostAddress address);
+    }
+}
diff --git a/src/GitHub.Api/ILoginCache.cs b/src/GitHub.Api/ILoginCache.cs
diff --git a/src/GitHub.Api/KeychainCredentialStore.cs b/src/GitHub.Api/KeychainCredentialStore.cs
@@ -0,0 +1,32 @@
+using System;
+using System.Threading.Tasks;
+using GitHub.Extensions;
+using GitHub.Primitives;
+using Octokit;
+
+namespace GitHub.Api
+{
+    /// <summary>
+    /// An Octokit credential store that reads from an <see cref="IKeychain"/>.
+    /// </summary>
+    public class KeychainCredentialStore : ICredentialStore
+    {
+        readonly IKeychain keychain;
+        readonly HostAddress address;
+
+        public KeychainCredentialStore(IKeychain keychain, HostAddress address)
+        {
+            Guard.ArgumentNotNull(keychain, nameof(keychain));
+            Guard.ArgumentNotNull(address, nameof(keychain));
+
+            this.keychain = keychain;
+            this.address = address;
+        }
+
+        public async Task<Credentials> GetCredentials()
+        {
+            var userPass = await keychain.Load(address).ConfigureAwait(false);
+            return userPass != null ? new Credentials(userPass.Item1, userPass.Item2) : Credentials.Anonymous;
+        }
+    }
+}
diff --git a/src/GitHub.Api/LoginManager.cs b/src/GitHub.Api/LoginManager.cs
@@ -13,7 +13,7 @@ namespace GitHub.Api
     public class LoginManager : ILoginManager
     {
         readonly string[] scopes = { "user", "repo", "gist", "write:public_key" };
-        readonly ILoginCache loginCache;
+        readonly IKeychain keychain;
         readonly ITwoFactorChallengeHandler twoFactorChallengeHandler;
         readonly string clientId;
         readonly string clientSecret;
@@ -23,26 +23,26 @@ public class LoginManager : ILoginManager
         /// <summary>
         /// Initializes a new instance of the <see cref="LoginManager"/> class.
         /// </summary>
-        /// <param name="loginCache">The cache in which to store login details.</param>
+        /// <param name="keychain">The keychain in which to store credentials.</param>
         /// <param name="twoFactorChallengeHandler">The handler for 2FA challenges.</param>
         /// <param name="clientId">The application's client API ID.</param>
         /// <param name="clientSecret">The application's client API secret.</param>
         /// <param name="authorizationNote">An note to store with the authorization.</param>
         /// <param name="fingerprint">The machine fingerprint.</param>
         public LoginManager(
-            ILoginCache loginCache,
+            IKeychain keychain,
             ITwoFactorChallengeHandler twoFactorChallengeHandler,
             string clientId,
             string clientSecret,
             string authorizationNote = null,
             string fingerprint = null)
         {
-            Guard.ArgumentNotNull(loginCache, nameof(loginCache));
+            Guard.ArgumentNotNull(keychain, nameof(keychain));
             Guard.ArgumentNotNull(twoFactorChallengeHandler, nameof(twoFactorChallengeHandler));
             Guard.ArgumentNotEmptyString(clientId, nameof(clientId));
             Guard.ArgumentNotEmptyString(clientSecret, nameof(clientSecret));
 
-            this.loginCache = loginCache;
+            this.keychain = keychain;
             this.twoFactorChallengeHandler = twoFactorChallengeHandler;
             this.clientId = clientId;
             this.clientSecret = clientSecret;
@@ -64,7 +64,7 @@ public async Task<User> Login(
 
             // Start by saving the username and password, these will be used by the `IGitHubClient`
             // until an authorization token has been created and acquired:
-            await loginCache.SaveLogin(userName, password, hostAddress).ConfigureAwait(false);
+            await keychain.Save(userName, password, hostAddress).ConfigureAwait(false);
 
             var newAuth = new NewAuthorization
             {
@@ -99,13 +99,13 @@ public async Task<User> Login(
                     }
                     else
                     {
-                        await loginCache.EraseLogin(hostAddress).ConfigureAwait(false);
+                        await keychain.Delete(hostAddress).ConfigureAwait(false);
                         throw;
                     }
                 }
             } while (auth == null);
 
-            await loginCache.SaveLogin(userName, auth.Token, hostAddress).ConfigureAwait(false);
+            await keychain.Save(userName, auth.Token, hostAddress).ConfigureAwait(false);
 
             var retry = 0;
 
@@ -141,7 +141,7 @@ public async Task Logout(HostAddress hostAddress, IGitHubClient client)
             Guard.ArgumentNotNull(hostAddress, nameof(hostAddress));
             Guard.ArgumentNotNull(client, nameof(client));
 
-            await loginCache.EraseLogin(hostAddress);
+            await keychain.Delete(hostAddress);
         }
 
         async Task<ApplicationAuthorization> CreateAndDeleteExistingApplicationAuthorization(
@@ -219,7 +219,7 @@ async Task<ApplicationAuthorization> HandleTwoFactorAuthorization(
                     catch (Exception e)
                     {
                         await twoFactorChallengeHandler.ChallengeFailed(e);
-                        await loginCache.EraseLogin(hostAddress).ConfigureAwait(false);
+                        await keychain.Delete(hostAddress).ConfigureAwait(false);
                         throw;
                     }
                 }

diff --git a/src/GitHub.Api/SimpleApiClientFactory.cs b/src/GitHub.Api/SimpleApiClientFactory.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.ComponentModel.Composition;
 using GitHub.Models;
 using GitHub.Primitives;
@@ -14,15 +13,21 @@ namespace GitHub.Api
     [PartCreationPolicy(CreationPolicy.Shared)]
     public class SimpleApiClientFactory : ISimpleApiClientFactory
     {
+        readonly IKeychain keychain;
         readonly ProductHeaderValue productHeader;
         readonly Lazy<IEnterpriseProbeTask> lazyEnterpriseProbe;
         readonly Lazy<IWikiProbe> lazyWikiProbe;
 
         static readonly ConcurrentDictionary<UriString, ISimpleApiClient> cache = new ConcurrentDictionary<UriString, ISimpleApiClient>();
 
        [ImportingConstructor]
-        public SimpleApiClientFactory(IProgram program, Lazy<IEnterpriseProbeTask> enterpriseProbe, Lazy<IWikiProbe> wikiProbe)
+        public SimpleApiClientFactory(
+            IProgram program,
+            IKeychain keychain,
+            Lazy<IEnterpriseProbeTask> enterpriseProbe,
+            Lazy<IWikiProbe> wikiProbe)
         {
+            this.keychain = keychain;
             productHeader = program.ProductHeader;
             lazyEnterpriseProbe = enterpriseProbe;
             lazyWikiProbe = wikiProbe;
@@ -31,8 +36,9 @@ public SimpleApiClientFactory(IProgram program, Lazy<IEnterpriseProbeTask> enter
         public Task<ISimpleApiClient> Create(UriString repositoryUrl)
         {
             var hostAddress = HostAddress.Create(repositoryUrl);
+            var credentialStore = new KeychainCredentialStore(keychain, hostAddress);
             var result = cache.GetOrAdd(repositoryUrl, new SimpleApiClient(repositoryUrl,
-                new GitHubClient(productHeader, new SimpleCredentialStore(hostAddress), hostAddress.ApiUri),
+                new GitHubClient(productHeader, credentialStore, hostAddress.ApiUri),
                 lazyEnterpriseProbe, lazyWikiProbe));
             return Task.FromResult(result);
         }

diff --git a/src/GitHub.Api/SimpleCredentialStore.cs b/src/GitHub.Api/SimpleCredentialStore.cs