Пример #1
0
        }//GenerateStringSimple2_r

        //REF tex converted from recursion (above) to using a stack object (recursion just uses program stack anyway).
        static void GenerateStringSimple_Stack(List <string>[] allWordsList)
        {
            Stack <RecurseStep> stack = new Stack <RecurseStep>();

            RecurseStep startState = new RecurseStep();

            startState.currentDepth         = 0;
            startState.currentWordListIndex = 0;
            startState.currentString        = "";

            stack.Push(startState);

            while (stack.Count > 0)
            {
                RecurseStep recurseStep = stack.Pop();

                if (recurseStep.currentDepth == allWordsList.Length)
                {
                    Console.WriteLine(recurseStep.currentString);
                }
                else
                {
                    List <string> wordList = allWordsList[recurseStep.currentDepth];
                    for (int wordListIndex = 0; wordListIndex < wordList.Count; wordListIndex++)
                    {
                        RecurseStep nextState = new RecurseStep();
                        nextState.currentDepth         = recurseStep.currentDepth + 1;
                        nextState.currentWordListIndex = wordListIndex;
                        nextState.currentString        = recurseStep.currentString + wordList[wordListIndex];

                        stack.Push(nextState);
                    }
                }
            }
        }//GenerateStringSimple_Stack
Пример #2
0
        }//GenerateStringSimple_r

        //REF tex evolution of above with state moved into struct
        static void GenerateStringSimple2_r(List <string>[] allWordsList, RecurseStep state)
        {
            if (state.currentDepth == allWordsList.Length)
            {
                Console.WriteLine(state.currentString);
                return;
            }
            else
            {
                List <string> wordList = allWordsList[state.currentDepth];
                for (int wordListIndex = 0; wordListIndex < wordList.Count; wordListIndex++)
                {
                    RecurseStep nextState = new RecurseStep();
                    nextState.currentDepth         = state.currentDepth + 1;
                    nextState.currentWordListIndex = wordListIndex;
                    nextState.currentString        = state.currentString + wordList[wordListIndex];

                    GenerateStringSimple2_r(allWordsList, nextState);
                }
            }
        }//GenerateStringSimple2_r
Пример #3
0
        private static void SimpleTests(List <string>[] allWordsLists)
        {
            Console.WriteLine("!!!!SimpleTests");

            //tex filling out all variables to get concanical serialization.
            GenConfig config = new GenConfig();

            config.batch_size      = 1;
            config.words_base_path = @"D:\GitHub\BruteGen\Examples\3x3 - test hashes";
            config.words_paths.Add("wordA");
            config.words_paths.Add("wordB");
            config.words_paths.Add("wordC");
            config.output_path = @"D:\GitHub\BruteGen\Examples\Examples Output";
            config.word_variations_all.Add("dont_add_original");
            config.word_variations_all.Add("all_upper");
            config.word_variations_all.Add("all_lower");
            config.word_variations_all.Add("capitalized");
            config.word_variations_all.Add("blank_optional");
            config.test_hashes_path = @"D:\GitHub\BruteGen\Examples\3x3 - test hashes\StrCode32Hashes";
            config.test_hashes_func = "StrCode32";

            JsonSerializerSettings serializeSettings = new JsonSerializerSettings();

            serializeSettings.Formatting = Formatting.Indented;
            string jsonStringOut = JsonConvert.SerializeObject(config, serializeSettings);
            string jsonOutPath   = @"D:\GitHub\BruteGen\full-config.json";

            File.WriteAllText(jsonOutPath, jsonStringOut);


            RecurseStep startStateS = new RecurseStep();

            startStateS.currentDepth         = 0;
            startStateS.currentWordListIndex = 0;
            startStateS.currentString        = "";
            GenerateStringSimple2_r(allWordsLists, startStateS);

            GenerateStringSimple_Stack(allWordsLists);
        } //SimpleTests
