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

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.             throws Exception {  
  185.         byte[] keyBytes = Base64Utils.decode(publicKey);  
  186.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);  
  187.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
  188.         Key publicK = keyFactory.generatePublic(x509KeySpec);  
  189.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
  190.         cipher.init(Cipher.DECRYPT_MODE, publicK);  
  191.         int inputLen = encryptedData.length;  
  192.         ByteArrayOutputStream out = new ByteArrayOutputStream();  
  193.         int offSet = 0;  
  194.         byte[] cache;  
  195.         int i = 0;  
  196.         // 对数据分段解密  
  197.         while (inputLen - offSet > 0) {  
  198.             if (inputLen - offSet > MAX_DECRYPT_BLOCK) {  
  199.                 cache = cipher.doFinal(encryptedData, offSet, MAX_DECRYPT_BLOCK);  
  200.             } else {  
  201.                 cache = cipher.doFinal(encryptedData, offSet, inputLen - offSet);  
  202.             }  
  203.             out.write(cache, 0, cache.length);  
  204.             i++;  
  205.             offSet = i * MAX_DECRYPT_BLOCK;  
  206.         }  
  207.         byte[] decryptedData = out.toByteArray();  
  208.         out.close();  
  209.         return decryptedData;  
  210.     }  
  211.   
  212.     /** *//** 
  213.      * <p> 
  214.      * 公钥加密 
  215.      * </p> 
  216.      *  
  217.      * @param data 源数据 
  218.      * @param publicKey 公钥(BASE64编码) 
  219.      * @return 
  220.      * @throws Exception 
  221.      */  
  222.     public static byte[] encryptByPublicKey(byte[] data, String publicKey)  
  223.             throws Exception {  
  224.         byte[] keyBytes = Base64Utils.decode(publicKey);  
  225.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);  
  226.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
  227.         Key publicK = keyFactory.generatePublic(x509KeySpec);  
  228.         // 对数据加密  
  229.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
  230.         cipher.init(Cipher.ENCRYPT_MODE, publicK);  
  231.         int inputLen = data.length;  
  232.         ByteArrayOutputStream out = new ByteArrayOutputStream();  
  233.         int offSet = 0;  
  234.         byte[] cache;  
  235.         int i = 0;  
  236.         // 对数据分段加密  
  237.         while (inputLen - offSet > 0) {  
  238.             if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {  
  239.                 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);  
  240.             } else {  
  241.                 cache = cipher.doFinal(data, offSet, inputLen - offSet);  
  242.             }  
  243.             out.write(cache, 0, cache.length);  
  244.             i++;  
  245.             offSet = i * MAX_ENCRYPT_BLOCK;  
  246.         }  
  247.         byte[] encryptedData = out.toByteArray();  
  248.         out.close();  
  249.         return encryptedData;  
  250.     }  
  251.   
  252.     /** *//** 
  253.      * <p> 
  254.      * 私钥加密 
  255.      * </p> 
  256.      *  
  257.      * @param data 源数据 
  258.      * @param privateKey 私钥(BASE64编码) 
  259.      * @return 
  260.      * @throws Exception 
  261.      */  
  262.     public static byte[] encryptByPrivateKey(byte[] data, String privateKey)  
  263.             throws Exception {  
  264.         byte[] keyBytes = Base64Utils.decode(privateKey);  
  265.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  
  266.         KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);  
  267.         Key privateK = keyFactory.generatePrivate(pkcs8KeySpec);  
  268.         Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());  
  269.         cipher.init(Cipher.ENCRYPT_MODE, privateK);  
  270.         int inputLen = data.length;  
  271.         ByteArrayOutputStream out = new ByteArrayOutputStream();  
  272.         int offSet = 0;  
  273.         byte[] cache;  
  274.         int i = 0;  
  275.         // 对数据分段加密  
  276.         while (inputLen - offSet > 0) {  
  277.             if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {  
  278.                 cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);  
  279.             } else {  
  280.                 cache = cipher.doFinal(data, offSet, inputLen - offSet);  
  281.             }  
  282.             out.write(cache, 0, cache.length);  
  283.             i++;  
  284.             offSet = i * MAX_ENCRYPT_BLOCK;  
  285.         }  
  286.         byte[] encryptedData = out.toByteArray();  
  287.         out.close();  
  288.         return encryptedData;  
  289.     }  
  290.   
  291.     /** *//** 
  292.      * <p> 
  293.      * 获取私钥 
  294.      * </p> 
  295.      *  
  296.      * @param keyMap 密钥对 
  297.      * @return 
  298.      * @throws Exception 
  299.      */  
  300.     public static String getPrivateKey(Map<String, Object> keyMap)  
  301.             throws Exception {  
  302.         Key key = (Key) keyMap.get(PRIVATE_KEY);  
  303.         return Base64Utils.encode(key.getEncoded());  
  304.     }  
  305.   
  306.     /** *//** 
  307.      * <p> 
  308.      * 获取公钥 
  309.      * </p> 
  310.      *  
  311.      * @param keyMap 密钥对 
  312.      * @return 
  313.      * @throws Exception 
  314.      */  
  315.     public static String getPublicKey(Map<String, Object> keyMap)  
  316.             throws Exception {  
  317.         Key key = (Key) keyMap.get(PUBLIC_KEY);  
  318.         return Base64Utils.encode(key.getEncoded());  
  319.     }  
  320.   
  321. }  

 

 Base64Utils.java

