java PBOC-DES-MAC算法，（包括DES加密解密）

最新推荐文章于 2021-09-18 10:58:30 发布
最新推荐文章于 2021-09-18 10:58:30 发布
阅读量1.1k 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhuni_xingfu/article/details/9212281
版权


DES算法：

package c.m;

import java.security.spec.KeySpec;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;

public class DES{
	
	public static void main(String[] args) throws Exception {
	   //DES加密 16进制字符串
	  ENCRYPTMethod("5C656FF73140F705","1111111111111111");
	  
	  //DES解密---使用ECB模式
	  test2("A104E4BA4E121B4E","1111111111111111","DES/ECB/NoPadding");
	 }
	 
	 
	 /**
	  * DES加密
	  * @param HexString  字符串（16位16进制字符串）
	  * @param keyStr     密钥16个1
	  * @throws Exception
	  */
	 public static void ENCRYPTMethod(String HexString,String keyStr) throws Exception{ 
	        try {
	           byte[] theKey = null;
	           byte[] theMsg = null;
	           theMsg = hexToBytes(HexString);
	           theKey = hexToBytes(keyStr);
	           KeySpec ks = new DESKeySpec(theKey);
	           SecretKeyFactory kf = SecretKeyFactory.getInstance("DES");
	           SecretKey ky = kf.generateSecret(ks);
	           Cipher cf = Cipher.getInstance("DES/ECB/NoPadding");
	           cf.init(Cipher.ENCRYPT_MODE,ky);
	           byte[] theCph = cf.doFinal(theMsg);
	           System.out.println("*************DES加密****************");
	           System.out.println("密钥    : "+bytesToHex(theKey));
	           System.out.println("字符串: "+bytesToHex(theMsg));
	           System.out.println("加密后: "+bytesToHex(theCph));
	        } catch (Exception e) {
	           e.printStackTrace();
	           return;
	        }
	     }
	 
		/**
		 * DES解密
		 * 
		 * @param hexStr  16位十六进制字符串
		 * @param keyStr  密钥16个1
		 * @param modeStr 解密模式:ECB
		 * @throws Exception
		 */
		 public static void test2(String hexStr,String keyStr,String modeStr) throws Exception{
			 	
		        String algorithm = modeStr;
		        try {
		           byte[] theKey = null;
		           byte[] theMsg = null;
		           theMsg = hexToBytes(hexStr);
		           theKey = hexToBytes(keyStr);
		           KeySpec ks = new DESKeySpec(theKey);
		           SecretKeyFactory kf
		              = SecretKeyFactory.getInstance("DES");
		           SecretKey ky = kf.generateSecret(ks);
		           Cipher cf = Cipher.getInstance(algorithm);
		           cf.init(Cipher.DECRYPT_MODE,ky);
		           byte[] theCph = cf.doFinal(theMsg);
		           System.out.println("*************DES解密****************");
		           System.out.println("密钥    : "+bytesToHex(theKey));
		           System.out.println("字符串: "+bytesToHex(theMsg));
		           System.out.println("解密后: "+bytesToHex(theCph));
		           
		        } catch (Exception e) {
		           e.printStackTrace();
		           return;
		        }
		 
		 }
	 
	 public static byte[] hexToBytes(String str) {
	       if (str==null) {
	          return null;
	       } else if (str.length() < 2) {
	          return null;
	       } else {
	          int len = str.length() / 2;
	          byte[] buffer = new byte[len];
	          for (int i=0; i<len; i++) {
	              buffer[i] = (byte) Integer.parseInt(
	                 str.substring(i*2,i*2+2),16);
	          }
	          return buffer;
	       }

	    }
	    public static String bytesToHex(byte[] data) {
	      if (data==null) {
	         return null;
	      } else {
	         int len = data.length;
	          String str = "";
	       for (int i=0; i<len; i++) {
	        if ((data[i]&0xFF)<16) str = str + "0"
	                  + java.lang.Integer.toHexString(data[i]&0xFF);
	        else str = str
	                  + java.lang.Integer.toHexString(data[i]&0xFF);
	    }
	       return str.toUpperCase();
	     }
	     }  
}

