微信支付退款通知解密（req_info）

最新推荐文章于 2023-02-02 09:49:33 发布
最新推荐文章于 2023-02-02 09:49:33 发布
阅读量1.3k 收藏 2
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43761722/article/details/119388964
版权

官方给出的开发文档解密步骤如下： 
（1）对加密串A做base64解码，得到加密串B
（2）对商户key做md5，得到32位小写key* ( key设置路径：微信商户平台(pay.weixin.qq.com)-->账户设置-->API安全-->密钥设置 )

（3）用key*对加密串B做AES-256-ECB解密（PKCS7Padding）

准备工作：

 

依赖：

      <dependency>
			<groupId>org.bouncycastle</groupId>
			<artifactId>bcprov-jdk15on</artifactId>
			<version>1.47</version>
		</dependency>

第三步的解密算法需要用到。
2.因为某些国家的进口管制限制，Java发布的运行环境包中的加解密有一定的限制。比如默认不允许256位密钥的AES加解密，解决方法就是修改策略文件，  从官方网站下载JCE无限制权限策略文件，注意自己JDK的版本别下错了。将local_policy.jar和US_export_policy.jar这两个文件替换%JDK_HOME%\jre\lib\security下原来的文件，注意先备份原文件。
 

官方网站提供了JCE无限制权限策略文件的下载：
JDK6的下载地址：
http://www.oracle.com/technetwork/java/javase/downloads/jce-6-download-429243.html

JDK7的下载地址：
http://www.oracle.com/technetwork/java/javase/downloads/jce-7-download-432124.html

JDK8的下载地址：
http://www.oracle.com/technetwork/java/javase/downloads/jce8-download-2133166.html

下载后解压，可以看到local_policy.jar和US_export_policy.jar以及readme.txt。
如果安装了JDK，将两个jar文件也放到%JDK_HOME%\jre\lib\security下 覆盖原来文件，记得先备份。。

然后在%JDK_HOME%\jre\lib\security添加语句

3、修改java.security文件

security.provider.11=org.bouncycastle.jce.provider.BouncyCastleProvider

编写代码：



public class Base64Util {

    private static final char S_BASE64CHAR[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
            'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't',
            'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'};
    private static final byte S_DECODETABLE[];

    static {
        S_DECODETABLE = new byte[128];
        for (int i = 0; i < S_DECODETABLE.length; i++)
            S_DECODETABLE[i] = 127;

        for (int i = 0; i < S_BASE64CHAR.length; i++)
            S_DECODETABLE[S_BASE64CHAR[i]] = (byte) i;

    }

    /**
     * @param ibuf
     * @param obuf
     * @param wp
     * @return
     */
    private static int decode0(char ibuf[], byte obuf[], int wp) {
        int outlen = 3;
        if (ibuf[3] == '=')
            outlen = 2;
        if (ibuf[2] == '=')
            outlen = 1;
        int b0 = S_DECODETABLE[ibuf[0]];
        int b1 = S_DECODETABLE[ibuf[1]];
        int b2 = S_DECODETABLE[ibuf[2]];
        int b3 = S_DECODETABLE[ibuf[3]];
        switch (outlen) {
            case 1: // '\001'
                obuf[wp] = (byte) (b0 << 2 & 252 | b1 >> 4 & 3);
                return 1;

            case 2: // '\002'
                obuf[wp++] = (byte) (b0 << 2 & 252 | b1 >> 4 & 3);
                obuf[wp] = (byte) (b1 << 4 & 240 | b2 >> 2 & 15);
                return 2;

            case 3: // '\003'
                obuf[wp++] = (byte) (b0 << 2 & 252 | b1 >> 4 & 3);
                obuf[wp++] = (byte) (b1 << 4 & 240 | b2 >> 2 & 15);
                obuf[wp] = (byte) (b2 << 6 & 192 | b3 & 63);
                return 3;
        }
        throw new RuntimeException("Internal error");
    }

    /**
     * @param data
     * @param off
     * @param len
     * @return
     */
    public static byte[] decode(char data[], int off, int len) {
        char ibuf[] = new char[4];
        int ibufcount = 0;
        byte obuf[] = new byte[(len / 4) * 3 + 3];
        int obufcount = 0;
        for (int i = off; i < off + len; i++) {
            char ch = data[i];
            if (ch != '=' && (ch >= S_DECODETABLE.length || S_DECODETABLE[ch] == 127))
                continue;
            ibuf[ibufcount++] = ch;
            if (ibufcount == ibuf.length) {
                ibufcount = 0;
                obufcount += decode0(ibuf, obuf, obufcount);
            }
        }

        if (obufcount == obuf.length) {
            return obuf;
        } else {
            byte ret[] = new byte[obufcount];
            System.arraycopy(obuf, 0, ret, 0, obufcount);
            return ret;
        }
    }

