using System;
using System.Collections.Generic;
using System.IO;
using System.Security.Cryptography;
using System.Text;

namespace Alipay.AopSdk.Core.Util
{
	public class AlipaySignature
	{
		/** 默认编码字符集 */
		private static readonly string DEFAULT_CHARSET = "utf-8";

		public static string GetSignContent(IDictionary<string, string> parameters)
		{
			// 第一步：把字典按Key的字母顺序排序
			IDictionary<string, string> sortedParams = new SortedDictionary<string, string>(parameters);
			var dem = sortedParams.GetEnumerator();

			// 第二步：把所有参数名和参数值串在一起
			var query = new StringBuilder("");
			while (dem.MoveNext())
			{
				var key = dem.Current.Key;
				var value = dem.Current.Value;
				if (!string.IsNullOrEmpty(key) && !string.IsNullOrEmpty(value))
					query.Append(key).Append("=").Append(value).Append("&");
			}
			var content = query.ToString().Substring(0, query.Length - 1);

			return content;
		}

		public static string RSASign(IDictionary<string, string> parameters, string privateKeyPem, string charset,
			string signType)
		{
			var signContent = GetSignContent(parameters);

			return RSASignCharSet(signContent, privateKeyPem, charset, signType);
		}

		public static string RSASign(string data, string privateKeyPem, string charset, string signType)
		{
			return RSASignCharSet(data, privateKeyPem, charset, signType);
		}

		///*
		public static string RSASign(IDictionary<string, string> parameters, string privateKeyPem, string charset,
			bool keyFromFile, string signType)
		{
			var signContent = GetSignContent(parameters);

			return RSASignCharSet(signContent, privateKeyPem, charset, keyFromFile, signType);
		}

		public static string RSASign(string data, string privateKeyPem, string charset, string signType, bool keyFromFile)
		{
			return RSASignCharSet(data, privateKeyPem, charset, keyFromFile, signType);
		}

		//*/
		public static string RSASignCharSet(string data, string privateKeyPem, string charset, string signType)
		{
			RSA rsaCsp = LoadCertificateFile(privateKeyPem, signType);
			byte[] dataBytes = null;
			if (string.IsNullOrEmpty(charset))
				dataBytes = Encoding.UTF8.GetBytes(data);
			else
				dataBytes = Encoding.GetEncoding(charset).GetBytes(data);

			var signatureBytes = rsaCsp.SignData(dataBytes, "RSA2".Equals(signType) ? HashAlgorithmName.SHA256 : HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1);

			return Convert.ToBase64String(signatureBytes);
		}


		public static string RSASignCharSet(string data, string privateKeyPem, string charset, bool keyFromFile,
			string signType)
		{
			byte[] signatureBytes = null;
			try
			{
				RSA rsaCsp = null;
				rsaCsp = keyFromFile ? LoadCertificateFile(privateKeyPem, signType) : LoadCertificateString(privateKeyPem, signType);

				byte[] dataBytes = null;
				if (string.IsNullOrEmpty(charset))
					dataBytes = Encoding.UTF8.GetBytes(data);
				else
					dataBytes = Encoding.GetEncoding(charset).GetBytes(data);
				if (null == rsaCsp)
					throw new AopException("您使用的私钥格式错误，请检查RSA私钥配置" + ",charset = " + charset);
				signatureBytes = rsaCsp.SignData(dataBytes, "RSA2".Equals(signType) ? HashAlgorithmName.SHA256 : HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1);
			}
			catch (Exception ex)
			{
				throw new AopException($"您使用的私钥格式错误，请检查RSA私钥配置,charset = {charset},异常信息:{ex.Message}", ex);
			}
			return Convert.ToBase64String(signatureBytes);
		}


		public static bool RSACheckV1(IDictionary<string, string> parameters, string publicKeyPem, string charset)
		{
			var sign = parameters["sign"];

			parameters.Remove("sign");
			parameters.Remove("sign_type");
			var signContent = GetSignContent(parameters);
			return RSACheckContent(signContent, sign, publicKeyPem, charset, "RSA");
		}