字符转换帮助类： 

package com.test.PBOCDES;
import java.io.ByteArrayInputStream;  
import java.io.ByteArrayOutputStream;  
import java.io.IOException;  
import java.io.ObjectInputStream;  
import java.io.ObjectOutputStream;  
import java.io.Serializable;  
import java.security.MessageDigest;  
import java.security.NoSuchAlgorithmException;  

//帮助类
public class ConvertUtil {
	 	public final static char[] BToA = "0123456789abcdef".toCharArray();  
	  
	    private ConvertUtil() {  
	  
	    }  
	  
	    /** 
	     * 把16进制字符串转换成字节数组 
	     *  
	     * @param hex 
	     * @return 
	     */  
	    public static byte[] hexStringToByte(String hex) {  
	        int len = (hex.length() / 2);  
	        byte[] result = new byte[len];  
	        char[] achar = hex.toCharArray();  
	        for (int i = 0; i < len; i++) {  
	            int pos = i * 2;  
	            result[i] = (byte) (toByte(achar[pos]) << 4 | toByte(achar[pos + 1]));  
	        }  
	        return result;  
	    }  
	  
	    private static byte toByte(char c) {  
	        byte b = (byte) "0123456789ABCDEF".indexOf(c);  
	        return b;  
	    }  
	  
	    /** 
	     * 把字节数组转换成16进制字符串 
	     *  
	     * @param bArray 
	     * @return 
	     */  
	    public static final String bytesToHexString(byte[] bArray) {  
	        if(bArray == null )  
	        {  
	            return "";  
	        }  
	        StringBuffer sb = new StringBuffer(bArray.length);  
	        String sTemp;  
	        for (int i = 0; i < bArray.length; i++) {  
	            sTemp = Integer.toHexString(0xFF & bArray[i]);  
	            if (sTemp.length() < 2)  
	                sb.append(0);  
	            sb.append(sTemp.toUpperCase());  
	        }  
	        return sb.toString();  
	    }  
	  
	    /** 
	     * 把字节数组转换为对象 
	     *  
	     * @param bytes 
	     * @return 
	     * @throws IOException 
	     * @throws ClassNotFoundException 
	     */  
	    public static final Object bytesToObject(byte[] bytes) throws IOException,  
	            ClassNotFoundException {  
	        ByteArrayInputStream in = new ByteArrayInputStream(bytes);  
	        ObjectInputStream oi = new ObjectInputStream(in);  
	        Object o = oi.readObject();  
	        oi.close();  
	        return o;  
	    }  
	  
	    /** 
	     * 把可序列化对象转换成字节数组 
	     *  
	     * @param s 
	     * @return 
	     * @throws IOException 
	     */  
	    public static final byte[] objectToBytes(Serializable s) throws IOException {  
	        ByteArrayOutputStream out = new ByteArrayOutputStream();  
	        ObjectOutputStream ot = new ObjectOutputStream(out);  
	        ot.writeObject(s);  
	        ot.flush();  
	        ot.close();  
	        return out.toByteArray();  
	    }  
	  
	    public static final String objectToHexString(Serializable s)  
	            throws IOException {  
	        return bytesToHexString(objectToBytes(s));  
	    }  
	  
	    public static final Object hexStringToObject(String hex)  
	            throws IOException, ClassNotFoundException {  
	        return bytesToObject(hexStringToByte(hex));  
	    }  
	  
	    /** 
	     * @函数功能: BCD码转为10进制串(阿拉伯数据) 
	     * @输入参数: BCD码 
	     * @输出结果: 10进制串 
	     */  
	    public static String bcd2Str(byte[] bytes) {  
	        StringBuffer temp = new StringBuffer(bytes.length * 2);  
	  
	        for (int i = 0; i < bytes.length; i++) {  
	            temp.append((byte) ((bytes[i] & 0xf0) >>> 4));  
	            temp.append((byte) (bytes[i] & 0x0f));  
	        }  
	        return temp.toString().substring(0, 1).equalsIgnoreCase("0") ? temp  
	                .toString().substring(1) : temp.toString();  
	    }  
	  
