微信公众号开发--用.Net Core实现微信消息加解密

1、进入微信公众号后台设置微信服务器配置参数（注意：Token和EncodingAESKey必须和微信服务器验证参数保持一致，不然验证不会通过）。

2、设置为安全模式

3、代码实现（主要分为验证接口和消息处理接口）：

 /// <summary>
 /// 验证接口
 /// </summary>
 /// <param name="signature">签名</param>
 /// <param name="timestamp">时间戳</param>
 /// <param name="nonce"></param>
 /// <param name="echostr"></param>
 /// <returns></returns>
 [HttpGet, Route("Message")]
 [AllowAnonymous]
 public ActionResult MessageGet(string signature, string timestamp, string nonce, string echostr)
 {
 if (new SecurityHelper().CheckSignature(signature, timestamp, nonce, _settings.Value.Token))
 {
 return Content(echostr);
 }
 return Content("");
 }

 /// <summary>
 /// 接收消息并处理和返回相应结果
 /// </summary>
 /// <param name="msg_signature">当加密模式时才会有该变量（消息签名）</param>
 /// <param name="signature">签名</param>
 /// <param name="timestamp">时间戳</param>
 /// <param name="nonce"></param>
 /// <returns></returns>
 [HttpPost, Route("Message")]
 [AllowAnonymous]
 public ActionResult MessagePost(string msg_signature, string signature, string timestamp, string nonce)
 {
 try
 {
 if (!new SecurityHelper().CheckSignature(signature, timestamp, nonce, _settings.Value.Token))
 {
 return Content(null);
 }
 using (Stream stream = HttpContext.Request.Body)
 {
 byte[] buffer = new byte[HttpContext.Request.ContentLength.Value];
 stream.Read(buffer, , buffer.Length);
 string content = Encoding.UTF8.GetString(buffer);
 if (!string.IsNullOrWhiteSpace(msg_signature)) // 消息加密模式
 {
 string decryptMsg = string.Empty;
 var wxBizMsgCrypt = new WXBizMsgCrypt(_settings.Value.Token, _settings.Value.EncodingAESKey, _settings.Value.AppId);
 int decryptResult = wxBizMsgCrypt.DecryptMsg(msg_signature, timestamp, nonce, content, ref decryptMsg);
 if (decryptResult ==  && !string.IsNullOrWhiteSpace(decryptMsg))
 {
 string resultMsg = new WechatMessageHelper().MessageResult(decryptMsg);
 string sEncryptMsg = string.Empty;
 if (!string.IsNullOrWhiteSpace(resultMsg))
 {
 int encryptResult = wxBizMsgCrypt.EncryptMsg(resultMsg, timestamp, nonce, ref sEncryptMsg);
 if (encryptResult ==  && !string.IsNullOrWhiteSpace(sEncryptMsg))
 {
 return Content(sEncryptMsg);
 }
 }
 }
 }
 else // 消息未加密码处理
 {
 string resultMsg = new WechatMessageHelper().MessageResult(content);
 return Content(resultMsg);
 }
 return Content(null);
 }
 }
 catch (Exception ex)
 {
 _logger.LogError("接收消息并处理和返回相应结果异常：", ex);
 return Content(null);
 }
 }