		public static bool RSACheckV1(IDictionary<string, string> parameters, string publicKeyPem)
		{
			var sign = parameters["sign"];

			parameters.Remove("sign");
			parameters.Remove("sign_type");
			var signContent = GetSignContent(parameters);

			return RSACheckContent(signContent, sign, publicKeyPem, DEFAULT_CHARSET, "RSA");
		}

        public static bool RSA2Check(IDictionary<string, string> parameters, string publicKeyPem)
        {
            var sign = parameters["sign"];

            parameters.Remove("sign");
            parameters.Remove("sign_type");
            var signContent = GetSignContent(parameters);

            return RSACheckContent(signContent, sign, publicKeyPem, DEFAULT_CHARSET, "RSA2");
        }

        public static bool RSACheckV1(IDictionary<string, string> parameters, string publicKeyPem, string charset,
			string signType, bool keyFromFile)
		{
			var sign = parameters["sign"];

			parameters.Remove("sign");
			parameters.Remove("sign_type");
			var signContent = GetSignContent(parameters);
			return RSACheckContent(signContent, sign, publicKeyPem, charset, signType, keyFromFile);
		}

		public static bool RSACheckV2(IDictionary<string, string> parameters, string publicKeyPem, string charset)
		{
			var sign = parameters["sign"];

			parameters.Remove("sign");
            parameters.Remove("sign_type");
            var signContent = GetSignContent(parameters);

			return RSACheckContent(signContent, sign, publicKeyPem, charset, "RSA");
		}

		public static bool RSACheckV2(IDictionary<string, string> parameters, string publicKeyPem, string charset,
			string signType, bool keyFromFile)
		{
			var sign = parameters["sign"];
			parameters.Remove("sign");
            parameters.Remove("sign_type");
            var signContent = GetSignContent(parameters);

			return RSACheckContent(signContent, sign, publicKeyPem, charset, signType, keyFromFile);
		}

		public static RSA CreateRsaProviderFromPublicKey(string publicKeyString,string signType)
		{
			// encoded OID sequence for  PKCS #1 rsaEncryption szOID_RSA_RSA = "1.2.840.113549.1.1.1"
			byte[] seqOid = { 0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01, 0x05, 0x00 };
			byte[] seq = new byte[15];

			var x509Key = Convert.FromBase64String(publicKeyString);

			// ---------  Set up stream to read the asn.1 encoded SubjectPublicKeyInfo blob  ------
			using (MemoryStream mem = new MemoryStream(x509Key))
			{
				using (BinaryReader binr = new BinaryReader(mem))  //wrap Memory Stream with BinaryReader for easy reading
				{
					byte bt = 0;
					ushort twobytes = 0;

					twobytes = binr.ReadUInt16();
					if (twobytes == 0x8130) //data read as little endian order (actual data order for Sequence is 30 81)
						binr.ReadByte();    //advance 1 byte
					else if (twobytes == 0x8230)
						binr.ReadInt16();   //advance 2 bytes
					else
						return null;

					seq = binr.ReadBytes(15);       //read the Sequence OID
					if (!CompareBytearrays(seq, seqOid))    //make sure Sequence for OID is correct
						return null;

					twobytes = binr.ReadUInt16();
					if (twobytes == 0x8103) //data read as little endian order (actual data order for Bit String is 03 81)
						binr.ReadByte();    //advance 1 byte
					else if (twobytes == 0x8203)
						binr.ReadInt16();   //advance 2 bytes
					else
						return null;

					bt = binr.ReadByte();
					if (bt != 0x00)     //expect null byte next
						return null;

					twobytes = binr.ReadUInt16();
					if (twobytes == 0x8130) //data read as little endian order (actual data order for Sequence is 30 81)
						binr.ReadByte();    //advance 1 byte
					else if (twobytes == 0x8230)
						binr.ReadInt16();   //advance 2 bytes
					else
						return null;

					twobytes = binr.ReadUInt16();
					byte lowbyte = 0x00;
					byte highbyte = 0x00;

					if (twobytes == 0x8102) //data read as little endian order (actual data order for Integer is 02 81)
						lowbyte = binr.ReadByte();  // read next bytes which is bytes in modulus
					else if (twobytes == 0x8202)
					{
						highbyte = binr.ReadByte(); //advance 2 bytes
						lowbyte = binr.ReadByte();
					}
					else
						return null;
					byte[] modint = { lowbyte, highbyte, 0x00, 0x00 };   //reverse byte order since asn.1 key uses big endian order
					int modsize = BitConverter.ToInt32(modint, 0);

					int firstbyte = binr.PeekChar();
					if (firstbyte == 0x00)
					{   //if first byte (highest order) of modulus is zero, don't include it
						binr.ReadByte();    //skip this null byte
						modsize -= 1;   //reduce modulus buffer size by 1
					}

					byte[] modulus = binr.ReadBytes(modsize);   //read the modulus bytes

					if (binr.ReadByte() != 0x02)            //expect an Integer for the exponent data
						return null;
					int expbytes = (int)binr.ReadByte();        // should only need one byte for actual exponent data (for all useful values)
					byte[] exponent = binr.ReadBytes(expbytes);

					// ------- create RSACryptoServiceProvider instance and initialize with public key -----
					var rsa = RSA.Create();
					rsa.KeySize = signType == "RSA" ? 1024 : 2048;
					RSAParameters rsaKeyInfo = new RSAParameters();
					rsaKeyInfo.Modulus = modulus;
					rsaKeyInfo.Exponent = exponent;
					rsa.ImportParameters(rsaKeyInfo);

					return rsa;
				}

			}
		}