Java代码  收藏代码
  1. import java.io.ByteArrayInputStream;  
  2. import java.io.ByteArrayOutputStream;  
  3. import java.io.File;  
  4. import java.io.FileInputStream;  
  5. import java.io.FileOutputStream;  
  6. import java.io.InputStream;  
  7. import java.io.OutputStream;  
  8.   
  9. //import it.sauronsoftware.base64.Base64;  
  10. import sun.misc.BASE64Decoder;  
  11. import sun.misc.BASE64Encoder;  
  12. //若报错,编译路径移除jdk,再添加jdk  
  13.   
  14. /** *//** 
  15.  * <p> 
  16.  * BASE64编码解码工具包 
  17.  * </p> 
  18.  * <p> 
  19.  * 依赖javabase64-1.3.1.jar 或 common-codec 
  20.  * </p> 
  21.  *  
  22.  * @author IceWee 
  23.  * @date 2012-5-19 
  24.  * @version 1.0 
  25.  */  
  26. public class Base64Utils {  
  27.   
  28.     /** *//** 
  29.      * 文件读取缓冲区大小 
  30.      */  
  31.     private static final int CACHE_SIZE = 1024;  
  32.       
  33.     /** *//** 
  34.      * <p> 
  35.      * BASE64字符串解码为二进制数据 
  36.      * </p> 
  37.      *  
  38.      * @param base64 
  39.      * @return 
  40.      * @throws Exception 
  41.      */  
  42.     public static byte[] decode(String base64) throws Exception {  
  43.         //return Base64.decode(base64.getBytes());  
  44.         return new BASE64Decoder().decodeBuffer(base64);  
  45.     }  
  46.       
  47.     /** *//** 
  48.      * <p> 
  49.      * 二进制数据编码为BASE64字符串 
  50.      * </p> 
  51.      *  
  52.      * @param bytes 
  53.      * @return 
  54.      * @throws Exception 
  55.      */  
  56.     public static String encode(byte[] bytes) throws Exception {  
  57.         //return new String(Base64.encode(bytes));  
  58.         return new BASE64Encoder().encode(bytes);  
  59.     }  
  60.       
  61.     /** *//** 
  62.      * <p> 
  63.      * 将文件编码为BASE64字符串 
  64.      * </p> 
  65.      * <p> 
  66.      * 大文件慎用,可能会导致内存溢出 
  67.      * </p> 
  68.      *  
  69.      * @param filePath 文件绝对路径 
  70.      * @return 
  71.      * @throws Exception 
  72.      */  
  73.     public static String encodeFile(String filePath) throws Exception {  
  74.         byte[] bytes = fileToByte(filePath);  
  75.         return encode(bytes);  
  76.     }  
  77.       
  78.     /** *//** 
  79.      * <p> 
  80.      * BASE64字符串转回文件 
  81.      * </p> 
  82.      *  
  83.      * @param filePath 文件绝对路径 
  84.      * @param base64 编码字符串 
  85.      * @throws Exception 
  86.      */  
  87.     public static void decodeToFile(String filePath, String base64) throws Exception {  
  88.         byte[] bytes = decode(base64);  
  89.         byteArrayToFile(bytes, filePath);  
  90.     }  
  91.       
  92.     /** *//** 
  93.      * <p> 
  94.      * 文件转换为二进制数组 
  95.      * </p> 
  96.      *  
  97.      * @param filePath 文件路径 
  98.      * @return 
  99.      * @throws Exception 
  100.      */  
  101.     public static byte[] fileToByte(String filePath) throws Exception {  
  102.         byte[] data = new byte[0];  
  103.         File file = new File(filePath);  
  104.         if (file.exists()) {  
  105.             FileInputStream in = new FileInputStream(file);  
  106.             ByteArrayOutputStream out = new ByteArrayOutputStream(2048);  
  107.             byte[] cache = new byte[CACHE_SIZE];  
  108.             int nRead = 0;  
  109.             while ((nRead = in.read(cache)) != -1) {  
  110.                 out.write(cache, 0, nRead);  
  111.                 out.flush();  
  112.             }  
  113.             out.close();  
  114.             in.close();  
  115.             data = out.toByteArray();  
  116.          }  
  117.         return data;  
  118.     }  
  119.       
  120.     /** *//** 
  121.      * <p> 
  122.      * 二进制数据写文件 
  123.      * </p> 
  124.      *  
  125.      * @param bytes 二进制数据 
  126.      * @param filePath 文件生成目录 
  127.      */  
  128.     public static void byteArrayToFile(byte[] bytes, String filePath) throws Exception {  
  129.         InputStream in = new ByteArrayInputStream(bytes);     
  130.         File destFile = new File(filePath);  
  131. //        if (!destFile.getParentFile().exists()) {  
  132. //            destFile.getParentFile().mkdirs();  
  133. //        }  
  134.         destFile.createNewFile();  
  135.         OutputStream out = new FileOutputStream(destFile);  
  136.         byte[] cache = new byte[CACHE_SIZE];  
  137.         int nRead = 0;  
  138.         while ((nRead = in.read(cache)) != -1) {     
  139.             out.write(cache, 0, nRead);  
  140.             out.flush();  
  141.         }  
  142.         out.close();  
  143.         in.close();  
  144.     }  
  145.       
  146.       
  147. }  

 