加解密实现（微信公众号官网有源码）

 using System;
 using System.Collections;
 using System.Security.Cryptography;
 using System.Text;
 using System.Xml;

 //-40001 ： 签名验证错误
 //-40002 :  xml解析失败
 //-40003 :  sha加密生成签名失败
 //-40004 :  AESKey 非法
 //-40005 :  appid 校验错误
 //-40006 :  AES 加密失败
 //-40007 ： AES 解密失败
 //-40008 ： 解密后得到的buffer非法
 //-40009 :  base64加密异常
 //-40010 :  base64解密异常
 namespace  Core.Common.Wechat
 {
     public class WXBizMsgCrypt
     {
         string m_sToken;
         string m_sEncodingAESKey;
         string m_sAppID;
         enum WXBizMsgCryptErrorCode
         {
             WXBizMsgCrypt_OK = ,
             WXBizMsgCrypt_ValidateSignature_Error = -,
             WXBizMsgCrypt_ParseXml_Error = -,
             WXBizMsgCrypt_ComputeSignature_Error = -,
             WXBizMsgCrypt_IllegalAesKey = -,
             WXBizMsgCrypt_ValidateAppid_Error = -,
             WXBizMsgCrypt_EncryptAES_Error = -,
             WXBizMsgCrypt_DecryptAES_Error = -,
             WXBizMsgCrypt_IllegalBuffer = -,
             WXBizMsgCrypt_EncodeBase64_Error = -,
             WXBizMsgCrypt_DecodeBase64_Error = -
         };

         //构造函数
         // @param sToken: 公众平台上，开发者设置的Token
         // @param sEncodingAESKey: 公众平台上，开发者设置的EncodingAESKey
         // @param sAppID: 公众帐号的appid
         public WXBizMsgCrypt(string sToken, string sEncodingAESKey, string sAppID)
         {
             m_sToken = sToken;
             m_sAppID = sAppID;
             m_sEncodingAESKey = sEncodingAESKey;
         }

         // 检验消息的真实性，并且获取解密后的明文
         // @param sMsgSignature: 签名串，对应URL参数的msg_signature
         // @param sTimeStamp: 时间戳，对应URL参数的timestamp
         // @param sNonce: 随机串，对应URL参数的nonce
         // @param sPostData: 密文，对应POST请求的数据
         // @param sMsg: 解密后的原文，当return返回0时有效
         // @return: 成功0，失败返回对应的错误码
         public int DecryptMsg(string sMsgSignature, string sTimeStamp, string sNonce, string sPostData, ref string sMsg)
         {
             if (m_sEncodingAESKey.Length != )
             {
                 return (int)WXBizMsgCryptErrorCode.WXBizMsgCrypt_IllegalAesKey;
             }
             XmlDocument doc = new XmlDocument();
             XmlNode root;
             string sEncryptMsg;
             try
             {
                 doc.LoadXml(sPostData);
                 root = doc.FirstChild;
                 sEncryptMsg = root["Encrypt"].InnerText;
             }
             catch (Exception)
             {
                 return (int)WXBizMsgCryptErrorCode.WXBizMsgCrypt_ParseXml_Error;
             }
             //verify signature
             int ret = ;
             ret = VerifySignature(m_sToken, sTimeStamp, sNonce, sEncryptMsg, sMsgSignature);
             if (ret != )
                 return ret;
             //decrypt
             string cpid = "";
             try
             {
                 sMsg = Cryptography.AES_decrypt(sEncryptMsg, m_sEncodingAESKey, ref cpid);
             }
             catch (FormatException)
             {
                 return (int)WXBizMsgCryptErrorCode.WXBizMsgCrypt_DecodeBase64_Error;
             }
             catch (Exception)
             {
                 return (int)WXBizMsgCryptErrorCode.WXBizMsgCrypt_DecryptAES_Error;
             }
             if (cpid != m_sAppID)
                 return (int)WXBizMsgCryptErrorCode.WXBizMsgCrypt_ValidateAppid_Error;
             return ;
         }

         //将企业号回复用户的消息加密打包
         // @param sReplyMsg: 企业号待回复用户的消息，xml格式的字符串
         // @param sTimeStamp: 时间戳，可以自己生成，也可以用URL参数的timestamp
         // @param sNonce: 随机串，可以自己生成，也可以用URL参数的nonce
         // @param sEncryptMsg: 加密后的可以直接回复用户的密文，包括msg_signature, timestamp, nonce, encrypt的xml格式的字符串,
         //                        当return返回0时有效
         // return：成功0，失败返回对应的错误码
         public int EncryptMsg(string sReplyMsg, string sTimeStamp, string sNonce, ref string sEncryptMsg)
         {
             if (m_sEncodingAESKey.Length != )
             {
                 return (int)WXBizMsgCryptErrorCode.WXBizMsgCrypt_IllegalAesKey;
             }
             string raw = "";
             try
             {
                 raw = Cryptography.AES_encrypt(sReplyMsg, m_sEncodingAESKey, m_sAppID);
             }
             catch (Exception)
             {
                 return (int)WXBizMsgCryptErrorCode.WXBizMsgCrypt_EncryptAES_Error;
             }
             string MsgSigature = "";
             int ret = ;
             ret = GenarateSinature(m_sToken, sTimeStamp, sNonce, raw, ref MsgSigature);
             if ( != ret)
                 return ret;
             sEncryptMsg = "";

             string EncryptLabelHead = "<Encrypt><![CDATA[";
             string EncryptLabelTail = "]]></Encrypt>";
             string MsgSigLabelHead = "<MsgSignature><![CDATA[";
             string MsgSigLabelTail = "]]></MsgSignature>";
             string TimeStampLabelHead = "<TimeStamp><![CDATA[";
             string TimeStampLabelTail = "]]></TimeStamp>";
             string NonceLabelHead = "<Nonce><![CDATA[";
             string NonceLabelTail = "]]></Nonce>";
             sEncryptMsg = sEncryptMsg + "<xml>" + EncryptLabelHead + raw + EncryptLabelTail;
             sEncryptMsg = sEncryptMsg + MsgSigLabelHead + MsgSigature + MsgSigLabelTail;
             sEncryptMsg = sEncryptMsg + TimeStampLabelHead + sTimeStamp + TimeStampLabelTail;
             sEncryptMsg = sEncryptMsg + NonceLabelHead + sNonce + NonceLabelTail;
             sEncryptMsg += "</xml>";
             return ;
         }

         public class DictionarySort : System.Collections.IComparer
         {
             public int Compare(object oLeft, object oRight)
             {
                 string sLeft = oLeft as string;
                 string sRight = oRight as string;
                 int iLeftLength = sLeft.Length;
                 int iRightLength = sRight.Length;
                 int index = ;
                 while (index < iLeftLength && index < iRightLength)
                 {
                     if (sLeft[index] < sRight[index])
                         return -;
                     else if (sLeft[index] > sRight[index])
                         return ;
                     else
                         index++;
                 }
                 return iLeftLength - iRightLength;

             }
         }
         //Verify Signature
         private static int VerifySignature(string sToken, string sTimeStamp, string sNonce, string sMsgEncrypt, string sSigture)
         {
             string hash = "";
             int ret = ;
             ret = GenarateSinature(sToken, sTimeStamp, sNonce, sMsgEncrypt, ref hash);
             if (ret != )
                 return ret;
             //System.Console.WriteLine(hash);
             if (hash == sSigture)
                 return ;
             else
             {
                 return (int)WXBizMsgCryptErrorCode.WXBizMsgCrypt_ValidateSignature_Error;
             }
         }

         public static int GenarateSinature(string sToken, string sTimeStamp, string sNonce, string sMsgEncrypt, ref string sMsgSignature)
         {
             ArrayList AL = new ArrayList();
             AL.Add(sToken);
             AL.Add(sTimeStamp);
             AL.Add(sNonce);
             AL.Add(sMsgEncrypt);
             AL.Sort(new DictionarySort());
             string raw = "";
             for (int i = ; i < AL.Count; ++i)
             {
                 raw += AL[i];
             }

             SHA1 sha;
             ASCIIEncoding enc;
             string hash = "";
             try
             {
                 sha = new SHA1CryptoServiceProvider();
                 enc = new ASCIIEncoding();
                 byte[] dataToHash = enc.GetBytes(raw);
                 byte[] dataHashed = sha.ComputeHash(dataToHash);
                 hash = BitConverter.ToString(dataHashed).Replace("-", "");
                 hash = hash.ToLower();
             }
             catch (Exception)
             {
                 return (int)WXBizMsgCryptErrorCode.WXBizMsgCrypt_ComputeSignature_Error;
             }
             sMsgSignature = hash;
             return ;
         }
     }
 }

 using System;
 using System.IO;
 using System.Net;
 using System.Security.Cryptography;
 using System.Text;

 namespace  Core.Common.Wechat
 {
     /// <summary>
     ///
     /// </summary>
     public class Cryptography
     {
         public static UInt32 HostToNetworkOrder(UInt32 inval)
         {
             UInt32 outval = ;
             for (int i = ; i < ; i++)
                 outval = (outval << ) + ((inval >> (i * )) & );
             return outval;
         }

         public static Int32 HostToNetworkOrder(Int32 inval)
         {
             Int32 outval = ;
             for (int i = ; i < ; i++)
                 outval = (outval << ) + ((inval >> (i * )) & );
             return outval;
         }
         /// <summary>
         /// 解密方法
         /// </summary>
         /// <param name="Input">密文</param>
         /// <param name="EncodingAESKey"></param>
         /// <returns></returns>
         ///
         public static string AES_decrypt(String Input, string EncodingAESKey, ref string appid)
         {
             byte[] Key;
             Key = Convert.FromBase64String(EncodingAESKey + "=");
             byte[] Iv = new byte[];
             Array.Copy(Key, Iv, );
             byte[] btmpMsg = AES_decrypt(Input, Iv, Key);

             int len = BitConverter.ToInt32(btmpMsg, );
             len = IPAddress.NetworkToHostOrder(len);

             byte[] bMsg = new byte[len];
             byte[] bAppid = new byte[btmpMsg.Length -  - len];
             Array.Copy(btmpMsg, , bMsg, , len);
             Array.Copy(btmpMsg,  + len, bAppid, , btmpMsg.Length -  - len);
             string oriMsg = Encoding.UTF8.GetString(bMsg);
             appid = Encoding.UTF8.GetString(bAppid);

             return oriMsg;
         }

         public static String AES_encrypt(String Input, string EncodingAESKey, string appid)
         {
             byte[] Key;
             Key = Convert.FromBase64String(EncodingAESKey + "=");
             byte[] Iv = new byte[];
             Array.Copy(Key, Iv, );
             string Randcode = CreateRandCode();
             byte[] bRand = Encoding.UTF8.GetBytes(Randcode);
             byte[] bAppid = Encoding.UTF8.GetBytes(appid);
             byte[] btmpMsg = Encoding.UTF8.GetBytes(Input);
             byte[] bMsgLen = BitConverter.GetBytes(HostToNetworkOrder(btmpMsg.Length));
             byte[] bMsg = new byte[bRand.Length + bMsgLen.Length + bAppid.Length + btmpMsg.Length];

             Array.Copy(bRand, bMsg, bRand.Length);
             Array.Copy(bMsgLen, , bMsg, bRand.Length, bMsgLen.Length);
             Array.Copy(btmpMsg, , bMsg, bRand.Length + bMsgLen.Length, btmpMsg.Length);
             Array.Copy(bAppid, , bMsg, bRand.Length + bMsgLen.Length + btmpMsg.Length, bAppid.Length);

             return AES_encrypt(bMsg, Iv, Key);

         }
         private static string CreateRandCode(int codeLen)
         {
             string codeSerial = "2,3,4,5,6,7,a,c,d,e,f,h,i,j,k,m,n,p,r,s,t,A,C,D,E,F,G,H,J,K,M,N,P,Q,R,S,U,V,W,X,Y,Z";
             if (codeLen == )
             {
                 codeLen = ;
             }
             string[] arr = codeSerial.Split(',');
             string code = "";
             int randValue = -;
             Random rand = new Random(unchecked((int)DateTime.Now.Ticks));
             for (int i = ; i < codeLen; i++)
             {
                 randValue = rand.Next(, arr.Length - );
                 code += arr[randValue];
             }
             return code;
         }

         private static String AES_encrypt(String Input, byte[] Iv, byte[] Key)
         {
             var aes = new RijndaelManaged();
             //秘钥的大小，以位为单位
             aes.KeySize = ;
             //支持的块大小
             aes.BlockSize = ;
             //填充模式
             aes.Padding = PaddingMode.PKCS7;
             aes.Mode = CipherMode.CBC;
             aes.Key = Key;
             aes.IV = Iv;
             var encrypt = aes.CreateEncryptor(aes.Key, aes.IV);
             byte[] xBuff = null;

             using (var ms = new MemoryStream())
             {
                 using (var cs = new CryptoStream(ms, encrypt, CryptoStreamMode.Write))
                 {
                     byte[] xXml = Encoding.UTF8.GetBytes(Input);
                     cs.Write(xXml, , xXml.Length);
                 }
                 xBuff = ms.ToArray();
             }
             String Output = Convert.ToBase64String(xBuff);
             return Output;
         }

         private static String AES_encrypt(byte[] Input, byte[] Iv, byte[] Key)
         {
             var aes = new RijndaelManaged();
             //秘钥的大小，以位为单位
             aes.KeySize = ;
             //支持的块大小
             aes.BlockSize = ;
             //填充模式
             //aes.Padding = PaddingMode.PKCS7;
             aes.Padding = PaddingMode.None;
             aes.Mode = CipherMode.CBC;
             aes.Key = Key;
             aes.IV = Iv;
             var encrypt = aes.CreateEncryptor(aes.Key, aes.IV);
             byte[] xBuff = null;

             #region 自己进行PKCS7补位，用系统自己带的不行
             byte[] msg = new byte[Input.Length +  - Input.Length % ];
             Array.Copy(Input, msg, Input.Length);
             byte[] pad = KCS7Encoder(Input.Length);
             Array.Copy(pad, , msg, Input.Length, pad.Length);
             #endregion

             #region 注释的也是一种方法，效果一样
             //ICryptoTransform transform = aes.CreateEncryptor();
             //byte[] xBuff = transform.TransformFinalBlock(msg, 0, msg.Length);
             #endregion

             using (var ms = new MemoryStream())
             {
                 using (var cs = new CryptoStream(ms, encrypt, CryptoStreamMode.Write))
                 {
                     cs.Write(msg, , msg.Length);
                 }
                 xBuff = ms.ToArray();
             }

             String Output = Convert.ToBase64String(xBuff);
             return Output;
         }

         private static byte[] KCS7Encoder(int text_length)
         {
             int block_size = ;
             // 计算需要填充的位数
             int amount_to_pad = block_size - (text_length % block_size);
             if (amount_to_pad == )
             {
                 amount_to_pad = block_size;
             }
             // 获得补位所用的字符
             char pad_chr = chr(amount_to_pad);
             string tmp = "";
             for (int index = ; index < amount_to_pad; index++)
             {
                 tmp += pad_chr;
             }
             return Encoding.UTF8.GetBytes(tmp);
         }
         /**
          * 将数字转化成ASCII码对应的字符，用于对明文进行补码
          *
          * @param a 需要转化的数字
          * @return 转化得到的字符
          */
         static char chr(int a)
         {

             byte target = (byte)(a & 0xFF);
             return (char)target;
         }
         private static byte[] AES_decrypt(String Input, byte[] Iv, byte[] Key)
         {
             RijndaelManaged aes = new RijndaelManaged();
             aes.KeySize = ;
             aes.BlockSize = ;
             aes.Mode = CipherMode.CBC;
             aes.Padding = PaddingMode.None;
             aes.Key = Key;
             aes.IV = Iv;
             var decrypt = aes.CreateDecryptor(aes.Key, aes.IV);
             byte[] xBuff = null;
             using (var ms = new MemoryStream())
             {
                 using (var cs = new CryptoStream(ms, decrypt, CryptoStreamMode.Write))
                 {
                     byte[] xXml = Convert.FromBase64String(Input);
                     byte[] msg = new byte[xXml.Length +  - xXml.Length % ];
                     Array.Copy(xXml, msg, xXml.Length);
                     cs.Write(xXml, , xXml.Length);
                 }
                 xBuff = decode2(ms.ToArray());
             }
             return xBuff;
         }
         private static byte[] decode2(byte[] decrypted)
         {
             int pad = (int)decrypted[decrypted.Length - ];
             if (pad <  || pad > )
             {
                 pad = ;
             }
             byte[] res = new byte[decrypted.Length - pad];
             Array.Copy(decrypted, , res, , decrypted.Length - pad);
             return res;
         }
     }
 }