public Entry(string hashAlgorithmId, BCryptOpenAlgorithmProviderFlags flags, SafeBCryptAlgorithmHandle handle)
: this()
{
HashAlgorithmId = hashAlgorithmId;
Flags = flags;
Handle = handle;
}
public Entry(string hashAlgorithmId, BCryptOpenAlgorithmProviderFlags flags, SafeBCryptAlgorithmHandle handle)
: this()
{
HashAlgorithmId = hashAlgorithmId;
Flags = flags;
Handle = handle;
}
/// <summary>
/// Return a SafeBCryptAlgorithmHandle of the desired algorithm and flags. This is a shared handle so do not dispose it!
/// </summary>
public static SafeBCryptAlgorithmHandle GetCachedBCryptAlgorithmHandle(string hashAlgorithmId, BCryptOpenAlgorithmProviderFlags flags)
{
// There aren't that many hash algorithms around so rather than use a LowLevelDictionary and guard it with a lock,
// we'll use a simple list. To avoid locking, we'll recreate the entire list each time an entry is added and replace it atomically.
//
// This does mean that on occasion, racing threads may create two handles of the same type, but this is ok.
// Latch the _cache value into a local so we aren't disrupted by concurrent changes to it.
Entry[] cache = _cache;
foreach (Entry entry in cache)
{
if (entry.HashAlgorithmId == hashAlgorithmId && entry.Flags == flags)
return entry.Handle;
}
SafeBCryptAlgorithmHandle safeBCryptAlgorithmHandle;
NTSTATUS ntStatus = Interop.BCrypt.BCryptOpenAlgorithmProvider(out safeBCryptAlgorithmHandle, hashAlgorithmId, null, flags);
if (ntStatus != NTSTATUS.STATUS_SUCCESS)
throw Interop.BCrypt.CreateCryptographicException(ntStatus);
Entry[] newCache = new Entry[cache.Length + 1];
Entry newEntry = new Entry(hashAlgorithmId, flags, safeBCryptAlgorithmHandle);
Array.Copy(cache, 0, newCache, 0, cache.Length);
newCache[newCache.Length - 1] = newEntry;
// Atomically overwrite the cache with our new cache. It's possible some other thread raced to add a new entry with us - if so, one of the new entries
// will be lost and the next guy that requests it will have to allocate it again. That's considered acceptable collateral damage.
_cache = newCache;
return newEntry.Handle;
}
/// <summary>
/// Loads and initializes a CNG provider.
/// </summary>
/// <param name="pszAlgId">
/// A pointer to a null-terminated Unicode string that identifies the requested
/// cryptographic algorithm. This can be one of the standard
/// CNG Algorithm Identifiers defined in <see cref="AlgorithmIdentifiers"/>
/// or the identifier for another registered algorithm.
/// </param>
/// <param name="pszImplementation">
/// <para>
/// A pointer to a null-terminated Unicode string that identifies the specific provider
/// to load. This is the registered alias of the cryptographic primitive provider.
/// This parameter is optional and can be NULL if it is not needed. If this parameter
/// is NULL, the default provider for the specified algorithm will be loaded.
/// </para>
/// <para>
/// Note If the <paramref name="pszImplementation"/> parameter value is NULL, CNG attempts to open each
/// registered provider, in order of priority, for the algorithm specified by the
/// <paramref name="pszAlgId"/> parameter and returns the handle of the first provider that is successfully
/// opened.For the lifetime of the handle, any BCrypt*** cryptographic APIs will use the
/// provider that was successfully opened.
/// </para>
/// </param>
/// <param name="dwFlags">Options for the function.</param>
/// <returns>
/// A pointer to a BCRYPT_ALG_HANDLE variable that receives the CNG provider handle.
/// When you have finished using this handle, release it by passing it to the
/// BCryptCloseAlgorithmProvider function.
/// </returns>
public static SafeAlgorithmHandle BCryptOpenAlgorithmProvider(
string pszAlgId,
string pszImplementation = null,
BCryptOpenAlgorithmProviderFlags dwFlags = BCryptOpenAlgorithmProviderFlags.None)
{
SafeAlgorithmHandle handle;
BCryptOpenAlgorithmProvider(
out handle,
pszAlgId,
pszImplementation,
dwFlags).ThrowOnError();
return(handle);
}
internal static extern NTSTATUS BCryptOpenAlgorithmProvider(out SafeBCryptAlgorithmHandle phAlgorithm, string pszAlgId, string pszImplementation, BCryptOpenAlgorithmProviderFlags dwFlags);
/// <summary>
/// Return a SafeBCryptAlgorithmHandle of the desired algorithm and flags. This is a shared handle so do not dispose it!
/// </summary>
public static SafeBCryptAlgorithmHandle GetCachedBCryptAlgorithmHandle(string hashAlgorithmId, BCryptOpenAlgorithmProviderFlags flags, out int hashSizeInBytes)
{
// There aren't that many hash algorithms around so rather than use a LowLevelDictionary and guard it with a lock,
// we'll use a simple list. To avoid locking, we'll recreate the entire list each time an entry is added and replace it atomically.
//
// This does mean that on occasion, racing threads may create two handles of the same type, but this is ok.
// Latch the _cache value into a local so we aren't disrupted by concurrent changes to it.
Entry[] cache = _cache;
foreach (Entry entry in cache)
{
if (entry.HashAlgorithmId == hashAlgorithmId && entry.Flags == flags)
{
hashSizeInBytes = entry.HashSizeInBytes;
return(entry.Handle);
}
}
SafeBCryptAlgorithmHandle safeBCryptAlgorithmHandle;
NTSTATUS ntStatus = Interop.BCrypt.BCryptOpenAlgorithmProvider(out safeBCryptAlgorithmHandle, hashAlgorithmId, null, flags);
if (ntStatus != NTSTATUS.STATUS_SUCCESS)
{
throw Interop.BCrypt.CreateCryptographicException(ntStatus);
}
Array.Resize(ref cache, cache.Length + 1);
Entry newEntry = new Entry(hashAlgorithmId, flags, safeBCryptAlgorithmHandle);
cache[^ 1] = new Entry(hashAlgorithmId, flags, safeBCryptAlgorithmHandle);
internal static extern NTSTATUS BCryptOpenAlgorithmProvider(out SafeBCryptAlgorithmHandle phAlgorithm, string pszAlgId, string pszImplementation, BCryptOpenAlgorithmProviderFlags dwFlags);
internal static extern int BCryptOpenAlgorithmProvider(out SafeBCryptAlgorithmHandle algorithmHandle, string algIdString, string implementationString, BCryptOpenAlgorithmProviderFlags flags);
public static extern NTStatus BCryptOpenAlgorithmProvider(
out SafeAlgorithmHandle phAlgorithm,
string pszAlgId,
string pszImplementation,
BCryptOpenAlgorithmProviderFlags dwFlags);
/// <summary>
/// Return a SafeBCryptAlgorithmHandle of the desired algorithm and flags. This is a shared handle so do not dispose it!
/// </summary>
public static SafeBCryptAlgorithmHandle GetCachedBCryptAlgorithmHandle(string hashAlgorithmId, BCryptOpenAlgorithmProviderFlags flags)
{
// There aren't that many hash algorithms around so rather than use a LowLevelDictionary and guard it with a lock,
// we'll use a simple list. To avoid locking, we'll recreate the entire list each time an entry is added and replace it atomically.
//
// This does mean that on occasion, racing threads may create two handles of the same type, but this is ok.
// Latch the _cache value into a local so we aren't disrupted by concurrent changes to it.
Entry[] cache = _cache;
foreach (Entry entry in cache)
{
if (entry.HashAlgorithmId == hashAlgorithmId && entry.Flags == flags)
{
return(entry.Handle);
}
}
SafeBCryptAlgorithmHandle safeBCryptAlgorithmHandle;
NTSTATUS ntStatus = Interop.BCrypt.BCryptOpenAlgorithmProvider(out safeBCryptAlgorithmHandle, hashAlgorithmId, null, flags);
if (ntStatus != NTSTATUS.STATUS_SUCCESS)
{
throw Interop.BCrypt.CreateCryptographicException(ntStatus);
}
Entry[] newCache = new Entry[cache.Length + 1];
Entry newEntry = new Entry(hashAlgorithmId, flags, safeBCryptAlgorithmHandle);
Array.Copy(cache, 0, newCache, 0, cache.Length);
newCache[newCache.Length - 1] = newEntry;
// Atomically overwrite the cache with our new cache. It's possible some other thread raced to add a new entry with us - if so, one of the new entries
// will be lost and the next guy that requests it will have to allocate it again. That's considered acceptable collateral damage.
_cache = newCache;
return(newEntry.Handle);
}
public static extern NtStatus BCryptOpenAlgorithmProvider(
out IntPtr phAlgorithm,
string pszAlgId,
string pszImplementation = null,
BCryptOpenAlgorithmProviderFlags dwFlags = BCryptOpenAlgorithmProviderFlags.None
);
public static extern NTStatus BCryptOpenAlgorithmProvider(
out SafeAlgorithmHandle phAlgorithm,
string pszAlgId,
string pszImplementation,
BCryptOpenAlgorithmProviderFlags dwFlags);
/// <summary>
/// Returns a SafeBCryptAlgorithmHandle of the desired algorithm and flags. This is a shared handle so do not dispose it!
/// </summary>
public static unsafe SafeBCryptAlgorithmHandle GetCachedBCryptAlgorithmHandle(string hashAlgorithmId, BCryptOpenAlgorithmProviderFlags flags, out int hashSizeInBytes)
{
var key = (hashAlgorithmId, flags);
while (true)
{
if (s_handles.TryGetValue(key, out (SafeBCryptAlgorithmHandle Handle, int HashSizeInBytes)result))
{
hashSizeInBytes = result.HashSizeInBytes;
return(result.Handle);
}
NTSTATUS ntStatus = Interop.BCrypt.BCryptOpenAlgorithmProvider(out SafeBCryptAlgorithmHandle handle, key.hashAlgorithmId, null, key.flags);
if (ntStatus != NTSTATUS.STATUS_SUCCESS)
{
Exception e = Interop.BCrypt.CreateCryptographicException(ntStatus);
handle.Dispose();
throw e;
}
int hashSize;
ntStatus = Interop.BCrypt.BCryptGetProperty(
handle,
Interop.BCrypt.BCryptPropertyStrings.BCRYPT_HASH_LENGTH,
&hashSize,
sizeof(int),
out int cbHashSize,
0);
if (ntStatus != NTSTATUS.STATUS_SUCCESS)
{
Exception e = Interop.BCrypt.CreateCryptographicException(ntStatus);
handle.Dispose();
throw e;
}
Debug.Assert(cbHashSize == sizeof(int));
Debug.Assert(hashSize > 0);
if (!s_handles.TryAdd(key, (handle, hashSize)))
{
handle.Dispose();
}
}
}
internal static extern int BCryptOpenAlgorithmProvider(out IntPtr phAlgorithm, string pszAlgId, string pszImplementation, BCryptOpenAlgorithmProviderFlags dwFlags);
