解密微信退款结果通知中的加密信息req_info遇到的坑

最新推荐文章于 2023-03-14 11:48:13 发布
最新推荐文章于 2023-03-14 11:48:13 发布
阅读量951 收藏 1
点赞数
分类专栏： # 解密微信退款结果通知中的加密信息req_info遇到的坑 文章标签： 解析微信小程序退款回调req_info
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_18446861/article/details/103437024
版权

在微信返回的退款结果通知中，包含了一个加密信息字段req_info

在这里插入图片描述微信支付文档中有提及到如何解密：
在这里插入图片描述前提工作：
1、添加maven依赖

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

2、替换jar包
JAVA运行环境默认不允许256位密钥的AES加解密，解决方法就是修改策略文件

JDK7版本JCE下载地址： http://www.oracle.com/technetwork/java/javase/downloads/jce-7-download-432124.html
JDK8版本JCE下载地址：http://www.oracle.com/technetwork/java/javase/downloads/jce8-download-2133166.html

下载后解压，可以看到local_policy.jar和US_export_policy.jar以及readme.txt
如果安装了JRE，将两个jar文件放到%JRE_HOME%\lib\security目录下覆盖原来的文件
如果安装了JDK，将两个jar文件放到%JDK_HOME%\jre\lib\security目录下覆盖原来文件

实践：
以JDK8为例，系统为WIN10，替换上述security文件夹下\policy\limited文件夹和\policy\unlimited文件夹里面的local_policy.jar和US_export_policy.jar这两个文件。

若是在服务器上，则只有在security目录下有local_policy.jar和US_export_policy.jar，替换即可

开始解密：
Base64Util

import java.io.IOException;
import java.io.OutputStream;
import java.io.Writer;

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 IOException
     */
    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);
        }
    }

}

import java.security.MessageDigest;

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"};

}```

```java
import org.bouncycastle.jce.provider.BouncyCastleProvider;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.security.Security;

public class AESUtil {

 
    /**
     * 密钥算法
     */
    private static final String ALGORITHM = "AES";
    /**
     * 加解密算法/工作模式/填充方式
     */
    private static final String ALGORITHM_MODE_PADDING = "AES/ECB/PKCS7Padding";
    /**
     * 生成key
     */
    //微信支付API密钥设置路径：微信商户平台(pay.weixin.qq.com)-->账户设置-->API安全-->密钥设置
    private static String paySign = "微信支付API密钥";
    //对商户key做md5，得到32位小写key*
    private static SecretKeySpec key = new SecretKeySpec(MD5Util.MD5Encode(paySign, "UTF-8").toLowerCase().getBytes(), ALGORITHM);

    static {

    }

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

    /**
     * AES解密
     *
     *（1）对加密串A做base64解码，得到加密串B
     *（2）用key*对加密串B做AES-256-ECB解密（PKCS7Padding）
     * @param base64Data
     * @return
     * @throws Exception
     */
    public static String decryptData(String base64Data) throws Exception {
        Security.addProvider(new BouncyCastleProvider());
        Cipher cipher = Cipher.getInstance(ALGORITHM_MODE_PADDING, "BC");
        cipher.init(Cipher.DECRYPT_MODE, key);
        return new String(cipher.doFinal(Base64Util.decode(base64Data)));
    }

