RAS 加密解密

最新推荐文章于 2024-05-17 06:20:46 发布
最新推荐文章于 2024-05-17 06:20:46 发布
阅读量3.2k 收藏 7
点赞数
分类专栏： java编程 java 文章标签： 加密 rsa
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/panlunyou/article/details/53816512
版权

RAS 加密解密

概念

RSA公钥加密算法是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。
RSA是目前最有影响力的公钥加密算法，它能够抵抗到目前为止已知的绝大多数密码攻击，已被ISO推荐为公钥数据加密算法。
RSA算法是一种非对称密码算法，所谓非对称，就是指该算法需要一对密钥，使用其中一个加密，则需要用另一个才能解密。

一下 java 版本基于jdk 实现 

package com.dndc.api.common.utils;

import java.io.ByteArrayOutputStream;
import java.io.UnsupportedEncodingException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;

import org.apache.commons.codec.binary.Base64;
import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**
 * ras 加密工具类
 * 
 * @author panlunyou 2016-12-21
 *
 */
public class RsaCreatePublicKey {
    public static final String KEY_SHA = "SHA";
    public static final String KEY_SHA_1 = "SHA-1";
    public static final String KEY_MD5 = "MD5";

    /** */
    /**
     * RSA最大加密明文大小
     */
    private static final int MAX_ENCRYPT_BLOCK = 117;

    /** */
    /**
     * RSA最大解密密文大小
     */
    private static final int MAX_DECRYPT_BLOCK = 128;

    public static final String pubkey = "";

    public static final String prikey =""; 

    /**
     * ras
     */
    public static final String KEY_ALGORTHM = "RSA";//
    public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
    public static final String PUBLIC_KEY = "RSAPublicKey";// 公钥
    public static final String PRIVATE_KEY = "RSAPrivateKey";// 私钥

    /**
     * 初始化密钥
     * 
     * @return
     * @throws Exception
     */
    public static Map<String, Object> initKey() throws Exception {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORTHM);
        keyPairGenerator.initialize(1024);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();

        // 公钥
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        // 私钥
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

