微信支付特约商户进件中base64格式图片上传

微信图片上传接口地址：https://api.mch.weixin.qq.com/v3/merchant/media/upload

1、上传方法

using HttpHandlerDemo;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Cryptography;
using System.Text;
using HttpHandler = Lib.HttpHandler;

namespace API
{
    public class Helper
    {        
        public static string UploadImg(string b64)
        {
            byte[] data = Convert.FromBase64String(b64);
            //证书本地路径
            string certPath = @"***";
            //证书秘钥
            string certPwd = "***";
            //商户号
            string mchid = "***";
            //证书编号
            string serialNo = "***";
            string boundary = string.Format("--{0}", DateTime.Now.Ticks.ToString("x"));
            var sha256 = Sha256(data);
            var meta = new
            {
                sha256 = sha256,
                filename = Guid.NewGuid().ToString().Replace("-", "") + ".png"
            };
            var json = JsonConvert.SerializeObject(meta);
            var httpHandler = new HttpHandler(mchid, serialNo, certPath, certPwd, json);
            HttpClient client = new HttpClient(httpHandler);
            using (var content = new MultipartFormDataContent(boundary))
            {
                content.Headers.ContentType = MediaTypeHeaderValue.Parse("multipart/form-data"); //这里必须添加
                content.Add(new StringContent(json, Encoding.UTF8, "application/json"), ""meta""); //这里主要必须要双引号

                var byteArrayContent = new ByteArrayContent(data);
                byteArrayContent.Headers.ContentType = new MediaTypeHeaderValue("image/jpg");
                content.Add(byteArrayContent, ""file"", """ + meta.filename + """);  //这里主要必须要双引号
                try
                {
                    using (var response = client.PostAsync("https://api.mch.weixin.qq.com/v3/merchant/media/upload", content)) //上传
                    using (var responseContent = response.Result.Content)
                    {
                        string responseBody = responseContent.ReadAsStringAsync().Result;
                        var dic = Newtonsoft.Json.Linq.JObject.Parse(responseBody);
                        return dic["media_id"].ToString();
                    }
                }
                catch (Exception e)
                {
                    return null;
                }


            }
        }

        public static string Sha256(byte[] bytes)
        {
            byte[] hash = SHA256Managed.Create().ComputeHash(bytes);
            StringBuilder builder = new StringBuilder();
            for (int i = 0; i < hash.Length; i++)
            {
                builder.Append(hash[i].ToString("X2"));
            }
            return builder.ToString();
        }

    }
}

2、Lib.HttpHandler代码

using System;
using System.Collections.Generic;
using System.IO;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Authentication;
using System.Security.Cryptography;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace Lib
{
    /// <summary>
    /// 头文件
    /// </summary>
    public class HttpHandler : DelegatingHandler
    {
        private readonly string merchantId;
        private readonly string serialNo;
        private readonly string certPath;
        private readonly string certPwd;
        private readonly string json;
        /// <summary>
        /// 构造方法
        /// </summary>
        /// <param name="merchantId">商户号</param>
        /// <param name="merchantSerialNo">证书序列号</param>
        /// <param name="certPath">证书路径</param>
        /// <param name="certPwd">证书秘钥</param>
        /// <param name="json">签名json数据,默认不需要传入，获取body内容，如传入签名传入参数上传图片时需传入</param>
        public HttpHandler(string merchantId, string merchantSerialNo, string certPath, string certPwd, string json = "")
        {

            HttpClientHandler handler = new HttpClientHandler();
            handler.ClientCertificateOptions = ClientCertificateOption.Manual;
            handler.SslProtocols = SslProtocols.Tls12;
            try
            {
                handler.ClientCertificates.Add(new X509Certificate2(certPath, certPwd,
                    X509KeyStorageFlags.PersistKeySet | X509KeyStorageFlags.MachineKeySet));
            }
            catch (Exception e)
            {
                throw new Exception("ca err(证书错误)");
            }
            handler.SslProtocols = SslProtocols.Tls12 | SslProtocols.Tls11 | SslProtocols.Tls;
            handler.ServerCertificateCustomValidationCallback = (message, cert, chain, errors) => true;
            InnerHandler = handler;
            this.merchantId = merchantId;
            this.serialNo = merchantSerialNo;
            this.certPath = certPath;
            this.certPwd = certPwd;
            this.json = json;
        }

        protected async override Task<HttpResponseMessage> SendAsync(
            HttpRequestMessage request,
            CancellationToken cancellationToken)
        {
            var auth = await BuildAuthAsync(request);
            string value = $"WECHATPAY2-SHA256-RSA2048 {auth}";
            request.Headers.Add("Authorization", value);
            request.Headers.Add("user-agent", "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/36.0.1985.143 Safari/537.36");
            MediaTypeWithQualityHeaderValue mediaTypeWithQualityHeader = new MediaTypeWithQualityHeaderValue("application/json");
            request.Headers.Accept.Add(mediaTypeWithQualityHeader);
            request.Headers.AcceptCharset.Add(new StringWithQualityHeaderValue("utf-8"));
            return await base.SendAsync(request, cancellationToken);
        }

        protected async Task<string> BuildAuthAsync(HttpRequestMessage request)
        {
            string method = request.Method.ToString();
            string body = "";
            if (method == "POST" || method == "PUT" || method == "PATCH")
            {
                if (!string.IsNullOrEmpty(json))
                    body = json;
                else
                {
                    var content = request.Content;
                    body = await content.ReadAsStringAsync();
                }
            }
            string uri = request.RequestUri.PathAndQuery;
            var timestamp = DateTimeOffset.Now.ToUnixTimeSeconds();
            string nonce = Guid.NewGuid().ToString("n");
            string message = $"{method}
{uri}
{timestamp}
{nonce}
{body}
";

            string signature = Sign(message);
            return $"mchid="{merchantId}",nonce_str="{nonce}",timestamp="{timestamp}",serial_no="{serialNo}",signature="{signature}"";
        }

        //SHA256withRSA
        public string Sign(string str)
        {
            byte[] bt = Encoding.GetEncoding("utf-8").GetBytes(str);
            var sha256 = new SHA256CryptoServiceProvider();
            byte[] rgbHash = sha256.ComputeHash(bt);

            try
            {
                var rsa = GetPrivateKey();
                var key = new RSACryptoServiceProvider();
                var paras = rsa.ExportParameters(true);
                key.ImportParameters(paras);
                RSAPKCS1SignatureFormatter formatter = new RSAPKCS1SignatureFormatter(key);
                formatter.SetHashAlgorithm("SHA256");
                byte[] inArray = formatter.CreateSignature(rgbHash);
                return Convert.ToBase64String(inArray);
            }
            catch (Exception e)
            {
                return e.Message;
            }
        }

        private RSACryptoServiceProvider GetPrivateKey()
        {
            var pc = new X509Certificate2(certPath, certPwd, X509KeyStorageFlags.Exportable | X509KeyStorageFlags.MachineKeySet);
            return (RSACryptoServiceProvider)pc.PrivateKey;
        }

    }
}

仅此记录一下