Пример #1
0
        /// <summary>
        /// Estimates the attempts required to guess the password.
        /// </summary>
        /// <param name="match">The match.</param>
        /// <param name="password">The actual password.</param>
        /// <returns>The guesses estimate.</returns>
        public static double EstimateGuesses(Match match, string password)
        {
            if (match.Guesses != 0)
            {
                return(match.Guesses);
            }

            var minGuesses = 1.0;

            if (match.Token.Length < password.Length)
            {
                minGuesses = match.Token.Length == 1 ? BruteForceGuessesCalculator.MinSubmatchGuessesSingleCharacter : BruteForceGuessesCalculator.MinSubmatchGuessesMultiCharacter;
            }

            var guesses = 0.0;

            switch (match.Pattern)
            {
            case "bruteforce":
                guesses = BruteForceGuessesCalculator.CalculateGuesses(match as BruteForceMatch);
                break;

            case "date":
                guesses = DateGuessesCalculator.CalculateGuesses(match as DateMatch);
                break;

            case "dictionary":
                guesses = DictionaryGuessesCalculator.CalculateGuesses(match as DictionaryMatch);
                break;

            case "regex":
                guesses = RegexGuessesCalculator.CalculateGuesses(match as RegexMatch);
                break;

            case "repeat":
                guesses = RepeatGuessesCalculator.CalculateGuesses(match as RepeatMatch);
                break;

            case "sequence":
                guesses = SequenceGuessesCalculator.CalculateGuesses(match as SequenceMatch);
                break;

            case "spatial":
                guesses = SpatialGuessesCalculator.CalculateGuesses(match as SpatialMatch);
                break;
            }

            match.Guesses = Math.Max(guesses, minGuesses);
            return(match.Guesses);
        }
Пример #2
0
        public void MultipliesByFourForSeparators()
        {
            var match = new DateMatch
            {
                Token     = "1923",
                Separator = "/",
                Year      = 1923,
                Month     = 1,
                Day       = 1,
                i         = 1,
                j         = 2,
            };

            var actual   = DateGuessesCalculator.CalculateGuesses(match);
            var expected = 365 * (DateMatcher.ReferenceYear - match.Year) * 4;

            actual.Should().Be(expected);
        }
Пример #3
0
        public void CalculatesBasedOnReferenceYear()
        {
            var match = new DateMatch
            {
                Token     = "1923",
                Separator = string.Empty,
                Year      = 1923,
                Month     = 1,
                Day       = 1,
                i         = 1,
                j         = 2,
            };

            var actual   = DateGuessesCalculator.CalculateGuesses(match);
            var expected = 365 * (DateMatcher.ReferenceYear - match.Year);

            actual.Should().Be(expected);
        }
Пример #4
0
        public void AssumesMinYearSpaceForRecentYears()
        {
            var match = new DateMatch
            {
                Token     = "2010",
                Separator = string.Empty,
                Year      = 2010,
                Month     = 1,
                Day       = 1,
                i         = 1,
                j         = 2,
            };

            var actual   = DateGuessesCalculator.CalculateGuesses(match);
            var expected = 365 * DateGuessesCalculator.MinimumYearSpace;

            actual.Should().Be(expected);
        }