Java加密技术（六）

最新推荐文章于 2024-08-21 20:45:00 发布
最新推荐文章于 2024-08-21 20:45:00 发布
阅读量471 收藏
点赞数
分类专栏： JAVA之加密解密 文章标签： 加密 java exception algorithm string object

关键字: dsa, 公钥, 私钥, 数字签名, 非对称加密

    接下来我们介绍DSA数字签名，非对称加密的另一种实现。
DSA
DSA-Digital Signature Algorithm 是Schnorr和ElGamal签名算法的变种，被美国NIST作为DSS(DigitalSignature Standard)。简单的说，这是一种更高级的验证方式，用作数字签名。不单单只有公钥、私钥，还有数字签名。私钥加密生成数字签名，公钥验证数据及签名。如果数据和签名不匹配则认为验证失败！数字签名的作用就是校验数据在传输过程中不被修改。数字签名，是单向加密的升级！


通过java代码实现如下： Coder类见 Java加密技术（一）
Java代码 复制代码
  1. import java.security.Key;   
  2. import java.security.KeyFactory;   
  3. import java.security.KeyPair;   
  4. import java.security.KeyPairGenerator;   
  5. import java.security.PrivateKey;   
  6. import java.security.PublicKey;   
  7. import java.security.SecureRandom;   
  8. import java.security.Signature;   
  9. import java.security.interfaces.DSAPrivateKey;   
  10. import java.security.interfaces.DSAPublicKey;   
  11. import java.security.spec.PKCS8EncodedKeySpec;   
  12. import java.security.spec.X509EncodedKeySpec;   
  13. import java.util.HashMap;   
  14. import java.util.Map;   
  15.   
  16. /**  
  17.  * DSA安全编码组件  
  18.  *   
  19.  * @author 梁栋  
  20.  * @version 1.0  
  21.  * @since 1.0  
  22.  */  
  23. public abstract class DSACoder extends Coder {   
  24.   
  25.     public static final String ALGORITHM = "DSA";   
  26.   
  27.     /**  
  28.      * 默认密钥字节数  
  29.      *   
  30.      * <pre>  
  31.      * DSA   
  32.      * Default Keysize 1024    
  33.      * Keysize must be a multiple of 64, ranging from 512 to 1024 (inclusive).  
  34.      * </pre>  
  35.      */  
  36.     private static final int KEY_SIZE = 1024;   
  37.   
  38.     /**  
  39.      * 默认种子  
  40.      */  
  41.     private static final String DEFAULT_SEED = "0f22507a10bbddd07d8a3082122966e3";   
  42.   
  43.     private static final String PUBLIC_KEY = "DSAPublicKey";   
  44.     private static final String PRIVATE_KEY = "DSAPrivateKey";   
  45.   
  46.     /**  
  47.      * 用私钥对信息生成数字签名  
  48.      *   
  49.      * @param data  
  50.      *            加密数据  
  51.      * @param privateKey  
  52.      *            私钥  
  53.      *   
  54.      * @return  
  55.      * @throws Exception  
  56.      */  
  57.     public static String sign(byte[] data, String privateKey) throws Exception {   
  58.         // 解密由base64编码的私钥   
  59.         byte[] keyBytes = decryptBASE64(privateKey);   
  60.   
  61.         // 构造PKCS8EncodedKeySpec对象   
  62.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);   
  63.   
  64.         // KEY_ALGORITHM 指定的加密算法   
  65.         KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);   
  66.   
  67.         // 取私钥匙对象   
  68.         PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);   
  69.   
  70.         // 用私钥对信息生成数字签名   
  71.         Signature signature = Signature.getInstance(keyFactory.getAlgorithm());   
  72.         signature.initSign(priKey);   
  73.         signature.update(data);   
  74.   
  75.         return encryptBASE64(signature.sign());   
  76.     }   
  77.   
  78.     /**  
  79.      * 校验数字签名  
  80.      *   
  81.      * @param data  
  82.      *            加密数据  
  83.      * @param publicKey  
  84.      *            公钥  
  85.      * @param sign  
  86.      *            数字签名  
  87.      *   
  88.      * @return 校验成功返回true 失败返回false  
  89.      * @throws Exception  
  90.      *   
  91.      */  
  92.     public static boolean verify(byte[] data, String publicKey, String sign)   
  93.             throws Exception {   
  94.   
  95.         // 解密由base64编码的公钥   
  96.         byte[] keyBytes = decryptBASE64(publicKey);   
  97.   
  98.         // 构造X509EncodedKeySpec对象   
  99.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);   
  100.   
  101.         // ALGORITHM 指定的加密算法   
  102.         KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);   
  103.   
  104.         // 取公钥匙对象   
  105.         PublicKey pubKey = keyFactory.generatePublic(keySpec);   
  106.   
  107.         Signature signature = Signature.getInstance(keyFactory.getAlgorithm());   
  108.         signature.initVerify(pubKey);   
  109.         signature.update(data);   
  110.   
  111.         // 验证签名是否正常   
  112.         return signature.verify(decryptBASE64(sign));   
  113.     }   
  114.   
  115.     /**  
  116.      * 生成密钥  
  117.      *   
  118.      * @param seed  
  119.      *            种子  
  120.      * @return 密钥对象  
  121.      * @throws Exception  
  122.      */  
  123.     public static Map<String, Object> initKey(String seed) throws Exception {   
  124.         KeyPairGenerator keygen = KeyPairGenerator.getInstance(ALGORITHM);   
  125.         // 初始化随机产生器   
  126.         SecureRandom secureRandom = new SecureRandom();   
  127.         secureRandom.setSeed(seed.getBytes());   
  128.         keygen.initialize(KEY_SIZE, secureRandom);   
  129.   
  130.         KeyPair keys = keygen.genKeyPair();   
  131.   
  132.         DSAPublicKey publicKey = (DSAPublicKey) keys.getPublic();   
  133.         DSAPrivateKey privateKey = (DSAPrivateKey) keys.getPrivate();   
  134.   
  135.         Map<String, Object> map = new HashMap<String, Object>(2);   
  136.         map.put(PUBLIC_KEY, publicKey);   
  137.         map.put(PRIVATE_KEY, privateKey);   
  138.   
  139.         return map;   
  140.     }   
  141.   
  142.     /**  
  143.      * 默认生成密钥  
  144.      *   
  145.      * @return 密钥对象  
  146.      * @throws Exception  
  147.      */  
  148.     public static Map<String, Object> initKey() throws Exception {   
  149.         return initKey(DEFAULT_SEED);   
  150.     }   
  151.   
  152.     /**  
  153.      * 取得私钥  
  154.      *   
  155.      * @param keyMap  
  156.      * @return  
  157.      * @throws Exception  
  158.      */  
  159.     public static String getPrivateKey(Map<String, Object> keyMap)   
  160.             throws Exception {   
  161.         Key key = (Key) keyMap.get(PRIVATE_KEY);   
  162.   
  163.         return encryptBASE64(key.getEncoded());   
  164.     }   
  165.   
  166.     /**  
  167.      * 取得公钥  
  168.      *   
  169.      * @param keyMap  
  170.      * @return  
  171.      * @throws Exception  
  172.      */  
  173.     public static String getPublicKey(Map<String, Object> keyMap)   
  174.             throws Exception {   
  175.         Key key = (Key) keyMap.get(PUBLIC_KEY);   
  176.   
  177.         return encryptBASE64(key.getEncoded());   
  178.     }   
  179. }  
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.SecureRandom;
import java.security.Signature;
import java.security.interfaces.DSAPrivateKey;
import java.security.interfaces.DSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