    /**
     * @param data
     * @return
     */
    public static byte[] decode(String data) {
        char ibuf[] = new char[4];
        int ibufcount = 0;
        byte obuf[] = new byte[(data.length() / 4) * 3 + 3];
        int obufcount = 0;
        for (int i = 0; i < data.length(); i++) {
            char ch = data.charAt(i);
            if (ch != '=' && (ch >= S_DECODETABLE.length || S_DECODETABLE[ch] == 127))
                continue;
            ibuf[ibufcount++] = ch;
            if (ibufcount == ibuf.length) {
                ibufcount = 0;
                obufcount += decode0(ibuf, obuf, obufcount);
            }
        }

        if (obufcount == obuf.length) {
            return obuf;
        } else {
            byte ret[] = new byte[obufcount];
            System.arraycopy(obuf, 0, ret, 0, obufcount);
            return ret;
        }
    }

    /**
     * @param data
     * @param off
     * @param len
     * @param ostream
     * @throws
     */
    public static void decode(char data[], int off, int len, OutputStream ostream) throws IOException {
        char ibuf[] = new char[4];
        int ibufcount = 0;
        byte obuf[] = new byte[3];
        for (int i = off; i < off + len; i++) {
            char ch = data[i];
            if (ch != '=' && (ch >= S_DECODETABLE.length || S_DECODETABLE[ch] == 127))
                continue;
            ibuf[ibufcount++] = ch;
            if (ibufcount == ibuf.length) {
                ibufcount = 0;
                int obufcount = decode0(ibuf, obuf, 0);
                ostream.write(obuf, 0, obufcount);
            }
        }

    }

    /**
     * @param data
     * @param ostream
     * @throws IOException
     */
    public static void decode(String data, OutputStream ostream) throws IOException {
        char ibuf[] = new char[4];
        int ibufcount = 0;
        byte obuf[] = new byte[3];
        for (int i = 0; i < data.length(); i++) {
            char ch = data.charAt(i);
            if (ch != '=' && (ch >= S_DECODETABLE.length || S_DECODETABLE[ch] == 127))
                continue;
            ibuf[ibufcount++] = ch;
            if (ibufcount == ibuf.length) {
                ibufcount = 0;
                int obufcount = decode0(ibuf, obuf, 0);
                ostream.write(obuf, 0, obufcount);
            }
        }

    }

    /**
     * @param data
     * @return
     */
    public static String encode(byte data[]) {
        return encode(data, 0, data.length);
    }

    /**
     * @param data
     * @param off
     * @param len
     * @return
     */
    public static String encode(byte data[], int off, int len) {
        if (len <= 0)
            return "";
        char out[] = new char[(len / 3) * 4 + 4];
        int rindex = off;
        int windex = 0;
        int rest;
        for (rest = len - off; rest >= 3; rest -= 3) {
            int i = ((data[rindex] & 255) << 16) + ((data[rindex + 1] & 255) << 8) + (data[rindex + 2] & 255);
            out[windex++] = S_BASE64CHAR[i >> 18];
            out[windex++] = S_BASE64CHAR[i >> 12 & 63];
            out[windex++] = S_BASE64CHAR[i >> 6 & 63];
            out[windex++] = S_BASE64CHAR[i & 63];
            rindex += 3;
        }

        if (rest == 1) {
            int i = data[rindex] & 255;
            out[windex++] = S_BASE64CHAR[i >> 2];
            out[windex++] = S_BASE64CHAR[i << 4 & 63];
            out[windex++] = '=';
            out[windex++] = '=';
        } else if (rest == 2) {
            int i = ((data[rindex] & 255) << 8) + (data[rindex + 1] & 255);
            out[windex++] = S_BASE64CHAR[i >> 10];
            out[windex++] = S_BASE64CHAR[i >> 4 & 63];
            out[windex++] = S_BASE64CHAR[i << 2 & 63];
            out[windex++] = '=';
        }
        return new String(out, 0, windex);
    }