RSATester.java

Java代码  收藏代码
  1. import java.util.Map;  
  2.   
  3. public class RSATester {  
  4.   
  5.     static String publicKey;  
  6.     static String privateKey;  
  7.   
  8.     static {  
  9.         try {  
  10.             Map<String, Object> keyMap = RSAUtils.genKeyPair();  
  11.             publicKey = RSAUtils.getPublicKey(keyMap);  
  12.             privateKey = RSAUtils.getPrivateKey(keyMap);  
  13.             System.err.println("公钥: \n\r" + publicKey);  
  14.             System.err.println("私钥: \n\r" + privateKey);  
  15.         } catch (Exception e) {  
  16.             e.printStackTrace();  
  17.         }  
  18.     }  
  19.       
  20.     public static void main(String[] args) throws Exception {  
  21.         test();  
  22.         testSign();  
  23.     }  
  24.   
  25.     static void test() throws Exception {  
  26.         System.err.println("公钥加密——私钥解密");  
  27.         String source = "这是一行没有任何意义的文字,你看完了等于没看,不是吗?";  
  28.         System.out.println("\r加密前文字:\r\n" + source);  
  29.         byte[] data = source.getBytes();  
  30.         byte[] encodedData = RSAUtils.encryptByPublicKey(data, publicKey);  
  31.         System.out.println("加密后文字:\r\n" + new String(encodedData));  
  32.         byte[] decodedData = RSAUtils.decryptByPrivateKey(encodedData, privateKey);  
  33.         String target = new String(decodedData);  
  34.         System.out.println("解密后文字: \r\n" + target);  
  35.     }  
  36.   
  37.     static void testSign() throws Exception {  
  38.         System.err.println("私钥加密——公钥解密");  
  39.         String source = "这是一行测试RSA数字签名的无意义文字";  
  40.         System.out.println("原文字:\r\n" + source);  
  41.         byte[] data = source.getBytes();  
  42.         byte[] encodedData = RSAUtils.encryptByPrivateKey(data, privateKey);  
  43.         System.out.println("加密后:\r\n" + new String(encodedData));  
  44.         byte[] decodedData = RSAUtils.decryptByPublicKey(encodedData, publicKey);  
  45.         String target = new String(decodedData);  
  46.         System.out.println("解密后: \r\n" + target);  
  47.         System.err.println("私钥签名——公钥验证签名");  
  48.         String sign = RSAUtils.sign(encodedData, privateKey);  
  49.         System.err.println("签名:\r" + sign);  
  50.         boolean status = RSAUtils.verify(encodedData, publicKey, sign);  
  51.         System.err.println("验证结果:\r" + status);  
  52.     }  
  53.       
  54. }  

 

