JAVA 非对称加密算法RSA

最新推荐文章于 2022-05-25 14:30:51 发布
最新推荐文章于 2022-05-25 14:30:51 发布
阅读量683 收藏 1
点赞数
分类专栏： 企业信息化 文章标签： 算法 加密 java rsa 对象

非对称加密算法 RSA过程 ： 以甲乙双方为例
　　1、初始化密钥 构建密钥对,生成公钥、私钥保存到keymap中
　　　　KeyPairGenerator ---> KeyPair --> RSAPublicKey、RSAPrivateKey
　　2、甲方使用私钥加密, 加密后在用私钥对加密数据进行数据签名，然后发送给乙方
　　　　RSACoder.encryptByPrivateKey(data, privateKey);
　　　　RSACoder.sign(encodedData, privateKey);
　　3、乙方则通过公钥验证签名的加密数据，如果验证正确则在通过公钥对加密数据进行解密
　　　　RSACoder.verify(encodedData, publicKey, sign);
　　　　RSACoder.decryptByPublicKey(encodedData, publicKey);
　　 4、乙方在通过公钥加密发送给甲方
　　　　RSACoder.encryptByPublicKey(decodedData, publicKey);
　　5、甲方通过私钥解密该数据
　　　　RSACoder.decryptPrivateKey(encodedData, privateKey);
流程图如下：

java代码实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
package  com.bank.utils;
 
import  java.security.MessageDigest;
 
import  javax.crypto.KeyGenerator;
import  javax.crypto.Mac;
import  javax.crypto.SecretKey;
import  javax.crypto.spec.SecretKeySpec;
 
import  sun.misc.BASE64Decoder;
import  sun.misc.BASE64Encoder;
 
public  abstract  class  Coder {
     public  static  final  String KEY_SHA =  "SHA" ;
     public  static  final  String KEY_MD5 =  "MD5" ;
     
     /**
      * MAC算法可选以下多种算法
      * 
      * <pre>
      * HmacMD5 
      * HmacSHA1 
      * HmacSHA256 
      * HmacSHA384 
      * HmacSHA512
      * </pre>
      */ 
     public  static  final  String KEY_MAC =  "HmacMD5" ;
     
     /**
      * 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  byte [] encryptSHA(  byte [] data)  throws  Exception {
         MessageDigest sha = MessageDigest.getInstance(KEY_SHA);
         sha.update(data);
         
         return  sha.digest();
     }
     
     /**
      * 初始化HMAC密钥
      * 
      * @return
      * @throws Exception
      */ 
     public  static  String initMacKey()  throws  Exception{
         KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);
         
         SecretKey secretKey = keyGenerator.generateKey();
         return  encryptBASE64(secretKey.getEncoded());
     }
     
     /**
      * HMAC  加密
      * @param data
      * @param key
      * @return
      * @throws Exception
      */
     public  static  byte [] encryptHMAC(  byte [] data, String key)  throws  Exception{
         SecretKey secretKey =  new  SecretKeySpec(decryptBASE64(key), KEY_MAC);
         Mac mac = Mac.getInstance(secretKey.getAlgorithm());
         mac.init(secretKey);
         return  mac.doFinal(data);
     }
}

　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
package  com.bank.utils;
 
import  java.security.Key;
import  java.security.KeyFactory;
import  java.security.KeyPair;
import  java.security.KeyPairGenerator;
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;
 
 
public  abstract  class  RSACoder  extends  Coder{
     public  static  final  String KEY_ALGORITHM =  "RSA" ;
     public  static  final  String SIGNATURE_ALGORITHM =  "MD5withRSA" ;
     
     private  static  final  String PUBLIC_KEY =  "RSAPublicKey" ;
     private  static  final  String PRIVATE_KEY =  "RSAPrivatekey" ;
     
