internal static extern ErrorCode BCryptCreateHash(SafeBCryptAlgorithmHandle hAlgorithm, [Out] out SafeBCryptHashHandle phHash, IntPtr pbHashObject, int cbHashObject, IntPtr pbSecret, int cbSecret, int dwFlags);
internal LiteHash(string algorithm) { BCryptOpenAlgorithmProviderFlags algorithmFlags = BCryptOpenAlgorithmProviderFlags.None; // This is a shared handle, do not put this in a using. SafeBCryptAlgorithmHandle algorithmHandle = Interop.BCrypt.BCryptAlgorithmCache.GetCachedBCryptAlgorithmHandle( algorithm, algorithmFlags, out _hashSizeInBytes); SafeBCryptHashHandle hashHandle; NTSTATUS ntStatus = Interop.BCrypt.BCryptCreateHash( algorithmHandle, out hashHandle, pbHashObject: IntPtr.Zero, cbHashObject: 0, secret: ReadOnlySpan <byte> .Empty, cbSecret: 0, BCryptCreateHashFlags.None); if (ntStatus != NTSTATUS.STATUS_SUCCESS) { hashHandle.Dispose(); throw Interop.BCrypt.CreateCryptographicException(ntStatus); } _hashHandle = hashHandle; }
public override int GetCurrentHash(Span <byte> destination) { Debug.Assert(destination.Length >= _hashSize); Debug.Assert(_hHash != null); using (SafeBCryptHashHandle tmpHash = Interop.BCrypt.BCryptDuplicateHash(_hHash)) { NTSTATUS ntStatus = Interop.BCrypt.BCryptFinishHash(tmpHash, destination, _hashSize, 0); if (ntStatus != NTSTATUS.STATUS_SUCCESS) { throw Interop.BCrypt.CreateCryptographicException(ntStatus); } return(_hashSize); } }
public void Initialize() { SafeBCryptHashHandle phHash = null; IntPtr zero = IntPtr.Zero; RuntimeHelpers.PrepareConstrainedRegions(); try { int cb = BCryptNative.GetInt32Property <SafeBCryptAlgorithmHandle>(this.m_algorithmHandle, "ObjectLength"); RuntimeHelpers.PrepareConstrainedRegions(); try { } finally { zero = Marshal.AllocCoTaskMem(cb); } BCryptNative.ErrorCode code = BCryptNative.UnsafeNativeMethods.BCryptCreateHash(this.m_algorithmHandle, out phHash, zero, cb, IntPtr.Zero, 0, 0); if (code != BCryptNative.ErrorCode.Success) { throw new CryptographicException((int)code); } phHash.HashObject = zero; } finally { if ((zero != IntPtr.Zero) && ((phHash == null) || (phHash.HashObject == IntPtr.Zero))) { Marshal.FreeCoTaskMem(zero); } } if (this.m_hashHandle != null) { this.m_hashHandle.Dispose(); } this.m_hashHandle = phHash; }
internal static extern ErrorCode BCryptHashData(SafeBCryptHashHandle hHash, [MarshalAs(UnmanagedType.LPArray), In] byte[] pbInput, int cbInput, int dwFlags);
internal static extern ErrorCode BCryptGetHashProperty(SafeBCryptHashHandle hObject, string pszProperty, [MarshalAs(UnmanagedType.LPArray), In, Out] byte[] pbOutput, int cbOutput, [In, Out] ref int pcbResult, int flags);
internal static extern BCryptNative.ErrorCode BCryptFinishHash(SafeBCryptHashHandle hHash, [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pbInput, int cbInput, int dwFlags);
public void Initialize() { Contract.Ensures(m_hashHandle != null && !m_hashHandle.IsInvalid && !m_hashHandle.IsClosed); Contract.Assert(m_algorithmHandle != null); // Try to create a new hash algorithm to use SafeBCryptHashHandle newHashAlgorithm = null; IntPtr hashObjectBuffer = IntPtr.Zero; // Creating a BCRYPT_HASH_HANDLE requires providing a buffer to hold the hash object in, which // is tied to the lifetime of the hash handle. Wrap this in a CER so we can tie the lifetimes together // safely. try { int hashObjectSize = BCryptNative.GetInt32Property(m_algorithmHandle, BCryptNative.ObjectPropertyName.ObjectLength); Debug.Assert(hashObjectSize > 0, "hashObjectSize > 0"); // Allocate in a CER because we could fail between the alloc and the assignment try { } finally { hashObjectBuffer = Marshal.AllocCoTaskMem(hashObjectSize); } BCryptNative.ErrorCode error = BCryptNative.UnsafeNativeMethods.BCryptCreateHash(m_algorithmHandle, out newHashAlgorithm, hashObjectBuffer, hashObjectSize, IntPtr.Zero, 0, 0); if (error != BCryptNative.ErrorCode.Success) { throw new CryptographicException((int)error); } } finally { // Make sure we've successfully transfered ownership of the hash object buffer to the safe handle if (hashObjectBuffer != IntPtr.Zero) { // If we created the safe handle, it needs to own the buffer and free it in release if (newHashAlgorithm != null) { newHashAlgorithm.HashObject = hashObjectBuffer; } else { Marshal.FreeCoTaskMem(hashObjectBuffer); } } } // If we could create it, dispose of any old hash handle we had and replace it with the new one if (m_hashHandle != null) { m_hashHandle.Dispose(); } m_hashHandle = newHashAlgorithm; }
internal static extern unsafe ErrorCode BCryptHashData(SafeBCryptHashHandle hHash, byte *pbInput, int cbInput, int dwFlags);