运行此类生成license 

LicenseGenerator.java

Java代码  收藏代码
  1. import java.io.File;  
  2.   
  3. /** 
  4.  * 生成license 
  5.  * @author happyqing 
  6.  * 2014.6.15 
  7.  */  
  8. public class LicenseGenerator {  
  9.       
  10.     /** 
  11.      * serial:由客户提供 
  12.      * timeEnd:过期时间 
  13.      */  
  14.     private static String licensestatic = "serial=568b8fa5cdfd8a2623bda1d8ab7b7b34;" +  
  15.                                           "timeEnd=1404057600000";  
  16.       
  17.     private static final String publicKey = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCaa8y9g+ioR2OSs8njT5uCGWm0YmOA1elSu/P5\n"  
  18.             + "D3XYPCHsUPab74V5Og+NEZeTk9/LtG+jPSpKekTWm67gS2lQYWoygTwnoWsr4woaqNXmWw7L8Ty0\n"  
  19.             + "LQFTojZgyynvu2RSIJp4c76z6SV/khiP/ireGtt8uzXPswPO5uaPU38tQQIDAQAB";  
  20.       
  21.     /** 
  22.      * RSA算法 
  23.      * 公钥和私钥是一对,此处只用私钥加密 
  24.      */  
  25.     public static final String privateKey = "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAJprzL2D6KhHY5KzyeNPm4IZabRi\n"  
  26.             + "Y4DV6VK78/kPddg8IexQ9pvvhXk6D40Rl5OT38u0b6M9Kkp6RNabruBLaVBhajKBPCehayvjChqo\n"  
  27.             + "1eZbDsvxPLQtAVOiNmDLKe+7ZFIgmnhzvrPpJX+SGI/+Kt4a23y7Nc+zA87m5o9Tfy1BAgMBAAEC\n"  
  28.             + "gYAVnlfohEoTHQN0q1TtTNzRhutEhK23gLsMiSGr0Z1G64w4QFF2HT9LbHR25GqbD426QAWNDegY\n"  
  29.             + "yytN/DesUQJqNXx8vuEuqs7+MQDgKgJqpAx+Fg3Iwsk/SVjq7meaSVGCgPKhtWHJk5oXoRMpsrlT\n"  
  30.             + "AwUjpdpAZXIIKW3mrqkW0QJBANq4INw6lZlqRFtxT4uzYQYtzmB/nxMnCbL2SQ4ZQ/4CWlQpOnR/\n"  
  31.             + "mH2JxIBCVtTADFlPM0DWF4aoqykYs9tu2X0CQQC0vgEk8DpkQbh1kgIyBGWCqYSKISTSXia0rbYo\n"  
  32.             + "FPnzdldgtZVirNGNmiJGL8RPz0YKpZNOg9FLHq/oYXSNFI4VAkAJ4OcbC0pWc4ZC2wtMs/1d2hPI\n"  
  33.             + "J/t3UfwOKTGDgYCgqFqMEpChUmIAyYgmgtiJI2NrZThbZVAKtPOGF6eH8anBAkAbxkL4wS3H8E1/\n"  
  34.             + "S7OoqgJLZO9oJpW4+hzqkPM4D5klb58Xzm+pXTNKllAEBx0cwpZZ1n3fh+Qmrg2MIUW+1FTNAkBt\n"  
  35.             + "WECowLUqW014M96WsFpiof7kjteOBNOjFyxhIbx2eT7//bnrADfq2Xu1/mSedUKrjGr/O+FRi7PO\n"  
  36.             + "u7WhF6C9";  
  37.       
  38.     public static void generator() throws Exception {  
  39.         System.err.println("私钥加密——公钥解密");  
  40.         //String source = "568b8fa5cdfd8a2623bda1d8ab7b7b34";  
  41.         System.out.println("原文字:\r\n" + licensestatic);  
  42.         byte[] data = licensestatic.getBytes();  
  43.         byte[] encodedData = RSAUtils.encryptByPrivateKey(data, privateKey);  
  44.         System.out.println("加密后:\r\n" + new String(encodedData)); //加密后乱码是正常的  
  45.           
  46.         Base64Utils.byteArrayToFile(encodedData, FileUtil.getBasePath()+File.separator+"license.dat");  
  47.         System.out.println("license.dat:\r\n" + FileUtil.getBasePath()+File.separator+"license.dat");  
  48.           
  49.         //解密  
  50.         byte[] decodedData = RSAUtils.decryptByPublicKey(encodedData, publicKey);  
  51.         String target = new String(decodedData);  
  52.         System.out.println("解密后: \r\n" + target);  
  53.     }  
  54.       
  55.     public static void main(String[] args) throws Exception {  
  56.         generator();  
  57.     }  
  58. }  
  59.    

