public static bool CanRunAlgorithm(out string aError,AlgorithmType aAlgType)
        {
            bool _result = true;
            string _algType = aAlgType.ToString();
            aError = "";
            
            if (Set == null)
            {
                _result = false;
                aError = "You must load a DataSet to apply a " + _algType + " algorithm. \r\n";
                return _result;
            }
            if (aAlgType == AlgorithmType.Clustering && (AttributesToCalculateProximity == null || AttributesToCalculateProximity.Count == 0))
            {
                _result = false;
                aError += "You must select at least one attribute to apply a " + _algType + " algorithm. \r\n";
            }
            if (aAlgType == AlgorithmType.Clustering && Proximity == null)
            {
                _result = false;
                aError += "You must select a Proximity to apply a " + _algType + " algorithm. \r\n";
            }


            return _result;
        }
示例#2
0
        public static void DisplayExpectedException(string input, string pattern, AlgorithmType algorithmType, RegexOptions options,
                                                    Exception ex)
        {
            displayHeader(input, pattern, options);

            Console.WriteLine("Exception was expected, this was thrown ({0}):", algorithmType.ToString());

            const string indent = "   ";

            for (Exception e = ex; e != null; e = e.InnerException)
            {
                Console.WriteLine(indent + "[{0}]", e.GetType().FullName);
                Console.WriteLine(indent + indent + e.Message.Replace("\n", "\n" + indent + indent));
            }

            Console.Write("\n");
        }
        /// <summary>
        /// Computes the hash.
        /// </summary>
        /// <param name="plainText">The plain text.</param>
        /// <param name="hashAlgorithm">The hash algorithm.</param>
        /// <param name="saltBytes">The salt bytes.</param>
        /// <returns>System.String.</returns>
        public static string ComputeHash(string plainText, AlgorithmType hashAlgorithm, byte[] saltBytes)
        {
            if (plainText == null)
                throw new Exception(nameof(plainText) + " cannot be null");

            // If salt is not specified, generate it on the fly.
            if (saltBytes == null)
            {
                // Define min and max salt sizes.
                var minSaltSize = 4;
                var maxSaltSize = 8;

                // Generate a random number for the size of the salt.
                var random = new Random();
                var saltSize = random.Next(minSaltSize, maxSaltSize);

                // Allocate a byte array, which will hold the salt.
                saltBytes = new byte[saltSize];

                // Initialize a random number generator.
                var rng = new RNGCryptoServiceProvider();

                // Fill the salt with cryptographically strong byte values.
                rng.GetNonZeroBytes(saltBytes);
            }

            // Convert plain text into a byte array.
            var plainTextBytes = Encoding.UTF8.GetBytes(plainText);

            // Allocate array, which will hold plain text and salt.
            var plainTextWithSaltBytes =
                new byte[plainTextBytes.Length + saltBytes.Length];

            // Copy plain text bytes into resulting array.
            for (var i = 0; i < plainTextBytes.Length; i++)
                plainTextWithSaltBytes[i] = plainTextBytes[i];

            // Append salt bytes to the resulting array.
            for (var i = 0; i < saltBytes.Length; i++)
                plainTextWithSaltBytes[plainTextBytes.Length + i] = saltBytes[i];

            // Because we support multiple hashing algorithms, we must define
            // hash object as a common (abstract) base class. We will specify the
            // actual hashing algorithm class later during object creation.
            HashAlgorithm hashServiceProvider;

            // Initialize appropriate hashing algorithm class.
            switch (hashAlgorithm.ToString().ToUpper())
            {
                case "SHA1":
                    hashServiceProvider = new SHA1Managed();
                    break;

                case "SHA256":
                    hashServiceProvider = new SHA256Managed();
                    break;

                case "SHA384":
                    hashServiceProvider = new SHA384Managed();
                    break;

                case "SHA512":
                    hashServiceProvider = new SHA512Managed();
                    break;

                case "MD5":
                    hashServiceProvider = new MD5CryptoServiceProvider();
                    break;

                default:
                    hashServiceProvider = new MD5CryptoServiceProvider();
                    break;
            }

            // Compute hash value of our plain text with appended salt.
            var hashBytes = hashServiceProvider.ComputeHash(plainTextWithSaltBytes);

            // Create array which will hold hash and original salt bytes.
            var hashWithSaltBytes = new byte[hashBytes.Length + saltBytes.Length];

            // Copy hash bytes into resulting array.
            for (var i = 0; i < hashBytes.Length; i++)
                hashWithSaltBytes[i] = hashBytes[i];

            // Append salt bytes to the result.
            for (var i = 0; i < saltBytes.Length; i++)
                hashWithSaltBytes[hashBytes.Length + i] = saltBytes[i];

            // Convert result into a base64-encoded string.
            var hashValue = Convert.ToBase64String(hashWithSaltBytes);

            // Return the result.
            return hashValue;
        }
示例#4
0
 public static void DisplayMatches(string input, string pattern, AlgorithmType algorithmType, RegexOptions options,
                                   IEnumerable<Match2> matches)
 {
     DisplayMatches(input, pattern, algorithmType.ToString(), options, matches);
 }
        /// <summary>
        /// Verifies the hash.
        /// </summary>
        /// <param name="plainText">The plain text.</param>
        /// <param name="hashAlgorithm">The hash algorithm.</param>
        /// <param name="hashValue">The hash value.</param>
        /// <returns><c>true</c>  if the 2 hashed values match, <c>false</c> otherwise.</returns>
        public static bool VerifyHash(string plainText, AlgorithmType hashAlgorithm, string hashValue)
        {
            // Convert base64-encoded hash value into a byte array.
            var hashWithSaltBytes = Convert.FromBase64String(hashValue);

            // We must know size of hash (without salt).
            int hashSizeInBits;

            // Size of hash is based on the specified algorithm.
            switch (hashAlgorithm.ToString().ToUpper())
            {
                case "SHA1":
                    hashSizeInBits = 160;
                    break;

                case "SHA256":
                    hashSizeInBits = 256;
                    break;

                case "SHA384":
                    hashSizeInBits = 384;
                    break;

                case "SHA512":
                    hashSizeInBits = 512;
                    break;

                default: // Must be MD5
                    hashSizeInBits = 128;
                    break;
            }

            // Convert size of hash from bits to bytes.
            var hashSizeInBytes = hashSizeInBits / 8;

            // Make sure that the specified hash value is long enough.
            if (hashWithSaltBytes.Length < hashSizeInBytes)
                return false;

            // Allocate array to hold original salt bytes retrieved from hash.
            var saltBytes = new byte[hashWithSaltBytes.Length - hashSizeInBytes];

            // Copy salt from the end of the hash to the new array.
            for (var i = 0; i < saltBytes.Length; i++)
                saltBytes[i] = hashWithSaltBytes[hashSizeInBytes + i];

            // Compute a new hash string.
            var expectedHashString = ComputeHash(plainText, hashAlgorithm, saltBytes);

            // If the computed hash matches the specified hash,
            // the plain text value must be correct.
            return (hashValue == expectedHashString);
        }