internal static byte[] GetHashProperty(SafeCspHashHandle hashHandle, HashProperty property)
{
Contract.Assert(hashHandle != null && !hashHandle.IsInvalid, "keyHandle != null && !keyHandle.IsInvalid");
int bufferSize = 0;
byte[] buffer = null;
// Figure out how big of a buffer we need to hold the property
if (!UnsafeNativeMethods.CryptGetHashParam(hashHandle, property, buffer, ref bufferSize, 0))
{
int errorCode = Marshal.GetLastWin32Error();
if (errorCode != (int)ErrorCode.MoreData)
{
throw new CryptographicException(errorCode);
}
}
// Now get the property bytes directly
buffer = new byte[bufferSize];
if (!UnsafeNativeMethods.CryptGetHashParam(hashHandle, property, buffer, ref bufferSize, 0))
{
throw new CryptographicException(Marshal.GetLastWin32Error());
}
return(buffer);
}
internal static bool VerifySignature(SafeCspHandle cspHandle, SafeCspKeyHandle keyHandle, CapiNative.AlgorithmID signatureAlgorithm, CapiNative.AlgorithmID hashAlgorithm, byte[] hashValue, byte[] signature)
{
byte[] numArray = new byte[signature.Length];
Array.Copy((Array)signature, (Array)numArray, numArray.Length);
Array.Reverse((Array)numArray);
using (SafeCspHashHandle hashAlgorithm1 = CapiNative.CreateHashAlgorithm(cspHandle, hashAlgorithm))
{
if (hashValue.Length != CapiNative.GetHashPropertyInt32(hashAlgorithm1, CapiNative.HashProperty.HashSize))
{
throw new CryptographicException(-2146893822);
}
CapiNative.SetHashProperty(hashAlgorithm1, CapiNative.HashProperty.HashValue, hashValue);
SafeCspHashHandle hHash = hashAlgorithm1;
byte[] pbSignature = numArray;
int length = pbSignature.Length;
SafeCspKeyHandle hPubKey = keyHandle;
// ISSUE: variable of the null type
__Null local = null;
int dwFlags = 0;
if (CapiNative.UnsafeNativeMethods.CryptVerifySignature(hHash, pbSignature, length, hPubKey, (string)local, dwFlags))
{
return(true);
}
int lastWin32Error = Marshal.GetLastWin32Error();
if (lastWin32Error != -2146893818)
{
throw new CryptographicException(lastWin32Error);
}
return(false);
}
}
internal static void SetHashProperty(SafeCspHashHandle hashHandle, CapiNative.HashProperty property, byte[] value)
{
if (!CapiNative.UnsafeNativeMethods.CryptSetHashParam(hashHandle, property, value, 0))
{
throw new CryptographicException(Marshal.GetLastWin32Error());
}
}
internal static bool VerifySignature(SafeCspHandle cspHandle, SafeCspKeyHandle keyHandle, CapiNative.AlgorithmID signatureAlgorithm, CapiNative.AlgorithmID hashAlgorithm, byte[] hashValue, byte[] signature)
{
byte[] array = new byte[signature.Length];
Array.Copy(signature, array, array.Length);
Array.Reverse(array);
bool result;
using (SafeCspHashHandle safeCspHashHandle = CapiNative.CreateHashAlgorithm(cspHandle, hashAlgorithm))
{
if (hashValue.Length != CapiNative.GetHashPropertyInt32(safeCspHashHandle, CapiNative.HashProperty.HashSize))
{
throw new CryptographicException(-2146893822);
}
CapiNative.SetHashProperty(safeCspHashHandle, CapiNative.HashProperty.HashValue, hashValue);
if (CapiNative.UnsafeNativeMethods.CryptVerifySignature(safeCspHashHandle, array, array.Length, keyHandle, null, 0))
{
result = true;
}
else
{
int lastWin32Error = Marshal.GetLastWin32Error();
if (lastWin32Error != -2146893818)
{
throw new CryptographicException(lastWin32Error);
}
result = false;
}
}
return(result);
}
internal static int GetHashPropertyInt32(SafeCspHashHandle hashHandle, CapiNative.HashProperty property)
{
byte[] hashProperty = CapiNative.GetHashProperty(hashHandle, property);
if (hashProperty.Length != 4)
{
return(0);
}
return(BitConverter.ToInt32(hashProperty, 0));
}
internal static SafeCspHashHandle CreateHashAlgorithm(SafeCspHandle cspHandle, CapiNative.AlgorithmID algorithm)
{
SafeCspHashHandle phHash = (SafeCspHashHandle)null;
if (!CapiNative.UnsafeNativeMethods.CryptCreateHash(cspHandle, algorithm, IntPtr.Zero, 0, out phHash))
{
throw new CryptographicException(Marshal.GetLastWin32Error());
}
return(phHash);
}
internal static void SetHashProperty(SafeCspHashHandle hashHandle,
HashProperty property,
byte[] value)
{
Contract.Assert(hashHandle != null && !hashHandle.IsInvalid, "hashHandle != null && !hashHandle.IsInvalid");
if (!UnsafeNativeMethods.CryptSetHashParam(hashHandle, property, value, 0))
{
throw new CryptographicException(Marshal.GetLastWin32Error());
}
}
internal static bool VerifySignature(SafeCspHandle cspHandle,
SafeCspKeyHandle keyHandle,
AlgorithmID signatureAlgorithm,
AlgorithmID hashAlgorithm,
byte[] hashValue,
byte[] signature)
{
Contract.Assert(cspHandle != null && !cspHandle.IsInvalid, "cspHandle != null && !cspHandle.IsInvalid");
Contract.Assert(keyHandle != null && !keyHandle.IsInvalid, "keyHandle != null && !keyHandle.IsInvalid");
Contract.Assert(((AlgorithmClass)signatureAlgorithm & AlgorithmClass.Signature) == AlgorithmClass.Signature, "Invalid signature algorithm");
Contract.Assert(((AlgorithmClass)hashAlgorithm & AlgorithmClass.Hash) == AlgorithmClass.Hash, "Invalid hash algorithm");
Contract.Assert(hashValue != null, "hashValue != null");
Contract.Assert(signature != null, "signature != null");
// CAPI and the CLR have inverse byte orders for signatures, so we need to reverse before verifying
byte[] signatureValue = new byte[signature.Length];
Array.Copy(signature, signatureValue, signatureValue.Length);
Array.Reverse(signatureValue);
using (SafeCspHashHandle hashHandle = CreateHashAlgorithm(cspHandle, hashAlgorithm)) {
// Make sure the hash value is the correct size and import it into the CSP
if (hashValue.Length != GetHashPropertyInt32(hashHandle, HashProperty.HashSize))
{
throw new CryptographicException((int)ErrorCode.BadHash);
}
SetHashProperty(hashHandle, HashProperty.HashValue, hashValue);
// Do the signature verification. A TRUE result means that the signature was valid. A FALSE
// result either means an invalid signature or some other error, so we need to check the last
// error to see which occured.
if (UnsafeNativeMethods.CryptVerifySignature(hashHandle,
signatureValue,
signatureValue.Length,
keyHandle,
null,
0))
{
return(true);
}
else
{
int error = Marshal.GetLastWin32Error();
if (error != (int)ErrorCode.BadSignature)
{
throw new CryptographicException(error);
}
return(false);
}
}
}
internal static SafeCspHashHandle CreateHashAlgorithm(SafeCspHandle cspHandle, AlgorithmID algorithm)
{
Contract.Assert(cspHandle != null && !cspHandle.IsInvalid, "cspHandle != null && !cspHandle.IsInvalid");
Contract.Assert(((AlgorithmClass)algorithm & AlgorithmClass.Hash) == AlgorithmClass.Hash, "Invalid hash algorithm");
SafeCspHashHandle hashHandle = null;
if (!UnsafeNativeMethods.CryptCreateHash(cspHandle, algorithm, IntPtr.Zero, 0, out hashHandle))
{
throw new CryptographicException(Marshal.GetLastWin32Error());
}
return(hashHandle);
}
internal static byte[] GetHashProperty(SafeCspHashHandle hashHandle, CapiNative.HashProperty property)
{
int num = 0;
byte[] array = null;
if (!CapiNative.UnsafeNativeMethods.CryptGetHashParam(hashHandle, property, array, ref num, 0))
{
int lastWin32Error = Marshal.GetLastWin32Error();
if (lastWin32Error != 234)
{
throw new CryptographicException(lastWin32Error);
}
}
array = new byte[num];
if (!CapiNative.UnsafeNativeMethods.CryptGetHashParam(hashHandle, property, array, ref num, 0))
{
throw new CryptographicException(Marshal.GetLastWin32Error());
}
return(array);
}
internal static byte[] GetHashProperty(SafeCspHashHandle hashHandle, CapiNative.HashProperty property)
{
int pdwDataLen = 0;
byte[] pbData1 = (byte[])null;
if (!CapiNative.UnsafeNativeMethods.CryptGetHashParam(hashHandle, property, pbData1, out pdwDataLen, 0))
{
int lastWin32Error = Marshal.GetLastWin32Error();
if (lastWin32Error != 234)
{
throw new CryptographicException(lastWin32Error);
}
}
byte[] pbData2 = new byte[pdwDataLen];
if (!CapiNative.UnsafeNativeMethods.CryptGetHashParam(hashHandle, property, pbData2, out pdwDataLen, 0))
{
throw new CryptographicException(Marshal.GetLastWin32Error());
}
return(pbData2);
}
internal static extern bool CryptVerifySignature(SafeCspHashHandle hHash,
[In, MarshalAs(UnmanagedType.LPArray)] byte[] pbSignature,
int dwSigLen,
SafeCspKeyHandle hPubKey,
string sDescription,
int dwFlags);
internal static extern bool CryptCreateHash(SafeCspHandle hProv, CapiNative.AlgorithmID Algid, IntPtr hKey, int dwFlags, out SafeCspHashHandle phHash);
internal static int GetHashPropertyInt32(SafeCspHashHandle hashHandle, HashProperty property)
{
byte[] rawProperty = GetHashProperty(hashHandle, property);
Contract.Assert(rawProperty.Length == sizeof(int) || rawProperty.Length == 0, "Unexpected property size");
return(rawProperty.Length == sizeof(int) ? BitConverter.ToInt32(rawProperty, 0) : 0);
}
internal static extern bool CryptVerifySignature(SafeCspHashHandle hHash,
[In, MarshalAs(UnmanagedType.LPArray)] byte[] pbSignature,
int dwSigLen,
SafeCspKeyHandle hPubKey,
string sDescription,
int dwFlags);
internal static extern bool CryptSetHashParam(SafeCspHashHandle hHash,
HashProperty dwParam,
[In, MarshalAs(UnmanagedType.LPArray)] byte[] pbData,
int dwFlags);
internal static extern bool CryptCreateHash(SafeCspHandle hProv,
AlgorithmID Algid,
IntPtr hKey, // SafeCspKeyHandle
int dwFlags,
[Out] out SafeCspHashHandle phHash);
internal static void SetHashProperty(SafeCspHashHandle hashHandle,
HashProperty property,
byte[] value) {
Contract.Assert(hashHandle != null && !hashHandle.IsInvalid, "hashHandle != null && !hashHandle.IsInvalid");
if (!UnsafeNativeMethods.CryptSetHashParam(hashHandle, property, value, 0)) {
throw new CryptographicException(Marshal.GetLastWin32Error());
}
}
internal static byte[] GetHashProperty(SafeCspHashHandle hashHandle, HashProperty property) {
Contract.Assert(hashHandle != null && !hashHandle.IsInvalid, "keyHandle != null && !keyHandle.IsInvalid");
int bufferSize = 0;
byte[] buffer = null;
// Figure out how big of a buffer we need to hold the property
if (!UnsafeNativeMethods.CryptGetHashParam(hashHandle, property, buffer, ref bufferSize, 0)) {
int errorCode = Marshal.GetLastWin32Error();
if (errorCode != (int)ErrorCode.MoreData) {
throw new CryptographicException(errorCode);
}
}
// Now get the property bytes directly
buffer = new byte[bufferSize];
if (!UnsafeNativeMethods.CryptGetHashParam(hashHandle, property, buffer, ref bufferSize, 0)) {
throw new CryptographicException(Marshal.GetLastWin32Error());
}
return buffer;
}
internal static extern bool CryptSetHashParam(SafeCspHashHandle hHash,
HashProperty dwParam,
[In, MarshalAs(UnmanagedType.LPArray)] byte[] pbData,
int dwFlags);
internal static extern bool CryptGetHashParam(SafeCspHashHandle hHash, CapiNative.HashProperty dwParam, [MarshalAs(UnmanagedType.LPArray), In, Out] byte[] pbData, [In, Out] ref int pdwDataLen, int dwFlags);
protected override bool ReleaseHandle()
{
return(SafeCspHashHandle.CryptDestroyHash(this.handle));
}
internal static int GetHashPropertyInt32(SafeCspHashHandle hashHandle, HashProperty property) {
byte[] rawProperty = GetHashProperty(hashHandle, property);
Contract.Assert(rawProperty.Length == sizeof(int) || rawProperty.Length == 0, "Unexpected property size");
return rawProperty.Length == sizeof(int) ? BitConverter.ToInt32(rawProperty, 0) : 0;
}