	    /** 
	     * @函数功能: 10进制串转为BCD码 
	     * @输入参数: 10进制串 
	     * @输出结果: BCD码 
	     */  
	    public static byte[] str2Bcd(String asc) {  
	        int len = asc.length();  
	        int mod = len % 2;  
	  
	        if (mod != 0) {  
	            asc = "0" + asc;  
	            len = asc.length();  
	        }  
	  
	        byte abt[] = new byte[len];  
	        if (len >= 2) {  
	            len = len / 2;  
	        }  
	  
	        byte bbt[] = new byte[len];  
	        abt = asc.getBytes();  
	        int j, k;  
	  
	        for (int p = 0; p < asc.length() / 2; p++) {  
	            if ((abt[2 * p] >= '0') && (abt[2 * p] <= '9')) {  
	                j = abt[2 * p] - '0';  
	            } else if ((abt[2 * p] >= 'a') && (abt[2 * p] <= 'z')) {  
	                j = abt[2 * p] - 'a' + 0x0a;  
	            } else {  
	                j = abt[2 * p] - 'A' + 0x0a;  
	            }  
	  
	            if ((abt[2 * p + 1] >= '0') && (abt[2 * p + 1] <= '9')) {  
	                k = abt[2 * p + 1] - '0';  
	            } else if ((abt[2 * p + 1] >= 'a') && (abt[2 * p + 1] <= 'z')) {  
	                k = abt[2 * p + 1] - 'a' + 0x0a;  
	            } else {  
	                k = abt[2 * p + 1] - 'A' + 0x0a;  
	            }  
	  
	            int a = (j << 4) + k;  
	            byte b = (byte) a;  
	            bbt[p] = b;  
	        }  
	        return bbt;  
	    }  
	  
	    public static String BCD2ASC(byte[] bytes) {  
	        StringBuffer temp = new StringBuffer(bytes.length * 2);  
	  
	        for (int i = 0; i < bytes.length; i++) {  
	            int h = ((bytes[i] & 0xf0) >>> 4);  
	            int l = (bytes[i] & 0x0f);  
	            temp.append(BToA[h]).append(BToA[l]);  
	        }  
	        return temp.toString();  
	    }  
	  
	    /** 
	     * 两字符数组异或 
	     */  
	    public static byte[] byteArrXor(byte[] arr1, byte[] arr2, int len){  
	        byte[] dest = new byte[len];  
	          
	        if((arr1.length < len) || (arr2.length < len)){  
	            return null;  
	        }  
	          
	        for(int i = 0;i < len;i++){  
	            dest[i] = (byte)(arr1[i] ^ arr2[i]);  
	        }  
	          
	        return dest;  
	    }  
	      
	  
	    /** 
	     * MD5加密字符串，返回加密后的16进制字符串 
	     * @param origin 
	     * @return 
	     */  
	    public static String MD5EncodeToHex(String origin) {  
	        return bytesToHexString(MD5Encode(origin));  
	    }  
	  
	    /** 
	     * MD5加密字符串，返回加密后的字节数组 
	     *  
	     * @param origin 
	     * @return 
	     */  
	    public static byte[] MD5Encode(String origin) {  
	        return MD5Encode(origin.getBytes());  
	    }  
	  
	    /** 
	     * MD5加密字节数组，返回加密后的字节数组 
	     *  
	     * @param bytes 
	     * @return 
	     */  
	    public static byte[] MD5Encode(byte[] bytes) {  
	        MessageDigest md = null;  
	        try {  
	            md = MessageDigest.getInstance("MD5");  
	            return md.digest(bytes);  
	        } catch (NoSuchAlgorithmException e) {  
	            e.printStackTrace();  
	            return new byte[0];  
	        }  
	  
	    }  
}


package com.test.PBOCDES;
import java.security.Key;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

