cryptnativehelper.cs

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

			PRIVATEKEYBLOB = 0x7,
			PLAINTEXTKEYBLOB = 0x8,
			OPAQUEKEYBLOB = 0x9,
			PUBLICKEYBLOBEX = 0xA,
			SYMMETRICWRAPKEYBLOB = 0xB,
			KEYSTATEBLOB = 0xC,
		}

		public enum ProviderType
		{
			PROV_RSA_FULL = 1,
			PROV_RSA_SIG = 2,
			PROV_DSS = 3,
			PROV_FORTEZZA = 4,
			PROV_MS_EXCHANGE = 5,
			PROV_SSL = 6,
			PROV_RSA_SCHANNEL = 12,
			PROV_DSS_DH = 13,
			PROV_EC_ECDSA_SIG = 14,
			PROV_EC_ECNRA_SIG = 15,
			PROV_EC_ECDSA_FULL = 16,
			PROV_EC_ECNRA_FULL = 17,
			PROV_DH_SCHANNEL = 18,
			PROV_SPYRUS_LYNKS = 20,
			PROV_RNG = 21,
			PROV_INTEL_SEC = 22,
			PROV_REPLACE_OWF = 23,
			PROV_RSA_AES = 24,
		}

		internal enum AcquireContextFlags : uint
		{
			None = 0,
			CRYPT_VERIFYCONTEXT = 0xF0000000,
			CRYPT_NEWKEYSET = 0x00000008,
			CRYPT_DELETEKEYSET = 0x00000010,
			CRYPT_MACHINE_KEYSET = 0x00000020,
			CRYPT_SILENT = 0x00000040,
		}

		private enum CryptGenFlags : uint
		{
			None = 0,
			CRYPT_EXPORTABLE = 1,
			CRYPT_NO_SALT = 0x00000010,
		}

		// Algorithm classes
		private const uint ALG_CLASS_ANY = (0);
		private const uint ALG_CLASS_SIGNATURE = (1 << 13);
		private const uint ALG_CLASS_MSG_ENCRYPT = (2 << 13);
		private const uint ALG_CLASS_DATA_ENCRYPT = (3 << 13);
		private const uint ALG_CLASS_HASH = (4 << 13);
		private const uint ALG_CLASS_KEY_EXCHANGE = (5 << 13);
		private const uint ALG_CLASS_ALL = (7 << 13);

		private const uint ALG_TYPE_ANY = 0;
		private const uint ALG_TYPE_DSS = (1 << 9);
		private const uint ALG_TYPE_RSA = (2 << 9);
		private const uint ALG_TYPE_BLOCK = (3 << 9);
		private const uint ALG_TYPE_STREAM = (4 << 9);
		private const uint ALG_TYPE_DH = (5 << 9);
		private const uint ALG_TYPE_SECURECHANNEL = (6 << 9);

		private const uint ALG_SID_ANY = 0;
		private const uint ALG_SID_MD2 = 1;
		private const uint ALG_SID_MD4 = 2;
		private const uint ALG_SID_MD5 = 3;
		private const uint ALG_SID_SHA = 4;
		private const uint ALG_SID_SHA1 = 4;
		private const uint ALG_SID_MAC = 5;
		private const uint ALG_SID_RIPEMD = 6;
		private const uint ALG_SID_RIPEMD160 = 7;
		private const uint ALG_SID_SSL3SHAMD5 = 8;
		private const uint ALG_SID_HMAC = 9;
		private const uint ALG_SID_TLS1PRF = 10;
		private const uint ALG_SID_HASH_REPLACE_OWF = 11;
		private const uint ALG_SID_SHA_256 = 12;
		private const uint ALG_SID_SHA_384 = 13;
		private const uint ALG_SID_SHA_512 = 14;

		// RC2 sub-ids
		private const uint ALG_SID_RC2 = 2;

		// Stream cipher sub-ids
		private const uint ALG_SID_RC4 = 1;
		private const uint ALG_SID_SEAL = 2;

		// Some RSA sub-ids
		private const uint ALG_SID_RSA_ANY = 0;
		private const uint ALG_SID_RSA_PKCS = 1;
		private const uint ALG_SID_RSA_MSATWORK = 2;
		private const uint ALG_SID_RSA_ENTRUST = 3;
		private const uint ALG_SID_RSA_PGP = 4;

		// Some DSS sub-ids
		private const uint ALG_SID_DSS_ANY = 0;
		private const uint ALG_SID_DSS_PKCS = 1;
		private const uint ALG_SID_DSS_DMS = 2;

		// Block cipher sub ids
		// DES sub_ids
		private const uint ALG_SID_DES = 1;
		private const uint ALG_SID_3DES = 3;
		private const uint ALG_SID_DESX = 4;
		private const uint ALG_SID_IDEA = 5;
		private const uint ALG_SID_CAST = 6;
		private const uint ALG_SID_SAFERSK64 = 7;
		private const uint ALG_SID_SAFERSK128 = 8;
		private const uint ALG_SID_3DES_112 = 9;
		private const uint ALG_SID_CYLINK_MEK = 12;
		private const uint ALG_SID_RC5 = 13;
		private const uint ALG_SID_AES_128 = 14;
		private const uint ALG_SID_AES_192 = 15;
		private const uint ALG_SID_AES_256 = 16;
		private const uint ALG_SID_AES = 17;

		// Fortezza sub-ids
		private const uint ALG_SID_SKIPJACK = 10;
		private const uint ALG_SID_TEK = 11;

		// Diffie-Hellman sub-ids
		private const uint ALG_SID_DH_SANDF = 1;
		private const uint ALG_SID_DH_EPHEM = 2;
		private const uint ALG_SID_AGREED_KEY_ANY = 3;
		private const uint ALG_SID_KEA = 4;

		private enum AlgorithmId : uint
		{
			CALG_MD2 = (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_MD2),
			CALG_MD4 = (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_MD4),
			CALG_MD5 = (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_MD5),
			CALG_SHA = (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_SHA),
			CALG_SHA1 = (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_SHA1),
			CALG_MAC = (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_MAC),
			CALG_RSA_SIGN = (ALG_CLASS_SIGNATURE | ALG_TYPE_RSA | ALG_SID_RSA_ANY),
			CALG_DSS_SIGN = (ALG_CLASS_SIGNATURE | ALG_TYPE_DSS | ALG_SID_DSS_ANY),
			CALG_NO_SIGN = (ALG_CLASS_SIGNATURE | ALG_TYPE_ANY | ALG_SID_ANY),
			CALG_RSA_KEYX = (ALG_CLASS_KEY_EXCHANGE | ALG_TYPE_RSA | ALG_SID_RSA_ANY),
			CALG_DES = (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_DES),
			CALG_3DES_112 = (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_3DES_112),
			CALG_3DES = (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_3DES),
			CALG_DESX = (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_DESX),
			CALG_RC2 = (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_RC2),
			CALG_RC4 = (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_STREAM | ALG_SID_RC4),
			CALG_SEAL = (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_STREAM | ALG_SID_SEAL),
			CALG_DH_SF = (ALG_CLASS_KEY_EXCHANGE | ALG_TYPE_DH | ALG_SID_DH_SANDF),
			CALG_DH_EPHEM = (ALG_CLASS_KEY_EXCHANGE | ALG_TYPE_DH | ALG_SID_DH_EPHEM),
			CALG_AGREEDKEY_ANY = (ALG_CLASS_KEY_EXCHANGE | ALG_TYPE_DH | ALG_SID_AGREED_KEY_ANY),
			CALG_KEA_KEYX = (ALG_CLASS_KEY_EXCHANGE | ALG_TYPE_DH | ALG_SID_KEA),
			CALG_HUGHES_MD5 = (ALG_CLASS_KEY_EXCHANGE | ALG_TYPE_ANY | ALG_SID_MD5),
			CALG_SKIPJACK = (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_SKIPJACK),
			CALG_TEK = (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_TEK),
			CALG_CYLINK_MEK = (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_CYLINK_MEK),
			CALG_SSL3_SHAMD5 = (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_SSL3SHAMD5),
			//CALG_SSL3_MASTER = (ALG_CLASS_MSG_ENCRYPT|ALG_TYPE_SECURECHANNEL|ALG_SID_SSL3_MASTER),
			//CALG_SCHANNEL_MASTER_HASH = (ALG_CLASS_MSG_ENCRYPT|ALG_TYPE_SECURECHANNEL|ALG_SID_SCHANNEL_MASTER_HASH),
			//CALG_SCHANNEL_MAC_KEY = (ALG_CLASS_MSG_ENCRYPT|ALG_TYPE_SECURECHANNEL|ALG_SID_SCHANNEL_MAC_KEY),
			//CALG_SCHANNEL_ENC_KEY = (ALG_CLASS_MSG_ENCRYPT|ALG_TYPE_SECURECHANNEL|ALG_SID_SCHANNEL_ENC_KEY),
			//CALG_PCT1_MASTER = (ALG_CLASS_MSG_ENCRYPT|ALG_TYPE_SECURECHANNEL|ALG_SID_PCT1_MASTER),
			//CALG_SSL2_MASTER = (ALG_CLASS_MSG_ENCRYPT|ALG_TYPE_SECURECHANNEL|ALG_SID_SSL2_MASTER),
			//CALG_TLS1_MASTER = (ALG_CLASS_MSG_ENCRYPT|ALG_TYPE_SECURECHANNEL|ALG_SID_TLS1_MASTER),
			CALG_RC5 = (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_RC5),
			CALG_HMAC = (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_HMAC),
			CALG_TLS1PRF = (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_TLS1PRF),
			CALG_HASH_REPLACE_OWF = (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_HASH_REPLACE_OWF),
			CALG_AES_128 = (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_AES_128),
			CALG_AES_192 = (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_AES_192),
			CALG_AES_256 = (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_AES_256),
			CALG_AES = (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_AES),
			CALG_SHA_256 = (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_SHA_256),
			CALG_SHA_384 = (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_SHA_384),
			CALG_SHA_512 = (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_SHA_512),
		}

		private enum KeySpec
		{
			AT_KEYEXCHANGE = 1,
			AT_SIGNATURE = 2,
		}

		private enum KeyParam
		{
			KP_IV = 1,       // Initialization vector
			KP_SALT = 2,       // Salt value
			KP_PADDING = 3,       // Padding values
			KP_MODE = 4,       // Mode of the cipher
			KP_MODE_BITS = 5,       // Number of bits to feedback
			KP_PERMISSIONS = 6,       // Key permissions DWORD
			KP_ALGID = 7,       // Key algorithm
			KP_BLOCKLEN = 8,       // Block size of the cipher
			KP_KEYLEN = 9,       // Length of key in bits
		}

		[Flags()]
		public enum ProvParam
		{
			PP_ENUMALGS = 1,
			PP_ENUMCONTAINERS = 2,
			PP_IMPTYPE = 3,
			PP_NAME = 4,
			PP_VERSION = 5,
			PP_CONTAINER = 6,
			PP_CHANGE_PASSWORD = 7,
			PP_KEYSET_SEC_DESCR = 8,      // get/set security descriptor of keyset
			PP_CERTCHAIN = 9,     // for retrieving certificates from tokens
			PP_KEY_TYPE_SUBTYPE = 10,
			PP_PROVTYPE = 16,
			PP_KEYSTORAGE = 17,
			PP_APPLI_CERT = 18,
			PP_SYM_KEYSIZE = 19,
			PP_SESSION_KEYSIZE = 20,
			PP_UI_PROMPT = 21,
			PP_ENUMALGS_EX = 22,
			PP_ENUMMANDROOTS = 25,
			PP_ENUMELECTROOTS = 26,
			PP_KEYSET_TYPE = 27,
			PP_ADMIN_PIN = 31,
			PP_KEYEXCHANGE_PIN = 32,
			PP_SIGNATURE_PIN = 33,
			PP_SIG_KEYSIZE_INC = 34,
			PP_KEYX_KEYSIZE_INC = 35,
			PP_UNIQUE_CONTAINER = 36,
			PP_SGC_INFO = 37,
			PP_USE_HARDWARE_RNG = 38,
			PP_KEYSPEC = 39,
			PP_ENUMEX_SIGNING_PROT = 40,
			PP_CRYPT_COUNT_KEY_USE = 41,
		}

		private enum HashParam
		{
			HP_HASHVAL = 0x0002,  // Hash value
			HP_HASHSIZE = 0x0004,  // Hash value size
			HP_HMAC_INFO = 0x0005,  // information for creating an HMAC
		}

		private const uint CRYPT_FIRST = 1;

		private static readonly bool isDesktop = Environment.OSVersion.Platform != PlatformID.WinCE;
		private const string cryptDll = "coredll.dll";
		private const string advapiDll = "advapi32.dll";

		internal static bool CryptAcquireContext(out IntPtr phProv, string pszContainer, string pszProvider, ProviderType dwProvType, AcquireContextFlags dwFlags)
		{
			if (isDesktop)
				return CryptAcquireContextDt(out phProv, pszContainer, pszProvider, dwProvType, dwFlags);
			else
				return CryptAcquireContextCf(out phProv, pszContainer, pszProvider, dwProvType, dwFlags);
		}

		[DllImport(advapiDll, EntryPoint = "CryptAcquireContext", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptAcquireContextDt(out IntPtr phProv, string pszContainer, string pszProvider, ProviderType dwProvType, AcquireContextFlags dwFlags);
		[DllImport(cryptDll, EntryPoint = "CryptAcquireContext", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptAcquireContextCf(out IntPtr phProv, string pszContainer, string pszProvider, ProviderType dwProvType, AcquireContextFlags dwFlags);

		private bool CryptCreateHash(IntPtr hProv, AlgorithmId Algid, IntPtr hKey, uint dwFlags, out IntPtr phHash)
		{
			if (isDesktop)
				return CryptCreateHashDt(hProv, Algid, hKey, dwFlags, out phHash);
			else
				return CryptCreateHashCf(hProv, Algid, hKey, dwFlags, out phHash);
		}

		[DllImport(advapiDll, EntryPoint = "CryptCreateHash", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptCreateHashDt(IntPtr hProv, AlgorithmId Algid, IntPtr hKey, uint dwFlags, out IntPtr phHash);
		[DllImport(cryptDll, EntryPoint = "CryptCreateHash", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptCreateHashCf(IntPtr hProv, AlgorithmId Algid, IntPtr hKey, uint dwFlags, out IntPtr phHash);

		private static bool CryptDecrypt(IntPtr hKey, IntPtr hHash, bool Final, uint dwFlags, byte[] pbData, ref uint pdwDataLen)
		{
			if (isDesktop)
				return CryptDecryptDt(hKey, hHash, Final, dwFlags, pbData, ref pdwDataLen);
			else
				return CryptDecryptCf(hKey, hHash, Final, dwFlags, pbData, ref pdwDataLen);
		}

		[DllImport(advapiDll, EntryPoint = "CryptDecrypt", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptDecryptDt(IntPtr hKey, IntPtr hHash, [MarshalAs(UnmanagedType.Bool)] bool Final, uint dwFlags, byte[] pbData, ref uint pdwDataLen);
		[DllImport(cryptDll, EntryPoint = "CryptDecrypt", SetLastError = true)]
		[return: MarshalAs(UnmanagedType.Bool)]
		private static extern bool CryptDecryptCf(IntPtr hKey, IntPtr hHash, [MarshalAs(UnmanagedType.Bool)] bool Final, uint dwFlags, byte[] pbData, ref uint pdwDataLen);