Авторизация пользователя. Как хранить логин и пароль

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Security.Cryptography;
 
namespace MyNameSpace
{
    class Encryptor
    {
        string encryPass;
        string encryString;
 
        public Encryptor()
        {
           encryPass = CreSap();
        }
        public Encryptor(string encrStr)
        {
           encryPass= CreSap();
            encryString = Encrypt(encrStr);
        }
        public string EncryptStr
        {
            get { return encryString; }
            set { encryString = Encrypt(value); }
             
        }
    
        double SimAlgEncry(int n)
        {
            if (n == 0)
            {
                return 0;
            }
            else
            {
                if (n == 1)
                {
                    return 1;
                }
                else
                {
                    return SimAlgEncry(n - 1) + SimAlgEncry(n - 2);
                }
            }
        }
        string CreSap()
        {
            return Math.Pow(SimAlgEncry(10),3).ToString();
        }
        /// <summary>
        /// Encrypt string
        /// </summary>
        /// <param name="source_str"></param>
        /// <returns></returns>
        string Encrypt(string source_str)
        {
            // Получаем из строки набор байт, которые будем шифровать
            byte[] source_data = Encoding.UTF8.GetBytes(source_str);
            // Алгоритм 
            SymmetricAlgorithm sa_in = Rijndael.Create();
            // Объект для преобразования данных
            ICryptoTransform ct_in = sa_in.CreateEncryptor(
                (new PasswordDeriveBytes(encryPass, null)).GetBytes(16), new byte[16]);
            // Поток
            MemoryStream ms_in = new MemoryStream();
            // Шифровальщик потока
            CryptoStream cs_in = new CryptoStream(ms_in, ct_in, CryptoStreamMode.Write);
            // Записываем шифрованные данные в поток
            cs_in.Write(source_data, 0, source_data.Length);
            cs_in.FlushFinalBlock();
            // Создаем строку
            return  Convert.ToBase64String(ms_in.ToArray());
            // Выводим зашифрованную строку
 
        }
        /// <summary>
        /// Decrypt string
        /// </summary>
        /// <param name="crypt_str"></param>
        /// <returns></returns>
        string Decrypt(string crypt_str)
        {
            // Получаем массив байт
            byte[] crypt_data = Convert.FromBase64String(crypt_str);
 
            // Алгоритм 
            SymmetricAlgorithm sa_out = Rijndael.Create();
            // Объект для преобразования данных
            ICryptoTransform ct_out = sa_out.CreateDecryptor(
                (new PasswordDeriveBytes(encryPass, null)).GetBytes(16),
                new byte[16]);
            // Поток
            MemoryStream ms_out = new MemoryStream(crypt_data);
            // Расшифровываем поток
            CryptoStream cs_out = new CryptoStream(ms_out, ct_out, CryptoStreamMode.Read);
            // Создаем строку
            StreamReader sr_out = new StreamReader(cs_out);
            string source_out = sr_out.ReadToEnd();
            return source_out;
        }
    }
}

    public static class Cryptor
    {
        private static TripleDES Create3DES(string key)
        {
            MD5 md5 = new MD5CryptoServiceProvider();
            TripleDES des = new TripleDESCryptoServiceProvider();
            des.Key = md5.ComputeHash(Encoding.Unicode.GetBytes(key));
            des.IV = new byte[des.BlockSize / 8];
            return des;
        }
 
        /// <summary>
        /// Шифровка
        /// </summary>
        /// <param name="plainText"></param>
        /// <param name="key"></param>
        /// <returns></returns>
        public static string EncryptTextTo3DES(string plainText, string key)
        {
            TripleDES des = Create3DES(key);
            ICryptoTransform ct = des.CreateEncryptor();
            byte[] input = Encoding.Unicode.GetBytes(plainText);
            byte[] resArr = ct.TransformFinalBlock(input, 0, input.Length);
            string result = Convert.ToBase64String(resArr);
            return result;
        }
 
        /// <summary>
        /// Дешифровка
        /// </summary>
        /// <param name="cypherText"></param>
        /// <param name="key"></param>
        /// <returns></returns>
        public static string DecryptTextFrom3DES(string cypherText, string key)
        {
            byte[] b = Convert.FromBase64String(cypherText);
            TripleDES des = Create3DES(key);
            ICryptoTransform ct = des.CreateDecryptor();
            byte[] output = ct.TransformFinalBlock(b, 0, b.Length);
            return Encoding.Unicode.GetString(output);
        }
    }

    internal class AuthSecurity
    {
        private const string LoginKey = "yty5767shYY#FHhw282h8hf";
        private const string PasswordKey = "Juve8764hs84tw433634342";
 
        /// <summary>
        /// Зашифровать данные для авторизации
        /// </summary>
        /// <param name="login">Логин</param>
        /// <param name="password">Пароль</param>
        /// <returns>Зашифрованные данные авторизации</returns>
        public static AuthData Encrypt(string login, string password)
        {
            string encriptedLogin = Cryptor.EncryptTextTo3DES(login, LoginKey);
            string encriptedPassword = Cryptor.EncryptTextTo3DES(password, PasswordKey);
            return new AuthData(encriptedLogin, encriptedPassword);
        }
 
        /// <summary>
        /// Расшифровать данные для авторизации
        /// </summary>
        /// <param name="cryptedLogin">Зашифрованный логин</param>
        /// <param name="cryptedPassword">Зашифрованный пароль</param>
        /// <returns>Расшифрованные данные авторизации</returns>
        public static AuthData Decrypt(string cryptedLogin, string cryptedPassword)
        {
            string decriptedLogin = Cryptor.DecryptTextFrom3DES(cryptedLogin, LoginKey);
            string decriptedPassword = Cryptor.DecryptTextFrom3DES(cryptedPassword, PasswordKey);
            return new AuthData(decriptedLogin, decriptedPassword);
        }
 
        /// <summary>
        /// Расшифровать данные для авторизации
        /// </summary>
        /// <param name="crypedAuthData">Зашифрованные данные авторизации</param>
        /// <returns>Расшифрованные данные авторизации</returns>
        public static AuthData Decrypt(AuthData crypedAuthData)
        {
            return Decrypt(crypedAuthData.Login, crypedAuthData.Password);
        }
    }

    [Serializable]
    public class AuthData
    {
        public AuthData()
            : this(string.Empty, string.Empty)
        {
        }
 
        public AuthData(string login, string password)
        {
            Login = login;
            Password = password;
        }
 
        public string Login { get; set; }
 
        public string Password { get; set; }
    }