        Map<String, Object> keyMap = new HashMap<String, Object>(2);
        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);

        return keyMap;
    }

    /**
     * 取得公钥，并转化为String类型
     * 
     * @param keyMap
     * @return
     * @throws Exception
     */
    public static String getPublicKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PUBLIC_KEY);
        return encryptBASE64(key.getEncoded());
    }

    /**
     * 取得私钥，并转化为String类型
     * 
     * @param keyMap
     * @return
     * @throws Exception
     */
    public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {
        Key key = (Key) keyMap.get(PRIVATE_KEY);
        return encryptBASE64(key.getEncoded());
    }

    /** */
    /**
     * <P>
     * 私钥解密
     * </p>
     * 
     * @param encryptedData
     *            已加密数据
     * @param privateKey
     *            私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey) throws Exception {
        byte[] keyBytes = decryptBase64(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, privateK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }

    /** */
    /**
     * <p>
     * 公钥解密
     * </p>
     * 
     * @param encryptedData
     *            已加密数据
     * @param publicKey
     *            公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey) throws Exception {
        byte[] keyBytes = decryptBase64(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.DECRYPT_MODE, publicK);
        int inputLen = encryptedData.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段解密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_DECRYPT_BLOCK) {
                cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_DECRYPT_BLOCK;
        }
        byte[] decryptedData = out.toByteArray();
        out.close();
        return decryptedData;
    }

    /** */
    /**
     * <p>
     * 公钥加密
     * </p>
     * 
     * @param data
     *            源数据
     * @param publicKey
     *            公钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPublicKey(byte[] data, String publicKey) throws Exception {
        byte[] keyBytes = decryptBase64(publicKey);
        X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
        Key publicK = keyFactory.generatePublic(x509KeySpec);
        // 对数据加密
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, publicK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }

    /** */
    /**
     * <p>
     * 私钥加密
     * </p>
     * 
     * @param data
     *            源数据
     * @param privateKey
     *            私钥(BASE64编码)
     * @return
     * @throws Exception
     */
    public static byte[] encryptByPrivateKey(byte[] data, String privateKey) throws Exception {
        byte[] keyBytes = decryptBase64(privateKey);
        PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
        Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);
        Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
        cipher.init(Cipher.ENCRYPT_MODE, privateK);
        int inputLen = data.length;
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        int offSet = 0;
        byte[] cache;
        int i = 0;
        // 对数据分段加密
        while (inputLen - offSet > 0) {
            if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
                cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
            } else {
                cache = cipher.doFinal(data, offSet, inputLen - offSet);
            }
            out.write(cache, 0, cache.length);
            i++;
            offSet = i * MAX_ENCRYPT_BLOCK;
        }
        byte[] encryptedData = out.toByteArray();
        out.close();
        return encryptedData;
    }

    public static String encryptBase64(byte[] b) throws UnsupportedEncodingException {
        return new String(Base64.encodeBase64(b), "UTF-8");
    }

    /**
     * BASE64解密
     * 
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] decryptBase64(String key) throws Exception {
        return (new BASE64Decoder()).decodeBuffer(key);
    }

    /**
     * BASE64加密
     * 
     * @param key
     * @return
     * @throws Exception
     */
    public static String encryptBASE64(byte[] key) throws Exception {
        return (new BASE64Encoder()).encodeBuffer(key);
    }

    /**
     * MD5加密
     * 
     * @param data
     * @return
     * @throws Exception
     */
    public static byte[] encryptMD5(byte[] data) throws Exception {
        MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);
        md5.update(data);
        return md5.digest();
    }

    /**
     * SHA加密
     * 
     * @param data
     * @return
     * @throws Exception
     */
    public static String encryptSHA(String decript) throws Exception {
        try {
            MessageDigest digest = java.security.MessageDigest.getInstance("SHA-1");
            digest.update(decript.getBytes());
            byte messageDigest[] = digest.digest();
            // Create Hex String
            StringBuffer hexString = new StringBuffer();
            // 字节数组转换为 十六进制 数
            for (int i = 0; i < messageDigest.length; i++) {
                String shaHex = Integer.toHexString(messageDigest[i] & 0xFF);
                if (shaHex.length() < 2) {
                    hexString.append(0);
                }
                hexString.append(shaHex);
            }
            return hexString.toString();

        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return "";
    }

    public static String SHA1(String decript) {
        try {
            MessageDigest digest = java.security.MessageDigest.getInstance(KEY_SHA_1);
            digest.update(decript.getBytes());
            byte messageDigest[] = digest.digest();
            // Create Hex String
            StringBuffer hexString = new StringBuffer();
            // 字节数组转换为 十六进制 数
            for (int i = 0; i < messageDigest.length; i++) {
                String shaHex = Integer.toHexString(messageDigest[i] & 0xFF);
                if (shaHex.length() < 2) {
                    hexString.append(0);
                }
                hexString.append(shaHex);
            }
            return hexString.toString();

        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 用私钥对信息生成数字签名
     * 
     * @param data
     *            //加密数据
     * @param privateKey
     *            //私钥
     * @return
     * @throws Exception
     */
    public static String sign(byte[] data, String privateKey) throws Exception {
        // 解密私钥
        byte[] keyBytes = decryptBase64(privateKey);
        // 构造PKCS8EncodedKeySpec对象
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);
        // 指定加密算法
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
        // 取私钥匙对象
        PrivateKey privateKey2 = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        // 用私钥对信息生成数字签名
        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initSign(privateKey2);
        signature.update(data);

        return encryptBASE64(signature.sign());
    }

    /**
     * 校验数字签名
     * 
     * @param data
     *            加密数据
     * @param publicKey
     *            公钥
     * @param sign
     *            数字签名
     * @return
     * @throws Exception
     */
    public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
        // 解密公钥
        byte[] keyBytes = decryptBase64(publicKey);
        // 构造X509EncodedKeySpec对象
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(keyBytes);
        // 指定加密算法
        KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORTHM);
        // 取公钥匙对象
        PublicKey publicKey2 = keyFactory.generatePublic(x509EncodedKeySpec);

        Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
        signature.initVerify(publicKey2);
        signature.update(data);
        // 验证签名是否正常
        return signature.verify(decryptBase64(sign));

    }

    /**
     * 将二进制转换成16进制
     * 
     * @param buf
     * @return
     */
    public static String parseByte2HexStr(byte buf[]) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < buf.length; i++) {
            String hex = Integer.toHexString(buf[i] & 0xFF);
            if (hex.length() == 1) {
                hex = '0' + hex;
            }
            sb.append(hex.toUpperCase());
        }
        return sb.toString();
    }

    /**
     * 将16进制转换为二进制
     * 
     * @param hexStr
     * @return
     */
    public static byte[] parseHexStr2Byte(String hexStr) {
        if (hexStr.length() < 1)
            return null;
        byte[] result = new byte[hexStr.length() / 2];
        for (int i = 0; i < hexStr.length() / 2; i++) {
            int high = Integer.parseInt(hexStr.substring(i * 2, i * 2 + 1), 16);
            int low = Integer.parseInt(hexStr.substring(i * 2 + 1, i * 2 + 2), 16);
            result[i] = (byte) (high * 16 + low);
        }
        return result;
    }

    /**
     * test ras 加密解密
     * 
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {

        String str = "测试需要加密的数据。。";
        Map mapkey=RasCreatePublicKey.initKey();

        String privateKey=RasCreatePublicKey.getPrivateKey(mapkey);
        String publicKey = RasCreatePublicKey.getPublicKey(mapkey);

        System.out.println("===privateKey :" + privateKey + "   ==publicKey :  " + publicKey);

        // 公钥加密
        String bb = encryptBase64(encryptByPublicKey(str.getBytes("utf-8"), publicKey));

        System.out.println("加密结果 ： " + bb);
        // 私钥解密
        String qq = new String(decryptByPrivateKey(decryptBase64(bb), privateKey), "utf-8");

        System.out.println(qq);
    }

}
jade-xp
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c# ras 加密解密 代码例子
02-08
本篇文章将深入探讨C#中如何实现RAS加密和解密，并通过一个WinForm应用实例——RasWinFormDemo来具体阐述。 首先，我们需要理解RAS的基本原理。RAS是一种非对称加密算法，它包括一对密钥：公钥和私钥。公钥可以公开...
RSA加密解密详解
热门推荐
weixin_43211186的博客
06-24 2万+
RSA算法是非对称密码算法。非对称密码又称为公钥密码，意思为每对加密包含一个公钥（可能为他人所知）和一个私钥（可能不为所有人所知）。有效的安全需要保持私钥的私密性；公钥可以在不影响安全性的情况下公开分发。RSA 的安全性依赖于分解两个大素数乘积的实际困难，但相对较慢，可以称为“分解问题”。已知：P = 11，q = 29，e = 3φ(n) = (p-1)(q-1) = (11-1)*(29-1) = 2803d ≡ 1 mod 280 3d mod 280 = 1 d = 187n = 11 * 29 =
Python 实现 RAS 加解密（ras模块，pycrypto模块）
laoyaogegeg的博客
01-31 2705
爬虫 js逆向 rsa加密 python 实现rsa加密 某浪微博登录rsa加密
RSA加密解密算法原理以及实现_rsa简介及源码实现
最新发布
2303_79055586的博客
05-17 1114
从古至今，如何用最有效的加密手段保护信息的安全性使之不被窃取、篡改或者破坏都是人们在信息传播中普遍关注的重大问题。最古老的文件加密手段莫过于对称加密，什么是对称加密，打个比方，有一个商人需要给合作伙伴送一批贵重的货物，他便将货物放在一个设置好密码的箱子中，这个密码只有商人知道，同时他又将设置好的密码提前告知合作伙伴，货物送达后，合作伙伴便可以用被告知的密码打开箱子取出货物。即用一种方法加密, 用同一种方法解密, 即为对称加密。
【RSA】RSA加密、解密、签名与验证
PlutoZuo的博客
12-22 1579
【RSA】RSA加密、解密、签名与验证
RAS加解密
weixin_39357459的博客
01-29 1016
RAS加解密其实就是通过密钥和密匙进行加解密的一种加密算法需要连个jar包 bcprov-ext-jdk14-1.45.jar commons-codec-1.6.jar 第一个类是生成密钥和密匙的package com.cai.util; import java.security.KeyPair; import java.security.KeyPairGenerator;
RSA加密解密原理
未完成的歌~的博客
01-15 1万+
引言：         CTF密码学类题目中，RSA加密可谓是很重要且常见的加密类型，今天就总结下 RSA加密的原理及解密方法。 文章目录RSA算法简介:1、什么是非对称加密算法：2、RSA 加密原理：3、RSA加密算法过程详解：1、找出质数 ：2、计算公共模数：3、计算欧拉函数 φ(n)：4、计算公钥 e：5、计算私钥 d：6、加密生成密文：7、解密生成明文：4、示例： RSA算法简介: RSA加密算法是一种 非对称加密
ras_加密解密vc_ras_
09-30
总的来说，“ras_加密解密vc_ras_”项目提供了一个使用VC++实现RAS加密解密算法的例子，这对于学习和理解非对称加密机制以及C++编程都是很有价值的。通过深入研究这个项目，可以提高对密码学和安全编程的理解，同时...
PHP-RAS加密解密数据
11-12
在IT行业中，加密技术是确保数据安全的重要手段之一。...在本篇内容中，我们将聚焦于PHP中的RSA加密解密机制，这是一种基于非对称加密...对于开发人员而言，理解和掌握RSA加密解密技术是提升系统安全性的重要技能之一。
Ras.rar_RAS C++_RAS加密解密 C_RAS解密 c++
09-22
"ras.dsp"和"ras.dsw"是Visual C++项目文件，用于管理和构建这个RAS加密解密程序。"ras.ncb"是Visual C++的类视图数据库，包含项目中类的信息。"ras.opt"存储了项目的编译和链接选项，而"ras.plg"是编译器的插件文件...
Ras加密解密，PHP和JAVA互通
05-29
在PHP和Java之间实现RSA加密解密的互通，需要确保两个环境都正确地处理PEM格式的密钥，并使用相同的标准库进行加密和解密。PHP中，我们可以使用openssl扩展来操作RSA密钥，例如`openssl_pkey_new()`用于生成密钥对，...
RSA加密、解密、签名、验签的原理及方法
拾一二的博客
04-08 9478
所以在实际应用中，要根据情况使用，也可以同时使用加密和签名，比如A和B都有一套自己的公钥和私钥，当A要给B发送消息时，先用B的公钥对消息加密，再对加密的消息使用A的私钥加签名，达到既不泄露也不被篡改，更能保证消息的安全性。在这个过程中，只有2次传递过程，第一次是A传递加签的消息和消息本身给B，第二次是B获取A的公钥，即使都被敌方截获，也没有危险性，因为只有A的私钥才能对消息进行签名，即使知道了消息内容，也无法伪造带签名的回复给B，防止了消息内容的篡改。公钥加密，私钥解密（私钥只有一个，公钥大家都知道）。
最通俗易懂的RSA加密解密指导
kiba518的博客
06-22 1308
前言 RSA加密算法是一种非对称加密算法，简单来说，就是加密时使用一个钥匙，解密时使用另一个钥匙。 因为加密的钥匙是公开的，所又称公钥，解密的钥匙是不公开的，所以称为私钥。 密钥 关于RSA加密有很多文章，但几乎都只介绍了RSACryptoServiceProvider类的使用方法，如果只是走走看看，是没问题的，但真的想使用时，就会发现，你没有密钥字符串。。。 下面我们从获取密钥字符串开始逐步学...
RSA加密/解密
arnodev
03-17 4619
RSA加密算法是一种可逆的非对称加密算法，即RSA加密时候用的密钥（公钥）和RSA解密时用的密钥（私钥）不是同一把。基本原理是将两个很大的质数相乘很容易得到乘积，但是该乘积分解质因数却很困难。RSA算法被广泛的用于加密解密和RSA签名/验证等领域。
RSA双向加解密（公钥加密-私钥解密；私钥加密-公钥解密）
qq_42014561的博客
12-20 9669
RSA私钥加密-公钥解密
SpringBoot-实现RAS+AES自动接口解密
qq_31700775的博客
07-11 901
​ 非对称加密算法是一种密钥的保密方法。 非对称加密算法需要两个密钥：公开密钥（publickey:简称公钥）和私有密钥（privatekey:简称私钥）。 公钥与私钥是一对，如果用公钥对数据进行加密，只有用对应的私钥才能解密。 因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。​ 加密秘钥和解密秘钥是一样，当你的密钥被别人知道后，就没有秘密可言了AES 是对称加密算法，优点：加密速度快；缺点：如果秘钥丢失，就容易解密密文，安全性相对比较差RSA 是非对称加密算法 ， 优点：安全 ；
关于RAS加密解密的一个文章，看着一个就够了！！！
人的生命周期还还没有代码的生命周期精彩
04-13 1362
RAS在网上看了太多文章很多都是不全的，复制过去各种问题，所有就有写个博客的想法，一是方便大家，二是方便自己,好了废话不多说了! 首先要注意一下证书级别 1024位的证书，加密时最大支持117个字节，解密时为128； 2048位的证书，加密时最大支持245个字节，解密时为256。 创建RAS工具类 package club.loserblog.blogreception.ut...
RSA双向加解密
qifeng78的博客
01-13 379
假设有这样一个场景 服务A与服务B需要通信 通信内容为了安全需要进行加密传输 并且服务A与服务B不能互相持有对方的钥匙。中 提供一个公钥一个私钥 一般情况下 采用公钥加密 私钥解密的方式。
ras加密解密算法C语言
06-01
RAS加密解密算法是一种非对称加密算法，常用于数据加密和数字签名。以下是RAS加密解密算法的C语言实现示例： ``` #include #include #include #include #include int main() { RSA *rsa = NULL; BIO *...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值