Inheritance: HashAlgorithm
示例#1
0
        /// <summary>
        /// Open file and get it's SHA1 hash
        /// </summary>
        /// <param name="file_name">File name (full path)</param>
        /// <returns>String representation of the SHA1 hash</returns>
        public static string GetSHAHashFromFile(string file_name, SHAType shaType)
        {
            System.IO.FileStream file = new System.IO.FileStream(file_name, System.IO.FileMode.Open, System.IO.FileAccess.Read);
            byte[] retVal             = null;
            switch (shaType)
            {
            case SHAType.SHA1:
                System.Security.Cryptography.SHA1 sha1obj = new System.Security.Cryptography.SHA1CryptoServiceProvider();
                retVal = sha1obj.ComputeHash(file);
                break;

            case SHAType.SHA256:
                System.Security.Cryptography.SHA256 sha256 = System.Security.Cryptography.SHA256.Create();
                retVal = sha256.ComputeHash(file);
                break;

            case SHAType.SHA384:
                System.Security.Cryptography.SHA384 sha384 = System.Security.Cryptography.SHA384.Create();
                retVal = sha384.ComputeHash(file);
                break;

            case SHAType.SHA512:
                System.Security.Cryptography.SHA512 sha512 = System.Security.Cryptography.SHA512.Create();
                retVal = sha512.ComputeHash(file);
                break;
            }
            file.Close();
            return(BitConverter.ToString(retVal).Replace("-", "").ToLower());
        }
 public static string GetSHA512(this Stream s)
 {
     using (System.Security.Cryptography.SHA512 sha512 = System.Security.Cryptography.SHA512.Create())
     {
         return(Convert.ToHexString(sha512.ComputeHash(s)).ToLower());
     }
 }
示例#3
0
        public string HashFile(string path)
        {
            sha512 = new SHA512Managed();
            calculatedHash = null;
            hashString = null;
            FileInfo fi = new FileInfo(path);

            try
            {
                FileStream fs = System.IO.File.OpenRead(path);
                fs.Position = 0;
                calculatedHash = sha512.ComputeHash(fs);
                fs.Close();
                hashString = ByteToString(calculatedHash);
                return hashString;
            }
            catch (FileNotFoundException)
            {
                // file not found
                Logger.Write("Error, file not found");
            }
            catch (IOException)
            {
                // file could not be accessed
                // warn user and try again on OK
                Logger.Write("Error, file not accessible " + fi.Name);
            }
            catch (UnauthorizedAccessException)
            {
                // no access permission
            }
            return null;
        }
示例#4
0
        internal static async Task InstallFromStream(Stream stream, Library library, string packagesDirectory,
            SHA512 sha512)
        {
            var packagePathResolver = new DefaultPackagePathResolver(packagesDirectory);

            var targetPath = packagePathResolver.GetInstallPath(library.Name, library.Version);
            var targetNuspec = packagePathResolver.GetManifestFilePath(library.Name, library.Version);
            var targetNupkg = packagePathResolver.GetPackageFilePath(library.Name, library.Version);
            var hashPath = packagePathResolver.GetHashPath(library.Name, library.Version);

            // Acquire the lock on a nukpg before we extract it to prevent the race condition when multiple
            // processes are extracting to the same destination simultaneously
            await ConcurrencyUtilities.ExecuteWithFileLocked(targetNupkg, async createdNewLock =>
            {
                // If this is the first process trying to install the target nupkg, go ahead
                // After this process successfully installs the package, all other processes
                // waiting on this lock don't need to install it again
                if (createdNewLock)
                {
                    Directory.CreateDirectory(targetPath);
                    using (var nupkgStream = new FileStream(targetNupkg, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite | FileShare.Delete))
                    {
                        await stream.CopyToAsync(nupkgStream);
                        nupkgStream.Seek(0, SeekOrigin.Begin);

                        ExtractPackage(targetPath, nupkgStream);
                    }

                    // Fixup the casing of the nuspec on disk to match what we expect
                    var nuspecFile = Directory.EnumerateFiles(targetPath, "*" + NuGet.Constants.ManifestExtension).Single();

                    if (!string.Equals(nuspecFile, targetNuspec, StringComparison.Ordinal))
                    {
                        Manifest manifest = null;
                        using (var nuspecStream = File.OpenRead(nuspecFile))
                        {
                            manifest = Manifest.ReadFrom(nuspecStream, validateSchema: false);
                            manifest.Metadata.Id = library.Name;
                        }

                        // Delete the previous nuspec file
                        File.Delete(nuspecFile);

                        // Write the new manifest
                        using (var targetNuspecStream = File.OpenWrite(targetNuspec))
                        {
                            manifest.Save(targetNuspecStream);
                        }
                    }

                    stream.Seek(0, SeekOrigin.Begin);
                    var nupkgSHA = Convert.ToBase64String(sha512.ComputeHash(stream));
                    File.WriteAllText(hashPath, nupkgSHA);
                }

                return 0;
            });
        }
 /// <summary>
 /// CheckSum512 method implementation
 /// </summary>
 public static byte[] CheckSum512(byte[] value)
 {
     byte[] hash = null;
     using (System.Security.Cryptography.SHA512 sha512 = System.Security.Cryptography.SHA512Cng.Create())
     {
         hash = sha512.ComputeHash(value);
     }
     return(hash);
 }
 /// <summary>
 /// CheckSum512 method implementation
 /// </summary>
 public static byte[] CheckSum512(string value)
 {
     byte[] hash = null;
     using (System.Security.Cryptography.SHA512 sha512 = System.Security.Cryptography.SHA512Managed.Create())
     {
         hash = sha512.ComputeHash(Encoding.UTF8.GetBytes(value));
     }
     return(hash);
 }
