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 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 byte[] GetKeyProperty(SafeCspKeyHandle keyHandle, KeyProperty property)
{
Contract.Assert(keyHandle != null && !keyHandle.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.CryptGetKeyParam(keyHandle, 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.CryptGetKeyParam(keyHandle, property, buffer, ref bufferSize, 0))
{
throw new CryptographicException(Marshal.GetLastWin32Error());
}
return(buffer);
}
internal static int GetKeyPropertyInt32(SafeCspKeyHandle keyHandle, CapiNative.KeyProperty property)
{
byte[] keyProperty = CapiNative.GetKeyProperty(keyHandle, property);
if (keyProperty.Length != 4)
{
return(0);
}
return(BitConverter.ToInt32(keyProperty, 0));
}
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 byte[] GetKeyProperty(SafeCspKeyHandle keyHandle, CapiNative.KeyProperty property)
{
int pdwDataLen = 0;
byte[] pbData1 = (byte[])null;
if (!CapiNative.UnsafeNativeMethods.CryptGetKeyParam(keyHandle, property, pbData1, out pdwDataLen, 0))
{
int lastWin32Error = Marshal.GetLastWin32Error();
if (lastWin32Error != 234)
{
throw new CryptographicException(lastWin32Error);
}
}
byte[] pbData2 = new byte[pdwDataLen];
if (!CapiNative.UnsafeNativeMethods.CryptGetKeyParam(keyHandle, property, pbData2, out pdwDataLen, 0))
{
throw new CryptographicException(Marshal.GetLastWin32Error());
}
return(pbData2);
}
internal static byte[] GetKeyProperty(SafeCspKeyHandle keyHandle, CapiNative.KeyProperty property)
{
int num = 0;
byte[] array = null;
if (!CapiNative.UnsafeNativeMethods.CryptGetKeyParam(keyHandle, property, array, ref num, 0))
{
int lastWin32Error = Marshal.GetLastWin32Error();
if (lastWin32Error != 234)
{
throw new CryptographicException(lastWin32Error);
}
}
array = new byte[num];
if (!CapiNative.UnsafeNativeMethods.CryptGetKeyParam(keyHandle, property, array, ref num, 0))
{
throw new CryptographicException(Marshal.GetLastWin32Error());
}
return(array);
}
internal static int GetKeyPropertyInt32(SafeCspKeyHandle keyHandle, KeyProperty property) {
byte[] rawProperty = GetKeyProperty(keyHandle, 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 int GetKeyPropertyInt32(SafeCspKeyHandle keyHandle, KeyProperty property)
{
byte[] rawProperty = GetKeyProperty(keyHandle, property);
Contract.Assert(rawProperty.Length == sizeof(int) || rawProperty.Length == 0, "Unexpected property size");
return(rawProperty.Length == sizeof(int) ? BitConverter.ToInt32(rawProperty, 0) : 0);
}
protected override bool ReleaseHandle()
{
return(SafeCspKeyHandle.CryptDestroyKey(this.handle));
}
internal static extern bool CryptImportKey(SafeCspHandle hProv,
[In, MarshalAs(UnmanagedType.LPArray)] byte[] pbData,
int pdwDataLen,
IntPtr hPubKey, // SafeCspKeyHandle
KeyGenerationFlags dwFlags,
[Out] out SafeCspKeyHandle phKey);
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 CryptGenKey(SafeCspHandle hProv,
int Algid,
uint dwFlags,
[Out] out SafeCspKeyHandle phKey);
internal static extern bool CryptGetKeyParam(SafeCspKeyHandle hKey,
KeyProperty dwParam,
[In, Out, MarshalAs(UnmanagedType.LPArray)] byte[] pbData,
[In, Out] ref int pdwDataLen,
int dwFlags);
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 byte[] GetKeyProperty(SafeCspKeyHandle keyHandle, KeyProperty property) {
Contract.Assert(keyHandle != null && !keyHandle.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.CryptGetKeyParam(keyHandle, 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.CryptGetKeyParam(keyHandle, property, buffer, ref bufferSize, 0)) {
throw new CryptographicException(Marshal.GetLastWin32Error());
}
return buffer;
}
internal static extern bool CryptImportKey(SafeCspHandle hProv, [MarshalAs(UnmanagedType.LPArray), In] byte[] pbData, int pdwDataLen, IntPtr hPubKey, CapiNative.KeyGenerationFlags dwFlags, out SafeCspKeyHandle phKey);
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 CryptGetKeyParam(SafeCspKeyHandle hKey,
KeyProperty dwParam,
[In, Out, MarshalAs(UnmanagedType.LPArray)] byte[] pbData,
[In, Out] ref int pdwDataLen,
int dwFlags);