Apply suggestions from code review

more minor fixes before I do larger fixes Co-Authored-By: LogicalPhallacy <44458166+LogicalPhallacy@users.noreply.github.com>
jellyfin · Bond-009 · Mar 7, 2019 · Jan 31, 2019 · Jan 31, 2019 · Feb 12, 2019
commit c31b0b311b339475650aa8812eb57152cac32d80
diff --git a/Emby.Server.Implementations/Cryptography/CryptographyProvider.cs b/Emby.Server.Implementations/Cryptography/CryptographyProvider.cs
@@ -83,7 +83,7 @@ private byte[] PBKDF2(string method, byte[] bytes, byte[] salt, int iterations)
         {
             //downgrading for now as we need this library to be dotnetstandard compliant
             //with this downgrade we'll add a check to make sure we're on the downgrade method at the moment
-            if(method == DefaultHashMethod)
+            if (method == DefaultHashMethod)
             {
                 using (var r = new Rfc2898DeriveBytes(bytes, salt, iterations))
                 {
@@ -96,7 +96,7 @@ private byte[] PBKDF2(string method, byte[] bytes, byte[] salt, int iterations)
 
         public byte[] ComputeHash(string hashMethod, byte[] bytes)
         {
-            return ComputeHash(hashMethod, bytes, new byte[0]);
+            return ComputeHash(hashMethod, bytes, Array.Empty<byte>());
         }
 
         public byte[] ComputeHashWithDefaultMethod(byte[] bytes)
@@ -106,7 +106,7 @@ public byte[] ComputeHashWithDefaultMethod(byte[] bytes)
 
         public byte[] ComputeHash(string hashMethod, byte[] bytes, byte[] salt)
         {
-            if(hashMethod == DefaultHashMethod)
+            if (hashMethod == DefaultHashMethod)
             {
                 return PBKDF2(hashMethod, bytes, salt, _defaultIterations);
             }

diff --git a/Emby.Server.Implementations/Library/DefaultAuthenticationProvider.cs b/Emby.Server.Implementations/Library/DefaultAuthenticationProvider.cs
@@ -101,7 +101,7 @@ private void ConvertPasswordFormat(User user)
             if (!user.Password.Contains("$"))
             {
                 string hash = user.Password;
-                user.Password = String.Format("$SHA1${0}", hash);
+                user.Password = string.Format("$SHA1${0}", hash);
             }
 
             if (user.EasyPassword != null && !user.EasyPassword.Contains("$"))

diff --git a/MediaBrowser.Model/Cryptography/PasswordHash.cs b/MediaBrowser.Model/Cryptography/PasswordHash.cs
@@ -8,34 +8,34 @@ public class PasswordHash
     {
         // Defined from this hash storage spec
         // https://github.com/P-H-C/phc-string-format/blob/master/phc-sf-spec.md
-        // $<id>[$<param>=<value>(,<param>=<value>)*][$<salt>[$<hash>]]
-        // with one slight amendment to ease the transition, we're writing out the bytes in hex
+        // $<id>[$<param>=<value>(,<param>=<value>)*][$<salt>[$<hash>]]
+        // with one slight amendment to ease the transition, we're writing out the bytes in hex
         // rather than making them a BASE64 string with stripped padding
 
-        private string _id;
+        private string _id;
 
-        private Dictionary<string, string> _parameters = new Dictionary<string, string>();
+        private Dictionary<string, string> _parameters = new Dictionary<string, string>();
 
-        private string _salt;
+        private string _salt;
 
-        private byte[] _saltBytes;
+        private byte[] _saltBytes;
 
-        private string _hash;
+        private string _hash;
+
+        private byte[] _hashBytes;
+
+        public string Id { get => _id; set => _id = value; }
+
+        public Dictionary<string, string> Parameters { get => _parameters; set => _parameters = value; }
+
+        public string Salt { get => _salt; set => _salt = value; }
+
+        public byte[] SaltBytes { get => _saltBytes; set => _saltBytes = value; }
+
+        public string Hash { get => _hash; set => _hash = value; }
+
+        public byte[] HashBytes { get => _hashBytes; set => _hashBytes = value; }
 
-        private byte[] _hashBytes;
-
-        public string Id { get => _id; set => _id = value; }
-
-        public Dictionary<string, string> Parameters { get => _parameters; set => _parameters = value; }
-
-        public string Salt { get => _salt; set => _salt = value; }
-
-        public byte[] SaltBytes { get => _saltBytes; set => _saltBytes = value; }
-
-        public string Hash { get => _hash; set => _hash = value; }
-
-        public byte[] HashBytes { get => _hashBytes; set => _hashBytes = value; }
-
         public PasswordHash(string storageString)
         {
             string[] splitted = storageString.Split('$');
@@ -46,14 +46,14 @@ public PasswordHash(string storageString)
                 {
                     if (!string.IsNullOrEmpty(paramset))
                     {
-                        string[] fields = paramset.Split('=');
-                        if (fields.Length == 2)
-                        {
-                            _parameters.Add(fields[0], fields[1]);
-                        }
-                        else
-                        {
-                            throw new Exception($"Malformed parameter in password hash string {paramset}");
+                        string[] fields = paramset.Split('=');
+                        if (fields.Length == 2)
+                        {
+                            _parameters.Add(fields[0], fields[1]);
+                        }
+                        else
+                        {
+                            throw new Exception($"Malformed parameter in password hash string {paramset}");
                         }
                     }
                 }
@@ -89,65 +89,65 @@ public PasswordHash(string storageString)
 
             }
 
-        }
-
+        }
+
         public PasswordHash(ICryptoProvider cryptoProvider)
         {
             _id = cryptoProvider.DefaultHashMethod;
             _saltBytes = cryptoProvider.GenerateSalt();
-            _salt = ConvertToByteString(SaltBytes);
-        }
-
-        public static byte[] ConvertFromByteString(string byteString)
-        {
-            List<byte> bytes = new List<byte>();
-            for (int i = 0; i < byteString.Length; i += 2)
-            {
-                // TODO: NetStandard2.1 switch this to use a span instead of a substring.
-                bytes.Add(Convert.ToByte(byteString.Substring(i, 2),16));
-            }
-
-            return bytes.ToArray();
-        }
-
-        public static string ConvertToByteString(byte[] bytes)
-        {
-            return BitConverter.ToString(bytes).Replace("-", "");
-        }
+            _salt = ConvertToByteString(SaltBytes);
+        }
+
+        public static byte[] ConvertFromByteString(string byteString)
+        {
+            List<byte> bytes = new List<byte>();
+            for (int i = 0; i < byteString.Length; i += 2)
+            {
+                // TODO: NetStandard2.1 switch this to use a span instead of a substring.
+                bytes.Add(Convert.ToByte(byteString.Substring(i, 2), 16));
+            }
+
+            return bytes.ToArray();
+        }
+
+        public static string ConvertToByteString(byte[] bytes)
+        {
+            return BitConverter.ToString(bytes).Replace("-", "");
+        }
 
         private string SerializeParameters()
         {
             string ReturnString = string.Empty;
             foreach (var KVP in _parameters)
             {
                 ReturnString += $",{KVP.Key}={KVP.Value}";
-            }
+            }
 
             if ((!string.IsNullOrEmpty(ReturnString)) && ReturnString[0] == ',')
             {
                 ReturnString = ReturnString.Remove(0, 1);
-            }
+            }
 
             return ReturnString;
         }
 
         public override string ToString()
-        {
-            string outString = "$" +_id;
-            string paramstring = SerializeParameters();
-            if (!string.IsNullOrEmpty(paramstring))
-            {
-                outString += $"${paramstring}";
-            }
-
-            if (!string.IsNullOrEmpty(_salt))
-            {
-                outString += $"${_salt}";
-            }
-
+        {
+            string outString = "$" + _id;
+            string paramstring = SerializeParameters();
+            if (!string.IsNullOrEmpty(paramstring))
+            {
+                outString += $"${paramstring}";
+            }
+
+            if (!string.IsNullOrEmpty(_salt))
+            {
+                outString += $"${_salt}";
+            }
+
             outString += $"${_hash}";
             return outString;
         }
     }
 
-}
+}