这里把解密逻辑也放这里了,实际上,公钥和解密逻辑应该放在软件运行的地方。


FileUtil.java

Java代码  收藏代码
  1. import java.io.File;  
  2. import java.io.FileInputStream;  
  3. import java.io.FileNotFoundException;  
  4. import java.io.IOException;  
  5. import java.io.UnsupportedEncodingException;  
  6. import java.net.URLDecoder;  
  7. import java.util.logging.Level;  
  8. import java.util.logging.Logger;  
  9.   
  10. /** 
  11.  * 文件工具类 
  12.  * @author happyqing 
  13.  */  
  14. public class FileUtil {  
  15.       
  16.     /** 
  17.      * 获得类的基路径,打成jar包也可以正确获得路径 
  18.      * @return  
  19.      */  
  20.     public static String getBasePath(){  
  21.         /* 
  22.         /D:/zhao/Documents/NetBeansProjects/docCompare/build/classes/ 
  23.         /D:/zhao/Documents/NetBeansProjects/docCompare/dist/bundles/docCompare/app/docCompare.jar 
  24.         */  
  25.         String filePath = FileUtil.class.getProtectionDomain().getCodeSource().getLocation().getFile();  
  26.           
  27.           
  28.         if (filePath.endsWith(".jar")){  
  29.             filePath = filePath.substring(0, filePath.lastIndexOf("/"));  
  30.             try {  
  31.                 filePath = URLDecoder.decode(filePath, "UTF-8"); //解决路径中有空格%20的问题  
  32.             } catch (UnsupportedEncodingException ex) {  
  33.   
  34.             }  
  35.   
  36.         }  
  37.         File file = new File(filePath);  
  38.         filePath = file.getAbsolutePath();  
  39.         return filePath;  
  40.     }  
  41.       
  42.     public static void main(String[] args) throws Exception {  
  43.         System.out.println(getBasePath());  
  44.     }  
  45. }  

 

