android Rsa 算法加密

青旅半醒 2022-08-06 17:11 165阅读 0赞

首先我们可以从上图看到：明文--->公钥--->密文   密文-->密钥-->明文

RSA由于public key<公钥> 和private key<密钥>的不同<也叫非对称算法加解密>,极大的提高了文件的安全性。  对称算法是同key的 ,这样很容易被人破解。

RSA算法：

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.interfaces.RSAPrivateKey;   
8.  **import** java.security.interfaces.RSAPublicKey;   
9.  **import** java.security.spec.PKCS8EncodedKeySpec;   
10. **import** java.security.spec.X509EncodedKeySpec;   
11.     
12. **import** javax.crypto.Cipher;   
13.     
14. **import** sun.misc.BASE64Decoder;   
15. **import** sun.misc.BASE64Encoder;   
16.     
17.     
18. **public** **class** RSAHelper \{   
19.     
20.         
21.       **public** **static** PublicKey getPublicKey(String key) **throws** Exception \{   
22.             **byte**\[\] keyBytes;   
23.             keyBytes = (**new** BASE64Decoder()).decodeBuffer(key);   
24.     
25.             X509EncodedKeySpec keySpec = **new** X509EncodedKeySpec(keyBytes);   
26.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");   
27.             PublicKey publicKey = keyFactory.generatePublic(keySpec);   
28.             **return** publicKey;   
29.       \}   
30.         
31.       **public** **static** PrivateKey getPrivateKey(String key) **throws** Exception \{   
32.             **byte**\[\] keyBytes;   
33.             keyBytes = (**new** BASE64Decoder()).decodeBuffer(key);   
34.     
35.             PKCS8EncodedKeySpec keySpec = **new** PKCS8EncodedKeySpec(keyBytes);   
36.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");   
37.             PrivateKey privateKey = keyFactory.generatePrivate(keySpec);   
38.             **return** privateKey;   
39.       \}   
40.     
41.         
42.       **public** **static** String getKeyString(Key key) **throws** Exception \{   
43.             **byte**\[\] keyBytes = key.getEncoded();   
44.             String s = (**new** BASE64Encoder()).encode(keyBytes);   
45.             **return** s;   
46.       \}   
47.     
48.     
49.       **public** **static** **void** main(String\[\] args) **throws** Exception \{   
50.     
51.             KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA");   
52.             //密钥位数   
53.             keyPairGen.initialize(1024);   
54.             //密钥对   
55.             KeyPair keyPair = keyPairGen.generateKeyPair();   
56.     
57.             // 公钥   
58.             PublicKey publicKey = (RSAPublicKey) keyPair.getPublic();   
59.     
60.             // 私钥   
61.             PrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();   
62.     
63.             String publicKeyString = getKeyString(publicKey);   
64.             System.out.println("public:/n" \+ publicKeyString);   
65.     
66.             String privateKeyString = getKeyString(privateKey);   
67.             System.out.println("private:/n" \+ privateKeyString);   
68.     
69.             //加解密类   
70.             Cipher cipher = Cipher.getInstance("RSA");//Cipher.getInstance("RSA/ECB/PKCS1Padding");   
71.     
72.             //明文   
73.             **byte**\[\] plainText = "我们都很好！邮件：@sina.com".getBytes();   
74.     
75.             //加密   
76.             cipher.init(Cipher.ENCRYPT\_MODE, publicKey);   
77.             **byte**\[\] enBytes = cipher.doFinal(plainText);   
78.     
79.            //通过密钥字符串得到密钥   
80.             publicKey = getPublicKey(publicKeyString);   
81.             privateKey = getPrivateKey(privateKeyString);   
82.     
83.             //解密   
84.             cipher.init(Cipher.DECRYPT\_MODE, privateKey);   
85.             **byte**\[\]deBytes = cipher.doFinal(enBytes);   
86.     
87.             publicKeyString = getKeyString(publicKey);   
88.             System.out.println("public:/n" \+publicKeyString);   
89.     
90.             privateKeyString = getKeyString(privateKey);   
91.             System.out.println("private:/n" \+ privateKeyString);   
92.     
93.             String s = **new** String(deBytes);   
94.             System.out.println(s);   
95.     
96.     
97.       \}   
98.     
99. \}