/**
 * DSA安全编码组件
 * 
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
public abstract class DSACoder extends Coder {

	public static final String ALGORITHM = "DSA";

	/**
	 * 默认密钥字节数
	 * 
	 * <pre>
	 * DSA 
	 * Default Keysize 1024  
	 * Keysize must be a multiple of 64, ranging from 512 to 1024 (inclusive).
	 * </pre>
	 */
	private static final int KEY_SIZE = 1024;

	/**
	 * 默认种子
	 */
	private static final String DEFAULT_SEED = "0f22507a10bbddd07d8a3082122966e3";

	private static final String PUBLIC_KEY = "DSAPublicKey";
	private static final String PRIVATE_KEY = "DSAPrivateKey";

	/**
	 * 用私钥对信息生成数字签名
	 * 
	 * @param data
	 *            加密数据
	 * @param privateKey
	 *            私钥
	 * 
	 * @return
	 * @throws Exception
	 */
	public static String sign(byte[] data, String privateKey) throws Exception {
		// 解密由base64编码的私钥
		byte[] keyBytes = decryptBASE64(privateKey);

		// 构造PKCS8EncodedKeySpec对象
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);

		// KEY_ALGORITHM 指定的加密算法
		KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);

		// 取私钥匙对象
		PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);

		// 用私钥对信息生成数字签名
		Signature signature = Signature.getInstance(keyFactory.getAlgorithm());
		signature.initSign(priKey);
		signature.update(data);

		return encryptBASE64(signature.sign());
	}

	/**
	 * 校验数字签名
	 * 
	 * @param data
	 *            加密数据
	 * @param publicKey
	 *            公钥
	 * @param sign
	 *            数字签名
	 * 
	 * @return 校验成功返回true 失败返回false
	 * @throws Exception
	 * 
	 */
	public static boolean verify(byte[] data, String publicKey, String sign)
			throws Exception {

		// 解密由base64编码的公钥
		byte[] keyBytes = decryptBASE64(publicKey);

		// 构造X509EncodedKeySpec对象
		X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

		// ALGORITHM 指定的加密算法
		KeyFactory keyFactory = KeyFactory.getInstance(ALGORITHM);

		// 取公钥匙对象
		PublicKey pubKey = keyFactory.generatePublic(keySpec);

		Signature signature = Signature.getInstance(keyFactory.getAlgorithm());
		signature.initVerify(pubKey);
		signature.update(data);

		// 验证签名是否正常
		return signature.verify(decryptBASE64(sign));
	}

	/**
	 * 生成密钥
	 * 
	 * @param seed
	 *            种子
	 * @return 密钥对象
	 * @throws Exception
	 */
	public static Map<String, Object> initKey(String seed) throws Exception {
		KeyPairGenerator keygen = KeyPairGenerator.getInstance(ALGORITHM);
		// 初始化随机产生器
		SecureRandom secureRandom = new SecureRandom();
		secureRandom.setSeed(seed.getBytes());
		keygen.initialize(KEY_SIZE, secureRandom);

		KeyPair keys = keygen.genKeyPair();

		DSAPublicKey publicKey = (DSAPublicKey) keys.getPublic();
		DSAPrivateKey privateKey = (DSAPrivateKey) keys.getPrivate();

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

		return map;
	}

	/**
	 * 默认生成密钥
	 * 
	 * @return 密钥对象
	 * @throws Exception
	 */
	public static Map<String, Object> initKey() throws Exception {
		return initKey(DEFAULT_SEED);
	}

	/**
	 * 取得私钥
	 * 
	 * @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());
	}
}


再给出一个测试类：
Java代码 复制代码
  1. import static org.junit.Assert.*;   
  2.   
  3. import java.util.Map;   
  4.   
  5. import org.junit.Test;   
  6.   
  7. /**  
  8.  *   
  9.  * @author 梁栋  
  10.  * @version 1.0  
  11.  * @since 1.0  
  12.  */  
  13. public class DSACoderTest {   
  14.   
  15.     @Test  
  16.     public void test() throws Exception {   
  17.         String inputStr = "abc";   
  18.         byte[] data = inputStr.getBytes();   
  19.   
  20.         // 构建密钥   
  21.         Map<String, Object> keyMap = DSACoder.initKey();   
  22.   
  23.         // 获得密钥   
  24.         String publicKey = DSACoder.getPublicKey(keyMap);   
  25.         String privateKey = DSACoder.getPrivateKey(keyMap);   
  26.   
  27.         System.err.println("公钥:/r" + publicKey);   
  28.         System.err.println("私钥:/r" + privateKey);   
  29.   
  30.         // 产生签名   
  31.         String sign = DSACoder.sign(data, privateKey);   
  32.         System.err.println("签名:/r" + sign);   
  33.   
  34.         // 验证签名   
  35.         boolean status = DSACoder.verify(data, publicKey, sign);   
  36.         System.err.println("状态:/r" + status);   
  37.         assertTrue(status);   
  38.   
  39.     }   
  40.   
  41. }  