    public static void main(String[] args) throws Exception {
        String A = "微信返回的加密信息req_info";
        System.out.println(AESUtil.decryptData(A));
    }```
....533
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
微信退款通知req_info解密java_微信退款通知信息解密 - osc_sg6lgczj的个人空间 - OSCHINA - 中文开源技术交流社区...
weixin_35443436的博客
02-24 274
在最近的开发需求中，有一个需求，就是需要把微信退款通知记录在数据库中，原本以为是一个简单的需求，但是微信文档的坑，是你不能理解的。在微信退款通知返回的字段中有一个加密信息字段req_info。这个加密字段需要三个解密步骤才能最终获取到信息。由此可见，这个字段是多么的重要。以下是微信官方文档给出的解密步骤：解密步骤如下：(1)对加密串A做base64解码，得到加密串B(2)对商户key做md5，得到...
微信退款回调加密信息-加密解密类
08-30
微信退款回调加密信息-加密解密类，经测试有效，记得导入包
python 微信支付 小程序红包 发放红包接口
weixin_41486438的博客
01-04 1104
随着小程序的不断发展，需要给用户发送小程序红包来增加留存。小程序红包是微信支付提供给商户在小程序场景下向用户发放红包的营销工具。区别于普通现金红包通过公众号消息推送红包的方式，小程序红包可以实现用户直接在小程序页面中领取红包，领取流程更加顺畅。以上就是今天要讲的内容，本文仅仅简单介绍了python 微信支付 小程序红包 发放红包接口的使用，还有其他的函数和方法。
微信小程序退款流程详解
竹林幽深
03-14 2104
在退款中还踩到了一个坑，如果在微信的商户平台中，开启了自动提现功能，那么会自动将基本账户内的资金全提现至结算银行卡中，隔日到账。这样如果被结算过的订单在被退款时商户平台也没有基本余额，就会报错提示“基本余额不足，请充值后重新发起退款”，所以最好先关闭自动提现，待订单超过退款周期后再对其进行结算，避免发起退款不成功的情况。在上面的代码中，读取了项目目录下的pkcs12证书文件，但是微信在官方文档中更加推荐不要将证书放在web服务器的虚拟目录下，通过放在有权限控制的目录中，防止被他人下载。
微信小程序退款通知加密异常： java.security.InvalidKeyException: Illegal key size
还要我怎样的博客
03-06 2154
场景：微信小程序退款给 用户 回调 报错 解密失败 微信报错 解密退款通知加密信息时出错 异常原因：微信使用AES加密解密32位密钥出现 Illegal key size 错 ，如果密钥大于128, 会抛出java.security.InvalidKeyException: Illegal key size 异常. 因为密钥长度是受限制的, java运行时环境读到的是受限的pol...
微信支付退款回调报错,提示解密退款通知加密信息时出错
zlfjavahome的专栏
11-16 678
Java 微信支付 回调
微信支付退款通知解密-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
微信退款回调AES解密--JDK8版本
12-03
微信支付退款回调接口，需要对req_info字段进行解密，其中需要用到AES-256进行加解密，这是修改本地jdk/jre文件的两个jar包，因为我是jdk8,所以此处是jdk8版本的，敬请下载，相关博文可以点击我博客名进行查询
suning易购商城app api_sign参数逆向解析 最新现可用_x_req_block_加密 解密sign等参数
06-08
在描述中提到的`_x_req_block_`可能是苏宁API中的一种加密或混淆机制，用于增强签名的安全性。逆向工程师需要通过静态分析（如查看源代码）或动态分析（如使用调试器跟踪运行时行为）来揭示这种加密算法的细节。JS...
微信小程序-微信支付和微信退款（Java后台）
12-22
微信支付流程 都是我自己工作中开发的，亲测可用，不喜勿喷。 controller中我是这么写的，你们需要根据自己的业务需求改动。ResponseBean是我自己封装的，你们可以改成你们想要的形式。` /** * 微信统一下单接口 ...
微信退款报文AES解密参考代码
09-27
当商户申请的退款有结果后，微信会把相关结果发送给商户，商户需要接收处理，并返回应答。退款结果对重要的数据进行了加密，商户需要用商户秘钥进行解密后才能获得结果通知的内容。退款报文解密参考代码
微信退款加密字段AES解密
05-24
微信退款加密数据解密工具代码，真的没搞懂微信怎么想的，微信退款，公众号消息，小程序，微信支付的加密解密方式全都不一样，每一个都要单独调试，简直要死人，那我就调试好一个就传一个上来
微信支付退款通知解密
08-16
微信支付退款通知解密 aes256 ecb pk7
微信支付退款通知解密-java版
04-17
（1）对加密串A做base64解码，得到加密串B （2）对商户key做md5，得到32位小写key* （3）用key*对加密串B做AES-256-ECB解密 包含需要替换的jar包，1.6、1.7、1.8
Express中间件针对微信小程序登录场景来解密微信用户信息数据
08-10
完成中间件编写后，进行单元测试和集成测试，确保在实际环境中能够正确处理微信小程序的登录请求，成功解密并返回用户信息。 通过以上步骤，我们可以在`Express`应用中有效地处理微信小程序的登录场景，确保用户...
微信支付之申请退款回调的解码异常问题
略简略烦的博客
08-30 4510
做微信支付推荐用github或者码云的开源工具，链接：https://gitee.com/binary/weixin-java-tools 其实在那个开源工具里都有解码，在package com.github.binarywang.wxpay.bean.notify下，名字叫WxPayRefundNotifyResult的类中，fromXML静态方法。不过它里面是AES/ECB/PKCS5Pad...
微信退款异步通知获得的req_infoAES加密和解密方法以及常见的问题
qq_34793634的博客
01-17 3235
在接触到微信退款时了解到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设置路径：微信商户平台(...
微信退款申请成功异步通知使用AES解密问题
技术无私的博客
05-17 5060
在微信退款申请成功后异步通知会返回一段加密串（在req_info字段里）按照微信文档的做法是1.对返回的加密串req_info做base64解码，得到另一个加密串byte[] b = Base64Util.decode(map.get("req_info"));2.对商户key做md5，得到32位小写key* ( key设置路径：微信商户平台(pay.weixin.qq.com)--&gt;账户设...
微信退款通知req_info解密java_微信退款通知信息解密
最新发布
06-10
好的，针对你的问题，我可以提供以下解密微信退款通知req_info的Java代码示例： ```java import java.io.ByteArrayInputStream; import java.io.InputStream; import java.security.Key; import java.security....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值