示例#7
0
文件: Hash.cs 项目: 4vz/Aveezo
        public static byte[] SHA512(byte[] input)
        {
            if (sha512 == null)
            {
                sha512 = System.Security.Cryptography.SHA512.Create();
            }

            return(sha512.ComputeHash(input));
        }
示例#8
0
    // Encrypt a password using SHA512
    public static byte[] EncryptPassword(string password)
    {
        // Make precalculated, generic rainbow tables ineffective by using a salt
        password = StaticSaltPassword(password);

        // Encrypt the password
        System.Security.Cryptography.SHA512 sha512 = System.Security.Cryptography.SHA512.Create();
        return(sha512.ComputeHash(System.Text.Encoding.Unicode.GetBytes(password)));
    }
示例#9
0
        public override string StringHashAlgorithm(string value)
        {
            System.Security.Cryptography.SHA512 sha = System.Security.Cryptography.SHA512.Create();
            byte[]        bytes = sha.ComputeHash(System.Text.ASCIIEncoding.UTF8.GetBytes(value));
            StringBuilder sb    = new StringBuilder();

            foreach (var b in bytes)
            {
                sb.Append(b.ToString("x2"));
            }
            return(sb.ToString());
        }
示例#10
0
        public static string GetSHA512Hashed(string input)
        {
            System.Security.Cryptography.SHA512 sha1 = System.Security.Cryptography.SHA512.Create();

            byte[] hash = sha1.ComputeHash(Encoding.UTF8.GetBytes(input.ToString()));

            StringBuilder output = new StringBuilder();

            for (int i = 0; i < hash.Length; i++)
            {
                output.Append(hash[i].ToString("X2"));
            }
            return(output.ToString());
        }
示例#11
0
        // sha512 below
        public static string GetSHA512Hash(string str)
        {
            System.Security.Cryptography.SHA512 sha512 = System.Security.Cryptography.SHA512.Create();
            byte[] bytes   = Encoding.Default.GetBytes(str);
            byte[] encoded = sha512.ComputeHash(bytes);

            StringBuilder sb = new StringBuilder();

            for (int i = 0; i < encoded.Length; i++)
            {
                sb.Append(encoded[i].ToString("x2"));
            }

            return(sb.ToString());
        }
示例#12
0
        private void CompareBlocks(ShaAlg Algorithm)
        {
            if (Algorithm == ShaAlg.SHA256)
            {
                byte[] buffer = new byte[639];
                byte[] hash1  = new byte[32];
                byte[] hash2  = new byte[32];

                using (System.Security.Cryptography.RNGCryptoServiceProvider rng = new System.Security.Cryptography.RNGCryptoServiceProvider())
                    rng.GetBytes(buffer);

                // SHA256 //
                // test digest
                using (VTDev.Projects.CEX.Crypto.Digests.SHA256Digest sha1 = new VTDev.Projects.CEX.Crypto.Digests.SHA256Digest())
                    hash1 = sha1.ComputeHash(buffer);

                using (System.Security.Cryptography.SHA256 sha = System.Security.Cryptography.SHA256Managed.Create())
                    hash2 = sha.ComputeHash(buffer);

                if (!Compare.AreEqual(hash1, hash2))
                {
                    throw new Exception("SHA512 hash is not equal!");
                }
            }
            else
            {
                // SHA512 //
                byte[] hash1  = new byte[64];
                byte[] hash2  = new byte[64];
                byte[] buffer = new byte[377];

                using (System.Security.Cryptography.RNGCryptoServiceProvider rng = new System.Security.Cryptography.RNGCryptoServiceProvider())
                    rng.GetBytes(buffer);

                // test digest
                using (VTDev.Projects.CEX.Crypto.Digests.SHA512Digest sha2 = new VTDev.Projects.CEX.Crypto.Digests.SHA512Digest())
                    hash1 = sha2.ComputeHash(buffer);

                using (System.Security.Cryptography.SHA512 sha = System.Security.Cryptography.SHA512Managed.Create())
                    hash2 = sha.ComputeHash(buffer);

                if (!Compare.AreEqual(hash1, hash2))
                {
                    throw new Exception("SHA256 hash is not equal!");
                }
            }
        }