//ECB模式  DES加密、解密算法
public class DesECBencrypt {
    /** 
     * 加密数据 
     * @param encryptString  注意：这里的数据长度只能为8的倍数 
     * @param encryptKey 
     * @return 
     * @throws Exception 
     */  
    public static byte[] encryptDES(byte[] encryptbyte, byte[] encryptKey) throws Exception {  
        SecretKeySpec key = new SecretKeySpec(getKey(encryptKey), "DES");  
        Cipher cipher = Cipher.getInstance("DES/ECB/NoPadding");  
        cipher.init(Cipher.ENCRYPT_MODE, key);  
        byte[] encryptedData = cipher.doFinal(encryptbyte);  
        return encryptedData;
    }  
      
    /** 
     * 自定义一个key 
     * @param string  
     */  
    public static byte[] getKey(byte[] keyRule) {  
        Key key = null;  
        byte[] keyByte = keyRule;  
        // 创建一个空的八位数组,默认情况下为0  
        byte[] byteTemp = new byte[8];  
        // 将用户指定的规则转换成八位数组  
        for (int i = 0; i < byteTemp.length && i < keyByte.length; i++) {  
            byteTemp[i] = keyByte[i];  
        }  
        key = new SecretKeySpec(byteTemp, "DES");  
        return key.getEncoded();  
    }  
      
    /*** 
     * 解密数据 
     * @param decryptString 
     * @param decryptKey 
     * @return 
     * @throws Exception 
     */  
    public static String decryptDES(String decryptString, byte[] decryptKey) throws Exception {  
        SecretKeySpec key = new SecretKeySpec(getKey(decryptKey), "DES");  
        Cipher cipher = Cipher.getInstance("DES/ECB/NoPadding");  
        cipher.init(Cipher.DECRYPT_MODE, key);  
        byte decryptedData[] = cipher.doFinal(ConvertUtil.hexStringToByte(decryptString));  
        
        return new String(decryptedData); 
    }  
    
    public static void main(String[] args) {
		String str="";
		System.out.println("-----------------");
		try {
			//str = decrypt("A104E4BA4E121B4E", "1111111111111111");
		} catch (Exception e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		System.out.println(str);
	}
      /*************java解密C#进行DES加密的字符串****************/
}

PBOC-DES-MAC算法： 

package com.test.PBOCDES;


//PBOCDES算法
public class PBOCDES {

	public static void main(String[] args) {
		//测试
		
		//包含汉字的字符串
		//String str= "1820130227084536000300000003003794                                                                       01|00000202|ksds|lk|20130227|20130309|499130293990007|优惠券";
		
		//纯字母数字
		String str2 = "1234567ABFXDF222222";
		String result = Get_PBOC_DES(str2.getBytes(),"0123456789ABCDEF", "0000000000000000");
		System.out.println("PBOCDES加密后："+result);
	}
	