import static org.junit.Assert.*;

import java.util.Map;

import org.junit.Test;

/**
 * 
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
public class DSACoderTest {

	@Test
	public void test() throws Exception {
		String inputStr = "abc";
		byte[] data = inputStr.getBytes();

		// 构建密钥
		Map<String, Object> keyMap = DSACoder.initKey();

		// 获得密钥
		String publicKey = DSACoder.getPublicKey(keyMap);
		String privateKey = DSACoder.getPrivateKey(keyMap);

		System.err.println("公钥:/r" + publicKey);
		System.err.println("私钥:/r" + privateKey);

		// 产生签名
		String sign = DSACoder.sign(data, privateKey);
		System.err.println("签名:/r" + sign);

		// 验证签名
		boolean status = DSACoder.verify(data, publicKey, sign);
		System.err.println("状态:/r" + status);
		assertTrue(status);

	}

}

控制台输出：
Console代码 复制代码
  1. 公钥:   
  2. MIIBtzCCASwGByqGSM44BAEwggEfAoGBAP1/U4EddRIpUt9KnC7s5Of2EbdSPO9EAMMeP4C2USZp   
  3. RV1AIlH7WT2NWPq/xfW6MPbLm1Vs14E7gB00b/JmYLdrmVClpJ+f6AR7ECLCT7up1/63xhv4O1fn   
  4. xqimFQ8E+4P208UewwI1VBNaFpEy9nXzrith1yrv8iIDGZ3RSAHHAhUAl2BQjxUjC8yykrmCouuE   
  5. C/BYHPUCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCBgLRJ   
  6. FnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhRkImo   
  7. g9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoDgYQAAoGAIu4RUlcQLp49PI0MrbssOY+3uySVnp0TULSv   
  8. 5T4VaHoKzsLHgGTrwOvsGA+V3yCNl2WDu3D84bSLF7liTWgOj+SMOEaPk4VyRTlLXZWGPsf1Mfd9   
  9. 21XAbMeVyKDSHHVGbMjBScajf3bXooYQMlyoHiOt/WrCo+mv7efstMM0PGo=   
  10.   
  11. 私钥:   
  12. MIIBTAIBADCCASwGByqGSM44BAEwggEfAoGBAP1/U4EddRIpUt9KnC7s5Of2EbdSPO9EAMMeP4C2   
  13. USZpRV1AIlH7WT2NWPq/xfW6MPbLm1Vs14E7gB00b/JmYLdrmVClpJ+f6AR7ECLCT7up1/63xhv4   
  14. O1fnxqimFQ8E+4P208UewwI1VBNaFpEy9nXzrith1yrv8iIDGZ3RSAHHAhUAl2BQjxUjC8yykrmC   
  15. ouuEC/BYHPUCgYEA9+GghdabPd7LvKtcNrhXuXmUr7v6OuqC+VdMCz0HgmdRWVeOutRZT+ZxBxCB   
  16. gLRJFnEj6EwoFhO3zwkyjMim4TwWeotUfI0o4KOuHiuzpnWRbqN/C/ohNWLx+2J6ASQ7zKTxvqhR   
  17. kImog9/hWuWfBpKLZl6Ae1UlZAFMO/7PSSoEFwIVAIegLUtmm2oQKQJTOiLugHTSjl/q   
  18.   
  19. 签名:   
  20. MC0CFQCMg0J/uZmF8GuRpr3TNq48w60nDwIUJCyYNah+HtbU6NcQfy8Ac6LeLQs=   
  21.   
  22. 状态:   
  23. true  


注意状态为true，就验证成功！

相关链接：
Java加密技术（一）
Java加密技术（二）
Java加密技术（三）
Java加密技术（四）
Java加密技术（五）
Java加密技术（六）
Java加密技术（七）
Java加密技术（八）
Java加密技术（九）
Java加密技术（十）
yzhjisji
关注
专栏目录
java securerandom使用_SecureRandom的正确使用
weixin_34174789的博客
02-26 3745
1. 什么是安全的随机数？在安全应用场景，随机数应该使用安全的随机数。密码学意义上的安全随机数，要求必须保证其不可预测性。2. 怎么得到安全的随机数可以直接使用真随机数产生器产生的随机数。或者使用真随机数产生器产生的随机数做种子，输入密码学安全的伪随机数产生器产生密码学安全随机数。非物理真随机数产生器有：Linux操作系统的/dev/random设备接口Windows操作系统的CryptGenRa...
java加密技术
08-31
Java加密技术是Java编程语言中用于保障数据安全的一系列加密方法和技术，它包括了单向加密算法、对称加密算法、非对称加密算法以及加密算法的高级应用如数字签名和数字证书等。本文将详细介绍这些加密技术，并结合...
加密强随机数 SecureRandom 详解
chenshun123的博客
06-12 2208
加密强随机数 SecureRandom
SecureRandom漏洞解析
fishmai的专栏
08-21 2707
 SecureRandom漏洞描述       2013年比特币开发商在一篇博客中透露，由于Android系统存在一处关键漏洞，该平台上的比特币电子钱包很容易失窃。比特币开发商称，该漏洞影响到Android平台上的每一个比特币电子钱包应用程序，包括流行的比特币钱包（Bitcoin Wallet）、blockchain.info钱包（blockchain.info wallet）、Bitco
加密与安全_解密AES加密中的IV和Seed
最新发布
小工匠
08-21 2745
在AES加密中，**IV（Initialization Vector，初始化向量）和Seed（种子）**是两个不同的概念，尽管它们都涉及到随机性和加密安全性，但用途和作用有所不同。
SecureRandom--生成随机数
PJF1501105594的博客
02-28 9105
*使用不当的方式* byte[] salt = new byte[128]; SecureRandom secureRandom = new SecureRandom(); secureRandom.setSeed(System.currentTimeMillis()); //使用系统时间作为种子 secureRandom.nextBytes(salt); 为什么？ 此处指定...
Java生成随机数SecureRandom
weixin_43392676的博客
10-03 2375
Java生成随机数 一、使用math方法，Math.random()随机生成一个double类型[0，1) int num = (int)(Math.random()*99); //生成1~99的随机数 二、使用Random方法生成随机数 public static void testRandom() { Random random = new Random(); random.setSeed(100L); for(int i = 0 ; i <
Java加密技术
03-24
Java加密技术是软件开发中一个重要的领域，尤其是在处理敏感数据、网络安全和隐私保护时不可或缺。在Java中，加密主要依赖于Java Cryptography Architecture (JCA) 和 Java Cryptography Extension (JCE)。JCA提供了...
JAVA加密技术.docx
11-20
在Java编程中，加密技术是确保信息安全的关键组成部分。本文将探讨几种常见的加密算法，包括单向加密和对称及非对称加密算法。首先，我们来看基础的单向加密算法，如BASE64、MD5、SHA和HMAC。 **BASE64** 是一种...
Java加密技术详解（参考文档）
08-24
2.2 Java 中的非对称加密Java 提供了 KeyPairGenerator 类用于生成公钥和私钥对，Cipher 类用于进行加密和解密操作。以下是一个简单的 RSA 加密示例：```javaimport java.security.KeyPair;import java.security....
Java SecureRandom的合理使用
dac55300424的专栏
09-06 8725
Proper use of Java SecureRandom August 14, 2009 Categories: Security Best Practices, Software Security Tags: java, securerandom When generating random numbers in Java for cryptogr
加密强随机数 SecureRandom
简简单单Onlinezuozuo
12-11 6658
文章目录加密强随机数 SecureRandom1、SecureRandom 应用场景2、如何创建 SecureRandom 实例3、正确使用的示例 加密强随机数 SecureRandom 1、SecureRandom 应用场景 第一个，由于当种子相同的时候，生成的随机数完全相同 第二个，当随机数生成量较大时，Random存在性能问题 所以，当需要大量随机数且对随机数安全性有要求的时候，使用Sec...
Java 8 SecureRandom 生成随机数
热门推荐
Hatsune_Miku_的博客
06-19 3万+
Java 8的SecureRandom API对原有的有几个变化 根据Oracle，已经做出了以下有趣的变化： 对于类UNIX平台，已经引入了两个新的实现，它们提供了阻塞和非阻塞行为：NativePRNGBlocking和NativePRNGNonBlocking。所述getInstanceStrong（）方法是在JDK 8中引入此方法返回的每个平台上可用的最强SecureRa
java.securityt SecureRandom类详解
kzcming的博客
04-26 7410
SecureRandom类介绍jdk 1.6 doc介绍:此类提供强加密生成器(RNG)强加密:根据rfc 1750 描述:任何传递给secureRandom对象的种子材料必须是不可预知的,所有SecureRandom对象输出的输出序列必须是强加密的对象获取:可通过无参构造或getInstance()方法获得对象方法:generateSeed(int size);返回给定的种子字节数量getAlg...
JAVA基础(37) 如何解决SecureRandom性能问题
babyZeng
09-29 4109
一、背景描述 近期对接微信二维码支付的接口，发现一个奇怪的问题: 现象为有一工具类定义了一个变量UUID,linux机器初始化贼慢，window机器下很正常，linux执行记录为: 每次项目重启后，首次加载该类时，执行时间很久，但第二次之后就一切正常..... 怀着好奇的心情，记录下这次经过，方便以后查阅。 二、代码分析 QRCodeUtils.java
加密法随机数生成器
keyu0915的专栏
08-26 3231
除了传统的线性同余法（即C语言里的rand())产生伪随机数外，还可以用密码来编写能够生成强伪随机数的伪随机 数生成器。密码的机密性是支撑伪随机数生成器不可预测性的基础。原理如下图： 有关的DES 的 openssl API和数据结构: openssl 有关的DES 的API和数据结构 void DES_string_to_
java中setseed,浅析五种最常用的Java加密算法，以后可以直接拿来用了
weixin_35834687的博客
03-21 561
听说微信搜索《Java鱼仔》会变更强哦！本文收录于JavaStarter ，里面有我完整的Java系列文章，学习或面试都可以看看哦(一)关于加密算法信息加密是现在几乎所有项目都需要用到的技术，身份认证、单点登陆、信息通讯、支付交易等场景中经常会需要用到加密算法，所谓加密算法，就是将原本的明文通过一系列算法操作变成密文。接下来就介绍一下目前比较常用的一些加密算法，本期不涉及算法底层，以应用介绍和代码...
Java ECC加密技术探索与实现
"Java加密技术第四部分，主要探讨了椭圆曲线加密算法(ECC)在Java中的应用。ECC是一种高效的公钥加密体制，尤其在软件注册保护和生成序列号等方面有广泛应用。虽然Java从1.5版本开始支持ECC，但其加密/解密操作通常...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值