     /**
      * 用私钥对信息生成数字签名
      * @param data 加密数据
      * @param privateKey 私钥
      * @return
      * @throws Exception
      */
     public  static  String sign( byte [] data, String privateKey)  throws  Exception {
         //解密由base64编码的私钥
         byte [] keyBytes = decryptBASE64(privateKey);
         
         PKCS8EncodedKeySpec pkcs8EncodedKeySpec =  new  PKCS8EncodedKeySpec(keyBytes);
         
         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
         
         //取私钥对象
         PrivateKey pKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
         
         //用私钥生成数字签名
         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
         signature.initSign(pKey);
         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{
         
         //解密有base64编码的公钥
         byte [] keyBytes = decryptBASE64(publicKey);
         
         X509EncodedKeySpec keySpec =  new  X509EncodedKeySpec(keyBytes);
         
         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
         
         //取公钥对象
         PublicKey pKey = keyFactory.generatePublic(keySpec);
         
         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
         signature.initVerify(pKey);
         signature.update(data);
         //验证签名是否正常
         return  signature.verify(decryptBASE64(sign));
     }
     
     /**
      * 解密
      *  用私钥解密
      * @param data 加密数据
      * @param key
      * @return
      * @throws Exception
      */
     public  static  byte [] decryptPrivateKey( byte [] data, String key)  throws  Exception{
         byte [] keyBytes = decryptBASE64(key);
         
         //取得私钥
         PKCS8EncodedKeySpec encodedKeySpec =  new  PKCS8EncodedKeySpec(keyBytes);
         KeyFactory factory = KeyFactory.getInstance(KEY_ALGORITHM);
         Key pKey = factory.generatePrivate(encodedKeySpec);
         
         //对数据解密
         Cipher cipher = Cipher.getInstance(factory.getAlgorithm());
         cipher.init(Cipher.DECRYPT_MODE, pKey);
         
         return  cipher.doFinal(data);
     }
     
     /**
      * 用公钥解密
      * @param data
      * @param key
      * @return
      * @throws Exception
      */
     public  static  byte [] decryptByPublicKey(  byte [] data, String key)  throws  Exception{
         
         //解密
         byte [] keyBytes = decryptBASE64(key);
         
         //取得公钥
         X509EncodedKeySpec keySpec =  new  X509EncodedKeySpec(keyBytes);
         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
         Key pKey = keyFactory.generatePublic(keySpec);
         
         //对数据解密
         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
         cipher.init(Cipher.DECRYPT_MODE, pKey);
         
         return  cipher.doFinal(data);
     }
     
     /**
      * 用公钥加密
      * @param data
      * @param key
      * @return
      * @throws Exception
      */
     public  static  byte [] encryptByPublicKey(  byte [] data, String key)  throws  Exception{
         
         byte [] keyBytes = decryptBASE64(key);
         
         X509EncodedKeySpec keySpec =  new  X509EncodedKeySpec(keyBytes);
         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
         Key pKey = keyFactory.generatePublic(keySpec);
         
         
         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
         cipher.init(Cipher.ENCRYPT_MODE, pKey);
         
         return  cipher.doFinal(data);
     }
     
     /**
      * 用私钥加密
      * @param data
      * @param key
      * @return
      * @throws Exception
      */
     public  static  byte [] encryptByPrivateKey( byte [] data, String key)  throws  Exception{
         
         byte [] keyBytes = decryptBASE64(key);
         
         PKCS8EncodedKeySpec keySpec =  new  PKCS8EncodedKeySpec(keyBytes);
         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
         Key privateKey = keyFactory.generatePrivate(keySpec);
         
         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
         cipher.init(Cipher.ENCRYPT_MODE, privateKey);
         
         return  cipher.doFinal(data);
     }
     
     /**
      * 取得私钥
      * @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());
     }
     
     /**
      * 取得公钥
      * @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());
     }
     /**
      * 初始化密钥
      * @return
      * @throws Exception
      */
     public  static  Map<String, Object> initKey()  throws  Exception{
         
         KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
         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(PRIVATE_KEY, privateKey);
         keyMap.put(PUBLIC_KEY, publicKey);
         return  keyMap;
     }
}

　　

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
package  com.bank.test;
 
import  java.util.Map;
 
import  org.junit.Assert;
import  org.junit.Before;
import  org.junit.Test;
 
import  com.bank.utils.RSACoder;
 
public  class  RSACoderTest {
     private  String publicKey;
     private  String privateKey;
     /*
      * 非对称加密算法   RSA过程 ： 以甲乙双方为例
      *      1、初始化密钥 构建密钥对,生成公钥、私钥保存到keymap中
      *              KeyPairGenerator --->    KeyPair     -->      RSAPublicKey、RSAPrivateKey
      *      2、甲方使用私钥加密, 加密后在用私钥对加密数据进行数据签名，然后发送给乙方
      *              RSACoder.encryptByPrivateKey(data, privateKey);
      *              RSACoder.sign(encodedData, privateKey);
      *      3、乙方则通过公钥验证签名的加密数据，如果验证正确则在通过公钥对加密数据进行解密
      *              RSACoder.verify(encodedData, publicKey, sign);
      *              RSACoder.decryptByPublicKey(encodedData, publicKey);               
      *
      *      4、乙方在通过公钥加密发送给甲方
      *              RSACoder.encryptByPublicKey(decodedData, publicKey);
      *      5、甲方通过私钥解密该数据      
      *              RSACoder.decryptPrivateKey(encodedData, privateKey);               
      */
     @Before
     public  void  setUp()  throws  Exception {
         
         Map<String , Object> keyMap = RSACoder.initKey();
         
         publicKey = RSACoder.getPublicKey(keyMap);
         privateKey = RSACoder.getPrivateKey(keyMap);
         
         System.out.println( "公钥：\n"  + publicKey);
         System.out.println( "私钥：\n"  + privateKey);
     }
     @Test
     public  void  test()  throws  Exception{
         String inputStr =  "abc" ;
         byte [] data = inputStr.getBytes(); //每次的得到的字节数组是不一样的。
         //第二步 私钥加密
         byte [] encodedData = RSACoder.encryptByPrivateKey(data, privateKey);
         //私钥进行数据签名
         String sign = RSACoder.sign(encodedData, privateKey);
         
         //第三步 公钥验证数字签名
         boolean  flag = RSACoder.verify(encodedData, publicKey, sign);
         System.out.println( "flag:"  + flag);
         //用公钥对数据解密
         byte [] decodedData = RSACoder.decryptByPublicKey(encodedData, publicKey);
         
         System.out.println( "data:"  + data +  "加密数据："  + encodedData +  "    解密数据："  + decodedData);
         System.out.println( "加密前数据-："  +  new  String(data) +  "     解密后数据： "  +  new  String(decodedData));
         
         //第四步使用公钥加密数据
         encodedData = RSACoder.encryptByPublicKey(decodedData, publicKey);
         
         //第五步 使用私钥解密数据
         decodedData = RSACoder.decryptPrivateKey(encodedData, privateKey);
         
         
         System.out.println( "data:"  + data +  "加密数据："  + encodedData +  "    解密数据："  + decodedData);
         System.out.println( "加密前数据："  + inputStr +  "     解密后数据： "  +  new  String(decodedData));
     }
     
     
     @Test
     public  void  test1()  throws  Exception{
         System.out.println( "私钥加密-----公钥解密" );
         String inputStr =  "abc" ;
         byte [] data = inputStr.getBytes();
         System.out.println( "data:"  + data);
         
         byte [] encodedData = RSACoder.encryptByPrivateKey(data, privateKey);
         byte [] decodedData = RSACoder.decryptByPublicKey(encodedData, publicKey);
     
         String outputStr =  new  String( decodedData );
         
         System.out.println( "加密前："  + inputStr + "\n 解密后："  + outputStr);
         
         Assert.assertEquals(inputStr, outputStr);
         
         
         System.out.println( "私钥签名---公钥验证签名" );
         //产生签名
         String sign = RSACoder.sign(encodedData, privateKey);
         System.out.println( "签名：\r"  + sign);
         
         //验证签名
         boolean  flag = RSACoder.verify(encodedData, publicKey, sign);
         
         System.out.println( "状态：\r"  + flag);
         
         Assert.assertTrue(flag);
     }
}

　　

meiru8
关注
专栏目录
JAVA 做非对称加密（RSA）
java_chc的博客
09-22 4512
java项目中使用 RSA 非对称加密实现对数据的加解密和生成签名（sign），全流程记录
Java非对称加密：RSA 数据加密与解密、数字签名与验签
最新发布
pan_junbiao的博客
10-28 1316
非对称加密（asymmetric cryptography），也称为公开密钥加密（public-key cryptography），是密码学中的一种重要算法。非对称加密使用一对密钥进行加密和解密操作，这两个密钥分别是公开密钥（public key）和私有密钥（private key）。公开密钥可以公开给任何人使用，而私有密钥则必须保密，只有密钥的持有者才能访问。这两个密钥之间存在数学上的联系，但不能从一个推导出另一个。
Java非对称加密算法
11-25
这是本人总结的Java 非对称 加密 算法，有疑问可以找我1038546502@qq.com
Java非对称加密算法 DH
tanksyg的专栏
11-18 206
一、概述 Diffie-Hellman算法(D-H算法)，密钥一致协议。是由公开密钥密码体制的奠基人Diffie和Hellman所提出的一种思想。简单的说就是允许两名用户在公开媒体上交换信息以生成"一致"的、可以共享的密钥。即就是由甲方产出一对密钥（公钥、私钥），乙方依照甲方公钥产生乙方密钥对（公钥、私钥）。以此为基线，作为数据传输保密基础，同时双方使用同一种对称加密算法构建本地密钥（Secr...
Java中的非对称加密算法
hi_0123的专栏
09-15 986
上篇博文中我们讲了Java中的对称加密，还没有看过的童鞋可以打开链接查看对称加密，今天我们重点讲一下Java中的非对称加密。 对于非对称加密，它需要两个密钥来进行加密和解密，分别为公钥和私钥，其相对于对称加密而言安全性更高；在Java中的非对称加密算法主要有DH算法和RSA算法。 DH算法加密： package com.example.asiatravel.learndes.dh_util;
非对称加密算法java
SmallTenMr的博客
05-25 417
public class GetSignFuncImpl implements GetSignFunc { private static final int MAX_ENCRYPT_BLOCK = 117; private static final int MAX_DECRYPT_BLOCK = 128; private static final String PUBLIC_KEY = "213213213213123dsvdvdsfdsfdsfsf"; @Over.
Java 非对称加密算法(RSA算法)
weixin_44264445的博客
10-27 398
public class RSAUtils { public static void main(String[] args) throws Exception { String publicKey="MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCapIG/XijKqbesb0LC9CdmcKbnzPJMIsa6tRbIwi1FKm3GSYkzYoJWQmHYq5WxVxDosc5aj2b0wBvhQ4WwLgaaNjyC5hcIfhSwAqMFD/
java 非对称加密算法RSA实现详解
08-25
Java 非对称加密算法RSA实现详解 Java 非对称加密算法RSA实现详解是 Java 语言中的一种常用加密算法，主要用于保护数据的安全性。 RSA 算法是一种基于大数分解的加密算法，它的安全性取决于大数分解的难度。在 Java...
Rsa.rar_RSA 算法_java 非对称 加密 算法_rsa java
09-19
RSA算法是一种非对称加密算法，它在信息安全领域有着广泛的应用，特别是在数据传输中的安全保护。这个RAR压缩包包含了一个名为“Rsa.java”的源代码文件，可能是用于演示如何在Java环境中实现RSA算法。另一个文件...
java实现非对称加密算法
他叫阿来
01-31 1437
文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import.
Java加密算法—非对称加密
热门推荐
一恍过去
02-16 1万+
Java加密算法—非对称加密
java非对称加密_JAVA 非对称加密算法RSA
weixin_27717759的博客
02-21 388
非对称加密算法 RSA过程 ： 以甲乙双方为例1、初始化密钥 构建密钥对,生成公钥、私钥保存到keymap中KeyPairGenerator --->KeyPair-->RSAPublicKey、RSAPrivateKey2、甲方使用私钥加密, 加密后在用私钥对加密数据进行数据签名，然后发送给乙方RSACoder.encryptByPrivateKey(data, privateKey...
Java实现非对称加密
I_LV_XJ的博客
05-04 4460
公开密钥密码学（英语：Public-key cryptography）也称非对称式密码学（英语：Asymmetric cryptography）是密码学的一种算法，它需要两个密钥，一个是公开密钥，另一个是私有密钥；公钥用作加密，私钥则用作解密。使用公钥把明文加密后所得的密文，只能用相对应的私钥才能解密并得到原本的明文，最初用来加密的公钥不能用作解密。由于加密和解密需要两个不同的密钥，故被称为非对称加密；不同于加密和解密都使用同一个密钥的对称加密。公钥可以公开，可任意向外发布；私钥不可以公开，必须由用户自行严
非对称加密算法 - Java加密与安全
Leon_Jinhai_Sun的博客
05-07 584
非对称加密算法 我们从DH算法中可以看到密钥对是一种非常有用的加密算法 密钥对中publicKey是可以公开的,而privateKey则是需要保密的,由此奠定了非对称加密的基础 非对称加密就是加密和解密使用的是不同的密钥,使用非对称加密的时候,使用同一个公钥和私钥对才能够正常的加密解密, 1. 在加密的时候使用自己的私钥加密,然后发送给对方 2. 然后解密的时候使用自己...
【Java】Java实现非对称加密（RSA算法）
weixin_38538285的博客
07-05 780
1、 简介 非对称加密算法又叫做现代加密算法 非对称加密，有两个秘钥，一个公钥一个私钥.公钥和私钥是一对，叫做密钥对 如果使用公钥加密必须使用私钥解密 如果使用私钥加密必须使用公钥解密 处理数据的速度较慢，因为安全级别高 2、 对称加密算法的对比 优点：其安全性更好，对称加密的通信双方使用相同的秘钥，如果一方的秘钥遭泄露，那么整个通信就会被破解。而非对称加密使用一对秘钥，一个用来加密，一个用来解密，而且公钥是公开的，秘钥是自己保存的，不需要像对称加密那样在通信之前要先同步秘钥。 缺点：非对称加密的缺点
非对称加密算法之java实现
charming的专栏
03-22 1790
非对称加密算法的秘钥分为公钥和私钥,公钥和私钥通常情况下是成对出现的,使用公钥加密的数据只有和它对应的私钥才能解开,反之亦然.在非对称加密算法中有一些算法是可以公钥加密,私钥解密的,反过来,私钥加密,公钥解密,下面是一些常见的非对称加密算法: DH(Diffie-Hellman)秘钥交换算法 RSA–基于大数因子分解 ElGamal–基于离散对数 ECC(Elliptical curve Crypt
Java实现RSA非对称加密算法的详解
资源摘要信息:"RSA算法是一种广泛应用于现代信息安全领域的非对称加密算法。该算法由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）在1977年提出，因此以三人的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值