Encryption and decryption using the RSA Algorithm on Android

First, we can see: plaintext ---> Public Key ---> ciphertext --> key --> plaintext

RSA greatly improves file security because of the differences between public key <Public Key> and private key <key> <also called asymmetric algorithm encryption and decryption>. Symmetric algorithms are of the same key, which can be easily cracked.

RSA algorithm:

 

1. ImportJava. Security. Key;
2. ImportJava. Security. keyfactory;
3. ImportJava. Security. keypair;
4. ImportJava. Security. keypairgenerator;
5. ImportJava. Security. privatekey;
6. ImportJava. Security. publickey;
7. ImportJava. Security. Interfaces. rsw.vatekey;
8. ImportJava. Security. Interfaces. rsapublickey;
9. ImportJava. Security. spec. pkcs8encodedkeyspec;
10. ImportJava. Security. spec. x509encodedkeyspec;
12. ImportJavax. crypto. cipher;
14. ImportSun. Misc. base64decoder;
15. ImportSun. Misc. base64encoder;
18. Public ClassRsahelper {
21. Public StaticPublickey getpublickey (string key)ThrowsException {
22. Byte[] Keybytes;
23. Keybytes = (NewBase64decoder (). decodebuffer (key );
25. X509encodedkeyspec keyspec =NewX509encodedkeyspec (keybytes );
26. Keyfactory = keyfactory. getinstance ("RSA ");
27. Publickey = keyfactory. generatepublic (keyspec );
28. ReturnPublickey;
29. }
31. Public StaticPrivatekey getprivatekey (string key)ThrowsException {
32. Byte[] Keybytes;
33. Keybytes = (NewBase64decoder (). decodebuffer (key );
35. Pkcs8encodedkeyspec keyspec =NewPkcs8encodedkeyspec (keybytes );
36. Keyfactory = keyfactory. getinstance ("RSA ");
37. Privatekey = keyfactory. generateprivate (keyspec );
38. ReturnPrivatekey;
39. }
42. Public StaticString getkeystring (Key key)ThrowsException {
43. Byte[] Keybytes = key. getencoded ();
44. String S = (NewBase64encoder (). encode (keybytes );
45. ReturnS;
46. }
49. Public Static VoidMain (string [] ARGs)ThrowsException {
51. Keypairgenerator keypairgen = keypairgenerator. getinstance ("RSA ");
52. // Number of keys
53. Keypairgen. initialize (1024 );
54. // Key pair
55. Keypair = keypairgen. generatekeypair ();
57. // Public Key
58. Publickey = (rsapublickey) keypair. getpublic ();
60. // Private Key
61. Privatekey = (rsw.vatekey) keypair. getprivate ();
63. String publickeystring = getkeystring (publickey );
64. System. Out. println ("public:/N" + publickeystring );
66. String privatekeystring = getkeystring (privatekey );
67. System. Out. println ("Private:/N" + privatekeystring );
69. // Encryption/Decryption class
70. Cipher cipher = cipher. getinstance ("RSA"); // cipher. getinstance ("RSA/ECB/pkcs1padding ");
72. // Plaintext
73. Byte[] Plaintext = "we are all good! Email: @ Sina.com ". getbytes ();
75. // Encryption
76. Cipher. INIT (Cipher. encrypt_mode, publickey );
77. Byte[] Enbytes = cipher. dofinal (plaintext );
79. // Obtain the key using the key string
80. Publickey = getpublickey (publickeystring );
81. Privatekey = getprivatekey (privatekeystring );
83. // Decrypt
84. Cipher. INIT (Cipher. decrypt_mode, privatekey );
85. Byte[] Debytes = cipher. dofinal (enbytes );
87. Publickeystring = getkeystring (publickey );
88. System. Out. println ("public:/N" + publickeystring );
90. Privatekeystring = getkeystring (privatekey );
91. System. Out. println ("Private:/N" + privatekeystring );
93. String S =NewString (debytes );
94. System. Out. println (s );
97. }
99. }

In actual development! We use our own modulus and publicexponent to encrypt and generate public keys, while privateexponet is used to generate private keys for development.

 

1. ImportJava. Math. biginteger;
3. ImportJava. Security. keyfactory;
5. ImportJava. Security. privatekey;
7. ImportJava. Security. publickey;
9. ImportJava. Security. spec. rsw.vatekeyspec;
11. ImportJava. Security. spec. rsapublickeyspec;
15. ImportJavax. crypto. cipher;
19. Public ClassRsakey {
23. PublicPublickey getpublickey (string modulus, string publicexponent)ThrowsException {
25. Biginteger M =NewBiginteger (modulus );
27. Biginteger E =NewBiginteger (publicexponent );
29. Rsapublickeyspec keyspec =NewRsapublickeyspec (M, e );
31. Keyfactory = keyfactory. getinstance ("RSA ");
32. Publickey = keyfactory. generatepublic (keyspec );
34. ReturnPublickey;
36. }
40. PublicPrivatekey getprivatekey (string modulus, string privateexponent)ThrowsException {
42. Biginteger M =NewBiginteger (modulus );
44. Biginteger E =NewBiginteger (privateexponent );
46. Rsw.vatekeyspec keyspec =NewRsw.vatekeyspec (M, e );
48. Keyfactory = keyfactory. getinstance ("RSA ");
50. Privatekey = keyfactory. generateprivate (keyspec );
52. ReturnPrivatekey;
54. }
58. Public Static VoidMain (string [] ARGs)ThrowsException {
60. String modulus = "10103166745709600780215616551837697832816413714471062522342538060943596036859967333870827790358555455232243383580565187280643159050869924436081447583051139 ";
62. String publicexponent = "65537 ";
64. String privateexponet = "367979294475011322800474185715497882523349856362702385535371444397399388741997039894583483410120364529325888461124714276674612930833020362278754665756193 ";
68. Rsakey key =NewRsakey ();
70. Publickey = key. getpublickey (modulus, publicexponent );
72. Privatekey = key. getprivatekey (modulus, privateexponet );
78. // Encryption/Decryption class
80. Cipher cipher = cipher. getinstance ("RSA"); // "RSA/ECB/pkcs1padding" indicates "algorithm/working mode/filling mode"
84. // Plaintext
86. Byte[] Plaintext = "Hello world! ". Getbytes ();
90. // Encryption
92. Cipher. INIT (Cipher. encrypt_mode, publickey );
94. Byte[] Enbytes = cipher. dofinal (plaintext );
100. Cipher. INIT (Cipher. decrypt_mode, privatekey );
102. Byte[] Debytes = cipher. dofinal (enbytes );
106. String S =NewString (debytes );
108. System. Out. println (s );
112. }

 

1. }