		private static bool CompareBytearrays(byte[] a, byte[] b)
		{
			if (a.Length != b.Length)
				return false;
			int i = 0;
			foreach (byte c in a)
			{
				if (c != b[i])
					return false;
				i++;
			}
			return true;
		}

		public static bool RSACheckContent(string signContent, string sign, string publicKeyPem, string charset,
			string signType)
		{
			try
			{
				if (string.IsNullOrEmpty(charset))
					charset = DEFAULT_CHARSET;

				var sPublicKeyPem = File.ReadAllText(publicKeyPem);

				var rsa = CreateRsaProviderFromPublicKey(sPublicKeyPem, signType);

				if ("RSA2".Equals(signType))
				{
					

					var bVerifyResultOriginal = rsa.VerifyData(Encoding.GetEncoding(charset).GetBytes(signContent),
						Convert.FromBase64String(sign),HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
					return bVerifyResultOriginal;
				}
				else
				{
					
					var bVerifyResultOriginal = rsa.VerifyData(Encoding.GetEncoding(charset).GetBytes(signContent),
						Convert.FromBase64String(sign), HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1);
					return bVerifyResultOriginal;
				}
			}
			catch
			{
				return false;
			}
		}

		public static bool RSACheckContent(string signContent, string sign, string publicKeyPem, string charset,
			string signType, bool keyFromFile)
		{
			try
			{
				if (string.IsNullOrEmpty(charset))
					charset = DEFAULT_CHARSET;

				string sPublicKeyPem= publicKeyPem;

				if (keyFromFile)
				{
					sPublicKeyPem = File.ReadAllText(publicKeyPem);
				}
				var rsa = CreateRsaProviderFromPublicKey(sPublicKeyPem, signType);

				if ("RSA2".Equals(signType))
				{
					

					var bVerifyResultOriginal = rsa.VerifyData(Encoding.GetEncoding(charset).GetBytes(signContent),
						Convert.FromBase64String(sign), HashAlgorithmName.SHA256, RSASignaturePadding.Pkcs1);
					return bVerifyResultOriginal;
				}
				else
				{
					var bVerifyResultOriginal = rsa.VerifyData(Encoding.GetEncoding(charset).GetBytes(signContent),
						Convert.FromBase64String(sign), HashAlgorithmName.SHA1, RSASignaturePadding.Pkcs1);
					return bVerifyResultOriginal;
				}
			}
			catch
			{
				return false;
			}
		}

		public static bool RSACheckContent(string signContent, string sign, string publicKeyPem, string charset,
			bool keyFromFile)
		{
			try
			{
				string sPublicKeyPem= publicKeyPem;
				if (keyFromFile)
				{
					sPublicKeyPem = File.ReadAllText(publicKeyPem);
				}
				var rsa = CreateRsaProviderFromPublicKey(sPublicKeyPem, "RSA");
				var sha1 = new SHA1CryptoServiceProvider();
				if (string.IsNullOrEmpty(charset))
					charset = DEFAULT_CHARSET;
				var bVerifyResultOriginal = rsa.VerifyData(Encoding.GetEncoding(charset).GetBytes(signContent),
					Convert.FromBase64String(sign),HashAlgorithmName.SHA1,RSASignaturePadding.Pkcs1);
				return bVerifyResultOriginal;
			}
			catch (Exception ex)
			{
				var s = ex.Message;
				return false;
			}
		}

		public static string CheckSignAndDecrypt(IDictionary<string, string> parameters, string alipayPublicKey,
			string cusPrivateKey, bool isCheckSign,
			bool isDecrypt)
		{
			var charset = parameters["charset"];
			var bizContent = parameters["biz_content"];
			if (isCheckSign)
				if (!RSACheckV2(parameters, alipayPublicKey, charset))
					throw new AopException("rsaCheck failure:rsaParams=" + parameters);

			if (isDecrypt)
				return RSADecrypt(bizContent, cusPrivateKey, charset, "RSA");

			return bizContent;
		}

		public static string CheckSignAndDecrypt(IDictionary<string, string> parameters, string alipayPublicKey,
			string cusPrivateKey, bool isCheckSign,
			bool isDecrypt, string signType, bool keyFromFile)
		{
			var charset = parameters["charset"];
			var bizContent = parameters["biz_content"];
			if (isCheckSign)
				if (!RSACheckV2(parameters, alipayPublicKey, charset, signType, keyFromFile))
					throw new AopException("rsaCheck failure:rsaParams=" + parameters);

			if (isDecrypt)
				return RSADecrypt(bizContent, cusPrivateKey, charset, signType, keyFromFile);

			return bizContent;
		}

		public static string encryptAndSign(string bizContent, string alipayPublicKey,
			string cusPrivateKey, string charset, bool isEncrypt,
			bool isSign, string signType, bool keyFromFile)
		{
			var sb = new StringBuilder();
			if (string.IsNullOrEmpty(charset))
				charset = DEFAULT_CHARSET;
			sb.Append("<?xml version=\"1.0\" encoding=\"" + charset + "\"?>");
			if (isEncrypt)
			{
// 加密
				sb.Append("<alipay>");
				var encrypted = RSAEncrypt(bizContent, alipayPublicKey, charset, keyFromFile);
				sb.Append("<response>" + encrypted + "</response>");
				sb.Append("<encryption_type>" + signType + "</encryption_type>");
				if (isSign)
				{
					var sign = RSASign(encrypted, cusPrivateKey, charset, signType, keyFromFile);
					sb.Append("<sign>" + sign + "</sign>");
					sb.Append("<sign_type>" + signType + "</sign_type>");
				}
				sb.Append("</alipay>");
			}
			else if (isSign)
			{
// 不加密，但需要签名
				sb.Append("<alipay>");
				sb.Append("<response>" + bizContent + "</response>");
				var sign = RSASign(bizContent, cusPrivateKey, charset, signType, keyFromFile);
				sb.Append("<sign>" + sign + "</sign>");
				sb.Append("<sign_type>" + signType + "</sign_type>");
				sb.Append("</alipay>");
			}
			else
			{
// 不加密，不加签
				sb.Append(bizContent);
			}
			return sb.ToString();
		}

		public static string encryptAndSign(string bizContent, string alipayPublicKey,
			string cusPrivateKey, string charset, bool isEncrypt,
			bool isSign)
		{
			var sb = new StringBuilder();
			if (string.IsNullOrEmpty(charset))
				charset = DEFAULT_CHARSET;
			sb.Append("<?xml version=\"1.0\" encoding=\"" + charset + "\"?>");
			if (isEncrypt)
			{
// 加密
				sb.Append("<alipay>");
				var encrypted = RSAEncrypt(bizContent, alipayPublicKey, charset);
				sb.Append("<response>" + encrypted + "</response>");
				sb.Append("<encryption_type>RSA</encryption_type>");
				if (isSign)
				{
					var sign = RSASign(encrypted, cusPrivateKey, charset, "RSA");
					sb.Append("<sign>" + sign + "</sign>");
					sb.Append("<sign_type>RSA</sign_type>");
				}
				sb.Append("</alipay>");
			}
			else if (isSign)
			{
// 不加密，但需要签名
				sb.Append("<alipay>");
				sb.Append("<response>" + bizContent + "</response>");
				var sign = RSASign(bizContent, cusPrivateKey, charset, "RSA");
				sb.Append("<sign>" + sign + "</sign>");
				sb.Append("<sign_type>RSA</sign_type>");
				sb.Append("</alipay>");
			}
			else
			{
// 不加密，不加签
				sb.Append(bizContent);
			}
			return sb.ToString();
		}

		public static string RSAEncrypt(string content, string publicKeyPem, string charset)
		{
			try
			{
				var sPublicKeyPEM = File.ReadAllText(publicKeyPem);
				var rsa = CreateRsaProviderFromPublicKey(sPublicKeyPEM, "RSA");
				if (string.IsNullOrEmpty(charset))
					charset = DEFAULT_CHARSET;
				var data = Encoding.GetEncoding(charset).GetBytes(content);
				var maxBlockSize = rsa.KeySize / 8 - 11; //加密块最大长度限制
				if (data.Length <= maxBlockSize)
				{
					var cipherbytes = rsa.Encrypt(data, RSAEncryptionPadding.Pkcs1);
					return Convert.ToBase64String(cipherbytes);
				}
				var plaiStream = new MemoryStream(data);
				var crypStream = new MemoryStream();
				var buffer = new byte[maxBlockSize];
				var blockSize = plaiStream.Read(buffer, 0, maxBlockSize);
				while (blockSize > 0)
				{
					var toEncrypt = new byte[blockSize];
					Array.Copy(buffer, 0, toEncrypt, 0, blockSize);
					var cryptograph = rsa.Encrypt(toEncrypt, RSAEncryptionPadding.Pkcs1);
					crypStream.Write(cryptograph, 0, cryptograph.Length);
					blockSize = plaiStream.Read(buffer, 0, maxBlockSize);
				}

				return Convert.ToBase64String(crypStream.ToArray(), Base64FormattingOptions.None);
			}
			catch (Exception ex)
			{
				throw new AopException("EncryptContent = " + content + ",charset = " + charset, ex);
			}
		}

		public static string RSAEncrypt(string content, string publicKeyPem, string charset, bool keyFromFile)
		{
			try
			{
				string sPublicKeyPEM= publicKeyPem;
				if (keyFromFile)
				{
					sPublicKeyPEM = File.ReadAllText(publicKeyPem);
				}
				var rsa = CreateRsaProviderFromPublicKey(publicKeyPem, "RSA");
				if (string.IsNullOrEmpty(charset))
					charset = DEFAULT_CHARSET;
				var data = Encoding.GetEncoding(charset).GetBytes(content);
				var maxBlockSize = rsa.KeySize / 8 - 11; //加密块最大长度限制
				if (data.Length <= maxBlockSize)
				{
					var cipherbytes = rsa.Encrypt(data, RSAEncryptionPadding.Pkcs1);
					return Convert.ToBase64String(cipherbytes);
				}
				var plaiStream = new MemoryStream(data);
				var crypStream = new MemoryStream();
				var buffer = new byte[maxBlockSize];
				var blockSize = plaiStream.Read(buffer, 0, maxBlockSize);
				while (blockSize > 0)
				{
					var toEncrypt = new byte[blockSize];
					Array.Copy(buffer, 0, toEncrypt, 0, blockSize);
					var cryptograph = rsa.Encrypt(toEncrypt, RSAEncryptionPadding.Pkcs1);
					crypStream.Write(cryptograph, 0, cryptograph.Length);
					blockSize = plaiStream.Read(buffer, 0, maxBlockSize);
				}

				return Convert.ToBase64String(crypStream.ToArray(), Base64FormattingOptions.None);
			}
			catch (Exception ex)
			{
				throw new AopException("EncryptContent = " + content + ",charset = " + charset, ex);
			}
		}

		public static string RSADecrypt(string content, string privateKeyPem, string charset, string signType)
		{
			try
			{
				var rsaCsp = LoadCertificateFile(privateKeyPem, signType);
				if (string.IsNullOrEmpty(charset))
					charset = DEFAULT_CHARSET;
				var data = Convert.FromBase64String(content);
				var maxBlockSize = rsaCsp.KeySize / 8; //解密块最大长度限制
				if (data.Length <= maxBlockSize)
				{
					var cipherbytes = rsaCsp.Decrypt(data, RSAEncryptionPadding.Pkcs1);
					return Encoding.GetEncoding(charset).GetString(cipherbytes);
				}
				var crypStream = new MemoryStream(data);
				var plaiStream = new MemoryStream();
				var buffer = new byte[maxBlockSize];
				var blockSize = crypStream.Read(buffer, 0, maxBlockSize);
				while (blockSize > 0)
				{
					var toDecrypt = new byte[blockSize];
					Array.Copy(buffer, 0, toDecrypt, 0, blockSize);
					var cryptograph = rsaCsp.Decrypt(toDecrypt, RSAEncryptionPadding.Pkcs1);
					plaiStream.Write(cryptograph, 0, cryptograph.Length);
					blockSize = crypStream.Read(buffer, 0, maxBlockSize);
				}

				return Encoding.GetEncoding(charset).GetString(plaiStream.ToArray());
			}
			catch (Exception ex)
			{
				throw new AopException("DecryptContent = " + content + ",charset = " + charset, ex);
			}
		}

		public static string RSADecrypt(string content, string privateKeyPem, string charset, string signType,
			bool keyFromFile)
		{
			try
			{
				RSA rsaCsp = null;
				if (keyFromFile)
					rsaCsp = LoadCertificateFile(privateKeyPem, signType);
				else
					rsaCsp = LoadCertificateString(privateKeyPem, signType);
				if (string.IsNullOrEmpty(charset))
					charset = DEFAULT_CHARSET;
				var data = Convert.FromBase64String(content);
				var maxBlockSize = rsaCsp.KeySize / 8; //解密块最大长度限制
				if (data.Length <= maxBlockSize)
				{
					var cipherbytes = rsaCsp.Decrypt(data, RSAEncryptionPadding.Pkcs1);
					return Encoding.GetEncoding(charset).GetString(cipherbytes);
				}
				var crypStream = new MemoryStream(data);
				var plaiStream = new MemoryStream();
				var buffer = new byte[maxBlockSize];
				var blockSize = crypStream.Read(buffer, 0, maxBlockSize);
				while (blockSize > 0)
				{
					var toDecrypt = new byte[blockSize];
					Array.Copy(buffer, 0, toDecrypt, 0, blockSize);
					var cryptograph = rsaCsp.Decrypt(toDecrypt, RSAEncryptionPadding.Pkcs1);
					plaiStream.Write(cryptograph, 0, cryptograph.Length);
					blockSize = crypStream.Read(buffer, 0, maxBlockSize);
				}

				return Encoding.GetEncoding(charset).GetString(plaiStream.ToArray());
			}
			catch (Exception ex)
			{
				throw new AopException("DecryptContent = " + content + ",charset = " + charset, ex);
			}
		}

		private static byte[] GetPem(string type, byte[] data)
		{
			var pem = Encoding.UTF8.GetString(data);
			var header = string.Format("-----BEGIN {0}-----\\n", type);
			var footer = string.Format("-----END {0}-----", type);
			var start = pem.IndexOf(header) + header.Length;
			var end = pem.IndexOf(footer, start);
			var base64 = pem.Substring(start, end - start);

			return Convert.FromBase64String(base64);
		}

		private static RSA LoadCertificateFile(string filename, string signType)
		{
			using (var fs = File.OpenRead(filename))
			{
				var data = new byte[fs.Length];
				byte[] res = null;
				fs.Read(data, 0, data.Length);
				if (data[0] != 0x30)
					res = GetPem("RSA PRIVATE KEY", data);
				try
				{
					var rsa = DecodeRSAPrivateKey(res, signType);
					return rsa;
				}
				catch (Exception ex)
				{
				}
				return null;
			}
		}

		public static RSA LoadCertificateString(string strKey, string signType)
		{
			byte[] data = null;
			//读取带
			//ata = Encoding.Default.GetBytes(strKey);
			data = Convert.FromBase64String(strKey);
			//data = GetPem("RSA PRIVATE KEY", data);
			try
			{
				var rsa = DecodeRSAPrivateKey(data, signType);
				return rsa;
			}
			catch (Exception ex)
			{
				throw new AopException("Alipay.AopSdk.Core.Util.AlipaySignature LoadCertificateString DecodeRSAPrivateKey Error", ex);
			}
			return null;
		}

		private static RSA DecodeRSAPrivateKey(byte[] privkey, string signType)
		{
			byte[] MODULUS, E, D, P, Q, DP, DQ, IQ;

			// --------- Set up stream to decode the asn.1 encoded RSA private key ------
			var mem = new MemoryStream(privkey);
			var binr = new BinaryReader(mem); //wrap Memory Stream with BinaryReader for easy reading
			byte bt = 0;
			ushort twobytes = 0;
			var elems = 0;
			try
			{
				twobytes = binr.ReadUInt16();
				if (twobytes == 0x8130) //data read as little endian order (actual data order for Sequence is 30 81)
					binr.ReadByte(); //advance 1 byte
				else if (twobytes == 0x8230)
					binr.ReadInt16(); //advance 2 bytes
				else
					return null;

				twobytes = binr.ReadUInt16();
				if (twobytes != 0x0102) //version number
					return null;
				bt = binr.ReadByte();
				if (bt != 0x00)
					return null;


				//------ all private key components are Integer sequences ----
				elems = GetIntegerSize(binr);
				MODULUS = binr.ReadBytes(elems);

				elems = GetIntegerSize(binr);
				E = binr.ReadBytes(elems);

				elems = GetIntegerSize(binr);
				D = binr.ReadBytes(elems);

				elems = GetIntegerSize(binr);
				P = binr.ReadBytes(elems);

				elems = GetIntegerSize(binr);
				Q = binr.ReadBytes(elems);

				elems = GetIntegerSize(binr);
				DP = binr.ReadBytes(elems);

				elems = GetIntegerSize(binr);
				DQ = binr.ReadBytes(elems);

				elems = GetIntegerSize(binr);
				IQ = binr.ReadBytes(elems);


				// ------- create RSACryptoServiceProvider instance and initialize with public key -----
				var CspParameters = new CspParameters();
				CspParameters.Flags = CspProviderFlags.UseMachineKeyStore;

				var bitLen = 1024;
				if ("RSA2".Equals(signType))
					bitLen = 2048;

				var rsa = RSA.Create();
				rsa.KeySize = bitLen;
				var rsAparams = new RSAParameters();
				rsAparams.Modulus = MODULUS;
				rsAparams.Exponent = E;
				rsAparams.D = D;
				rsAparams.P = P;
				rsAparams.Q = Q;
				rsAparams.DP = DP;
				rsAparams.DQ = DQ;
				rsAparams.InverseQ = IQ;
				rsa.ImportParameters(rsAparams);
				return rsa;
			}
			catch (Exception ex)
			{
				return null;
			}
			finally
			{
				binr.Close();
			}
		}

		private static int GetIntegerSize(BinaryReader binr)
		{
			byte bt = 0;
			byte lowbyte = 0x00;
			byte highbyte = 0x00;
			var count = 0;
			bt = binr.ReadByte();
			if (bt != 0x02) //expect integer
				return 0;
			bt = binr.ReadByte();

			if (bt == 0x81)
			{
				count = binr.ReadByte(); // data size in next byte
			}
			else if (bt == 0x82)
			{
				highbyte = binr.ReadByte(); // data size in next 2 bytes
				lowbyte = binr.ReadByte();
				byte[] modint = {lowbyte, highbyte, 0x00, 0x00};
				count = BitConverter.ToInt32(modint, 0);
			}
			else
			{
				count = bt; // we already have the data size
			}

			while (binr.ReadByte() == 0x00)
				//remove high order zeros in data
				count -= 1;
			binr.BaseStream.Seek(-1, SeekOrigin.Current); //last ReadByte wasn't a removed zero, so back up a byte
			return count;
		}
	}
}