BeWoPlaner/BeWoPlanerMobil/Util/PasswordUtils.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using BeWo.Data.Access;
using BS.Shared.DataContracts;

namespace BeWoPlanerMobil.Util
{
    internal class PasswordUtils
    {
        private const string Numbers = "0123456789";
        private const string LowercaseLetters = "abcdefghijklmnopqrstuvwxyz";
        private const string UppercaseLetters = "ABDEFGHIJKLMNOPQRSTUVWXYZ";
        private const string LowercaseUmlauts = "äöüß";
        private const string UppercaseUmlauts = "ÄÖÜ";
        private const string SpecialCharacters1 = "\\\"\'µ@€!";
        private const string SpecialCharacters2 = "&/()=?+#*";
        private const string SpecialCharacters3 = ",.-;:_><|";
        private const string SpecialCharacters4 = "§$%'{[]}´";
        private const string SpecialCharacters5 = "`^°~²³";

        private string _PartialPassword = string.Empty;
        private bool _IsPartial;
        private int _PasswordLengthDifference;

        private int _Score;
        private int _PreviousValue;
        private bool _Schalter;
        private readonly List<int> _PreviousValues = new List<int>();

        public int EvaluatePasswordStrength(string passwordToEvaluate)
        {
            if(!string.IsNullOrEmpty(passwordToEvaluate))
            {
                var partialPassword = string.Empty;
                var passwordStrength = 0;

                foreach(var token in passwordToEvaluate)
                {
                    partialPassword += token.ToString();

                    if(partialPassword.Length < _PartialPassword.Length)
                    {
                        _IsPartial = true;
                        _PasswordLengthDifference = _PartialPassword.Length - partialPassword.Length;
                    }

                    if(!_PartialPassword.Equals(partialPassword))
                    {
                        _PartialPassword = partialPassword;
                    }

                    passwordStrength = EvaluatePartialPasswordStrength(partialPassword);
                }

                return passwordStrength;
            }

            _Score = 0;
            _PreviousValue = 0;

            return -1;
        }

        private void AddLengthScore(int valueToAdd)
        {
            _Score += valueToAdd;
            _PreviousValue = valueToAdd;
            _Schalter = true;
        }

        private void AddTokenScore(int valueToAdd)
        {
            _Score += valueToAdd;

            if(_Schalter)
            {
                _PreviousValue += valueToAdd;
            }
            else
            {
                _PreviousValue = valueToAdd;
            }
        }

        public string CheckPassword(string newPassword)
        {
            if(string.IsNullOrEmpty(newPassword))
            {
                return "Das Passwort muss mindestens 8 Zeichen lang sein!";
            }

            var passwordLength = newPassword.Length;

            if(passwordLength < 8)
            {
                return "Das Passwort muss mindestens 8 Zeichen lang sein!";
            }

            var richtliniencount = 0;

            if(newPassword.Any(character => Numbers.Contains(character)))
            {
                richtliniencount++;
            }

            if(newPassword.Any(character => LowercaseLetters.Contains(character) || LowercaseUmlauts.Contains(character)))
            {
                richtliniencount++;
            }

            if(newPassword.Any(character => UppercaseLetters.Contains(character) || UppercaseUmlauts.Contains(character)))
            {
                richtliniencount++;
            }

            if(newPassword.Any(character => SpecialCharacters1.Contains(character) || SpecialCharacters2.Contains(character) || SpecialCharacters3.Contains(character) || SpecialCharacters4.Contains(character) || SpecialCharacters5.Contains(character)))
            {
                richtliniencount++;
            }

            return richtliniencount < 3 ? "Das Passwort muss mindestens drei Zeichen aus der Gruppe Sonderzeichen, Zahlen, Groß- und Kleinbuchstaben enthalten." : null;
        }

        private int EvaluatePartialPasswordStrength(string partialPassword)
        {
            var passwordStrength = 0;
            _PreviousValue = 0;

            if(string.IsNullOrWhiteSpace(partialPassword))
            {
                return 0;
            }

            if(_IsPartial)
            {
                if(_PasswordLengthDifference == 1)
                {
                    _Score -= _PreviousValues.Last();
                    _PreviousValues.RemoveAt(_PreviousValues.Count - 1);
                }
                else
                {
                    for(var i = 0; i < _PasswordLengthDifference; i++)
                    {
                        _Score += _PreviousValues.Last();
                        _PreviousValues.RemoveAt(_PreviousValues.Count - 1);
                    }
                }

                _IsPartial = false;
            }
            else
            {
                var passwordLength = partialPassword.Length;

                if(passwordLength > 5 && passwordLength < 9)
                {
                    AddLengthScore(1);
                }

                if(passwordLength > 8 && passwordLength < 12)
                {
                    AddLengthScore(2);
                }

                if(passwordLength > 11 && passwordLength < 18)
                {
                    AddLengthScore(3);
                }

                if(passwordLength > 17)
                {
                    AddLengthScore(4);
                }

                // Ziffern
                if(partialPassword.Any(character => Numbers.Contains(character)))
                {
                    AddTokenScore(3);
                }

                // Großbuchstaben
                if(partialPassword.Any(character => UppercaseLetters.Contains(character)))
                {
                    AddTokenScore(3);
                }

                // Großumlaute
                if(partialPassword.Any(character => UppercaseUmlauts.Contains(character)))
                {
                    AddTokenScore(2);
                }

                // Kleinbuchstaben
                if(partialPassword.Any(character => LowercaseLetters.Contains(character)))
                {
                    AddTokenScore(2);
                }

                // Kleinumlaute
                if(partialPassword.Any(character => LowercaseUmlauts.Contains(character)))
                {
                    AddTokenScore(2);
                }

                // Sonderzeichen
                if(partialPassword.Any(character => SpecialCharacters1.Contains(character)))
                {
                    AddTokenScore(4);
                }

                if(partialPassword.Any(character => SpecialCharacters2.Contains(character)))
                {
                    AddTokenScore(4);
                }

                if(partialPassword.Any(character => SpecialCharacters3.Contains(character)))
                {
                    AddTokenScore(4);
                }

                if(partialPassword.Any(character => SpecialCharacters4.Contains(character)))
                {
                    AddTokenScore(4);
                }

                if(partialPassword.Any(character => SpecialCharacters5.Contains(character)))
                {
                    AddTokenScore(4);
                }

                _PreviousValues.Add(_PreviousValue);
            }

            if(_Score < 16)
            {
                passwordStrength = 0;
            }

            if(_Score > 15 && _Score < 56)
            {
                passwordStrength = 1;
            }

            if(_Score > 55 && _Score < 116)
            {
                passwordStrength = 2;
            }

            if(_Score > 115 && _Score < 156)
            {
                passwordStrength = 3;
            }

            if(_Score > 155)
            {
                passwordStrength = 4;
            }

            return passwordStrength;
        }
    }
}