Algoritma Enkripsi RSA
Mari kita tinjau algoritma enkripsi RSA. Kami menggunakan bahasa yang relatif standar untuk menggambarkan algoritma ini berdasarkan definisi algoritma enkripsi kunci publik dan algoritma tanda tangan.
Sistem enkripsi kunci publik RSA mencakup 3 algoritma berikut: KeyGen (algoritma generasi kunci), enkripsi (enkripsi) dan dekripsi (algoritma dekripsi).
Algoritma pembuatan kunci menggunakan konstanta keamanan sebagai input untuk menghasilkan PK kunci publik dan kunci kunci pribadi. Konstanta keamanan digunakan untuk menentukan seberapa aman algoritma enkripsi, yang umumnya terkait dengan ukuran bilangan prima P yang digunakan oleh algoritma enkripsi. Semakin besar bilangan prima P adalah, semakin besar sistemnya, memastikan keamanan yang lebih tinggi. Dalam RSA, algoritma generasi kunci adalah sebagai berikut: algoritma pertama kali secara acak menghasilkan dua bilangan prima besar yang berbeda p dan q, dan menghitung n = pq. Kemudian, algoritma menghitung fungsi Euler. Selanjutnya, algoritma secara acak memilih integer kurang dari E dan menghitung elemen Modulo Inverse D dari E. Akhirnya, kunci publik adalah pk = (n, e) dan kunci pribadi adalah sk = (n, d).
Algoritma enkripsi menggunakan PK kunci publik dan pesan m yang akan dienkripsi sebagai input dan mengeluarkan ciphertext CT. Dalam RSA, algoritma enkripsi adalah sebagai berikut: algoritma secara langsung menghasilkan ciphertext sebagai algoritma dekripsi menggunakan kunci pribadi dan ciphertext CT sebagai input, dan mengeluarkan pesan M. dalam RSA, algoritma dekripsi. Karena E dan D berbatasan dengan satu sama lain, kami memiliki:
Oleh karena itu, dari deskripsi algoritma, kita juga dapat melihat bahwa kunci publik digunakan untuk mengenkripsi data, dan kunci pribadi digunakan untuk mendekripsi data. Tentu saja, ini juga dapat dipahami secara intuitif: kunci publik adalah kunci publik, dan hanya ketika diungkapkan, semua orang dapat menggunakannya untuk mengenkripsi data. Kunci pribadi adalah kunci pribadi, dan siapa pun yang memiliki kunci ini dapat mendekripsi ciphertext. Kalau tidak, jika semua orang dapat melihat kunci pribadi dan mendekripsi, itu akan berantakan.
Mari kita lihat implementasi sederhana di Java:
paket com.stone.security; impor java.security.keypair; impor java.security.keypairgenerator; impor java.security.privatekey; impor java.security.publickey; impor java.util.arrays; impor javax.crypto.cipher; / *** Algoritma RSA Enkripsi Kunci Publik Enkripsi Enkripsi asimetris*/ kelas publik RSA {public static final string key_algorithm = "rsa"; string final statis publik cipher_algorithm_ecb1 = "rsa/ecb/pkcs1padding"; string final statis publik cipher_algorithm_ecb2 = "rsa/ecb/oaepwithsha-1andmgf1padding"; // Anda tidak dapat menggunakan string final statis public cipher_algorithm_ecb3 = "oaepwithsha-256andmgf1padding"; // Anda tidak dapat menggunakan publikasi publickey statis; privateKey privateKey statis; Cipher cipher statis; keypair keypair statis; public static void main (string [] args) melempar pengecualian {method1 ("skoda u*(sfsad7f ()*^%% $"); method2 ("skoda u*(sfsad7f ()*^%% $"); method3 ("skoda u*(sfsad7f ()*^%% $"); method3 ("skoda u*(sfsad7f ()*^%% $" Cipher_algorithm_ecb1 * @param str * @throws Exception */ static void Method1 (string str) melempar Exception {keypairgenerator keygenerator = keypairgenerator.getInstance (KEYGEYNITM); keypair.getprivate (); Arrays.tostring (enkripsi)); Cipher_algorithm_ecb1 * @param str * @throws Exception */ static void method2 (string str) melempar Exception {keyPairGenerator keygenerator = keyPairGenerator.getInstance (key_algorithM); Keypair keypair = keygenerator.generatePeyPair (); publicKey = keypair.getPublic (); privateKey = keyPair.getPrivate (); cipher = cipher.getInstance (key_algorithm); cipher.init (cipher.encrypt_mode, privateKey); // byte enkripsi kunci pribadi [] encrypt = cipher.dofinal (str.getbytes ()); System.out.println ("Enkripsi Kunci Pribadi 2:" + Arrays.tostring (Encrypt)); cipher.init (cipher.decrypt_mode, publickey); // byte decrypt kunci publik [] decrypt = cipher.dofinal (enkripsi); System.out.println ("Dekripsi Kunci Publik 2:" + String Baru (Decrypt)); }/** * Enkripsi kunci pribadi, Dekripsi kunci publik menggunakan cipher_algorithm_ecb1 = rsa/ecb/pkcs1padding * @param str * @throws exception */static void method3 (string str) lempar pengecualian {keypairgenerator keygorererator = keypairgeneror.geteer.geteRyMiPAirTiPenerator (keypairgeneror.gete. Keypair keypair = keygenerator.generatePeyPair (); publicKey = keypair.getPublic (); privateKey = keyPair.getPrivate (); cipher = cipher.getInstance (cipher_algorithm_ecb1); cipher.init (cipher.encrypt_mode, privateKey); // byte enkripsi kunci pribadi [] encrypt = cipher.dofinal (str.getbytes ()); System.out.println ("Enkripsi Kunci Pribadi 3:" + Arrays.tostring (Encrypt)); cipher.init (cipher.decrypt_mode, publickey); // byte dekripsi kunci publik [] decrypt = cipher.dofinal (enkripsi); System.out.println ("3 setelah dekripsi kunci publik:" + string baru (decrypt)); }} Algoritma DSA dan tanda tangan digital
DSA umumnya digunakan untuk tanda tangan digital dan sertifikasi.
DSA adalah varian algoritma tanda tangan Schnorr dan Elgamal, dan digunakan oleh NIST di Amerika Serikat sebagai DSS (standar tanda tangan digital).
DSA didasarkan pada masalah logaritmik diskrit domain integer, dan keamanannya mirip dengan RSA.
Dalam DSA Digital Signature and Authentication, pengirim menggunakan kunci pribadinya sendiri untuk menandatangani file atau pesan, dan penerima menggunakan kunci publik pengirim untuk memverifikasi keaslian tanda tangan setelah menerima pesan. DSA hanyalah sebuah algoritma, dan perbedaan antara RSA adalah bahwa ia tidak dapat digunakan untuk enkripsi dan dekripsi, atau untuk pertukaran utama.
Hanya untuk tanda tangan, jauh lebih cepat dari RSA.
paket com.stone.security; impor java.security.key; impor java.security.keyfactory; impor java.security.keypair; impor java.security.keypairgenerator; impor java.security.privatekey; impor java.security.publickey; impor java.security.securerandom; impor java.security.signature; impor java.security.spec.pkcs8encodedkeyspec; impor java.security.spec.x509encodedkeyspec; impor java.util.hashmap; impor java.util.map; impor sun.misc.base64decoder; impor sun.misc.base64encoder; /*** Algoritma tanda tangan DSA-Digital adalah varian algoritma tanda tangan Schnorr dan Elgamal, dan digunakan sebagai DSS oleh NIST di Amerika Serikat. * Singkatnya, ini adalah metode verifikasi yang lebih maju yang digunakan sebagai tanda tangan digital. Tidak hanya kunci publik dan pribadi, tetapi juga tanda tangan digital. Enkripsi kunci pribadi menghasilkan tanda tangan digital, data verifikasi kunci publik dan tanda tangan. * Jika data dan tanda tangan tidak cocok, verifikasi akan dianggap gagal! Artinya, data dalam transmisi tidak lagi dapat dienkripsi. Setelah penerima mendapatkan data, ia mendapatkan kunci publik dan tanda tangan untuk memverifikasi apakah data tersebut valid. */ kelas publik DSA {/ ***Tidak hanya Anda dapat menggunakan algoritma DSA, tetapi Anda juga dapat menggunakan algoritma RSA untuk tanda tangan digital*/ string final statis public key_algorithm = "rsa"; Public Static Final String Signature_algorithm = "md5withrsa";*/ string final statis public key_algorithM = "dsa"; Public Static Final String Signature_algorithm = "DSA"; String final statis publik default_seed = "$%^*%^() (hjg8awfjas7"; // seed default public static final string public_key = "dsapublickey"; string final static public private_key = "dsaprivateKey"; public static void main (string [] args) lemparan pengecualian {string dsap = " Loves You*()_+"; byte[] data = str.getBytes(); Map<String, Object> keyMap = initKey();// build key PublicKey publicKey = (PublicKey) keyMap.get(PUBLIC_KEY); PrivateKey privateKey = (PrivateKey) keyMap.get(PRIVATE_KEY); System.out.println("Private key format:" + privateKey.getFormat()); System.out.println (format kunci publik: " + publicKey.getFormat ()); Verifikasi1); } / *** Hasilkan tombol** @param seed* @return Object Key* @throws Exception* / public peta statis public <string, objek> initkey (string seed) melempar pengecualian {System.out.println ("Generate Key"); Keypairgenerator keygen = keypairgenerator.getInstance (key_algorithm); Securerandom SecureRandom = new SecureRandom (); Securerandom.setseed (seed.getbytes ()); // Ukuran modulus harus berkisar dari 512 hingga 1024 dan menjadi kelipatan 64 keygen. Tombol keypair = keygen.genkeypair (); PrivateKey privateKey = keys.getPrivate (); PublicKey publicKey = keys.getPublic (); Peta <String, Object> MAP = HashMap baru <String, Object> (2); peta.put (public_key, publickey); peta.put (private_key, privateKey); peta mengembalikan; } / *** Hasilkan tombol default** @return Object Key* @throws Exception* / public peta statis <string, objek> initkey () melempar pengecualian {return initkey (default_seed); } / ** * Dapatkan kunci pribadi * * @param keymap * @return * @throws Exception * / public static string getPrivateKey (peta <string, objek> keymap) melempar pengecualian {tombol kunci = (key) keymap.get (private_key); return encryptBase64 (key.getEncoded ()); // Base64 Enkripsi Kunci pribadi}/** * Dapatkan kunci publik * * @param keymap * @return * @throws Exception */Public Static String getPublickey (peta <string, objek> keymap) melempar pengecualian {key key = (key) keymap.get (public_key); return encryptBase64 (key.getEncoded ()); //base64 encryption public key} /** * Use the private key to digitally sign the information* @param data Encrypted data* @param privateKey private key - base64 encrypted * @return * @throws Exception */ public static String sign(byte[] data, String privateKey) throws Exception { System.out.println("digitize the information with the private key"); byte [] keybytes = decryptbase64 (privateKey); Pkcs8encodedkeyspec keyspec = pkcs8encodedkeyspec baru (keybytes); KeyFactory factory = keyfactory.getInstance (key_algorithm); PrivateKey prikey = factory.generatePrivate (keyspec); // Hasilkan kunci pribadi // informasi digitsign dengan tanda tangan kunci privat Signature = Signature.getInstance (Signature_algorithm); Signature.Initsign (Prikey); Signature.update (data); return encryptBase64 (Signature.sign ()); } / *** enkripsi base64Encoder* @param data data yang akan dienkripsi* @return dienkripsi string* / string statis privat enryptBase64 (byte [] data) {base64Encoder encoder = base64encoder baru (); String encode = encoder.encode (data); return encode; } / *** base64decoder decrypt* @param string data untuk didekripsi* @return decrypted byte []* @throws Exception* / private static byte [] decryptbase64 (string data) lemparan pengecualian {base64decoder decoder = base64decoder baru (); byte [] buffer = decoder.decodebuffer (data); Buffer pengembalian; } / *** Verifikasi tanda tangan digital* @param data yang dienkripsi data* @param publickey* @param tanda digital tanda tangan* @return* @throws Exception* / public static boolean verify (byte [] data, string publickey, string tanda) lemparan pengecualian {byte [] keybytes = decryptbase64 (publickey); X509Encodedkeyspec keyspec = new X509EncodedKeyspec (keybytes); KeyFactory keyFactory = keyfactory.getInstance (key_algorithm); PublicKey pubkey = keyfactory.generatePublic (keyspec); Signature Signature = Signature.getInstance (Signature_algorithm); Signature.Initverify (PubKey); Signature.update (data); return Signature.Verify (decryptbase64 (tanda)); // Verifikasi tanda tangan}}