    /**
     * @param data
     * @param off
     * @param len
     * @param ostream
     * @throws IOException
     */
    public static void encode(byte data[], int off, int len, OutputStream ostream) throws IOException {
        if (len <= 0)
            return;
        byte out[] = new byte[4];
        int rindex = off;
        int rest;
        for (rest = len - off; rest >= 3; rest -= 3) {
            int i = ((data[rindex] & 255) << 16) + ((data[rindex + 1] & 255) << 8) + (data[rindex + 2] & 255);
            out[0] = (byte) S_BASE64CHAR[i >> 18];
            out[1] = (byte) S_BASE64CHAR[i >> 12 & 63];
            out[2] = (byte) S_BASE64CHAR[i >> 6 & 63];
            out[3] = (byte) S_BASE64CHAR[i & 63];
            ostream.write(out, 0, 4);
            rindex += 3;
        }

        if (rest == 1) {
            int i = data[rindex] & 255;
            out[0] = (byte) S_BASE64CHAR[i >> 2];
            out[1] = (byte) S_BASE64CHAR[i << 4 & 63];
            out[2] = 61;
            out[3] = 61;
            ostream.write(out, 0, 4);
        } else if (rest == 2) {
            int i = ((data[rindex] & 255) << 8) + (data[rindex + 1] & 255);
            out[0] = (byte) S_BASE64CHAR[i >> 10];
            out[1] = (byte) S_BASE64CHAR[i >> 4 & 63];
            out[2] = (byte) S_BASE64CHAR[i << 2 & 63];
            out[3] = 61;
            ostream.write(out, 0, 4);
        }
    }

    /**
     * @param data
     * @param off
     * @param len
     * @param writer
     * @throws IOException
     */
    public static void encode(byte data[], int off, int len, Writer writer) throws IOException {
        if (len <= 0)
            return;
        char out[] = new char[4];
        int rindex = off;
        int rest = len - off;
        int output = 0;
        do {
            if (rest < 3)
                break;
            int i = ((data[rindex] & 255) << 16) + ((data[rindex + 1] & 255) << 8) + (data[rindex + 2] & 255);
            out[0] = S_BASE64CHAR[i >> 18];
            out[1] = S_BASE64CHAR[i >> 12 & 63];
            out[2] = S_BASE64CHAR[i >> 6 & 63];
            out[3] = S_BASE64CHAR[i & 63];
            writer.write(out, 0, 4);
            rindex += 3;
            rest -= 3;
            if ((output += 4) % 76 == 0)
                writer.write("\n");
        }
        while (true);
        if (rest == 1) {
            int i = data[rindex] & 255;
            out[0] = S_BASE64CHAR[i >> 2];
            out[1] = S_BASE64CHAR[i << 4 & 63];
            out[2] = '=';
            out[3] = '=';
            writer.write(out, 0, 4);
        } else if (rest == 2) {
            int i = ((data[rindex] & 255) << 8) + (data[rindex + 1] & 255);
            out[0] = S_BASE64CHAR[i >> 10];
            out[1] = S_BASE64CHAR[i >> 4 & 63];
            out[2] = S_BASE64CHAR[i << 2 & 63];
            out[3] = '=';
            writer.write(out, 0, 4);
        }
    }

}

public class MD5Util {

    public final static String MD5(String s) {
        char hexDigits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
        try {
            byte[] btInput = s.getBytes();
            // 获得MD5摘要算法的 MessageDigest 对象
            MessageDigest mdInst = MessageDigest.getInstance("MD5");
            // 使用指定的字节更新摘要
            mdInst.update(btInput);
            // 获得密文
            byte[] md = mdInst.digest();
            // 把密文转换成十六进制的字符串形式
            int j = md.length;
            char str[] = new char[j * 2];
            int k = 0;
            for (int i = 0; i < j; i++) {
                byte byte0 = md[i];
                str[k++] = hexDigits[byte0 >>> 4 & 0xf];
                str[k++] = hexDigits[byte0 & 0xf];
            }
            return new String(str);
        }
        catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    private static String byteArrayToHexString(byte b[]) {
        StringBuffer resultSb = new StringBuffer();
        for (int i = 0; i < b.length; i++)
            resultSb.append(byteToHexString(b[i]));

        return resultSb.toString();
    }

    private static String byteToHexString(byte b) {
        int n = b;
        if (n < 0)
            n += 256;
        int d1 = n / 16;
        int d2 = n % 16;
        return hexDigits[d1] + hexDigits[d2];
    }

    public static String MD5Encode(String origin, String charsetname) {
        String resultString = null;
        try {
            resultString = new String(origin);
            MessageDigest md = MessageDigest.getInstance("MD5");
            if (charsetname == null || "".equals(charsetname))
                resultString = byteArrayToHexString(md.digest(resultString.getBytes()));
            else
                resultString = byteArrayToHexString(md.digest(resultString.getBytes(charsetname)));
        }
        catch (Exception exception) {
        }
        return resultString;
    }

    private static final String hexDigits[] = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };

