cryptnativehelper.cs

Microsoft Mobile Development Handbook的代码,有C#,VB,C++的

		private static bool CryptDeriveKey(IntPtr phProv, AlgorithmId Algid, IntPtr hBaseData, CryptGenFlags dwFlags, out IntPtr phKey)
		{
			if (isDesktop)
				return CryptDeriveKeyDt(phProv, Algid, hBaseData, dwFlags, out phKey);
			else
				return CryptDeriveKeyCf(phProv, Algid, hBaseData, dwFlags, out phKey);
		}

		[DllImport(advapiDll, EntryPoint = "CryptDeriveKey", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptDeriveKeyDt(IntPtr phProv, AlgorithmId Algid, IntPtr hBaseData, CryptGenFlags dwFlags, out IntPtr phKey);
		[DllImport(cryptDll, EntryPoint = "CryptDeriveKey", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptDeriveKeyCf(IntPtr phProv, AlgorithmId Algid, IntPtr hBaseData, CryptGenFlags dwFlags, out IntPtr phKey);

		private static bool CryptDestroyKey(IntPtr hKey)
		{
			if (isDesktop)
				return CryptDestroyKeyDt(hKey);
			else
				return CryptDestroyKeyCf(hKey);
		}

		[DllImport(advapiDll, EntryPoint = "CryptDestroyKey", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptDestroyKeyDt(IntPtr hKey);
		[return: MarshalAs(UnmanagedType.Bool)]
		[DllImport(cryptDll, EntryPoint = "CryptDestroyKey", SetLastError = true)]
		private static extern bool CryptDestroyKeyCf(IntPtr hKey);

		private static bool CryptExportKey(IntPtr hKey, IntPtr hExpKey, BlobType dwBlobType, uint dwFlags, IntPtr pbData, ref int pdwbDataLen)
		{
			if (isDesktop)
				return CryptExportKeyDt(hKey, hExpKey, dwBlobType, dwFlags, pbData, ref pdwbDataLen);
			else
				return CryptExportKeyCf(hKey, hExpKey, dwBlobType, dwFlags, pbData, ref pdwbDataLen);
		}

		[DllImport(advapiDll, EntryPoint = "CryptExportKey", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptExportKeyDt(IntPtr hKey, IntPtr hExpKey, BlobType dwBlobType, uint dwFlags, IntPtr pbData, ref int pdwbDataLen);
		[DllImport(cryptDll, EntryPoint = "CryptExportKey", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptExportKeyCf(IntPtr hKey, IntPtr hExpKey, BlobType dwBlobType, uint dwFlags, IntPtr pbData, ref int pdwbDataLen);

		private static bool CryptGetHashParam(IntPtr hKey, HashParam dwParam, byte[] data, ref int pdwDataLen, uint dwFlags)
		{
			if (isDesktop)
				return CryptGetHashParamDt(hKey, dwParam, data, ref pdwDataLen, dwFlags);
			else
				return CryptGetHashParamCf(hKey, dwParam, data, ref pdwDataLen, dwFlags);
		}

		[DllImport(advapiDll, EntryPoint = "CryptGetHashParam", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptGetHashParamDt(IntPtr hKey, HashParam dwParam, byte[] data, ref int pdwDataLen, uint dwFlags);
		[DllImport(cryptDll, EntryPoint = "CryptGetHashParam", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptGetHashParamCf(IntPtr hKey, HashParam dwParam, byte[] data, ref int pdwDataLen, uint dwFlags);

		private static bool CryptGetHashParam(IntPtr hKey, HashParam dwParam, out int data, ref int pdwDataLen, uint dwFlags)
		{
			if (isDesktop)
				return CryptGetHashParamDt(hKey, dwParam, out data, ref pdwDataLen, dwFlags);
			else
				return CryptGetHashParamCf(hKey, dwParam, out data, ref pdwDataLen, dwFlags);
		}

		[DllImport(advapiDll, EntryPoint = "CryptGetHashParam", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptGetHashParamDt(IntPtr hKey, HashParam dwParam, out int data, ref int pdwDataLen, uint dwFlags);
		[DllImport(cryptDll, EntryPoint = "CryptGetHashParam", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptGetHashParamCf(IntPtr hKey, HashParam dwParam, out int data, ref int pdwDataLen, uint dwFlags);

		private static bool CryptGetKeyParam(IntPtr hKey, KeyParam dwParam, IntPtr pData, ref int pdwDataLen, uint dwFlags)
		{
			if (isDesktop)
				return CryptGetKeyParamDt(hKey, dwParam, pData, ref pdwDataLen, dwFlags);
			else
				return CryptGetKeyParamCf(hKey, dwParam, pData, ref pdwDataLen, dwFlags);
		}

		[DllImport(advapiDll, EntryPoint = "CryptGetKeyParam", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptGetKeyParamDt(IntPtr hKey, KeyParam dwParam, IntPtr pData, ref int pdwDataLen, uint dwFlags);
		[DllImport(cryptDll, EntryPoint = "CryptGetKeyParam", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptGetKeyParamCf(IntPtr hKey, KeyParam dwParam, IntPtr pData, ref int pdwDataLen, uint dwFlags);

		private static bool CryptGetKeyParam(IntPtr hKey, KeyParam dwParam, byte[] data, ref int pdwDataLen, uint dwFlags)
		{
			if (isDesktop)
				return CryptGetKeyParamDt(hKey, dwParam, data, ref pdwDataLen, dwFlags);
			else
				return CryptGetKeyParamCf(hKey, dwParam, data, ref pdwDataLen, dwFlags);
		}
		[DllImport(advapiDll, EntryPoint = "CryptGetKeyParam", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptGetKeyParamDt(IntPtr hKey, KeyParam dwParam, byte[] data, ref int pdwDataLen, uint dwFlags);
		[DllImport(cryptDll, EntryPoint = "CryptGetKeyParam", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptGetKeyParamCf(IntPtr hKey, KeyParam dwParam, byte[] data, ref int pdwDataLen, uint dwFlags);

		private static bool CryptGetKeyParam(IntPtr hKey, KeyParam dwParam, out int pData, ref int pdwDataLen, uint dwFlags)
		{
			if (isDesktop)
				return CryptGetKeyParamDt(hKey, dwParam, out pData, ref pdwDataLen, dwFlags);
			else
				return CryptGetKeyParamCf(hKey, dwParam, out pData, ref pdwDataLen, dwFlags);
		}

		[DllImport(advapiDll, EntryPoint = "CryptGetKeyParam", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptGetKeyParamDt(IntPtr hKey, KeyParam dwParam, out int pData, ref int pdwDataLen, uint dwFlags);
		[DllImport(cryptDll, EntryPoint = "CryptGetKeyParam", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptGetKeyParamCf(IntPtr hKey, KeyParam dwParam, out int pData, ref int pdwDataLen, uint dwFlags);

		private static bool CryptGetProvParam(IntPtr hProv, ProvParam dwParam, byte[] pbData, ref int pdwDataLen, uint dwFlags)
		{
			if (isDesktop)
				return CryptGetProvParamDt(hProv, dwParam, pbData, ref pdwDataLen, dwFlags);
			else
				return CryptGetProvParamCf(hProv, dwParam, pbData, ref pdwDataLen, dwFlags);
		}

		[DllImport(advapiDll, EntryPoint = "CryptGetProvParam", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptGetProvParamDt(IntPtr hProv, ProvParam dwParam, byte[] pbData, ref int pdwDataLen, uint dwFlags);
		[DllImport(cryptDll, EntryPoint = "CryptGetProvParam", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptGetProvParamCf(IntPtr hProv, ProvParam dwParam, byte[] pbData, ref int pdwDataLen, uint dwFlags);

		private static bool CryptGetProvParam(IntPtr hProv, ProvParam dwParam, int[] pbData, ref int pdwDataLen, uint dwFlags)
		{
			if (isDesktop)
				return CryptGetProvParamDt(hProv, dwParam, pbData, ref pdwDataLen, dwFlags);
			else
				return CryptGetProvParamCf(hProv, dwParam, pbData, ref pdwDataLen, dwFlags);
		}

		[DllImport(advapiDll, EntryPoint = "CryptGetProvParam", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptGetProvParamDt(IntPtr hProv, ProvParam dwParam, int[] pbData, ref int pdwDataLen, uint dwFlags);
		[DllImport(cryptDll, EntryPoint = "CryptGetProvParam", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptGetProvParamCf(IntPtr hProv, ProvParam dwParam, int[] pbData, ref int pdwDataLen, uint dwFlags);

		private static bool CryptGetUserKey(IntPtr hProv, KeySpec dwKeySpec, out IntPtr phUserKey)
		{
			if (isDesktop)
				return CryptGetUserKeyDt(hProv, dwKeySpec, out phUserKey);
			else
				return CryptGetUserKeyCf(hProv, dwKeySpec, out phUserKey);
		}

		[DllImport(advapiDll, EntryPoint = "CryptGetUserKey", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptGetUserKeyDt(IntPtr hProv, KeySpec dwKeySpec, out IntPtr phUserKey);
		[DllImport(cryptDll, EntryPoint = "CryptGetUserKey", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptGetUserKeyCf(IntPtr hProv, KeySpec dwKeySpec, out IntPtr phUserKey);

		private static bool CryptGenKey(IntPtr hProv, AlgorithmId algid, CryptGenFlags dwFlags, out IntPtr phKey)
		{
			if (isDesktop)
				return CryptGenKeyDt(hProv, algid, dwFlags, out phKey);
			else
				return CryptGenKeyCf(hProv, algid, dwFlags, out phKey);
		}

		[DllImport(advapiDll, EntryPoint = "CryptGenKey", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptGenKeyDt(IntPtr hProv, AlgorithmId algid, CryptGenFlags dwFlags, out IntPtr phKey);
		[DllImport(cryptDll, EntryPoint = "CryptGenKey", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptGenKeyCf(IntPtr hProv, AlgorithmId algid, CryptGenFlags dwFlags, out IntPtr phKey);

		private static bool CryptGenKey(IntPtr hProv, KeySpec algid, CryptGenFlags dwFlags, out IntPtr phKey)
		{
			if (isDesktop)
				return CryptGenKeyDt(hProv, algid, dwFlags, out phKey);
			else
				return CryptGenKeyCf(hProv, algid, dwFlags, out phKey);
		}

		[DllImport(advapiDll, EntryPoint = "CryptGenKey", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptGenKeyDt(IntPtr hProv, KeySpec algid, CryptGenFlags dwFlags, out IntPtr phKey);
		[DllImport(cryptDll, EntryPoint = "CryptGenKey", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptGenKeyCf(IntPtr hProv, KeySpec algid, CryptGenFlags dwFlags, out IntPtr phKey);

		private static bool CryptGenRandom(IntPtr hProv, int dwSize, byte[] buffer)
		{
			if (isDesktop)
				return CryptGenRandomDt(hProv, dwSize, buffer);
			else
				return CryptGenRandomCf(hProv, dwSize, buffer);
		}

		[DllImport(advapiDll, EntryPoint = "CryptGenRandom", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptGenRandomDt(IntPtr hProv, int dwSize, byte[] buffer);
		[DllImport(cryptDll, EntryPoint = "CryptGenRandom", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptGenRandomCf(IntPtr hProv, int dwSize, byte[] buffer);

		private static bool CryptHashData(IntPtr hHash, byte[] pbData, int dwDataLen, uint dwFlags)
		{
			if (isDesktop)
				return CryptHashDataDt(hHash, pbData, dwDataLen, dwFlags);
			else
				return CryptHashDataCf(hHash, pbData, dwDataLen, dwFlags);
		}

		[DllImport(advapiDll, EntryPoint = "CryptHashData", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptHashDataDt(IntPtr hHash, byte[] pbData, int dwDataLen, uint dwFlags);
		[DllImport(cryptDll, EntryPoint = "CryptHashData", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptHashDataCf(IntPtr hHash, byte[] pbData, int dwDataLen, uint dwFlags);

		private static bool CryptImportKey(IntPtr hProv, byte[] pbData, int dwDataLen, IntPtr hPubKey, CryptGenFlags dwFlags, out IntPtr phKey)
		{
			if (isDesktop)
				return CryptImportKeyDt(hProv, pbData, dwDataLen, hPubKey, dwFlags, out phKey);
			else
				return CryptImportKeyCf(hProv, pbData, dwDataLen, hPubKey, dwFlags, out phKey);
		}

		[DllImport(advapiDll, EntryPoint = "CryptImportKey", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptImportKeyDt(IntPtr hProv, byte[] pbData, int dwDataLen, IntPtr hPubKey, CryptGenFlags dwFlags, out IntPtr phKey);
		[DllImport(cryptDll, EntryPoint = "CryptImportKey", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptImportKeyCf(IntPtr hProv, byte[] pbData, int dwDataLen, IntPtr hPubKey, CryptGenFlags dwFlags, out IntPtr phKey);

		internal static bool CryptReleaseContext(IntPtr phProv, uint dwFlags)
		{
			if (isDesktop)
				return CryptReleaseContextDt(phProv, dwFlags);
			else
				return CryptReleaseContextCf(phProv, dwFlags);
		}

		[DllImport(advapiDll, EntryPoint = "CryptReleaseContext", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		internal static extern bool CryptReleaseContextDt(IntPtr phProv, uint dwFlags);
		[DllImport(cryptDll, EntryPoint = "CryptReleaseContext", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		internal static extern bool CryptReleaseContextCf(IntPtr phProv, uint dwFlags);

		private static bool CryptSetHashParam(IntPtr hHash, HashParam dwParam, int[] pbData, uint dwFlags)
		{
			if (isDesktop)
				return CryptSetHashParamDt(hHash, dwParam, pbData, dwFlags);
			else
				return CryptSetHashParamCf(hHash, dwParam, pbData, dwFlags);
		}

		[DllImport(advapiDll, EntryPoint = "CryptSetHashParam", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptSetHashParamDt(IntPtr hHash, HashParam dwParam, int[] pbData, uint dwFlags);
		[DllImport(cryptDll, EntryPoint = "CryptSetHashParam", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptSetHashParamCf(IntPtr hHash, HashParam dwParam, int[] pbData, uint dwFlags);

		private static bool CryptDestroyHash(IntPtr hHash)
		{
			if (isDesktop)
				return CryptDestroyHashDt(hHash);
			else
				return CryptDestroyHashCf(hHash);
		}

		[DllImport(advapiDll, EntryPoint = "CryptDestroyHash", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptDestroyHashDt(IntPtr hHash);
		[DllImport(cryptDll, EntryPoint = "CryptDestroyHash", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptDestroyHashCf(IntPtr hHash);
	}
}