Saya merasa sudah lama sejak terakhir kali saya menulis blog. Biarkan saya mengeluh dulu. Bulan ini, perusahaan telah bekerja lembur, menerbitkan dan meluncurkan publikasi, dan proyek -proyek baru terlalu ketat, jadi saya tidak akan banyak bicara tentang yang spesifik. Hari ini, sangat penting untuk berbicara tentang enkripsi asimetris. Enkripsi asimetris sangat diperlukan dalam kehidupan kita sehari -hari.
konsep
Sebelum berbicara tentang RSA, mari kita bicarakan tentang apa enkripsi asimetris. Ketika berbicara tentang enkripsi simetris, pernah dikatakan bahwa algoritma enkripsi simetris menggunakan kunci rahasia yang sama saat mengenkripsi dan mendekripsi, dan kedua belah pihak untuk mengenkripsi dan mendekripsi harus menggunakan kunci yang sama untuk berkomunikasi secara normal. Enkripsi asimetris tidak terjadi. Algoritma enkripsi asimetris membutuhkan dua kunci untuk mengenkripsi dan mendekripsi, yaitu kunci publik dan kunci pribadi.
Satu hal yang perlu diperhatikan adalah bahwa kunci publik dan kunci pribadi haruslah pasangan. Jika data dienkripsi dengan kunci publik, maka hanya kunci pribadi yang sesuai yang dapat didekripsi, dan sebaliknya. Karena enkripsi dan dekripsi menggunakan dua kunci yang berbeda, algoritma ini disebut algoritma enkripsi asimetris.
Proses kerja
Seperti yang ditunjukkan pada gambar di bawah ini, data ditransmisikan menggunakan enkripsi asimetris.
Algoritma utama yang digunakan dalam enkripsi asimetris meliputi: RSA, elgamal, algoritma ransel, Rabin, DH, ECC (algoritma enkripsi kurva elips), dll. Hari ini, kami terutama akan memperkenalkan RSA. Adapun algoritma lain, kami akan memilih beberapa untuk memperkenalkannya nanti.
RSA
Faktanya, RSA muncul pada awal 1978, dan itu adalah algoritma pertama yang dapat digunakan untuk enkripsi data dan tanda tangan digital. Mudah dimengerti dan dioperasikan dan juga sangat populer. Prinsipnya seperti yang dijelaskan dalam proses kerja di atas.
Algoritma RSA didasarkan pada fakta teori bilangan yang sangat sederhana: mudah untuk melipatgandakan dua bilangan prima yang besar, tetapi sangat sulit untuk memfaktorkan produk mereka, sehingga produk dapat diungkapkan sebagai kunci enkripsi.
Implementasi Kode
Mari kita lihat implementasi kode spesifik di bawah ini.
impor com.google.common.collect.maps; impor sun.misc.base64decoder; impor sun.misc.base64encoder; impor javax.crypto.cipher; impor java.security.*; impor java.security.interfaces.rsaprivateKey; impor java.security.interfaces.rsapublickey; impor java.security.spec.pkcs8encodedkeyspec; impor java.security.spec.x509encodedkeyspec; impor java.util.map; /*** dibuat oleh xiang.li pada 2015/3/3. * Kelas Alat Enkripsi dan Dekripsi RSA*/ Kelas Publik RSA {/ *** Tentukan metode enkripsi*/ Private Final Static String key_rsa = "RSA"; / *** Tentukan algoritma tanda tangan*/ string statis akhir privat key_rsa_signature = "md5withrsa"; / *** Tentukan algoritma kunci publik*/ string statis final privat key_rsa_publickey = "rsapublickey"; / *** Tentukan algoritma kunci pribadi*/ string statis final privat key_rsa_privatekey = "rsaprivateKey"; / *** Kunci Inisialisasi* @return*/ public public <String, Object> init () {peta <String, Object> MAP = null; coba {keyPairGenerator generator = keyPairGenerator.getInstance (key_rsa); generator.initialize (1024); Keypair keypair = generator.generatePeyPair (); // kunci publik rsapublickey publicKey = (rsapublickey) keypair.getPublic (); // Kunci pribadi rsaprivateKey privateKey = (rsaprivateKey) keypair.getPrivate (); // Encapsulate kunci sebagai peta peta = maps.newhashmap (); peta.put (key_rsa_publickey, publickey); peta.put (key_rsa_privatekey, privateKey); } catch (nosuchalgorithMexception e) {e.printstacktrace (); } return peta; } / *** Gunakan kunci pribadi untuk menghasilkan tanda tangan digital untuk informasi* @param data yang dienkripsi data* @param privateKey private Key* @return* / public static String Sign (byte [] data, string privateKey) {string str = ""; Coba {// dekripsi Kunci Pribadi yang dikodekan byte [] bytes = decryptbase64 (privateKey); // Bangun pkcs8encodedkeyspec objek pkcs8encodedkeyspec pkcs = new pkcs8encodedkeyspec (bytes); // algoritma enkripsi yang ditentukan KeyFactory factory = keyfactory.getInstance (key_rsa); // Dapatkan Objek Kunci Pribadi PrivateKey Key = Factory.GeneratePrivate (PKCS); // Gunakan kunci pribadi untuk menghasilkan tanda tangan digital untuk tanda tangan informasi Signature = Signature.getInstance (key_rsa_signature); Signature.Initsign (Key); Signature.update (data); str = encryptBase64 (Signature.sign ()); } catch (Exception e) {E.PrintStackTrace (); } return str; } / *** Verifikasi tanda tangan digital* @param data yang dienkripsi data* @param publickey kunci publik* @param tanda tangan digital* @return verifikasi hasil yang berhasil, gagal kembali false* / public static boolean verifikasi (byte [] data, string publicKey, string tanda) {boolean bendera = false; coba {// dekripsi kunci publik yang dikodekan byte [] bytes = decryptbase64 (publicKey); // Bangun X509EncodedKeyspec Object X509EncodedKeySpec keyspec = new X509EncodedKeyspec (bytes); // algoritma enkripsi yang ditentukan KeyFactory factory = keyfactory.getInstance (key_rsa); // Dapatkan Objek Kunci Publik PublicKey Key = Factory.GeneratePublic (Keyspec); // Verifikasi tanda tangan digital dengan tanda tangan kunci tanda tangan Tanda tangan = Signature.getInstance (key_rsa_signature); Signature.Initverify (Key); Signature.update (data); flag = Signature.Verify (decryptbase64 (tanda)); } catch (Exception e) {E.PrintStackTrace (); } mengembalikan bendera; } / *** Dekripsi Kunci Pribadi* @param data yang dienkripsi data* @param Key Private Key* @return* / public static byte [] decryptbyprivateKey (byte [] data, tombol string) {byte [] result = null; coba {// dekripsi byte kunci pribadi [] bytes = decryptbase64 (key); // Dapatkan kunci pribadi PKCS8EncodedKeySpec keyspec = PKCS8EncodedKeySpec (byte) baru; KeyFactory factory = keyfactory.getInstance (key_rsa); PrivateKey privateKey = factory.generatePrivate (keyspec); // mendekripsi cipher cipher data = cipher.getInstance (factory.getalgorithm ()); cipher.init (cipher.decrypt_mode, privateKey); hasil = cipher.dofinal (data); } catch (Exception e) {E.PrintStackTrace (); } hasil pengembalian; } / *** Dekripsi Kunci Pribadi* @param data yang dienkripsi data* @param Key Public Key* @return* / public static byte [] decryptbypublickey (byte [] data, tombol string) {byte [] result = null; coba {// dekripsi byte kunci publik [] bytes = decryptbase64 (key); // Dapatkan kunci publik X509EncodedKeySpec keyspec = new X509EncodedKeyspec (bytes); KeyFactory factory = keyfactory.getInstance (key_rsa); PublicKey publicKey = factory.generatePublic (keyspec); // mendekripsi cipher cipher data = cipher.getInstance (factory.getalgorithm ()); cipher.init (cipher.decrypt_mode, publickey); hasil = cipher.dofinal (data); } catch (Exception e) {E.PrintStackTrace (); } hasil pengembalian; } / *** Enkripsi kunci publik* @param Data data yang akan dienkripsi* Kunci Publik Kunci @param* @return* / public static byte [] encryptBypublickey (byte [] data, tombol string) {byte [] hasil = null; coba {byte [] bytes = decryptbase64 (key); // Dapatkan kunci publik X509EncodedKeySpec keyspec = new X509EncodedKeyspec (bytes); KeyFactory factory = keyfactory.getInstance (key_rsa); PublicKey publicKey = factory.generatePublic (keyspec); // mengenkripsi data cipher cipher = cipher.getInstance (factory.getalgorithm ()); cipher.init (cipher.encrypt_mode, publickey); hasil = cipher.dofinal (data); } catch (Exception e) {E.PrintStackTrace (); } hasil pengembalian; } / *** Enkripsi kunci pribadi* @param data yang akan dienkripsi* @param Key Private Key* @return* / public static byte [] encryptByPrivateKey (byte [] data, tombol string) {byte [] result = null; coba {byte [] bytes = decryptbase64 (key); // Dapatkan kunci pribadi PKCS8EncodedKeySpec keyspec = PKCS8EncodedKeySpec (byte) baru; KeyFactory factory = keyfactory.getInstance (key_rsa); PrivateKey privateKey = factory.generatePrivate (keyspec); // mengenkripsi data cipher cipher = cipher.getInstance (factory.getalgorithm ()); cipher.init (cipher.encrypt_mode, privateKey); hasil = cipher.dofinal (data); } catch (Exception e) {E.PrintStackTrace (); } hasil pengembalian; } / ** * Dapatkan kunci publik * @param peta * @return * / public static string getPublickey (peta <string, objek> peta) {string str = ""; coba {key key = (key) map.get (key_rsa_publickey); str = encryptBase64 (key.getEncoded ()); } catch (Exception e) {E.PrintStackTrace (); } return str; } / ** * Dapatkan kunci pribadi * @param peta * @return * / public static string getPrivateKey (peta <string, objek> peta) {string str = ""; coba {key key = (key) map.get (key_rsa_privatekey); str = encryptBase64 (key.getEncoded ()); } catch (Exception e) {E.PrintStackTrace (); } return str; } / *** base64 decrypt* @param string kunci yang perlu didekripsi* @return byte array* @throws Exception* / public static byte [] decryptbase64 (tombol string) melempar pengecualian {return (base64decoder () baru ()). DecodeBuffer (tombol); } / *** Enkripsi base64* @param Key byte array yang perlu dienkripsi* @return string* @throws Exception* / public static string encryptBase64 (byte [] key) melempar Exception {return (base64encoder baru ()). EncodeBuffer (tombol); } / *** Metode tes* @param args* / public static void main (string [] args) {string privateKey = ""; String publicKey = ""; // menghasilkan kunci kunci pribadi peta kunci pribadi <string, object> peta = init (); publicKey = getPublicKey (peta); privateKey = getprivatekey (peta); System.out.println ("Kunci publik: /n /r" + publicKey); System.out.println ("Kunci pribadi: /n /r" + privateKey); System.out.println("Public key encryption------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- "; byte[] encWord = EncryptByPublickey (Word.getBytes (), PublicKey); encryption---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- EncryptByPrivateKey (English.getbytes (), PrivateKey); String decenglish = string baru (decryptbypublickey (encenglish, publickey)); System.out.println ("Sebelum enkripsi:" + bahasa Inggris + "/n/r" + "Setelah dekripsi:" + decenglish); System.out.println ("Tanda Tanda Kunci Tanda Tangan Publis Pribadi"); // Hasilkan tanda tanda tangan tanda = tanda (encenglish, privateKey); System.out.println ("Signature:/R" + Sign); // Verifikasi status boolean tanda tangan = verifikasi (encenglish, publickey, tanda); System.out.println ("Status:/R" + Status); }} Mengenkripsi dan mendekripsi hasil
Kesimpulan
Faktanya, proses yang tampaknya kompleks dapat dijelaskan dalam satu kalimat: menggunakan enkripsi kunci publik dan dekripsi kunci pribadi, satu transfer data dari Pihak B ke Pihak A selesai, melalui enkripsi kunci pribadi dan dekripsi kunci publik, dan pada saat yang sama, melalui tanda tangan kunci pribadi dan tanda tangan verifikasi publik, satu transfer data dan verifikasi dari partai A ke partai B diselesaikan, dan dua transfer data yang diselesaikan. DATA DATA DATA.
Munculnya algoritma enkripsi asimetris adalah untuk menyelesaikan masalah enkripsi dan mendekripsi hanya satu kunci. Selama kunci ini hilang atau diungkapkan, data terenkripsi akan mudah diserang. Pada saat yang sama, justru karena kemunculan algoritma enkripsi asimetris bahwa tanda tangan digital berikutnya, sertifikat digital, dll. Diperoleh.
Oke, mari kita berhenti di sini hari ini. Artikel berikutnya melanjutkan enkripsi asimetris. Adapun yang mana, saya akan tahu pada waktu itu. Simpan rahasia di sini dulu