java RSA加密生成license,用CPU序列号生成机器码

license里就是一些注册信息，键值对组成的字符串

对称加密：

DES，AES，加密解密都用一个秘钥，速度快

非对称机密

RSA，可以私钥加密公钥解密，也可以公钥机密私钥解密，速度慢

注意：
RSA加密明文最大长度117字节，解密要求密文最大长度为128字节，所以在加密和解密的过程中需要分块进行。
RSA加密对明文的长度是有限制的，如果加密数据过大会抛出异常：

常见加密算法

DES 

    DES是Data Encryption Standard（数据加密标准）的缩写，DES算法为密码体制中的对称密码体制。它是由IBM公司研制的一种加密算法，美国国家标准局于1977年公布把它作为非机要部门使用的数据加密标准，二十年来，它一直活跃在国际保密通信的舞台上，扮演了十分重要的角色。
    DES是一个分组加密算法，他以64位为分组对数据加密。同时DES也是一个对称算法：加密和解密用的是同一个算法。它的密匙长度是56位（因为每个第8位都用作奇偶校验），密匙可以是任意的56位的数，而且可以任意时候改变。其中有极少量的数被认为是弱密匙，但是很容易避开他们。所以保密性依赖于密钥。
    特点：分组比较短、密钥太短、密码生命周期短、运算速度较慢。
　　DES算法具有极高安全性，到目前为止，除了用穷举搜索法对DES算法进行攻击外，还没有发现更有效的办法。而56位长的密钥的穷举空间为256，这意味着如果一台计算机的速度是每一秒种检测一百万个密钥，则它搜索完全部密钥就需要将近2285年的时间。

    DES现在已经不视为一种安全的加密算法，因为它使用的56位秘钥过短，以现代计算能力，24小时内即可能被破解。也有一些分析报告提出了该算法的理论上的弱点，虽然实际情况未必出现。该标准在最近已经被高级加密标准（AES）所取代。

AES

    高级加密标准（Advanced Encryption Standard，AES），又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。2006年，高级加密标准已然成为对称密钥加密中最流行的算法之一。

    AES的区块长度固定为128 位元，密钥长度则可以是128，192或256位元。

RSA

    RSA加密算法是一种非对称加密算法。在公钥加密标准和电子商业中RSA被广泛使用。RSA是1977年由罗纳德·李维斯特（Ron Rivest）、阿迪·萨莫尔（Adi Shamir）和伦纳德·阿德曼（Leonard Adleman）一起提出的。当时他们三人都在麻省理工学院工作。RSA就是他们三人姓氏开头字母拼在一起组成的。

    RSA算法的可靠性基于分解极大的整数是很困难的。假如有人找到一种很快的分解因子的算法的话，那么用RSA加密的信息的可靠性就肯定会极度下降。但找到这样的算法的可能性是非常小的。今天只有短的RSA钥匙才可能被强力方式解破。到2008年为止，世界上还没有任何可靠的攻击RSA算法的方式。只要其钥匙的长度足够长，用RSA加密的信息实际上是不能被解破的。

    RSA算法利用两个很大的质数相乘所产生的乘积来加密。这两个质数无论哪一个先与原文件编码相乘，对文件加密，均可由另一个质数再相乘来解密。但要用一个质数来求出另一个质数，则是十分困难的。因此将这一对质数称为密钥对(Key Pair)。在加密应用时，某个用户总是将一个密钥公开，让需发信的人员将信息用其公共密钥加密后发给该用户，而一旦信息加密后，只有用该用户一个人知道的私用密钥才能解密。具有数字凭证身份的人员的公共密钥可在网上查到，亦可在请对方发信息时主动将公共密钥传给对方，这样保证在Internet上传输信息的保密和安全。

本文采用RSA加密算法加密license信息，可以运行RSATester.java生成公钥和私钥。
RSAUtils.java

