消息摘要算法-MAC算法系列

最新推荐文章于 2022-07-08 23:53:04 发布
最新推荐文章于 2022-07-08 23:53:04 发布
阅读量425 收藏 1
点赞数
分类专栏： 算法 文章标签： java c/c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/free0006/article/details/84513768
版权

一、简述

  mac（Message Authentication Code，消息认证码算法）是含有密钥散列函数算法，兼容了MD和SHA算法的特性，并在此基础上加上了密钥。因此MAC算法也经常被称作HMAC算法。关于hmac算法的详情可以参看RFC 2104(http://www.ietf.org/rfc/rfc2104.txt)，这里包含了HmacMD5算法的C语言实现。

  这里需要说明的是经过mac算法得到的摘要值也可以使用十六进制编码表示，其摘要值得长度与实现算法的摘要值长度相同。例如 HmacSHA算法得到的摘要长度就是SHA1算法得到的摘要长度，都是160位二进制数，换算成十六进制的编码为40位。

 

二、模型分析

甲乙双方进行数据交换可以采取如下流程完成

1、甲方向乙方公布摘要算法（就是指定要使用的摘要算法名）

2、甲乙双方按照约定构造密钥，双方拥有相同的密钥（一般是一方构造密钥后通知另外一方，此过程不需要通过程序实现，就是双方约定个字符串，但是这个字符串可不是随便设定的，也是通过相关算法获取的）

3、甲方使用密钥对消息做摘要处理，然后将消息和生成的摘要消息一同发送给乙方

4、乙方收到消息后，使用甲方已经公布的摘要算法+约定好的密钥 对收到的消息进行摘要处理。然后比对自己的摘要消息和甲方发过来的摘要消息。甄别消息是否是甲方发送过来的

 

三、MAC系列算法支持表

 

算法摘要长度备注
HmacMD5128JAVA6实现
HmacSHA1160JAVA6实现
HmacSHA256256JAVA6实现
HmacSHA384384JAVA6实现
HmacSHA512512JAVA6实现
HmacMD2128BouncyCastle实现
HmacMD4128BouncyCastle实现
HmacSHA224224BouncyCastle实现

 

四、sun以及bouncycastle的hmac算法实现

 

import java.security.Security;  
import javax.crypto.KeyGenerator;  
import javax.crypto.Mac;  
import javax.crypto.SecretKey;  
import javax.crypto.spec.SecretKeySpec;  
import org.bouncycastle.jce.provider.BouncyCastleProvider;  
import org.bouncycastle.util.encoders.Hex;  
/** 
 * MAC消息摘要组件 
 * @author kongqz 
 * */  
public class MACCoder {  
///HmacMD5///  
    /** 
     * 初始化HmacMD5的密钥 
     * @return byte[] 密钥 
     *  
     * */  
    public static byte[] initHmacMD5Key() throws Exception{  
        //初始化KeyGenerator  
        KeyGenerator keyGenerator=KeyGenerator.getInstance("HmacMD5");  
        //产生密钥  
        SecretKey secretKey=keyGenerator.generateKey();  
        //获取密钥  
        return secretKey.getEncoded();  
    }  
    /** 
     * HmacMD5消息摘要 
     * @param data 待做摘要处理的数据 
     * @param key 密钥 
     * @return  byte[] 消息摘要 
     * */  
    public static byte[] encodeHmacMD5(byte[] data,byte[] key) throws Exception{  
        //还原密钥，因为密钥是以byte形式为消息传递算法所拥有  
        SecretKey secretKey=new SecretKeySpec(key,"HmacMD5");  
        //实例化Mac  
        Mac mac=Mac.getInstance(secretKey.getAlgorithm());  
        //初始化Mac  
        mac.init(secretKey);  
        //执行消息摘要处理  
        return mac.doFinal(data);  
    }  
      
///HmacSHA1//  
    /** 
     * 初始化HmacSHA1的密钥 
     * @return byte[] 密钥 
     *  
     * */  
    public static byte[] initHmacSHAKey() throws Exception{  
        //初始化KeyGenerator  
        KeyGenerator keyGenerator=KeyGenerator.getInstance("HmacSHA1");  
        //产生密钥  
        SecretKey secretKey=keyGenerator.generateKey();  
        //获取密钥  
        return secretKey.getEncoded();  
    }  
    /** 
     * HmacSHA1消息摘要 
     * @param data 待做摘要处理的数据 
     * @param key 密钥 
     * @return  byte[] 消息摘要 
     * */  
    public static byte[] encodeHmacSHA(byte[] data,byte[] key) throws Exception{  
        //还原密钥，因为密钥是以byte形式为消息传递算法所拥有  
        SecretKey secretKey=new SecretKeySpec(key,"HmacSHA1");  
        //实例化Mac  
        Mac mac=Mac.getInstance(secretKey.getAlgorithm());  
        //初始化Mac  
        mac.init(secretKey);  
        //执行消息摘要处理  
        return mac.doFinal(data);  
    }  
      
///HmacSHA256//  
    /** 
     * 初始化HmacSHA256的密钥 
     * @return byte[] 密钥 
     *  
     * */  
    public static byte[] initHmacSHA256Key() throws Exception{  
        //初始化KeyGenerator  
        KeyGenerator keyGenerator=KeyGenerator.getInstance("HmacSHA256");  
        //产生密钥  
        SecretKey secretKey=keyGenerator.generateKey();  
        //获取密钥  
        return secretKey.getEncoded();  
    }  
    /** 
     * HmacSHA256消息摘要 
     * @param data 待做摘要处理的数据 
     * @param key 密钥 
     * @return  byte[] 消息摘要 
     * */  
    public static byte[] encodeHmacSHA256(byte[] data,byte[] key) throws Exception{  
        //还原密钥，因为密钥是以byte形式为消息传递算法所拥有  
        SecretKey secretKey=new SecretKeySpec(key,"HmacSHA256");  
        //实例化Mac  
        Mac mac=Mac.getInstance(secretKey.getAlgorithm());  
        //初始化Mac  
        mac.init(secretKey);  
        //执行消息摘要处理  
        return mac.doFinal(data);  
    }  
      
///HmacSHA384//  
    /** 
     * 初始化HmacSHA384的密钥 
     * @return byte[] 密钥 
     *  
     * */  
    public static byte[] initHmacSHA384Key() throws Exception{  
        //初始化KeyGenerator  
        KeyGenerator keyGenerator=KeyGenerator.getInstance("HmacSHA384");  
        //产生密钥  
        SecretKey secretKey=keyGenerator.generateKey();  
        //获取密钥  
        return secretKey.getEncoded();  
    }  
    /** 
     * HmacSHA384消息摘要 
     * @param data 待做摘要处理的数据 
     * @param key 密钥 
     * @return  byte[] 消息摘要 
     * */  
    public static byte[] encodeHmacSHA384(byte[] data,byte[] key) throws Exception{  
        //还原密钥，因为密钥是以byte形式为消息传递算法所拥有  
        SecretKey secretKey=new SecretKeySpec(key,"HmacSHA384");  
        //实例化Mac  
        Mac mac=Mac.getInstance(secretKey.getAlgorithm());  
        //初始化Mac  
        mac.init(secretKey);  
        //执行消息摘要处理  
        return mac.doFinal(data);  
    }  
      
///HmacSHA512//  
    /** 
     * 初始化HmacSHA512的密钥 
     * @return byte[] 密钥 
     *  
     * */  
    public static byte[] initHmacSHA512Key() throws Exception{  
        //初始化KeyGenerator  
        KeyGenerator keyGenerator=KeyGenerator.getInstance("HmacSHA512");  
        //产生密钥  
        SecretKey secretKey=keyGenerator.generateKey();  
        //获取密钥  
        return secretKey.getEncoded();  
    }  
    /** 
     * HmacSHA512消息摘要 
     * @param data 待做摘要处理的数据 
     * @param key 密钥 
     * @return  byte[] 消息摘要 
     * */  
    public static byte[] encodeHmacSHA512(byte[] data,byte[] key) throws Exception{  
        //还原密钥，因为密钥是以byte形式为消息传递算法所拥有  
        SecretKey secretKey=new SecretKeySpec(key,"HmacSHA512");  
        //实例化Mac  
        Mac mac=Mac.getInstance(secretKey.getAlgorithm());  
        //初始化Mac  
        mac.init(secretKey);  
        //执行消息摘要处理  
        return mac.doFinal(data);  
    }  
///HmacMD2-BouncyCastle才支持的实现//  
    /** 
     * 初始化HmacMD2的密钥 
     * @return byte[] 密钥 
     * */  
    public static byte[] initHmacMD2Key() throws Exception{  
          
        //加入BouncyCastleProvider的支持  
        Security.addProvider(new BouncyCastleProvider());  
        //初始化KeyGenerator  
        KeyGenerator keyGenerator=KeyGenerator.getInstance("HmacMD2");  
        //产生密钥  
        SecretKey secretKey=keyGenerator.generateKey();  
        //获取密钥  
        return secretKey.getEncoded();  
    }  
    /** 
     * HmacMD2消息摘要 
     * @param data 待做摘要处理的数据 
     * @param key 密钥 
     * @return  byte[] 消息摘要 
     * */  
    public static byte[] encodeHmacMD2(byte[] data,byte[] key) throws Exception{  
        //加入BouncyCastleProvider的支持  
        Security.addProvider(new BouncyCastleProvider());  
        //还原密钥，因为密钥是以byte形式为消息传递算法所拥有  
        SecretKey secretKey=new SecretKeySpec(key,"HmacMD2");  
        //实例化Mac  
        Mac mac=Mac.getInstance(secretKey.getAlgorithm());  
        //初始化Mac  
        mac.init(secretKey);  
        //执行消息摘要处理  
        return mac.doFinal(data);  
    }  
    /** 
     * HmacMD2Hex消息摘要 
     * @param data 待做消息摘要处理的数据 
     * @param String 密钥 
     * @return byte[] 消息摘要 
     * */  
    public static String encodeHmacMD2Hex(byte[] data,byte[] key) throws Exception{  
        //执行消息摘要处理  
        byte[] b=encodeHmacMD2(data,key);  
        //做十六进制转换  
        return new String(Hex.encode(b));  
    }  
      
///HmacMD4-BouncyCastle才支持的实现//  
    /** 
     * 初始化HmacMD2的密钥 
     * @return byte[] 密钥 
     * */  
    public static byte[] initHmacMD4Key() throws Exception{  
          
        //加入BouncyCastleProvider的支持  
        Security.addProvider(new BouncyCastleProvider());  
        //初始化KeyGenerator  
        KeyGenerator keyGenerator=KeyGenerator.getInstance("HmacMD4");  
        //产生密钥  
        SecretKey secretKey=keyGenerator.generateKey();  
        //获取密钥  
        return secretKey.getEncoded();  
    }  
    /** 
     * HmacMD4消息摘要 
     * @param data 待做摘要处理的数据 
     * @param key 密钥 
     * @return  byte[] 消息摘要 
     * */  
    public static byte[] encodeHmacMD4(byte[] data,byte[] key) throws Exception{  
        //加入BouncyCastleProvider的支持  
        Security.addProvider(new BouncyCastleProvider());  
        //还原密钥，因为密钥是以byte形式为消息传递算法所拥有  
        SecretKey secretKey=new SecretKeySpec(key,"HmacMD4");  
        //实例化Mac  
        Mac mac=Mac.getInstance(secretKey.getAlgorithm());  
        //初始化Mac  
        mac.init(secretKey);  
        //执行消息摘要处理  
        return mac.doFinal(data);  
    }  
    /** 
     * HmacMD4Hex消息摘要 
     * @param data 待做消息摘要处理的数据 
     * @param String 密钥 
     * @return byte[] 消息摘要 
     * */  
    public static String encodeHmacMD4Hex(byte[] data,byte[] key) throws Exception{  
        //执行消息摘要处理  
        byte[] b=encodeHmacMD4(data,key);  
        //做十六进制转换  
        return new String(Hex.encode(b));  
    }  
///HmacSHA224-BouncyCastle才支持的实现//  
    /** 
     * 初始化HmacSHA224的密钥 
     * @return byte[] 密钥 
     * */  
    public static byte[] initHmacSHA224Key() throws Exception{  
          
        //加入BouncyCastleProvider的支持  
        Security.addProvider(new BouncyCastleProvider());  
        //初始化KeyGenerator  
        KeyGenerator keyGenerator=KeyGenerator.getInstance("HmacSHA224");  
        //产生密钥  
        SecretKey secretKey=keyGenerator.generateKey();  
        //获取密钥  
        return secretKey.getEncoded();  
    }  
    /** 
     * HmacSHA224消息摘要 
     * @param data 待做摘要处理的数据 
     * @param key 密钥 
     * @return  byte[] 消息摘要 
     * */  
    public static byte[] encodeHmacSHA224(byte[] data,byte[] key) throws Exception{  
        //加入BouncyCastleProvider的支持  
        Security.addProvider(new BouncyCastleProvider());  
        //还原密钥，因为密钥是以byte形式为消息传递算法所拥有  
        SecretKey secretKey=new SecretKeySpec(key,"HmacSHA224");  
        //实例化Mac  
        Mac mac=Mac.getInstance(secretKey.getAlgorithm());  
        //初始化Mac  
        mac.init(secretKey);  
        //执行消息摘要处理  
        return mac.doFinal(data);  
    }  
    /** 
     * HmacSHA224Hex消息摘要 
     * @param data 待做消息摘要处理的数据 
     * @param String 密钥 
     * @return byte[] 消息摘要 
     * */  
    public static String encodeHmacSHA224Hex(byte[] data,byte[] key) throws Exception{  
        //执行消息摘要处理  
        byte[] b=encodeHmacSHA224(data,key);  
        //做十六进制转换  
        return new String(Hex.encode(b));  
    }  
    /** 
     * 进行相关的摘要算法的处理展示 
     * @throws Exception  
     * **/  
    public static void main(String[] args) throws Exception {  
        String str="HmacMD5消息摘要";  
        //初始化密钥  
        byte[] key1=MACCoder.initHmacMD5Key();  
        //获取摘要信息  
        byte[] data1=MACCoder.encodeHmacMD5(str.getBytes(), key1);  
          
        System.out.println("原文："+str);  
        System.out.println();  
        System.out.println("HmacMD5的密钥:"+key1.toString());  
        System.out.println("HmacMD5算法摘要："+data1.toString());  
        System.out.println();  
          
        //初始化密钥  
        byte[] key2=MACCoder.initHmacSHA256Key();  
        //获取摘要信息  
        byte[] data2=MACCoder.encodeHmacSHA256(str.getBytes(), key2);  
        System.out.println("HmacSHA256的密钥:"+key2.toString());  
        System.out.println("HmacSHA256算法摘要："+data2.toString());  
        System.out.println();  
          
          
        //初始化密钥  
        byte[] key3=MACCoder.initHmacSHAKey();  
        //获取摘要信息  
        byte[] data3=MACCoder.encodeHmacSHA(str.getBytes(), key3);  
        System.out.println("HmacSHA1的密钥:"+key3.toString());  
        System.out.println("HmacSHA1算法摘要："+data3.toString());  
        System.out.println();  
          
          
        //初始化密钥  
        byte[] key4=MACCoder.initHmacSHA384Key();  
        //获取摘要信息  
        byte[] data4=MACCoder.encodeHmacSHA384(str.getBytes(), key4);  
        System.out.println("HmacSHA384的密钥:"+key4.toString());  
        System.out.println("HmacSHA384算法摘要："+data4.toString());  
        System.out.println();  
          
          
        //初始化密钥  
        byte[] key5=MACCoder.initHmacSHA512Key();  
        //获取摘要信息  
        byte[] data5=MACCoder.encodeHmacSHA512(str.getBytes(), key5);  
        System.out.println("HmacSHA512的密钥:"+key5.toString());  
        System.out.println("HmacSHA512算法摘要："+data5.toString());  
        System.out.println();  
          
        System.out.println("================以下的算法支持是bouncycastle支持的算法，sun java6不支持=======================");  
        //初始化密钥  
        byte[] key6=MACCoder.initHmacMD2Key();  
        //获取摘要信息  
        byte[] data6=MACCoder.encodeHmacMD2(str.getBytes(), key6);  
        String datahex6=MACCoder.encodeHmacMD2Hex(str.getBytes(), key6);  
        System.out.println("Bouncycastle HmacMD2的密钥:"+key6.toString());  
        System.out.println("Bouncycastle HmacMD2算法摘要："+data6.toString());  
        System.out.println("Bouncycastle HmacMD2Hex算法摘要："+datahex6.toString());  
        System.out.println();  
          
        //初始化密钥  
        byte[] key7=MACCoder.initHmacMD4Key();  
        //获取摘要信息  
        byte[] data7=MACCoder.encodeHmacMD4(str.getBytes(), key7);  
        String datahex7=MACCoder.encodeHmacMD4Hex(str.getBytes(), key7);  
        System.out.println("Bouncycastle HmacMD4的密钥:"+key7.toString());  
        System.out.println("Bouncycastle HmacMD4算法摘要："+data7.toString());  
        System.out.println("Bouncycastle HmacMD4Hex算法摘要："+datahex7.toString());  
        System.out.println();  
          
        //初始化密钥  
        byte[] key8=MACCoder.initHmacSHA224Key();  
        //获取摘要信息  
        byte[] data8=MACCoder.encodeHmacSHA224(str.getBytes(), key8);  
        String datahex8=MACCoder.encodeHmacSHA224Hex(str.getBytes(), key8);  
        System.out.println("Bouncycastle HmacSHA224的密钥:"+key8.toString());  
        System.out.println("Bouncycastle HmacSHA224算法摘要："+data8.toString());  
        System.out.println("Bouncycastle HmacSHA224算法摘要："+datahex8.toString());  
        System.out.println();  
    }  
}

 

原文：HmacMD5消息摘要

HmacMD5的密钥:[B@f3d6a5
HmacMD5算法摘要：[B@911f71

HmacSHA256的密钥:[B@1b10d42
HmacSHA256算法摘要：[B@dd87b2

HmacSHA1的密钥:[B@1a0c10f
HmacSHA1算法摘要：[B@e2eec8

HmacSHA384的密钥:[B@67ac19
HmacSHA384算法摘要：[B@53ba3d

HmacSHA512的密钥:[B@1813fac
HmacSHA512算法摘要：[B@7b7072

================以下的算法支持是bouncycastle支持的算法，sun java6不支持=======================
Bouncycastle HmacMD2的密钥:[B@1e4457d
Bouncycastle HmacMD2算法摘要：[B@18e2b22
Bouncycastle HmacMD2Hex算法摘要：103403efad9df90180d9c5528060950e

Bouncycastle HmacMD4的密钥:[B@efd552
Bouncycastle HmacMD4算法摘要：[B@19dfbff
Bouncycastle HmacMD4Hex算法摘要：9afc6aba973434b4092c9c4840dd0e41

Bouncycastle HmacSHA224的密钥:[B@16cd7d5
Bouncycastle HmacSHA224算法摘要：[B@cdedfd
Bouncycastle HmacSHA224算法摘要：293398d4bb063705dd2007be210022f40f34fb445fe4c1318ce4a550

 

五、总结

 

1、sun支持了5中算法，但是不支持转成16进制，但是可以用commons codec或者bouncycastle的16进制转换协助进行转换

2、bouncycastle支持补充了三种算法，并支持16进制转换

free0006
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MAC算法总结
LYX_WIN
08-11 9630
1.POS终端MAC的算法 POS终端采用ECB的加密方式，简述如下： a) 将欲发送给POS中心的消息中，从消息类型（MTI）到63域之间的部分构成MACELEMEMENT BLOCK （MAB）。 b) 对MAB，按每8个字节做异或（不管信息中的字符格式），如果最后不满8个字节，则添加“0X00”。 示例 ： MAB = M1 M2 M3
常见的MAC算法（PBOC_3DES_MAC、ANSI X9.9MAC算法、ANSI x9.19算法）
kxlele
02-07 2283
个人总结的常用mac算法，附上源码，完全使用java原生写法，效率极高 [code="java"] public final class Pboc3DesMACUtils { public static final byte[] ZERO_IVC = new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }; /** * 计算MAC(hex) PBOC...
MAC算法详解
10-22
MAC算法详解，附有流程图示，附带介绍XOR，9.9,9.19，银联MAC算法的区别等，是实践经验的小结。
Java加密 消息摘要算法MAC实现详解
08-25
主要介绍了Java 消息摘要算法MAC实现详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java消息摘要算法MAC实现与应用完整示例
08-25
Java 消息摘要算法 MAC 实现与应用完整示例 Java 消息摘要算法 MAC（Message Authentication Code）是一种用于数据完整性和身份验证的算法。它可以确保数据的完整性和一致性，防止数据被篡改或伪造。 概念： * ...
MAC算法之消息摘要算法HmacMD5的实现
08-29
MAC算法之消息摘要算法HmacMD5的实现 MAC（Message Authentication Code，消息验证码）算法是一种常用的消息认证机制，它可以确保消息的完整性和真实性。在实际应用中，MAC算法通常与加密算法结合使用，以确保消息...
数字信息摘要常见算法1
最新发布
08-04
摘要算法将任意长度的输入（如文本、图片或文件）转换为固定长度的输出，这个输出称为摘要，它具有不可逆性，即不能通过摘要恢复原始信息。以下是几种常见的摘要算法： 1. **Hex编码**： - Hex编码是一种将二进制...
Python中摘要算法MD5，SHA1简介及应用实例代码
09-20
摘要算法在信息技术领域中扮演着重要的角色，它们主要用于数据完整性检查和安全性验证。在Python中，我们可以使用内置的`hashlib`库来实现常见的摘要算法，如MD5和SHA1。 MD5（Message-Digest Algorithm 5）是一种...
MAC算法的实现，仅参考
10-09
MAC算法的实现，仅参考，学习之用.请多多交流。
MAC算法小工具
02-08
包含标准的DES算法，再次基础上实现ANSI-X99MAC算法和PBOC3DES算法。他们都是用DES算法再经过一层算法实现的。
银联mac算法和各种算法
11-12
算法工具用于计算DES、3DES、MAC等加密、解密操作,支持DES,3DES加解密,MAC运算,XOR运算。zip
MAC之常用数学算法
代码解释生活
07-04 576
https://www.cnblogs.com/zhangmingzhao/p/7823226.html
消息摘要-mac
小炫风技术旅行
05-14 1159
摘要分类：MD SHA MAC 可以说MAC是在SHA MD基础上发展而来,现也称HMAC算法，兼容了MD和SHA算法的特性，HMAC 摘要长度等同SHA1算法的摘要长度，160位的二进制数！
java mac算法_消息摘要算法-MAC算法系列
weixin_26808023的博客
02-16 626
一、简述mac(Message Authentication Code，消息认证码算法)是含有密钥散列函数算法，兼容了MD和SHA算法的特性，并在此基础上加上了密钥。因此MAC算法也经常被称作HMAC算法。关于hmac算法的详情可以参看RFC 2104(http://www.ietf.org/rfc/rfc2104.txt)，这里包含了HmacMD5算法的C语言实现。这里需要说明的是经过mac算法...
13 摘要算法之mac
weixin_39563769的博客
07-08 2413
mac
MAC消息摘要
原此航的博客
08-12 273
   MAC算法结合了MD5和SHA算法的优势, 并加入了密钥的支持, 是一种更为安全的消息摘要算法.   1. 环境   jdk1.6 commons-codec-1.4.jar   2. 代码 import javax.crypto.KeyGenerator; import javax.crypto.Mac; import javax.crypto.SecretKey;...
MAC信息摘要
weixin_30568715的博客
12-09 165
MAC(Message Authentication Code ，消息认证码算法)是含有密钥散列函数算法，兼容MD和SHA算法的特性，并在此基础上加入了密钥。因此，MAC也称为HMAC。 MAC算法集合了MD和SHA两大系列消息摘要算法。MD系列有HmacMD2、HmacMD4、HmacMD5三种算法。SHA系列的有HmacSHA1、HmacSHA224、HmacSH...
消息认证与杂凑算法：安全威胁与MAC功能解析
"安全威胁二-消息认证和杂凑算法" 在信息安全领域，确保信息的完整性和来源的真实性至关重要。本话题主要探讨了消息认证和杂凑算法在抵御安全威胁中的应用，特别是针对伪造消息的防范。 首先，描述中提到的伪造...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值