Авторизация пользователя с шифрованным паролем (hash random) в приложение

internal class Password
    {
        private byte[] _salt;       // синхропосылка
        private byte[] _hash;       // хэш пароля
        /*все четыре свойства просто возвращают значения
         * соответствующих полей объекта
         */
        internal string Salt
        {
            get { return Convert.ToBase64String(_salt); }
        }
 
        internal string Hash
        {
            get { return Convert.ToBase64String(_hash); }
        }
 
        internal byte[] RawSalt
        {
            get { return (byte[])_salt.Clone(); }
        }
 
        internal byte[] RawHash
        {
            get { return (byte[])_hash.Clone(); }
        }
        internal Password(string salt, string hash)
        {
            /*Конструктор с двумя строковыми аргументами
             * просто преобразует синхропосылку и хэш из base64
             * в двоичное представление и сохраняет в
             * соответствующих полях класса
             */
            _salt = Convert.FromBase64String(salt);
            _hash = Convert.FromBase64String(hash);
        }
        internal Password(byte[] salt, byte[] hash)
        {
            /*Конструктор, принимающий массивы байт,
             * создает копии входных массивов
             */
            _salt = (byte[])salt.Clone();
            _hash = (byte[])hash.Clone();
        }
        internal Password(char[] clearText)
        {
            /*Конструктор с одним аргументом генерирует
             * случайную синхропосылку и вычисляет хэш
             * предоставленного пароля, используя внутренний
             * метод HashPassword()
             */
            _salt = GenerateRandom(6);
            _hash = HashPassword(clearText);
        }
        /*Метод Verify сначала вычисляет хэш предоставленного
         * пароля, используя все тот же внутренний метод
         * HashPassword, после чего сравнивает байты сохраненного
         * хэша с байтами только что вычисленного хэша. Совпадение
         * всех до одного байтов хэша означает, что пароль верный.
         */
        internal bool Verify(char[] clearText)
        {
            byte[] hash = HashPassword(clearText);
 
            if (hash.Length == _hash.Length)
            {
                for (int i = 0; i < hash.Length; i++)
                {
                    if (hash[i] != _hash[i])
                        return false;
                }
 
                return true;
            }
 
            return false;
        }
        /*Статический метод Generate просто генерирует
         * массив случайных байтов и преобразует его
         * в base64-строку.
         */
        private static char[] Generate()
        {
            char[] random = new char[12];
 
            // генерируем 9 случайных байтов; этого достаточно, чтобы
            // получить 12 случайных символов из набора base64
            byte[] rnd = GenerateRandom(9);
 
            // конвертируем случайные байты в base64
            Convert.ToBase64CharArray(rnd, 0, rnd.Length, random, 0);
 
            // очищаем рабочий массив
            Array.Clear(rnd, 0, rnd.Length);
 
            return random;
        }
        /* Метод записывает синхропосылку и пароль в поток на
         * основе массива байтов, а затем вычисляет хэш
         * содержимого потока. В качестве хэш-функции используется
         * алгоритм SHA-256.
         */
        private byte[] HashPassword(char[] clearText)
        {
            Encoding utf8 = Encoding.UTF8;
            byte[] hash;
 
            // создаем рабочий массив достаточного размера, чтобы вместить
            byte[] data = new byte[_salt.Length
                        + utf8.GetMaxByteCount(clearText.Length)];
 
            try
            {
                // копируем синхропосылку в рабочий массив
                Array.Copy(_salt, 0, data, 0, _salt.Length);
 
                // копируем пароль в рабочий массив, преобразуя его в UTF-8
                int byteCount = utf8.GetBytes(clearText, 0, clearText.Length,
                  data, _salt.Length);
 
                // хэшируем данные массива
                using (HashAlgorithm alg = new SHA256Managed())
                    hash = alg.ComputeHash(data, 0, _salt.Length + byteCount);
            }
            finally
            {
                // очищаем рабочий массив в конце работы, чтобы избежать
                // утечки открытого пароля
                Array.Clear(data, 0, data.Length);
            }
 
            return hash;
        }
        /*Метод GenerateRandom генерирует массив указанной длины,
         * состоящий из случайных байтов.
         */
        private static byte[] GenerateRandom(int size)
        {
            byte[] random = new byte[size];
            RandomNumberGenerator.Create().GetBytes(random);
            return random;
        }
 
    }