    public static void main(String[] asd) {
        String con = "hello kitty";
        String str = MD5Encode(con, "UTF-8");
        System.out.println(str.toUpperCase());
    }
}


    @Test
    void contextLoads() throws Exception {
       // Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());

        //String A 为测试字符串，是微信返回过来的退款通知字符串
        String A = "1111";
        String B =decryptData(A);
        System.out.println(B);
    }



    /**
     * 密钥算法
     */
    private static final String ALGORITHM = "AES";
    /**
     * 加解密算法/工作模式/填充方式
     */
    private static final String ALGORITHM_MODE_PADDING = "AES/ECB/PKCS7Padding";
    /**
     * 生成key
     */
    private static final String key = "key";//此处为测试key，正式环境请替换成商户密钥
    private static SecretKeySpec secretKey = new SecretKeySpec(MD5Util.MD5Encode(key, "UTF-8").toLowerCase().getBytes(), ALGORITHM);

    /**
     * AES加密
     *
     * @param data
     * @return
     * @throws Exception
     */
    public static String encryptData(String data) throws Exception {
        // 创建密码器
        Cipher cipher = Cipher.getInstance(ALGORITHM_MODE_PADDING);
        // 初始化
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
        return Base64Util.encode(cipher.doFinal(data.getBytes()));
    }

    /**
     * AES解密
     *
     * @param base64Data
     * @return
     * @throws Exception
     */
    public  String decryptData(String base64Data) throws Exception {

        // 创建密码器
        Cipher cipher = Cipher.getInstance(ALGORITHM_MODE_PADDING);
        // 初始化
        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        return new String(cipher.doFinal(Base64Util.decode(base64Data)));
    }

如果不懂 可以去看看这个

https://shentuzhigang.blog.csdn.net/article/details/107330649