1. import java.io.ByteArrayOutputStream;  
2. import java.security.Key;  
3. import java.security.KeyFactory;  
4. import java.security.KeyPair;  
5. import java.security.KeyPairGenerator;  
6. import java.security.PrivateKey;  
7. import java.security.PublicKey;  
8. import java.security.Signature;  
9. import java.security.interfaces.RSAPrivateKey;  
10. import java.security.interfaces.RSAPublicKey;  
11. import java.security.spec.PKCS8EncodedKeySpec;  
12. import java.security.spec.X509EncodedKeySpec;  
13. import java.util.HashMap;  
14. import java.util.Map;  
15.   
16. import javax.crypto.Cipher;  
17.   
18. /** *//** 
19.  * <p> 
20.  * RSA公钥/私钥/签名工具包 
21.  * </p> 
22.  * <p> 
23.  * 罗纳德·李维斯特（Ron [R]ivest）、阿迪·萨莫尔（Adi [S]hamir）和伦纳德·阿德曼（Leonard [A]dleman） 
24.  * </p> 
25.  * <p> 
26.  * 字符串格式的密钥在未在特殊说明情况下都为BASE64编码格式<br/> 
27.  * 由于非对称加密速度极其缓慢，一般文件不使用它来加密而是使用对称加密，<br/> 
28.  * 非对称加密算法可以用来对对称加密的密钥加密，这样保证密钥的安全也就保证了数据的安全 
29.  * </p> 
30.  *  
31.  * @author IceWee 
32.  * @date 2012-4-26 
33.  * @version 1.0 
34.  */  
35. public class RSAUtils {  
36.   
37.     /** *//** 
38.      * 加密算法RSA 
39.      */  
40.     public static final String KEY_ALGORITHM = "RSA";  
41.       
42.     /** *//** 
43.      * 签名算法 
44.      */  
45.     public static final String SIGNATURE_ALGORITHM = "MD5withRSA";  
46.   
47.     /** *//** 
48.      * 获取公钥的key 
49.      */  
50.     private static final String PUBLIC_KEY = "RSAPublicKey";  
51.       
52.     /** *//** 
53.      * 获取私钥的key 
54.      */  
55.     private static final String PRIVATE_KEY = "RSAPrivateKey";  
56.       
57.     /** *//** 
58.      * RSA最大加密明文大小 
59.      */  
60.     private static final int MAX_ENCRYPT_BLOCK = 117;  
61.       
62.     /** *//** 
63.      * RSA最大解密密文大小 
64.      */  
65.     private static final int MAX_DECRYPT_BLOCK = 128;  
66.   
67.     /** *//** 
68.      * <p> 
69.      * 生成密钥对(公钥和私钥) 
70.      * </p> 
71.      *  
72.      * @return 
73.      * @throws Exception 
74.      */  
75.     public static Map<String, Object> genKeyPair() throws Exception {  
76.         KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);  
77.         keyPairGen.initialize(1024);  
78.         KeyPair keyPair = keyPairGen.generateKeyPair();  
79.         RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  
80.         RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();  
81.         Map<String, Object> keyMap = new HashMap<String, Object>(2);  
82.         keyMap.put(PUBLIC_KEY, publicKey);  
83.         keyMap.put(PRIVATE_KEY, privateKey);  
84.         return keyMap;  
85.     }  
86.       
87.     /** *//** 
88.      * <p> 
89.      * 用私钥对信息生成数字签名 
90.      * </p> 
91.      *  
92.      * @param data 已加密数据 
93.      * @param privateKey 私钥(BASE64编码) 
94.      *  
95.      * @return 
96.      * @throws Exception 
97.      */  
98.     public static String sign(byte[] data, String privateKey) throws Exception {  
99.         byte[] keyBytes = Base64Utils.decode(privateKey);  
100.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  
101.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
102.         PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);  
103.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);  
104.         signature.initSign(privateK);  
105.         signature.update(data);  
106.         return Base64Utils.encode(signature.sign());  
107.     }  
108.   
109.     /** *//** 
110.      * <p> 
111.      * 校验数字签名 
112.      * </p> 
113.      *  
114.      * @param data 已加密数据 
115.      * @param publicKey 公钥(BASE64编码) 
116.      * @param sign 数字签名 
117.      *  
118.      * @return 
119.      * @throws Exception 
120.      *  
121.      */  
122.     public static boolean verify(byte[] data, String publicKey, String sign)  
123.             throws Exception {  
124.         byte[] keyBytes = Base64Utils.decode(publicKey);  
125.         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);  
126.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
127.         PublicKey publicK = keyFactory.generatePublic(keySpec);  
128.         Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);  
129.         signature.initVerify(publicK);  
130.         signature.update(data);  
131.         return signature.verify(Base64Utils.decode(sign));  
132.     }  
133.   
134.     /** *//** 
135.      * <P> 
136.      * 私钥解密 
137.      * </p> 
138.      *  
139.      * @param encryptedData 已加密数据 
140.      * @param privateKey 私钥(BASE64编码) 
141.      * @return 
142.      * @throws Exception 
143.      */  
144.     public static byte[] decryptByPrivateKey(byte[] encryptedData, String privateKey)  
145.             throws Exception {  
146.         byte[] keyBytes = Base64Utils.decode(privateKey);  
147.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  
148.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
149.         Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);  
150.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
151.         cipher.init(Cipher.DECRYPT_MODE, privateK);  
152.         int inputLen = encryptedData.length;  
153.         ByteArrayOutputStream out = new ByteArrayOutputStream();  
154.         int offSet = 0;  
155.         byte[] cache;  
156.         int i = 0;  
157.         // 对数据分段解密  
158.         while (inputLen - offSet > 0) {  
159.             if (inputLen - offSet > MAX_DECRYPT_BLOCK) {  
160.                 cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);  
161.             } else {  
162.                 cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);  
163.             }  
164.             out.write(cache, 0, cache.length);  
165.             i++;  
166.             offSet = i * MAX_DECRYPT_BLOCK;  
167.         }  
168.         byte[] decryptedData = out.toByteArray();  
169.         out.close();  
170.         return decryptedData;  
171.     }  
172.   
173.     /** *//** 
174.      * <p> 
175.      * 公钥解密 
176.      * </p> 
177.      *  
178.      * @param encryptedData 已加密数据 
179.      * @param publicKey 公钥(BASE64编码) 
180.      * @return 
181.      * @throws Exception 
182.      */  
183.     public static byte[] decryptByPublicKey(byte[] encryptedData, String publicKey)  
184.