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

static void Main()
{   
    // это внутренний словарь всех слов
    string[] allWords = { "кот", "кто", "парк", "диван" };
 
    // преподаватель загадал это слово и
    string original = "кот";
 
    // придумал к нему правила замен
    string ruleUp =     "кккооттттт";
    string ruleDown =   "дА4ьыхЦсыФ";
 
    // после замены, допустим что слово "кот" превратилось в
    string outPass = "4ыы";
 
    // потом получили хеш зашифрованного слова
    int outPassHash = outPass.GetHashCode();
 
 
    // следующий метод симулирует вторую часть вашего проекта
    // и возвращает массив слов из словаря, которые теоретически подходят под зашифрованый хеш
 
    // метод принимает данные, указанные в вашей второй части задания:
    // то-есть есть хеш зашифрованного пароля, наборы правил замены.
    // а так же передаём словарь, чтобы потом с ними сверятся.
 
    // последний параметр опционален, чисто для тестов, он вкл/выкл вывод в консоль этапы работы метода.
    List<string> results = PasswordFinder.getOriginalPass(outPassHash, ruleUp, ruleDown, allWords, true);
}

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 Lab1CSapp
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }
        private void button1_Click(object sender, EventArgs e)
        {
            string password = null;
            
            if (password_box.Text.Length != 0)
            { password = password_box.Text; }
 
                using (MD5 md5Hash = MD5.Create())
                {
                    string hash = GetMd5Hash(md5Hash, password);
                    hash_of_password1_box.Text = (hash).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 static Dictionary<char, List<int>> createCharMap(string source)
        {
            Dictionary<char, List<int>> lettersMap = new Dictionary<char, List<int>>();
 
            for (int i = 0; i < source.Length; i++)
            {
                char c = source[i];
 
                if (lettersMap.ContainsKey(c) == false)
                {
                    lettersMap.Add(c, new List<int>());
                }
 
                lettersMap[c].Add(i);
            }
 
            return lettersMap;
        }
 
        private void button2_Click(object sender, EventArgs e)
        {
            string source_letters2 = null;
            string final_letters2 = null;
            string hash_of_password2 = null;
            if (source_letters_box2.Text.Length != 0)
            { source_letters2 = source_letters_box2.Text; }
            if (final_letters_box2.Text.Length != 0)
            { final_letters2 = final_letters_box2.Text; }
            if (hash_of_password2_box.Text.Length != 0)
            { hash_of_password2 = hash_of_password2_box.Text; }
            string password_with_change;
            int found = 0;
            string path = @"dictionary.txt";
            string[] words = File.ReadAllLines(path);
            
           
        }
        static void Main()
        {
            // это внутренний словарь всех слов
            string[] allWords = { "кот", "кто", "парк", "диван" };
 
            // преподаватель загадал это слово и
            string original = "кот";
 
            // придумал к нему правила замен
            string ruleUp = "кккооттттт";
            string ruleDown = "дА4ьыхЦсыФ";
 
            // после замены, допустим что слово "кот" превратилось в
            string outPass = "4ыы";
 
            // потом получили хеш зашифрованного слова
            int outPassHash = outPass.GetHashCode();
 
 
            // следующий метод симулирует вторую часть вашего проекта
            // и возвращает массив слов из словаря, которые теоретически подходят под зашифрованый хеш
 
            // метод принимает данные, указанные в вашей второй части задания:
            // то-есть есть хеш зашифрованного пароля, наборы правил замены.
            // а так же передаём словарь, чтобы потом с ними сверятся.
 
            // последний параметр опционален, чисто для тестов, он вкл/выкл вывод в консоль этапы работы метода.
            List<string> results = PasswordFinder.getOriginalPass(outPassHash, ruleUp, ruleDown, allWords, true);
        }
 
        private void button3_Click(object sender, EventArgs e)
        {
            Process.Start(@"dictionary.txt");
        }
    }
    public static class PasswordFinder
    {
        public static List<string> getOriginalPass(int outPassHash, string ruleUp, string ruleDown, string[] allWords, bool writeProcessInfo = false)
        {
            var charsMap = getRaplacementMap(ruleUp, ruleDown);
 
            // просто вывод в консоль
            //if (writeProcessInfo)
            //{
            //    Console.WriteLine("Правило замены символов:");
            //    foreach (var item in charsMap)
            //    {
            //        Console.WriteLine(item.Key + ": " + string.Join(", ", item.Value));
            //    }
            //    Console.WriteLine();
            //}
 
            //------------------------------------------------
            //------------------------------------------------
 
            var allCominations = getAllValueCombinations(charsMap);
            string findedOutPass = "";
 
            foreach (string s in allCominations)
            {
                if (s.GetHashCode().Equals(outPassHash))
                {
                    findedOutPass = s;
                }
            }
 
            // просто вывод в консоль
            if (writeProcessInfo)
            {
                Console.WriteLine("Все комбинации перебора символов:");
                foreach (string s in allCominations)
                {
                    Console.Write(s);
                    if (s.GetHashCode().Equals(outPassHash))
                    {
                        Console.Write($" - этот хеш совпадает с зашифрованным паролем!");
                    }
                    Console.WriteLine();
                }
                Console.WriteLine();
            }
 
            //------------------------------------------------
            //------------------------------------------------
 
            List<string> suitableWords = new List<string>();
 
            for (int i = 0; i < allWords.Length; i++)
            {
                string currentWord = allWords[i];
                bool wordSuit = true;
 
                for (int j = 0; j < currentWord.Length; j++)
                {
                    char wordChar = currentWord[j];
 
                    if ((charsMap.ContainsKey(wordChar) && charsMap[wordChar].Contains(findedOutPass[j])) == false)
                    {
                        wordSuit = false;
                        break;
                    }
 
                }
 
                if (wordSuit) suitableWords.Add(currentWord);
            }
 
            // просто вывод в консоль
            if (writeProcessInfo)
            {
                Console.WriteLine("Подходящие слова из словаря:");
                if (suitableWords.Count > 0)
                { Console.WriteLine(string.Join(Environment.NewLine, suitableWords)); }//////////////////////////
            else
                Console.WriteLine("не найдены...");
 
                Console.WriteLine();
            }
 
            return suitableWords;
        }
 
        private static List<string> getAllValueCombinations(Dictionary<char, List<char>> map)
        {
            List<List<char>> rows = new List<List<char>>();
            foreach (var row in map.Values)
            {
                rows.Add(row);
            }
 
            List<string> combinations = new List<string>();
            foo(rows, 0, new char[rows.Count]);
 
            // рекурсивный перебор для нахождения всех вариантов комбинаций
            void foo(List<List<char>> charRows, int row, char[] results)
            {
                for (int i = 0; i < charRows[row].Count; i++)
                {
                    results[row] = charRows[row][i];
                    if (row == charRows.Count - 1)
                    {
                        combinations.Add(string.Join("", results));
                    }
                    else
                    {
                        foo(charRows, row + 1, results);
                    }
                }
            }
 
            return combinations;
        }
 
 
        //source1 = ккоотт
        //source2 = фывапр
 
        //на выходе словарь:
        //key(char)     value(List<char>)
 
        //к             фы
        //о             ва
        //т             пр
        private static Dictionary<char, List<char>> getRaplacementMap(string source1, string source2)
        {
            if (source1.Length != source2.Length)
            {
                throw new Exception("Длины слов не совпадают, или равны нулю.");
            }
 
            Dictionary<char, List<char>> lettersMap = new Dictionary<char, List<char>>();
 
            for (int i = 0; i < source1.Length; i++)
            {
                char c = source1[i];
 
                if (lettersMap.ContainsKey(c) == false)
                {
                    lettersMap.Add(c, new List<char>());
                }
 
                lettersMap[c].Add(source2[i]);
            }
 
            return lettersMap;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;
 
namespace Lab1CSapp
{
    static class Program
    {
        /// <summary>
        /// Главная точка входа для приложения.
        /// </summary>
        [STAThread]
        static void Main()
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);
            Application.Run(new Form1());
        }
    }
}

 password_box.Text = password;

using System;
using System.Collections.Generic;
using System.Linq;
 
namespace CyberForum
{
    class Program
    {
        static void Main()
        {
            string ruleUp = "аааааббббррркд";
            string ruleDown = "уврнбрапенабнш";
            List<string> combinations = getAllCombinations(ruleUp, ruleDown);
 
            Console.WriteLine(string.Join("\n", combinations));
        }
 
 
        private static List<string> getAllCombinations(string ruleUp, string ruleDown)
        {
            List<List<char>> map = new List<List<char>>();
 
            char lastChar = ruleUp[0];
            map.Add(new List<char>() { lastChar, ruleDown[0] });
            for (int i = 1; i < ruleUp.Length; i++)
            {
                char currentChar = ruleUp[i];
                if (currentChar == lastChar)
                {
                    map.Last().Add(ruleDown[i]);
                }
                else
                {
                    map.Add(new List<char>() { currentChar, ruleDown[i] });
                }
                lastChar = currentChar;
            }
 
            List<string> combinations = new List<string>();
            foo(map, 0, new char[map.Count]);
 
            // рекурсивный перебор для нахождения всех вариантов комбинаций
            void foo(List<List<char>> charRows, int row, char[] results)
            {
                for (int i = 1; i < charRows[row].Count; i++)
                {
                    results[row] = charRows[row][i];
                    if (row == charRows.Count - 1)
                    {
                        combinations.Add(string.Join("", results));
                    }
                    else
                    {
                        foo(charRows, row + 1, results);
                    }
                }
            }
 
            return combinations;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Security.Cryptography;
using System.Text;
 
namespace CyberForum
{
    class Program
    {
        static void Main()
        {
            // 1) некий внешний словарь
            string[] dictionary = {  "кто", "дед", "мед", "лёд", "барабашка", "ложка", "кошка" };
 
            // 2) пароль из словаря загаданный преподавателем
            string word = "барабашка";
 
            // 3) придуманые правила замен букв для пароля
            string ruleUp =     "рррааабббккк";
            string ruleDown =   "вльызвалдлли";
 
            // 4) после замен букв, зашифрованый пароль получился допустим таким...
            string pass = "дзлвлвшкв";
 
 
            //-------------------------------------------------------------------------------------------------------
 
            // вычисляем хеш зашифрованного пароля
            string passHash = HashMD5.GetHash(pass);
 
 
            // запускаем поиск слова в словаре, передаём: хеш зашифрованного пароля, правила замены и ссылку на словарь
            List<string> results = PasswordFinder.findWordsInDictionaryByRules(passHash, ruleUp, ruleDown, dictionary);
 
 
            // вывод поиска
            if (results.Count != 0)
            {
                Console.WriteLine("Возможные совпадения:");
                foreach (var item in results)
                {
                    Console.WriteLine(item);
                }
            }
            else
            {
                Console.WriteLine("Совпадения не найдены..");
            }
 
        }
 
    }
 
 
    public static class PasswordFinder
    {
        public static List<string> findWordsInDictionaryByRules(string outPassHash, string ruleUp, string ruleDown, string[] dictionary)
        {
 
            List<string> resuls = new List<string>();
 
            Dictionary<char, List<char>> patternRule = getPatternRule(ruleUp, ruleDown);
 
            List<List<char>> map = new List<List<char>>();
            foreach (var item in patternRule)
            {
                map.Add(item.Value);
            }
 
            //------------------------
 
            for (int i = 0; i < dictionary.Length; i++)
            {
                // word map
                List<List<char>> wordMap = createMapByPatternRule(dictionary[i], patternRule);
 
                //combos
                var combos = getAllCombinations(wordMap);
                foreach (var item in combos)
                {
                    if (HashMD5.GetHash(item).Equals(outPassHash))
                    {
                        if (!resuls.Contains(dictionary[i])) resuls.Add(dictionary[i]);
                    }
                }
            }
 
            return resuls;
        }
 
        /// <summary>
        /// Берём слово из словаря и создаём для него карту вариантов замены каждой буквы по шаблону.
        /// </summary>
        /// <param name="wordFromDict"></param>
        /// <param name="patternRule"></param>
        /// <returns></returns>
        private static List<List<char>> createMapByPatternRule(string wordFromDict, Dictionary<char, List<char>> patternRule)
        {
            List<List<char>> map = new List<List<char>>();
            for (int i = 0; i < wordFromDict.Length; i++)
            {
                char wordChar = wordFromDict[i];
                if (patternRule.ContainsKey(wordChar))
                {
                    map.Add(new List<char>(patternRule[wordChar]));
                }
                else map.Add(new List<char>() { wordChar });
            }
 
            return map;
        }
 
 
 
 
        /// <summary>
        /// Составляет шаблон замен по правилам. Где каждой букве могут соответствовать другие символы
        /// </summary>
        /// <param name="ruleUp"></param>
        /// <param name="ruleDown"></param>
        /// <returns></returns>
        private static Dictionary<char, List<char>> getPatternRule(string ruleUp, string ruleDown)
        {
            Dictionary<char, List<char>> map = new Dictionary<char, List<char>>();
 
            for (int i = 0; i < ruleUp.Length; i++)
            {
                char charKey = ruleUp[i];
                if (!map.ContainsKey(charKey)) map.Add(charKey, new List<char>() { charKey });
 
                map[charKey].Add(ruleDown[i]);
            }
 
            return map;
        }
 
 
 
        /// <summary>
        /// Получает на входе карту символов и возвращает массив всех возможных комбинаций (сверху вниз поочередно)
        /// </summary>
        /// <param name="patternMap"></param>
        /// <returns></returns>
        private static List<string> getAllCombinations(List<List<char>> patternMap)
        {
 
            List<string> combinations = new List<string>();
            foo(patternMap, 0, new char[patternMap.Count]);
 
            // рекурсивный перебор для нахождения всех вариантов комбинаций
            void foo(List<List<char>> charRows, int row, char[] results)
            {
                for (int i = 0; i < charRows[row].Count; i++)
                {
                    results[row] = charRows[row][i];
                    if (row == charRows.Count - 1)
                    {
                        combinations.Add(string.Join("", results));
                    }
                    else
                    {
                        foo(charRows, row + 1, results);
                    }
                }
            }
 
            return combinations;
        }
    }
 
 
    public static class HashMD5
    {
        public static string GetHash(string input)
        {
            using (MD5 md5Hash = MD5.Create())
            {
                byte[] data = md5Hash.ComputeHash(Encoding.UTF8.GetBytes(input));
                StringBuilder sBuilder = new StringBuilder();
 
                for (int i = 0; i < data.Length; i++)
                {
                    sBuilder.Append(data[i].ToString("x2"));
                }
 
                return sBuilder.ToString();
            }
 
        }
    }
}