Пример #4
0
        }//BatchTest

        //REF CULL Old stack based
        static void GenerateStringsStack(Stack <RecurseStep> resumeState, List <string>[] allWordsLists, HashInfo hashInfo, int batchSize, bool testOnBatch, string resumeStatePath, string stringsOutPath)
        {
            var totalStopwatch = new System.Diagnostics.Stopwatch();

            totalStopwatch.Start();

            int loopCount = 0;

            bool isResume = resumeState != null;

            List <string> batch = new List <string>();

            List <int> recurseState = new List <int>(new int[allWordsLists.Length]);//tex purely for user to get an idea of how it's progressing

            //tex using a custom stack instead of the usual nested loops for generating strings, this allows the whole state to be saved of so program can be quit and resumed later.
            //tex initialize stack
            Stack <RecurseStep> stack = new Stack <RecurseStep>();

            if (resumeState == null)
            {
                RecurseStep startState = new RecurseStep();
                startState.currentDepth         = 0;
                startState.currentWordListIndex = 0;
                startState.currentString        = "";

                stack.Push(startState);
            }
            else
            {
                // tex more stack order shenanigans, dont ask me why
                while (resumeState.Count > 0)
                {
                    stack.Push(resumeState.Pop());
                }
            }//init stack

            if (!isResume)
            {
                Console.WriteLine("Starting GenerateStrings");
            }
            else
            {
                Console.WriteLine("Resuming GenerateStrings");
            }

            using (StreamWriter sw = new StreamWriter(stringsOutPath, isResume)) {//tex StreamWriter append = isResume
                while (stack.Count > 0)
                {
                    loopCount++;
                    RecurseStep state = stack.Pop();

                    //tex you can output currentString here if you want to catch each stage of generation instead of just complete string below
                    //but I currently prefer just having empty strings in the word lists for per word control

                    if (state.currentDepth == allWordsLists.Length)  //tex generated whole test-string
                    {
                        string currentString = state.currentString;

                        if (!testOnBatch)
                        {
                            //tex if no inputhashes then we just write every generated string
                            if (hashInfo.inputHashes == null)
                            {
                                sw.WriteLine(currentString);
                            }
                            else
                            {
                                var hash = hashInfo.HashFunc(currentString);
                                if (hashInfo.inputHashes.Contains(hash))
                                {
                                    sw.WriteLine(currentString);
                                }
                            }
                        }//testOnBatch
                        batch.Add(currentString);

                        //tex write/flush current strings and write resume_state
                        if (batch.Count >= batchSize)
                        {
                            //tex write resume state
                            string jsonStringOut = JsonConvert.SerializeObject(stack);
                            File.WriteAllText(resumeStatePath, jsonStringOut);

                            //tex give user feedback
                            string rs = "";
                            foreach (int wordIndex in recurseState)
                            {
                                rs += " " + wordIndex;
                            }
                            Console.WriteLine(rs + "          : " + currentString);//TODO: order is shifted by one in comparison to wordcounts output earlier in the program, figure out what's up.

                            //tex test batch
                            if (testOnBatch)
                            {
                                BatchTest(hashInfo, batch, sw);
                            }//testOnBatch

                            //tex clear batch and flush/write matches streamwriter
                            batch = new List <string>();
                            sw.Flush();
                        }//batchSize
                    }
                    else    //tex recurse
                    {
                        recurseState[state.currentDepth] = state.currentWordListIndex;

                        List <string> wordList = allWordsLists[state.currentDepth];
                        //tex due to stack the order is actually reversed compared to recursion
                        // for (int wordListIndex = 0; wordListIndex < wordList.Count; wordListIndex++)
                        for (int wordListIndex = wordList.Count - 1; wordListIndex >= 0; wordListIndex--)
                        {
                            //tex this is where we'd normally recursively call the generation function with the current state of the partially generated string
                            //instead we're just seting up our stack of that state, for the next loop
                            RecurseStep nextState = new RecurseStep();
                            nextState.currentDepth         = state.currentDepth + 1;
                            nextState.currentWordListIndex = wordListIndex;
                            nextState.currentString        = state.currentString + wordList[wordListIndex];

                            stack.Push(nextState);
                        }
                    } //if generated whole word
                }     //while stack

                //tex need to process incomplete batch
                if (batch.Count > 0)
                {
                    //tex test batch
                    if (testOnBatch)
                    {
                        BatchTest(hashInfo, batch, sw);
                    }//testOnBatch

                    //tex clear batch and flush/write matches streamwriter
                    batch = new List <string>();
                    sw.Flush();
                } //batch.Count > 0
            }     //using sw

            totalStopwatch.Stop();
            var timeSpan = totalStopwatch.Elapsed;

            Console.WriteLine($"GenerateStrings completed in {timeSpan.Hours}:{timeSpan.Minutes}:{timeSpan.Seconds}:{timeSpan.Milliseconds}");
            Console.WriteLine($"LoopCount: {loopCount}");
        }//GenerateStrings