Перебор вариантов

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
 
namespace Brutforce
{
    class Program
    {
        static void Main(string[] args)
        {
            //исходные данные
            string[] dict = { "барк", "ведро", "вишня", "долина", "колос", "кость", "кот",
                "остров", "порт", "абракадабра", "кадабраабра" };
 
            var rule = "аааааббббррркд";
            var alphabet = "уврнбрапенабнш";
            var hash = MD5Helpers.GetMD5Hash("врабнушнпбн"); //абракадабра
 
            var sw = new Stopwatch();
            sw.Start();
 
            var tool = new HackTool(dict, rule, alphabet, hash);
            if (tool.TryHack(out var result_abra))
            {
                Console.WriteLine("Пароль найден:");
                Console.WriteLine(result_abra);
            }
            else
            {
                Console.WriteLine("Пароль не найден");
            }
 
            Console.WriteLine();
            Console.WriteLine("Длина словаря: " + dict.Length);
 
            sw.Stop();
            Console.WriteLine("Затраченное время: " + sw.Elapsed);
 
        }
    }
    public interface IPasswordHack : ISourceData
    {
        string Encrypt(string src, int[] key);
        IEnumerable<int[]> GetKeys(string wordFromDict);
    }
 
    public interface ISourceData
    {
        string Rule { get; } //верхняя строка правила
        string Alphabet { get; } //нижняя строка
    }
    public interface IHackTool : ISourceData
    {
        public string[] Dict { get; }
        public string ControlHash { get; }
        bool TryHack(out string result);
    }
    public static class MD5Helpers
    {
        public static string GetMD5Hash(string input)
        {
            var md5 = MD5.Create();
            byte[] data = md5.ComputeHash(Encoding.UTF8.GetBytes(input));
 
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < data.Length; i++)
            {
                sb.Append(data[i].ToString("x2"));
            }
 
            return sb.ToString();
        }
 
        public static bool CheckMD5Hash(string input, string controlHash)
        {
            var hash = GetMD5Hash(input);
            return hash.Equals(controlHash);
        }
    }
    public class HackTool : IHackTool
    {
        readonly IPasswordHack _hack;
        public string[] Dict { get; }
        public string Rule { get; }
        public string Alphabet { get; }
        public string ControlHash { get; }
 
        public HackTool(string[] dict, string rule, string alphabet, string controlHash)
        {
            Dict = dict;
            Rule = rule;
            Alphabet = alphabet;
            ControlHash = controlHash;
            _hack = new PasswordHack(Rule, Alphabet);
        }
 
        public bool TryHack(out string result)
        {
            //Для сокращения времени перебора, сортируем словарь по количеству входящих в него символов из правила
            //Далее будем работать с этим словарем
            var actualDict = Dict.Select(s => s.ToLower())
                .OrderByDescending(s => s.Intersect(Rule.ToLower()).Count());
 
            foreach (var item in actualDict)
            {
                //получаем перечисление ключей
                var keys = _hack.GetKeys(item);
 
                //шифруем и проверяем
                foreach (var key in keys)
                {
                    var encrypted = _hack.Encrypt(item, key);
                    if (MD5Helpers.CheckMD5Hash(encrypted, ControlHash))
                    {
                        result = item;
                        return true;
                    }
                }
            }
 
            result = null;
            return false;
        }
 
    }
 
    public class PasswordHack : IPasswordHack, ISourceData
    {
        private readonly Dictionary<char, List<char>> _map;
        public string Rule { get; }
        public string Alphabet { get; }
 
        public PasswordHack(string rule, string alphabet)
        {
            Rule = rule;
            Alphabet = alphabet;
 
            //заполняем карту
            _map = new Dictionary<char, List<char>>();
            for (int i = 0; i < Rule.Length; i++)
            {
                if (_map.ContainsKey(Rule[i]))
                {
                    _map[Rule[i]].Add(Alphabet[i]);
                }
                else
                {
                    _map.Add(Rule[i], new List<char>() { Alphabet[i] });
                }
            }
        }
 
        public string Encrypt(string src, int[] key)
        {
            var res = src.ToCharArray();
            for (int i = 0, k = 0; i < res.Length && k < key.Length; i++)
            {
                var currentSymbol = res[i];
                if (_map.ContainsKey(currentSymbol))
                {
                    res[i] = _map[currentSymbol][key[k++]];
                }
            }
 
            return new string(res);
        }
        public IEnumerable<int[]> GetKeys(string wordFromDict)
        {
            //выбираем из слова те символы, которые содержатся в карте 
            //(имеют варианты замены), включая повторяющиеся символы,
            //и вычисляем для каждого максимальные значения ключа
            //(количество возможных замен - 1)
            var keyMaxValues = wordFromDict
                .Where(c => _map.ContainsKey(c))
                .Select(c => _map[c].Count - 1)
                .ToArray();
 
            //создадим массив, который будем преобразовывать для получения всех комбинаций
            var key = new int[keyMaxValues.Length];
 
            //скопируем в него максимальные значения ключа - это первая комбинация
            Array.Copy(keyMaxValues, key, keyMaxValues.Length);
 
            //вернем первую комбинацию
            yield return key;
 
            //в последней комбинации все разряды ключа равны 0
            //это условие выхода из цикла
            while (!key.All(x => x == 0))
            {
                var n = key.Length;
 
                for (int i = n - 1; i >= 0; i--)
                {
                    if (key[i] > 0)
                    {
                        key[i]--;
                        if (i == n - 1)
                        {
                            yield return key;
                            i++;
                            continue;
                        }
 
                        key[i + 1] = keyMaxValues[i + 1] + 1;
                        i += 2;
                    }
                }
            }
        }
 
    }
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Security.Cryptography;
using System.IO;
using System.Diagnostics;
 
