Merge pull request #5707 from twitchax/autosave_fix

Fix for Enable-AzureRmContextAutosave in Netcore (#5690).

Author: markcowl

src/Common/Commands.Common.Authentication/Authentication/ProtectedFileTokenCache.cs

@@ -73,27 +73,7 @@ public ProtectedFileTokenCache(string cacheFile, IDataStore store = null)
 
         private void Initialize(string fileName)
         {
-            lock (fileLock)
-            {
-                if (_store.FileExists(fileName))
-                {
-                    var existingData = _store.ReadFileAsBytes(fileName);
-                    if (existingData != null)
-                    {
-                        try
-                        {
-                            Deserialize(ProtectedData.Unprotect(existingData, null, DataProtectionScope.CurrentUser));
-                        }
-                        catch (CryptographicException)
-                        {
-                            _store.DeleteFile(fileName);
-                        }
-                    }
-                }
-                
-                // Create the file to start with
-                _store.WriteFile(CacheFileName, ProtectedData.Protect(Serialize(), null, DataProtectionScope.CurrentUser));
-            }
+            EnsureCacheFile(fileName);
 
             AfterAccess = AfterAccessNotification;
             BeforeAccess = BeforeAccessNotification;
@@ -113,45 +93,109 @@ public override void Clear()
         // Reload the cache from the persistent store in case it changed since the last access.
         void BeforeAccessNotification(TokenCacheNotificationArgs args)
         {
+            ReadFileIntoCache();
+        }
+
+        // Triggered right after ADAL accessed the cache.
+        void AfterAccessNotification(TokenCacheNotificationArgs args)
+        {
+            // if the access operation resulted in a cache update
+            EnsureStateSaved();
+        }
+
+        void EnsureStateSaved()
+        {
+            if (HasStateChanged)
+            {
+                WriteCacheIntoFile();
+            }
+        }
+
+        private void ReadFileIntoCache(string cacheFileName = null)
+        {
+            if(cacheFileName == null)
+            {
+                cacheFileName = ProtectedFileTokenCache.CacheFileName;
+            }
+
             lock (fileLock)
             {
-                if (_store.FileExists(CacheFileName))
+                if (_store.FileExists(cacheFileName))
                 {
-                    var existingData = _store.ReadFileAsBytes(CacheFileName);
+                    var existingData = _store.ReadFileAsBytes(cacheFileName);
                     if (existingData != null)
                     {
+#if !NETSTANDARD
                         try
                         {
                             Deserialize(ProtectedData.Unprotect(existingData, null, DataProtectionScope.CurrentUser));
                         }
                         catch (CryptographicException)
                         {
-                            _store.DeleteFile(CacheFileName);
+                            _store.DeleteFile(cacheFileName);
                         }
+#else
+                        Deserialize(existingData);
+#endif
                     }
                 }
             }
         }
 
-        // Triggered right after ADAL accessed the cache.
-        void AfterAccessNotification(TokenCacheNotificationArgs args)
+        private void WriteCacheIntoFile(string cacheFileName = null)
         {
-            // if the access operation resulted in a cache update
-            EnsureStateSaved();
+            if(cacheFileName == null)
+            {
+                cacheFileName = ProtectedFileTokenCache.CacheFileName;
+            }
+
+#if !NETSTANDARD
+            var dataToWrite = ProtectedData.Protect(Serialize(), null, DataProtectionScope.CurrentUser);
+#else
+            var dataToWrite = Serialize();
+#endif
+
+            lock(fileLock)
+            {
+                if (HasStateChanged)
+                {  
+                    _store.WriteFile(cacheFileName, dataToWrite);
+                    HasStateChanged =  false;
+                }
+            }
         }
 
-        void EnsureStateSaved()
+        private void EnsureCacheFile(string cacheFileName = null)
         {
             lock (fileLock)
             {
-                if (HasStateChanged)
+                if (_store.FileExists(cacheFileName))
                 {
-                    // reflect changes in the persistent store
-                    _store.WriteFile(CacheFileName,
-                    ProtectedData.Protect(Serialize(), null, DataProtectionScope.CurrentUser));
-                    // once the write operation took place, restore the HasStateChanged bit to false
-                    HasStateChanged = false;
+                    var existingData = _store.ReadFileAsBytes(cacheFileName);
+                    if (existingData != null)
+                    {
+#if !NETSTANDARD
+                        try
+                        {
+                            Deserialize(ProtectedData.Unprotect(existingData, null, DataProtectionScope.CurrentUser));
+                        }
+                        catch (CryptographicException)
+                        {
+                            _store.DeleteFile(cacheFileName);
+                        }
+#else
+                        Deserialize(existingData);
+#endif
+                    }
                 }
+                
+                // Eagerly create cache file.
+#if !NETSTANDARD
+                var dataToWrite = ProtectedData.Protect(Serialize(), null, DataProtectionScope.CurrentUser);
+#else
+                var dataToWrite = Serialize();
+#endif
+                _store.WriteFile(cacheFileName, dataToWrite);
             }
         }
     }

src/ServiceManagement/Services/Commands.Test/Profile/ProfileCmdltsTests.cs

@@ -170,15 +170,20 @@ public void ClearAzureProfileClearsTokenCache()
         [Trait(Category.AcceptanceType, Category.CheckIn)]
         public void DeleteCorruptedTokenCache()
         {
-            //setup
+            var corruptData = new byte[] { 0, 1 };
+            
             string testFileName = @"c:\foobar\TokenCache.dat";
-            AzureSession.Instance.DataStore.WriteFile(testFileName, new byte[] { 0, 1 });
+            AzureSession.Instance.DataStore.WriteFile(testFileName, corruptData);
 
-            //Act
+            // Should delete the file because it is corrupt and create a "good" one.
             ProtectedFileTokenCache tokenCache = new ProtectedFileTokenCache(testFileName);
 
-            //Assert
-            Assert.False(AzureSession.Instance.DataStore.FileExists(testFileName));
+            // File should still exist because it was recreated.
+            Assert.True(AzureSession.Instance.DataStore.FileExists(testFileName));
+#if !NETSTANDARD
+            // But the data should not be the same when using DPAPI..
+            Assert.NotEqual(corruptData, tokenCache.CacheData);
+#endif
         }
 
         [Fact]