	/*
	 *  PBOCDES加密
	 *  @param shuju:加密的数据的byte[]
	 *  @param key:密钥 16位十六进制
	 *  @param IV:初始向量，默认为0000000000000000
	 */
	public static String Get_PBOC_DES(byte[] shuju, String key, String IV)
	{
		String returntype = "";
		try
		{
	         //----------------------------------------
	         byte[] keyss = new byte[8];
	         byte[] IVS = new byte[8];
	         keyss = ConvertUtil.hexStringToByte(key);
	         IVS = ConvertUtil.hexStringToByte(IV);
	         //----------------------------------------
	         byte[] keys = keyss;
	         //数据内容字节数组
	         String slshuju = ConvertUtil.bytesToHexString(shuju);
	         int TLen = 0;
	         int DBz = 0;
	         if (slshuju.length() % 16 != 0 || slshuju.length() % 16 == 0)
	         {
	             TLen = (((int)(slshuju.length() / 16)) + 1) * 16;
	             DBz = (slshuju.length() / 16) + 1;
	             slshuju = slshuju + "8";
	             TLen = TLen - slshuju.length();
	             for (int i = 0; i < TLen; i++)
	             {
	                 slshuju = slshuju + "0";
	             }
	         }
	         byte[] Zshuju = new byte[slshuju.length() / 2];
	         Zshuju = ConvertUtil.hexStringToByte(slshuju);
	         
	         byte[] D1 = new byte[8];
	         byte[] D2 = new byte[8];
	         byte[] I2 = new byte[8];
	         byte[] I3 = new byte[8];
	         byte[] bytTemp = new byte[8];
	         byte[] bytTempX = new byte[8];
	         //初始向量
	         byte[] I0 = IVS;
	         if (DBz >= 1)
	         {
	             for (int i = 0; i < 8; i++)
	             {
	                 D1[i] = Zshuju[i];
	             }
	             for (int i = 0; i < 8; i++)
	             {
	                 bytTemp[i] = (byte)(I0[i] ^ D1[i]);
	             }
	             I2 = bytTemp;
	             bytTempX = DesECBencrypt.encryptDES(I2, keys);
	         }
	         if (DBz >= 2)
	         {
	             for (int j = 2; j <= DBz; j++)
	             {
	                 for (int i = (j - 1) * 8; i < j * 8; i++)
	                 {
	                     D2[i - (j - 1) * 8] = Zshuju[i];
	                 }
	                 for (int i = 0; i < 8; i++)
	                 {
	                     bytTemp[i] =  (byte)(bytTempX[i] ^ D2[i]);
	                 }
	                 I3 = bytTemp;
	                 bytTempX = DesECBencrypt.encryptDES(I3, keys);
	             }
	         }
	         returntype = ConvertUtil.bytesToHexString(bytTempX);
	         
		}catch(Exception e)
		{
			returntype = "";
		}
		return returntype;
	}
	
}




1988_1989
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java PBOC-3DES-MAC算法
07-01 2100
package com.PBOC3DES; import java.io.UnsupportedEncodingException; import com.test.PBOCDES.ConvertUtil; import com.test.PBOCDES.DesECBencrypt; /** * PBOC3DES 加密算法 * @author Administrator * */ p
常见的MAC算法（PBOC_3DES_MAC、ANSI X9.9MAC算法、ANSI x9.19算法）
kxlele
02-07 2285
个人总结的常用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...
PBOC-DES-MAC\PBOC_3DES-MAC算法小工具
07-01
测试小工具、 来检测PBOC-DES-MAC,DES,PBOC-3DES-MAC算法的结果是否正确
PBOC 3DES MAC
07-17
MAC，使用 PBOC-3DES-MAC 算法。
PBOC MAC 计算算法 实现
abc
05-04 2258
win7 64位 PC vs2013 建立 一个 控制台 空工程： 添加下面两个文件： des.cpp // DES算法利用一个56+8奇偶校验位(第8,16,24,32,40,48,56,64位)=64位的密钥对以64位为单位的块数据进行加解密 #include "memory.h" #include "stdio.h" #include "conio.h" enum { E...
DELPHI源码，银联PBOC2.0算法工具XOR,DES,MAC 附带验证网址。
10-08
DELPHI源码，银联PBOC2.0算法工具XOR,DES,MAC 附带验证网址。有测试工具校对。
银联标准之MAC算法实现（POS终端加密）
热门推荐
LeBron_Six的专栏
06-24 1万+
本文详细讲解银联标准MAC算法的过程，以及通过Java代码来实现这一运算过程。POS终端采用ECB的加密方式，简述如下：将欲发送给POS中心的消息中，从消息类型（MTI）到63域之间的部分构成MAC ELEMEMENT BLOCK （MAB）对MAB，按每8个字节做异或（不管信息中的字符格式），如果最后不满8个字节，则添加“0x00”下面举个例子来说明MAC算法的过程：        MAB =
java mac算法_银行业加密算法，MAC算法算法（java-国密）
weixin_39538789的博客
02-16 910
之前自己在网上找相关算法找不到，最后只能自己实现，现在把实现的内容分享给大家，大家可以参考，因为文档不全，所以不完全准确，但在已有环境验证过。/*** mac算法* @author Administrator** 银联用calculateANSIX9_9MAC*/public class MAC {/*** ANSI X9.9MAC算法 * (1) ANSI X9.9MAC算法只使用单倍长密钥。 ...
Java加密算法---HMAC
wangshuang1631的博客
09-20 7134
HMAC算法介绍：HMAC是密钥相关的哈希运算消息认证码（Hash-based Message Authentication Code）,HMAC运算利用哈希算法，以一个密钥和一个消息为输入，生成一个消息摘要作为输出。 HMAC算法详解：HMAC使用公开函数和密钥产生一个固定长度的值作为认证标识，用这个标识鉴别消息的完整性。使用一个密钥生成一个固定大小的小数据块，即MAC，并将其加入到消息中
java PBOC3DES.rar
03-01
Java版PBOC3DES加密算法，初始向量全0，适合金融级别POS机具加解密算法，多次开发实践使用，类似进行3次des运算，大家可测试效果。
源码实现单DES加解密，3Des加解密和pboc标准结算mac
08-05
源码实现单DES加解密，3Des加解密和pboc标准结算mac，主要算法有明确的注释，已经测试通过，目前我已经用在项目中
C# DES 3DES AES SM4 PBOC加解密源码
最新发布
05-05
`TestConsole`可能是测试程序，用于验证加密解密功能的正确性。而`DataSecurity`可能是一个包含加密算法实现的类库项目。通过理解和使用这些源码，开发者可以更好地理解加密机制，并根据需求定制安全策略。
DES算法工具(DES_3DES_MAC加密解密器)
03-19
一：加解密 DES(单倍长) 3DES(双倍长) 3DES(三倍长) 二：MAC运算 ANSI-X9.9-MAC PBOC-DES-MAC PBOC-3DES-MAC . . .
PBOC/EMV之DES算法
lucasma的博客
10-27 2987
Des是在金融电子领域用的比较多的一种加解密算法, 比如POS,ATM,智能IC卡等领域. 这个算法网上可以找到很多, 这篇文章只是自己整理一个版本，加入了一些自己的理解和注释.
ANSI-X99MAC算法和PBOC的3DES MAC算法，附DES算法工具
编程小战
09-17 5395
[cpp] view plaincopy /**************************************************  * PBOC-3DES MAC计算  **************************************************/   void PBOC_3DES_MAC( U08 *buf, U32 b
pboc规范详细解释
davidtps的专栏
03-28 8297
转载自：http://blog.sina.com.cn/s/blog_9282a6e4010106bm.html 最近在做一个基于PBOC电子现金卡的终端应用, 项目还没有完成, 但电子现金部分的处理模块已完成，剩下的基本是UI和调试的事情了. 想把对PBOC电子现金理解整理成一篇文章. 电子现金的概念是在PBOC规范的第十三部分 >>里提出的。 可以这样理解，电子现金是PBOC里的一个
MAC： PBOC-MAC DES算法
萧海的博客
09-18 499
MAC： PBOC-MAC DES算法 密钥 长度8(0x08)字节 4F F6 3E 5D 02 FF CA 1B 初始向量 长度8(0x08)字节 00 00 00 00 00 00 00 00 数据 长度19(0x13)字节 00 00 12 34 02 00 00 00 00 00 01 20 12 12 07 16 41 00 80 结果 长度8(0x08)字节 9E BA 3F F7 CC E1 9B 1D 计算过程 强制补0x80再用0x00补齐8的倍数得到0000123
ANSI-X99MAC算法和PBOC的3DES MAC算法
独行猫a 的沉淀、积累、总结。天天学习，好好向上...c/c++,嵌入式 linux,Android,HarmonyOS)
10-16 4151
只要有标准的DES加密和解密算法，类似ANSI-X99MAC算法和PBOC3DES算法就很好实现。他们都是用DES算法再经过一层算法实现的。实现原理看 图就能看明白。3DES算法实现就更简单了。就是DES算法再加解密一次。 /* ***********************************************************************************
中国金融IC卡规范：PBOC3.0第16部分-互联网终端要求
"PBOC3.0-16部分 IC卡终端" 《中行IC卡规范 PBOC3.0第16部分》是中国金融集成电路（IC）卡规范的重要组成部分，主要针对IC卡互联网终端的规范，对于开发和制造支付终端的企业来说，这是不可或缺的技术指南。这份...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值