namespace Brutforce
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        void StartHacking(string[] dict, string rule, string alphabet, string hash )//аналог main, было static
        {
            var tool = new HackTool(dict, rule, alphabet, hash);//подаем входные параметры и начинаем искать пароль
            if (tool.TryHack(out var result_abra))
            {
                //password_with_change_box2.Text = encrypted;
                word_dict_box.Text = result_abra; //вывод найденного слова из словаря
            }
            else
            {
                word_dict_box.Text = "Пароль не найден";
            }
            
        }
        private void button1_Click(object sender, EventArgs e)
        {
            string password = null;
            if (password_box.Text.Length != 0)
            { password = password_box.Text; }
 
            if (password_box.Text.Length != 0)
            {
                using (MD5 md5Hash = MD5.Create()) //вычисление хэша для пароля
                {
                    string hashed_pass = GetMd5Hash(md5Hash, password);
                    hash_of_password1_box.Text = (hashed_pass).ToString();
                }
                string GetMd5Hash(MD5 md5Hash, string input)
                {
                    // Convert the input string to a byte array and compute the hash.
                    byte[] data = md5Hash.ComputeHash(Encoding.UTF8.GetBytes(input));
                    // Create a new Stringbuilder to collect the bytes
                    // and create a string.
                    StringBuilder sBuilder = new StringBuilder();
                    // Loop through each byte of the hashed data 
                    // and format each one as a hexadecimal string.
                    for (int i = 0; i < data.Length; i++)
                    {
                        sBuilder.Append(data[i].ToString("x2"));
                    }
                    // Return the hexadecimal string.
                    return sBuilder.ToString();
                }
            }
        }
 
        private void button2_Click(object sender, EventArgs e)
        {
            string path = @"dictionary.txt";
            string[] dict = File.ReadAllLines(path);//словарь слов
            string rule = source_letters_box2.Text;//верхняя строка замен
            string alphabet = final_letters_box2.Text;//нижняя строка замен
            string hash = hash_of_password2_box.Text;//скопированный хэш пароля
            StartHacking(dict, rule, alphabet, hash);
        }
 
        private void button3_Click(object sender, EventArgs e)
        {
            Process.Start(@"dictionary.txt");
        }
    }
}