示例#13
0
        /// <summary>
        /// Return SHA-512 (SHA-2) for a string.
        /// </summary>
        /// <param name="text">Source text to calculate hash from</param>
        /// <param name="encoding">Text encoding</param>
        /// <returns>SHA1 hash in hex format</returns>
        public static string SHA512(string text, Encoding encoding)
        {
            if (text == null)
            {
                return(null);
            }
#if !NETCF
            using (System.Security.Cryptography.SHA512 cipher = System.Security.Cryptography.SHA512.Create())
            {
                byte[] array = cipher.ComputeHash(encoding.GetBytes(text));
                return(Energy.Base.Hex.ArrayToHex(array).ToLower());
            }
#endif
#if NETCF
            return(null);
#endif
        }
        /// <summary>
        ///  验证面md5值是否先等
        /// </summary>
        /// <param name="md5Hash"></param>
        /// <param name="input"></param>
        /// <param name="hash"></param>
        /// <returns></returns>
        private static bool VerifySHA512Hash(SHA512 SHA1Hash, string input, string hash)
        {
            // Hash the input.
            string hashOfInput = GetSHA512Hash(SHA1Hash, input);

            // Create a StringComparer an compare the hashes.
            StringComparer comparer = StringComparer.OrdinalIgnoreCase;

            if (0 == comparer.Compare(hashOfInput, hash))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
示例#15
0
        public static string GetSha512(string value)
        {
            if (value == null)
            {
                return(string.Empty);
            }

            value = value.Trim();
            if (value == string.Empty)
            {
                return(string.Empty);
            }

            try
            {
                System.Security.Cryptography.SHA512 oHash =
                    System.Security.Cryptography.SHA512.Create();

                byte[] bytInputs =
                    System.Text.Encoding.ASCII.GetBytes(value);

                byte[] bytHashes = oHash.ComputeHash(bytInputs);

                // Convert the byte array to hexadecimal string
                System.Text.StringBuilder oStringBuilder =
                    new System.Text.StringBuilder();

                for (int intIndex = 0; intIndex < bytHashes.Length; intIndex++)
                {
                    oStringBuilder.Append(bytHashes[intIndex].ToString("X2"));

                    // To force the hex string to lower-case letters instead of
                    // upper-case, use he following line instead:
                    // sb.Append(hashBytes[i].ToString("x2"));
                }

                return(oStringBuilder.ToString());

                //return (System.Web.Security.FormsAuthentication
                //	.HashPasswordForStoringInConfigFile(value, "SHA1"));
            }
            catch
            {
                return(string.Empty);
            }
        }
        /// <summary>
        /// 获取md5值
        /// </summary>
        /// <param name="md5Hash"></param>
        /// <param name="input"></param>
        /// <returns></returns>
        private static string GetSHA512Hash(SHA512 hash, string input)
        {

            // Convert the input string to a byte array and compute the hash.
            byte[] data = hash.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();
        }
	public void FIPS186_Test1 (SHA512 hash) 
	{
		string className = hash.ToString ();
		byte[] result = { 0xdd, 0xaf, 0x35, 0xa1, 0x93, 0x61, 0x7a, 0xba,
				  0xcc, 0x41, 0x73, 0x49, 0xae, 0x20, 0x41, 0x31, 
				  0x12, 0xe6, 0xfa, 0x4e, 0x89, 0xa9, 0x7e, 0xa2, 
				  0x0a, 0x9e, 0xee, 0xe6, 0x4b, 0x55, 0xd3, 0x9a, 
				  0x21, 0x92, 0x99, 0x2a, 0x27, 0x4f, 0xc1, 0xa8,
				  0x36, 0xba, 0x3c, 0x23, 0xa3, 0xfe, 0xeb, 0xbd, 
				  0x45, 0x4d, 0x44, 0x23, 0x64, 0x3c, 0xe8, 0x0e, 
				  0x2a, 0x9a, 0xc9, 0x4f, 0xa5, 0x4c, 0xa4, 0x9f };
		byte[] input = Encoding.Default.GetBytes (input1);

		string testName = className + " 1";
		FIPS186_a (testName, hash, input, result);
		FIPS186_b (testName, hash, input, result);
		FIPS186_c (testName, hash, input, result);
		FIPS186_d (testName, hash, input, result);
		FIPS186_e (testName, hash, input, result);
	}
	public void FIPS186_Test2 (SHA512 hash) 
	{
		string className = hash.ToString ();
		byte[] result = { 0x8e, 0x95, 0x9b, 0x75, 0xda, 0xe3, 0x13, 0xda, 
				  0x8c, 0xf4, 0xf7, 0x28, 0x14, 0xfc, 0x14, 0x3f, 
				  0x8f, 0x77, 0x79, 0xc6, 0xeb, 0x9f, 0x7f, 0xa1, 
				  0x72, 0x99, 0xae, 0xad, 0xb6, 0x88, 0x90, 0x18, 
				  0x50, 0x1d, 0x28, 0x9e, 0x49, 0x00, 0xf7, 0xe4, 
				  0x33, 0x1b, 0x99, 0xde, 0xc4, 0xb5, 0x43, 0x3a, 
				  0xc7, 0xd3, 0x29, 0xee, 0xb6, 0xdd, 0x26, 0x54, 
				  0x5e, 0x96, 0xe5, 0x5b, 0x87, 0x4b, 0xe9, 0x09 };
		byte[] input = Encoding.Default.GetBytes (input2);

		string testName = className + " 2";
		FIPS186_a (testName, hash, input, result);
		FIPS186_b (testName, hash, input, result);
		FIPS186_c (testName, hash, input, result);
		FIPS186_d (testName, hash, input, result);
		FIPS186_e (testName, hash, input, result);
	}
示例#19
0
        /// <summary>
        /// Get SHA1 hash from buffer of bytes
        /// </summary>
        /// <param name="input_buffer">Input buffer</param>
        /// <returns>16-byte array of hash</returns>
        public static byte[] GetSHAHash(byte[] input_buffer, SHAType shaType)
        {
            switch (shaType)
            {
            case SHAType.SHA1:
                SHA1 sha1 = new SHA1CryptoServiceProvider();
                return(sha1.ComputeHash(input_buffer));

            case SHAType.SHA256:
                System.Security.Cryptography.SHA256 sha256 = System.Security.Cryptography.SHA256.Create();
                return(sha256.ComputeHash(input_buffer));

            case SHAType.SHA384:
                System.Security.Cryptography.SHA384 sha384 = System.Security.Cryptography.SHA384.Create();
                return(sha384.ComputeHash(input_buffer));

            case SHAType.SHA512:
                System.Security.Cryptography.SHA512 sha512 = System.Security.Cryptography.SHA512.Create();
                return(sha512.ComputeHash(input_buffer));
            }
            return(null);
        }
示例#20
0
	public void FIPS186_Test3 (SHA512 hash) 
	{
		string className = hash.ToString ();
		byte[] result = { 0xe7, 0x18, 0x48, 0x3d, 0x0c, 0xe7, 0x69, 0x64, 
				  0x4e, 0x2e, 0x42, 0xc7, 0xbc, 0x15, 0xb4, 0x63, 
				  0x8e, 0x1f, 0x98, 0xb1, 0x3b, 0x20, 0x44, 0x28,
				  0x56, 0x32, 0xa8, 0x03, 0xaf, 0xa9, 0x73, 0xeb,
                                  0xde, 0x0f, 0xf2, 0x44, 0x87, 0x7e, 0xa6, 0x0a, 
				  0x4c, 0xb0, 0x43, 0x2c, 0xe5, 0x77, 0xc3, 0x1b, 
				  0xeb, 0x00, 0x9c, 0x5c, 0x2c, 0x49, 0xaa, 0x2e, 
				  0x4e, 0xad, 0xb2, 0x17, 0xad, 0x8c, 0xc0, 0x9b };
		byte[] input = new byte [1000000];
		for (int i = 0; i < 1000000; i++)
			input[i] = 0x61; // a

		string testName = className + " 3";
		FIPS186_a (testName, hash, input, result);
		FIPS186_b (testName, hash, input, result);
		FIPS186_c (testName, hash, input, result);
		FIPS186_d (testName, hash, input, result);
		FIPS186_e (testName, hash, input, result);
	}
示例#21
0
        internal static async Task InstallFromStream(Stream stream,
            Library library,
            string packagesDirectory,
            SHA512 sha512,
            bool performingParallelInstalls = false)
        {
            var packagePathResolver = new DefaultPackagePathResolver(packagesDirectory);

            var targetPath = packagePathResolver.GetInstallPath(library.Name, library.Version);
            var targetNuspec = packagePathResolver.GetManifestFilePath(library.Name, library.Version);
            var targetNupkg = packagePathResolver.GetPackageFilePath(library.Name, library.Version);
            var hashPath = packagePathResolver.GetHashPath(library.Name, library.Version);

            // Acquire the lock on a nukpg before we extract it to prevent the race condition when multiple
            // processes are extracting to the same destination simultaneously
            await ConcurrencyUtilities.ExecuteWithFileLocked(targetNupkg, async createdNewLock =>
            {
                // If this is the first process trying to install the target nupkg, go ahead
                // After this process successfully installs the package, all other processes
                // waiting on this lock don't need to install it again.
                if (createdNewLock && !File.Exists(targetNupkg))
                {
                    var extractPath = targetPath;
                    if (performingParallelInstalls)
                    {
                        // Extracting to the {id}/{version} has an issue with concurrent installs - when a package has been partially
                        // extracted, the Restore Operation can inadvertly conclude the package is available locally and proceed to read
                        // partially written package contents. To avoid this we'll extract the package to a sibling directory and Move it 
                        // to the target path.
                        extractPath = Path.Combine(Path.GetDirectoryName(targetPath), Path.GetRandomFileName());
                        targetNupkg = Path.Combine(extractPath, Path.GetFileName(targetNupkg));
                    }

                    var extractDirectory = Directory.CreateDirectory(extractPath);
                    using (var nupkgStream = new FileStream(
                        targetNupkg,
                        FileMode.Create,
                        FileAccess.ReadWrite,
                        FileShare.ReadWrite | FileShare.Delete,
                        bufferSize: 4096,
                        useAsync: true))
                    {
                        await stream.CopyToAsync(nupkgStream);
                        nupkgStream.Seek(0, SeekOrigin.Begin);

                        ExtractPackage(extractPath, nupkgStream);
                    }

                    // Fixup the casing of the nuspec on disk to match what we expect
                    var nuspecFile = Directory.EnumerateFiles(targetPath, "*" + NuGet.Constants.ManifestExtension).Single();

                    if (!string.Equals(nuspecFile, targetNuspec, StringComparison.Ordinal))
                    {
                        Manifest manifest = null;
                        using (var nuspecStream = File.OpenRead(nuspecFile))
                        {
                            manifest = Manifest.ReadFrom(nuspecStream, validateSchema: false);
                            manifest.Metadata.Id = library.Name;
                        }

                        // Delete the previous nuspec file
                        File.Delete(nuspecFile);

                        // Write the new manifest
                        using (var targetNuspecStream = File.OpenWrite(targetNuspec))
                        {
                            manifest.Save(targetNuspecStream);
                        }
                    }

                    stream.Seek(0, SeekOrigin.Begin);
                    var nupkgSHA = Convert.ToBase64String(sha512.ComputeHash(stream));
                    File.WriteAllText(hashPath, nupkgSHA);

                    if (performingParallelInstalls)
                    {
                        extractDirectory.MoveTo(targetPath);
                    }
                }

                return 0;
            });
        }
        private static unsafe void FillKeyDerivation(
            ReadOnlySpan <byte> password,
            ReadOnlySpan <byte> salt,
            int iterations,
            string hashAlgorithmName,
            Span <byte> destination)
        {
            SafeBCryptKeyHandle keyHandle;
            int hashBlockSizeBytes = GetHashBlockSize(hashAlgorithmName);

            // stackalloc 0 to let compiler know this cannot escape.
            Span <byte>         clearSpan            = stackalloc byte[0];
            ReadOnlySpan <byte> symmetricKeyMaterial = stackalloc byte[0];
            int symmetricKeyMaterialLength;

            if (password.IsEmpty)
            {
                // CNG won't accept a null pointer for the password.
                symmetricKeyMaterial       = stackalloc byte[1];
                symmetricKeyMaterialLength = 0;
                clearSpan = default;
            }
            else if (password.Length <= hashBlockSizeBytes)
            {
                // Password is small enough to use as-is.
                symmetricKeyMaterial       = password;
                symmetricKeyMaterialLength = password.Length;
                clearSpan = default;
            }
            else
            {
                // RFC 2104: "The key for HMAC can be of any length (keys longer than B bytes are
                //     first hashed using H).
                //     We denote by B the byte-length of such
                //     blocks (B=64 for all the above mentioned examples of hash functions)
                //
                // Windows' PBKDF2 will do this up to a point. To ensure we accept arbitrary inputs for
                // PBKDF2, we do the hashing ourselves.
                Span <byte> hashBuffer = stackalloc byte[512 / 8]; // 64 bytes is SHA512, the largest digest handled.
                int         hashBufferSize;

                switch (hashAlgorithmName)
                {
                case HashAlgorithmNames.SHA1:
                    hashBufferSize = SHA1.HashData(password, hashBuffer);
                    break;

                case HashAlgorithmNames.SHA256:
                    hashBufferSize = SHA256.HashData(password, hashBuffer);
                    break;

                case HashAlgorithmNames.SHA384:
                    hashBufferSize = SHA384.HashData(password, hashBuffer);
                    break;

                case HashAlgorithmNames.SHA512:
                    hashBufferSize = SHA512.HashData(password, hashBuffer);
                    break;

                default:
                    Debug.Fail($"Unexpected hash algorithm '{hashAlgorithmName}'");
                    throw new CryptographicException();
                }

                clearSpan                  = hashBuffer.Slice(0, hashBufferSize);
                symmetricKeyMaterial       = clearSpan;
                symmetricKeyMaterialLength = hashBufferSize;
            }

            Debug.Assert(symmetricKeyMaterial.Length > 0);

            NTSTATUS generateKeyStatus;

            if (Interop.BCrypt.PseudoHandlesSupported)
            {
                fixed(byte *pSymmetricKeyMaterial = symmetricKeyMaterial)
                {
                    generateKeyStatus = Interop.BCrypt.BCryptGenerateSymmetricKey(
                        (nuint)BCryptAlgPseudoHandle.BCRYPT_PBKDF2_ALG_HANDLE,
                        out keyHandle,
                        pbKeyObject: IntPtr.Zero,
                        cbKeyObject: 0,
                        pSymmetricKeyMaterial,
                        symmetricKeyMaterialLength,
                        dwFlags: 0);
                }
            }
            else
            {
                if (s_pbkdf2AlgorithmHandle is null)
                {
                    NTSTATUS openStatus = Interop.BCrypt.BCryptOpenAlgorithmProvider(
                        out SafeBCryptAlgorithmHandle pbkdf2AlgorithmHandle,
                        Internal.NativeCrypto.BCryptNative.AlgorithmName.Pbkdf2,
                        null,
                        BCryptOpenAlgorithmProviderFlags.None);

                    if (openStatus != NTSTATUS.STATUS_SUCCESS)
                    {
                        pbkdf2AlgorithmHandle.Dispose();
                        CryptographicOperations.ZeroMemory(clearSpan);
                        throw Interop.BCrypt.CreateCryptographicException(openStatus);
                    }

                    // This might race, and that's okay. Worst case the algorithm is opened
                    // more than once, and the ones that lost will get cleaned up during collection.
                    Interlocked.CompareExchange(ref s_pbkdf2AlgorithmHandle, pbkdf2AlgorithmHandle, null);
                }

                fixed(byte *pSymmetricKeyMaterial = symmetricKeyMaterial)
                {
                    generateKeyStatus = Interop.BCrypt.BCryptGenerateSymmetricKey(
                        s_pbkdf2AlgorithmHandle,
                        out keyHandle,
                        pbKeyObject: IntPtr.Zero,
                        cbKeyObject: 0,
                        pSymmetricKeyMaterial,
                        symmetricKeyMaterialLength,
                        dwFlags: 0);
                }
            }

            CryptographicOperations.ZeroMemory(clearSpan);

            if (generateKeyStatus != NTSTATUS.STATUS_SUCCESS)
            {
                keyHandle.Dispose();
                throw Interop.BCrypt.CreateCryptographicException(generateKeyStatus);
            }

            Debug.Assert(!keyHandle.IsInvalid);

            ulong kdfIterations = (ulong)iterations; // Previously asserted to be positive.

            using (keyHandle)
                fixed(char *pHashAlgorithmName = hashAlgorithmName)
                fixed(byte *pSalt        = salt)
                fixed(byte *pDestination = destination)
                {
                    Span <BCryptBuffer> buffers = stackalloc BCryptBuffer[3];

                    buffers[0].BufferType = CngBufferDescriptors.KDF_ITERATION_COUNT;
                    buffers[0].pvBuffer   = (IntPtr)(&kdfIterations);
                    buffers[0].cbBuffer   = sizeof(ulong);

                    buffers[1].BufferType = CngBufferDescriptors.KDF_SALT;
                    buffers[1].pvBuffer   = (IntPtr)pSalt;
                    buffers[1].cbBuffer   = salt.Length;

                    buffers[2].BufferType = CngBufferDescriptors.KDF_HASH_ALGORITHM;
                    buffers[2].pvBuffer   = (IntPtr)pHashAlgorithmName;

                    // C# spec: "A char* value produced by fixing a string instance always points to a null-terminated string"
                    buffers[2].cbBuffer = checked ((hashAlgorithmName.Length + 1) * sizeof(char)); // Add null terminator.

                    fixed(BCryptBuffer *pBuffers = buffers)
                    {
                        Interop.BCrypt.BCryptBufferDesc bufferDesc;
                        bufferDesc.ulVersion = Interop.BCrypt.BCRYPTBUFFER_VERSION;
                        bufferDesc.cBuffers  = buffers.Length;
                        bufferDesc.pBuffers  = (IntPtr)pBuffers;

                        NTSTATUS deriveStatus = Interop.BCrypt.BCryptKeyDerivation(
                            keyHandle,
                            &bufferDesc,
                            pDestination,
                            destination.Length,
                            out uint resultLength,
                            dwFlags: 0);

                        if (deriveStatus != NTSTATUS.STATUS_SUCCESS)
                        {
                            throw Interop.BCrypt.CreateCryptographicException(deriveStatus);
                        }

                        if (destination.Length != resultLength)
                        {
                            Debug.Fail("PBKDF2 resultLength != destination.Length");
                            throw new CryptographicException();
                        }
                    }
                }
        }
	public void FIPS186_e (string testName, SHA512 hash, byte[] input, byte[] result) 
	{
		byte[] copy = new byte [input.Length];
		for (int i=0; i < input.Length - 1; i++)
			hash.TransformBlock (input, i, 1, copy, i);
		byte[] output = hash.TransformFinalBlock (input, input.Length - 1, 1);
		// LAMESPEC or FIXME: TransformFinalBlock doesn't return HashValue !
		// AssertEquals (testName + ".e.1", result, output);
		Assert.IsNotNull (output, testName + ".e.1");
		Assert.AreEqual (result, hash.Hash, testName + ".e.2");
		// required or next operation will still return old hash
		hash.Initialize ();
	}
示例#24
0
	public void FIPS186_a (string testName, SHA512 hash, byte[] input, byte[] result) 
	{
		byte[] output = hash.ComputeHash (input); 
		AssertEquals (testName + ".a.1", result, output);
		AssertEquals (testName + ".a.2", result, hash.Hash);
		// required or next operation will still return old hash
		hash.Initialize ();
	}
	public void FIPS186_c (string testName, SHA512 hash, byte[] input, byte[] result) 
	{
		MemoryStream ms = new MemoryStream (input);
		byte[] output = hash.ComputeHash (ms); 
		Assert.AreEqual (result, output, testName + ".c.1");
		Assert.AreEqual (result, hash.Hash, testName + ".c.2");
		// required or next operation will still return old hash
		hash.Initialize ();
	}
	public void FIPS186_b (string testName, SHA512 hash, byte[] input, byte[] result) 
	{
		byte[] output = hash.ComputeHash (input, 0, input.Length); 
		Assert.AreEqual (result, output, testName + ".b.1");
		Assert.AreEqual (result, hash.Hash, testName + ".b.2");
		// required or next operation will still return old hash
		hash.Initialize ();
	}
示例#27
0
 public Hash()
 {
     hasher = new SHA512Managed();
 }
示例#28
0
 /// <summary>Creates an instance of the default implementation of <see cref="T:System.Security.Cryptography.SHA512" />.</summary>
 /// <returns>A new instance of <see cref="T:System.Security.Cryptography.SHA512" />.</returns>
 /// <exception cref="T:System.Reflection.TargetInvocationException">The algorithm was used with Federal Information Processing Standards (FIPS) mode enabled, but is not FIPS compatible.</exception>
 /// <PermissionSet>
 ///   <IPermission class="System.Security.Permissions.SecurityPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Flags="UnmanagedCode" />
 /// </PermissionSet>
 public new static SHA512 Create()
 {
     return(SHA512.Create("System.Security.Cryptography.SHA512"));
 }
示例#29
0
    IEnumerator Login(string formScreenName, string formPassword)
    {
        string formText = "";
        string URL      = UserBlobManager.GetComponent <UserBlobManager>().ServerURL + "uw.php";
        string hash     = UserBlobManager.GetComponent <UserBlobManager>().ServerHash;
        string date     = System.DateTime.Now.Year.ToString("D4");

        date += System.DateTime.Now.Month.ToString("D2");
        date += System.DateTime.Now.Day.ToString("D2");

        // encrypt the password
        byte[] bytes = System.Text.Encoding.ASCII.GetBytes(hash + formPassword);
        System.Security.Cryptography.SHA512 sha = System.Security.Cryptography.SHA512.Create();
        byte[] shaHash = sha.ComputeHash(bytes);
        string result  = ByteArrayToHexString(shaHash);

        WWWForm form = new WWWForm();

        form.AddField("action", "login");
        form.AddField("myform_hash", hash);
        form.AddField("myform_ScreenName", formScreenName);
        form.AddField("myform_Password", result);
        form.AddField("myform_Date", date);
        WWW w = new WWW(URL, form);

        yield return(w);

        if (w.error != null)
        {
            // connection error
            print(w.error);

            if (w.error.Contains("Could not resolve host"))
            {
                if (PopUpActive == false)
                {
                    PopUpOkDialog("Can NOT connect to server.\nPlease check your internet connection.", this.gameObject.GetComponent <UI_Login>(), "WrongScreenNamePassword");
                }
            }
        }
        else
        {
            formText = w.text;

            if (formText.Contains("HASH code is different from your app"))
            {
                print("Can't connect");
                w.Dispose();
                if (PopUpActive == false)
                {
                    PopUpOkDialog("Cant connect to server.", this.gameObject.GetComponent <UI_Login>(), "WrongScreenNamePassword");
                }
            }
            else
            {
                if (formText.Contains("ScreenName or password is wrong."))
                {
                    if (PopUpActive == false)
                    {
                        PopUpOkDialog("Screen name or password is wrong.", this.gameObject.GetComponent <UI_Login>(), "WrongScreenNamePassword");
                    }
                }

                if (formText.Contains("Data invalid - cant find name"))
                {
                    if (PopUpActive == false)
                    {
                        PopUpOkDialog("Screen name is wrong.", this.gameObject.GetComponent <UI_Login>(), "WrongScreenNamePassword");
                    }
                }

                if (formText.Contains("PASSWORD CORRECT"))
                {
                    print("Login OK");
                    string[] tempArray = formText.Split('#');

                    string name          = tempArray[1];
                    string firstName     = tempArray[2];
                    string lastName      = tempArray[3];
                    string email         = tempArray[4];
                    string streetAddress = tempArray[5];
                    string city          = tempArray[6];
                    string state         = tempArray[7];
                    string zip           = tempArray[8];
                    string gender        = tempArray[9];

                    if (UserBlobManager.GetComponent <UserBlobManager>().UserSettingsData.RememberLoginPassword == true)
                    {
                        UserBlobManager.GetComponent <UserBlobManager>().UserSettingsData.UserLogin         = name;
                        UserBlobManager.GetComponent <UserBlobManager>().UserSettingsData.UserPassword      = formPassword;
                        UserBlobManager.GetComponent <UserBlobManager>().UserSettingsData.UserFirstName     = firstName;
                        UserBlobManager.GetComponent <UserBlobManager>().UserSettingsData.UserLastName      = lastName;
                        UserBlobManager.GetComponent <UserBlobManager>().UserSettingsData.UserEmail         = email;
                        UserBlobManager.GetComponent <UserBlobManager>().UserSettingsData.UserStreetAddress = streetAddress;
                        UserBlobManager.GetComponent <UserBlobManager>().UserSettingsData.UserCity          = city;
                        UserBlobManager.GetComponent <UserBlobManager>().UserSettingsData.UserState         = state;
                        UserBlobManager.GetComponent <UserBlobManager>().UserSettingsData.UserZip           = zip;
                        UserBlobManager.GetComponent <UserBlobManager>().UserSettingsData.UserGender        = gender;
                        UserBlobManager.GetComponent <UserBlobManager>().SaveSettings();
                    }
                    UserBlobManager.GetComponent <UserBlobManager>().UserDownloadTrainingDataString = "";
                    UserBlobManager.GetComponent <UserBlobManager>().UserDownloadWorkoutDataString  = "";
                    UserBlobManager.GetComponent <UserBlobManager>().UserDownloadExerciseDataString = "";
                    UIShare.GetComponent <UI_Share>().UpdateFriendList = true;
                    UIManager.GetComponent <UI_Manager>().SwitchStates("ShareState");
                }
            }
        }
        w.Dispose();
    }
示例#30
0
        private LockFileLibrary CreateLockFileLibrary(LocalPackageInfo package, SHA512 sha512, string correctedPackageName)
        {
            var lockFileLib = new LockFileLibrary();

            // package.Id is read from nuspec and it might be in wrong casing.
            // correctedPackageName should be the package name used by dependency graph and
            // it has the correct casing that runtime needs during dependency resolution.
            lockFileLib.Name = correctedPackageName ?? package.Id;
            lockFileLib.Version = package.Version;

            using (var nupkgStream = File.OpenRead(package.ZipPath))
            {
                lockFileLib.Sha512 = Convert.ToBase64String(sha512.ComputeHash(nupkgStream));
                nupkgStream.Seek(0, SeekOrigin.Begin);

                var packageReader = new PackageReader(nupkgStream);

                // Get package files, excluding directory entries
                lockFileLib.Files = packageReader.GetFiles().Where(x => !x.EndsWith("/")).ToList();
            }

            return lockFileLib;
        }
 public FileSystemSessionManager(string path)
 {
     this.path = path;
     this.encrypter = new SHA512Managed();
 }
示例#32
0
 public Sha512()
 {
     _digest = SHA512.Create();
     _digest.Initialize();
 }
示例#33
0
        public static byte[] Sha512(params byte[][] sources)
        {
            if (sources == null)
            {
                throw new ArgumentNullException(nameof(sources), "The sources array is null.");
            }

            foreach (byte[] source in sources)
            {
                if (source == null)
                {
                    throw new ArgumentNullException(nameof(sources), "The sources array contains null element.");
                }
            }

            lock (sha512Lock)
            {
                if (sha512Alg == null)
                {
                    sha512Alg = SHA512.Create();
                }
                sha512Alg.Initialize();

                foreach (byte[] source in sources)
                {
                    int offset = 0;
                    while (offset < source.Length)
                    {
                        offset += sha512Alg.TransformBlock(source, offset, source.Length - offset, source, offset);
                    }
                }

                sha512Alg.TransformFinalBlock(new byte[0], 0, 0);

                return sha512Alg.Hash;
            }
        }
	public void FIPS186_d (string testName, SHA512 hash, byte[] input, byte[] result) 
	{
		byte[] output = hash.TransformFinalBlock (input, 0, input.Length);
		// LAMESPEC or FIXME: TransformFinalBlock doesn't return HashValue !
		// AssertEquals( testName + ".d.1", result, output );
		Assert.IsNotNull (output, testName + ".d.1");
		Assert.AreEqual (result, hash.Hash, testName + ".d.2");
		// required or next operation will still return old hash
		hash.Initialize ();
	}
 /// <summary>
 /// Gets the SHA512 of the password.
 /// </summary>
 /// <param name="password">the password to hash.</param>
 /// <param name="hashProvider">The hash provider.</param>
 /// <returns>The computed hash.</returns>
 private static byte[] GetHash(
     SecureString password,
     SHA512 hashProvider)
 {
     byte[] encodedText = password.ToEncodedClearText();
     try
     {
         return hashProvider.ComputeHash(encodedText);
     }
     finally
     {
         encodedText.Zero();
     }
 }
示例#36
0
 private static SHA512 pGetSHA512()
 {
     if (objSHA512 == null) {
         return objSHA512 = new SHA512Managed();
     }
     return objSHA512;
 }
 // Initialize the static class
 static Cryptography()
 {
     shaHasher = new SHA512Managed();
     md5Hasher = MD5.Create();
     encoder = new UTF8Encoding();
 }
示例#38
0
        public static LockFileLibrary CreateLockFileLibraryForProject(
            Runtime.Project project,
            IPackage package,
            SHA512 sha512,
            IEnumerable<FrameworkName> frameworks,
            IPackagePathResolver resolver,
            string correctedPackageName = null)
        {
            var lockFileLib = new LockFileLibrary();

            // package.Id is read from nuspec and it might be in wrong casing.
            // correctedPackageName should be the package name used by dependency graph and
            // it has the correct casing that runtime needs during dependency resolution.
            lockFileLib.Name = correctedPackageName ?? package.Id;
            lockFileLib.Version = package.Version;

            using (var nupkgStream = package.GetStream())
            {
                lockFileLib.Sha = Convert.ToBase64String(sha512.ComputeHash(nupkgStream));
            }
            lockFileLib.Files = package.GetFiles().Select(p => p.Path).ToList();

            foreach (var framework in frameworks)
            {
                var group = new LockFileFrameworkGroup();
                group.TargetFramework = framework;

                IEnumerable<PackageDependencySet> dependencySet;
                if (VersionUtility.TryGetCompatibleItems(framework, package.DependencySets, out dependencySet))
                {
                    var set = dependencySet.FirstOrDefault()?.Dependencies?.ToList();

                    if (set != null)
                    {
                        group.Dependencies = set;
                    }
                }

                // TODO: Remove this when we do #596
                // ASP.NET Core isn't compatible with generic PCL profiles
                if (!string.Equals(framework.Identifier, VersionUtility.AspNetCoreFrameworkIdentifier, StringComparison.OrdinalIgnoreCase) &&
                    !string.Equals(framework.Identifier, VersionUtility.DnxCoreFrameworkIdentifier, StringComparison.OrdinalIgnoreCase))
                {
                    IEnumerable<FrameworkAssemblyReference> frameworkAssemblies;
                    if (VersionUtility.TryGetCompatibleItems(framework, package.FrameworkAssemblies, out frameworkAssemblies))
                    {
                        foreach (var assemblyReference in frameworkAssemblies)
                        {
                            if (!assemblyReference.SupportedFrameworks.Any() &&
                                !VersionUtility.IsDesktop(framework))
                            {
                                // REVIEW: This isn't 100% correct since none *can* mean
                                // any in theory, but in practice it means .NET full reference assembly
                                // If there's no supported target frameworks and we're not targeting
                                // the desktop framework then skip it.

                                // To do this properly we'll need all reference assemblies supported
                                // by each supported target framework which isn't always available.
                                continue;
                            }

                            group.FrameworkAssemblies.Add(assemblyReference);
                        }
                    }
                }

                group.RuntimeAssemblies = GetPackageAssemblies(package, framework);

                string contractPath = Path.Combine("lib", "contract", package.Id + ".dll");
                var hasContract = lockFileLib.Files.Any(path => path == contractPath);
                var hasLib = group.RuntimeAssemblies.Any();

                if (hasContract && hasLib && !VersionUtility.IsDesktop(framework))
                {
                    group.CompileTimeAssemblies.Add(contractPath);
                }
                else if (hasLib)
                {
                    group.CompileTimeAssemblies.AddRange(group.RuntimeAssemblies);
                }

                lockFileLib.FrameworkGroups.Add(group);
            }

            var installPath = resolver.GetInstallPath(package.Id, package.Version);
            foreach (var assembly in lockFileLib.FrameworkGroups.SelectMany(f => f.RuntimeAssemblies))
            {
                var assemblyPath = Path.Combine(installPath, assembly);
                if (IsAssemblyServiceable(assemblyPath))
                {
                    lockFileLib.IsServiceable = true;
                    break;
                }
            }

            return lockFileLib;
        }
示例#39
0
 private static SHA512 GetHasher512() {
     if (_hasher512 == null) {
         _hasher512 = SHA512Managed.Create();
     }
     return _hasher512;
 }
 /// <summary>
 /// MD5 is no longer safe. The implementation will now use SHA512
 /// Hashes the given byte array
 /// </summary>
 /// <param name="input">Byte array to hash</param>
 public static byte[] CalculateMD5Hash(byte[] input)
 {
     using (var hasher = SHA512.Create()) return(hasher.ComputeHash(input));
 }
 public HashProvider()
 {
     _hashCalculator = new SHA512Managed();
 }
示例#42
0
 public override byte[] ByteHashAlgorithm(string value)
 {
     System.Security.Cryptography.SHA512 sha = System.Security.Cryptography.SHA512.Create();
     byte[] bytes = sha.ComputeHash(System.Text.ASCIIEncoding.UTF8.GetBytes(value));
     return(bytes);
 }