在实际开发中！ 我们通过自己的modulus ,publicExponent 这两个是用户加密产生public key 而 privateExponet 用于产生private key  来开发的情况比较多。

1.  **import** java.math.BigInteger;   
2.    
3.  **import** java.security.KeyFactory;   
4.    
5.  **import** java.security.PrivateKey;   
6.    
7.  **import** java.security.PublicKey;   
8.    
9.  **import** java.security.spec.RSAPrivateKeySpec;   
10.   
11. **import** java.security.spec.RSAPublicKeySpec;   
12.   
13.     
14.   
15. **import** javax.crypto.Cipher;   
16.   
17.     
18.   
19. **public** **class** RsaKey \{   
20.   
21.     
22.   
23.       **public** PublicKey getPublicKey(String modulus,String publicExponent) **throws** Exception \{   
24.   
25.             BigInteger m = **new** BigInteger(modulus);   
26.   
27.             BigInteger e = **new** BigInteger(publicExponent);   
28.   
29.             RSAPublicKeySpec keySpec = **new** RSAPublicKeySpec(m,e);   
30.   
31.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");     
32.             PublicKey publicKey = keyFactory.generatePublic(keySpec);   
33.   
34.             **return** publicKey;   
35.   
36.       \}   
37.   
38.     
39.   
40.       **public** PrivateKey getPrivateKey(String modulus,String privateExponent) **throws** Exception \{   
41.   
42.             BigInteger m = **new** BigInteger(modulus);   
43.   
44.             BigInteger e = **new** BigInteger(privateExponent);   
45.   
46.             RSAPrivateKeySpec keySpec = **new** RSAPrivateKeySpec(m,e);   
47.   
48.             KeyFactory keyFactory = KeyFactory.getInstance("RSA");   
49.   
50.             PrivateKey privateKey = keyFactory.generatePrivate(keySpec);   
51.   
52.             **return** privateKey;   
53.   
54.       \}   
55.   
56.     
57.   
58.       **public** **static** **void** main(String\[\] args) **throws** Exception \{   
59.   
60.             String modulus = "10103166745709600780215616551837697832816413714471062522342538060943596036859967333870827790358555455232243383580565187280643159050869924436081447583051139";   
61.   
62.             String publicExponent = "65537";   
63.   
64.             String privateExponet = "367979294475011322800474185715497882523349856362702385535371444397399388741997039894583483410120364529325888461124714276674612930833020362278754665756193";   
65.   
66.     
67.   
68.             RsaKey key = **new** RsaKey();   
69.   
70.             PublicKey publicKey = key.getPublicKey(modulus, publicExponent);   
71.   
72.             PrivateKey privateKey = key.getPrivateKey(modulus, privateExponet);   
73.   
74.     
75.   
76.     
77.   
78.             //加解密类   
79.   
80.             Cipher cipher = Cipher.getInstance("RSA");   //"RSA/ECB/PKCS1Padding"   就是：“算法/工作模式/填充模式”
81.   
82.     
83.   
84.             //明文   
85.   
86.             **byte**\[\] plainText = "hello world !".getBytes();   
87.   
88.     
89.   
90.             //加密   
91.   
92.             cipher.init(Cipher.ENCRYPT\_MODE, publicKey);   
93.   
94.         **byte**\[\] enBytes = cipher.doFinal(plainText);   
95.   
96.     
97.   
98.     
99.   
100.         cipher.init(Cipher.DECRYPT\_MODE, privateKey);   
101.   
102.             **byte**\[\]deBytes = cipher.doFinal(enBytes);   
103.   
104.     
105.   
106.             String s = **new** String(deBytes);   
107.   
108.             System.out.println(s);   
109.   
110.     
111.   
112.       \}

1.  \}