serial是软件运行的地方提供的,

纯java获取CPU序列号,生成机器码

http://happyqing.iteye.com/blog/2080402

 

参考

http://www.blogjava.net/icewee/archive/2012/05/19/378570.html

 

一个简单的RSA加密类

http://yuncode.net/code/c_5049f78253ad762

RSAEncrypt.java

Java代码  收藏代码
  1. import java.security.KeyPair;  
  2. import java.security.KeyPairGenerator;  
  3. import java.security.interfaces.RSAPrivateKey;  
  4. import java.security.interfaces.RSAPublicKey;  
  5. import javax.crypto.Cipher;  
  6.   
  7. /** 
  8.  * RSA加密类 
  9.  */  
  10. public class RSAEncrypt {  
  11.     public static void main(String[] args) {  
  12.         try {  
  13.             RSAEncrypt encrypt = new RSAEncrypt();  
  14.             String encryptText = "12345678";  
  15.             KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");  
  16.             keyPairGen.initialize(1024);  
  17.             KeyPair keyPair = keyPairGen.generateKeyPair();  
  18.               
  19.             // Generate keys  
  20.             RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate(); // 私钥  
  21.             RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic(); // 公钥  
  22.             byte[] e = encrypt.encrypt(publicKey, encryptText.getBytes());  
  23.             byte[] de = encrypt.decrypt(privateKey, e);  
  24.             System.out.println(encrypt.bytesToString(e));  
  25.             System.out.println();  
  26.             System.out.println(encrypt.bytesToString(de));  
  27.         } catch (Exception e) {  
  28.             e.printStackTrace();  
  29.         }  
  30.     }  
  31.   
  32.     /** 
  33.      * byte数组转为string 
  34.      * @param encrytpByte 
  35.      * @return 
  36.      */  
  37.     protected String bytesToString(byte[] encrytpByte) {  
  38.         String result = "";  
  39.         for (Byte bytes : encrytpByte) {  
  40.             result += (char) bytes.intValue();  
  41.         }  
  42.         return result;  
  43.     }  
  44.   
  45.     /** 
  46.      * 加密方法 
  47.      * @param publicKey 
  48.      * @param obj 
  49.      * @return 
  50.      */  
  51.     protected byte[] encrypt(RSAPublicKey publicKey, byte[] obj) {  
  52.         if (publicKey != null) {  
  53.             try {  
  54.                 Cipher cipher = Cipher.getInstance("RSA");  
  55.                 cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
  56.                 return cipher.doFinal(obj);  
  57.             } catch (Exception e) {  
  58.                 e.printStackTrace();  
  59.             }  
  60.         }  
  61.         return null;  
  62.     }  
  63.   
  64.     /** 
  65.      * 解密方法 
  66.      * @param privateKey 
  67.      * @param obj 
  68.      * @return 
  69.      */  
  70.     protected byte[] decrypt(RSAPrivateKey privateKey, byte[] obj) {  
  71.         if (privateKey != null) {  
  72.             try {  
  73.                 Cipher cipher = Cipher.getInstance("RSA");  
  74.                 cipher.init(Cipher.DECRYPT_MODE, privateKey);  
  75.                 return cipher.doFinal(obj);  
  76.             } catch (Exception e) {  
  77.                 e.printStackTrace();  
  78.             }  
  79.         }  
  80.         return null;  
  81.     }  
  82. }  

 

说明:

公钥私钥要自己生成,别拷别人的

Over

发布了522 篇原创文章 · 获赞 1231 · 访问量 471万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: Age of Ai 设计师: meimeiellie

分享到微信朋友圈

×

扫一扫,手机浏览