i酷
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
[微信支付]C# .net 微信扫码Native支付模式二以及成功回调
YuanMxy'Home
04-19 1万+
0x0001 前言 经过一周的摧残,终于完成了微信支付,做完总结一下,觉得其实并不难,主要是网上没有一个明确的教程. 本文是基于C#语言上进行开发,其实本人是做java的,但由于最近接手维护的项目是C#的,所以也强制让自己简单的熟悉一遍C#(偷偷的说,我C# .net .asp都还没清楚,不过最重要的是思路,语言只是一种工具~~~) 0x0002 项目背景(可略过) 项目类型:在线考试系统;...
微信支付退款通知解密-java-亲测可用版
01-29
微信支付退款通知解密-java-亲测可用版 （1）对加密串A做base64解码，得到加密串B （2）对商户key做md5，得到32位小写key* （3）用key*对加密串B做AES-256-ECB解密 包含需要替换的jar包，1.6、1.7、1.8
c# .net 微信支付v3,支付结果通知处理；含AEAD_AES_256_GCM解码
橙-极纪元-cplvfx-JJY.Cheng
12-31 4289
c# .net 微信支付v3,支付结果通知处理；含AEAD_AES_256_GCM解码
小程序微信退款（退款信息回调解密）
一杯敬豆浆的博客
08-10 4955
一、微信支付（简单贴一下） /** 发起微信支付 */ public Map wechatPay(String openid, HttpServletRequest request, String outTradeNo, Integer totalFee) { //生成的随机32位字符串 String nonce_str = RandomStrin...
nodejs解密notify_url回调的req_info
xiaoyong_zeng的博客
06-01 689
在做微信支付退款时，为了确切的知道退款是否成功，往往需要在参数中添加notify_url，以便接收微信退款成功之后的回调。在过程中有两个问题：回调的文档中没有明确的指明怎么接收回调的结果，通过普通的交互请求对象request/body来获取参数往往获取不到参数，后经测试，其实它是通过流数据来传递，示例代码： 解密req_info问题 同时，在接收到传递参数后，req_info是密文发送，文档有介绍加密、解密的过程，但没给出示例，而网上大多是JAVA版的解析，参考意义不大。经摸索与测试，nodejs版解密代码
微信退款回调AES解密--JDK8版本
12-03
微信支付退款回调接口，需要对req_info字段进行解密，其中需要用到AES-256进行加解密，这是修改本地jdk/jre文件的两个jar包，因为我是jdk8,所以此处是jdk8版本的，敬请下载，相关博文可以点击我博客名进行查询
微信小程序-微信支付和微信退款（Java后台）
12-22
微信支付流程 都是我自己工作中开发的，亲测可用，不喜勿喷。 controller中我是这么写的，你们需要根据自己的业务需求改动。ResponseBean是我自己封装的，你们可以改成你们想要的形式。` /** * 微信统一下单接口 ...
.Net微信开发之如何解决access_token过期问题
10-22
在.NET微信开发中，`access_token` 是一个关键的授权凭证，用于调用微信提供的各种高级接口和服务。由于`access_token`的有效期仅为7200秒，因此开发者必须妥善处理其过期问题，以确保应用的正常运行。本文将详细...
C#常用加密解密方法（Base64加密解密）
热门推荐
MarcoPro的博客
02-02 1万+
本节主要分享Base64加密解密：Base64是网络上最常见的用于传输8Bit字节码的编码方式之一，Base64就是一种基于64个可打印字符来表示二进制数据的方法。可查看RFC2045～RFC2049，上面有MIME的详细规范。Base64编码是从二进制到字符的过程，可用于在HTTP环境下传递较长的标识信息。采用Base64编码具有不可读性，需要解码后才能阅读。
微信退款报文AES解密_已经运行成功参考代码
12-06
（1）对加密串A做base64解码，得到加密串B （2）对商户key做md5，得到32位小写key* ( key设置路径：微信商户平台(pay.weixin.qq.com)-->账户设置-->API安全-->密钥设置 ) （3）用key*对加密串B做AES-256-ECB解密 里面包含了jce 适用于jdk6 jdk6 jdk8 例如：我的是覆盖如下目录 C:\Program Files\Java\jre1.8.0_121\lib\security
java微信退款解密,微信退款-异步通知 报文解密
weixin_39686048的博客
03-13 398
拿到报文 对req_info 用商户秘钥进行解密package com.ly.upg.message.util;import com.alibaba.fastjson.JSONObject;import com.snake.bsys.common.log.Log;import com.tencent.common.MD5;import com.tencent.common.XMLParser;im...
微信小程序开发实战11_2 小程序调起支付以及支付通知的处理
haming123的专栏
01-01 4302
介绍如何试图用小程序调用支付API（wx.requestPayment）来拉起微信客户端进行支付，以及支付通知的处理逻辑。
微信小程序APIv3支付回调解密
qq_16746785的博客
09-13 2771
namespace app\api\controller; use think\Db; class Paysuccessback extends Common{ public function notify(){ $receipt = file_get_contents("php://input"); if ($receipt == null) { $receipt = $GLOBALS['HTTP_RAW_POST_DATA']; .
微信退款结果通知之解密
xfy18317776108的博客
10-16 2783
@RestController @RequestMapping("/manage") public class AESUtil { @RequestMapping("/ceshijiemi") public String getjiemi() throws Exception {//此处的a是获得的微信退款通知结果的加密信息 String a = "m4Nnwrt...
微信退款异步通知密文解码
Charles_lxx的博客
04-10 6940
一、通知接口 我们对一笔微信退款是否成功除了查询以外，还有最保险的一种模式就是对通知的解析，但是微信退款通知居然是密文模式的。 我们要根据他的要求解密出来以后才可以解析。那么先拿到通知吧。 二、接收通知 三、解析通知 这里我就不做详细的介绍，直贴代码 public Map<String, String> getRequestParams(HttpServletRequest r...
微信退款异步通知获得的req_infoAES加密和解密方法以及常见的问题
qq_34793634的博客
01-17 3233
在接触到微信退款时了解到AES解密 微信退款异步通知接口地址 https://pay.weixin.qq.com/wiki/doc/api/H5.php?chapter=9_16&amp;index=10 里面提到对于req_info 解密的方法如下: （1）对加密串A做base64解码，得到加密串B （2）对商户key做md5，得到32位小写key* ( key设置路径：微信商户平台(...
微信退款通知req_info解密java_微信退款通知信息解密
最新发布
06-10
其中，`encryptedReqInfo` 是微信退款通知接口返回的 `req_info` 参数的值，`mchKey` 是商户密钥，`PUBLIC_KEY` 是微信支付平台的公钥，需要在微信商户平台获取。 需要注意的是，上述代码中使用了 `javax.crypto` ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值