एक सममित एन्क्रिप्शन
सममित एन्क्रिप्शन और असममित एन्क्रिप्शन दो अलग-अलग एन्क्रिप्शन विधियाँ हैं, जो डेटा सुरक्षा और सूचना संचार में महत्त्वपूर्ण भूमिका निभाती हैं। नीचे मैं इन दोनों एन्क्रिप्शन तकनीकों का अलग-अलग परिचय दूँगा：
1.1 सममित एन्क्रिप्शन（Symmetric Encryption）
सममित एन्क्रिप्शन का अर्थ है कि एन्क्रिप्शन और डिक्रिप्शन दोनों में एक ही कुंजी का उपयोग होता है।इसका मतलब है कि एन्क्रिप्शन और डिक्रिप्शन करने के लिए प्रेषक और प्राप्तकर्ता दोनों के पास यह कुंजी होना आवश्यक है।
सामान्य सममित एन्क्रिप्शन एल्गोरिदम：
AES（उन्नत एन्क्रिप्शन मानक）
DES（डेटा एन्क्रिप्शन मानक）
3DES（तिहरा डेटा एन्क्रिप्शन एल्गोरिदम）
1.2 सममित एन्क्रिप्शन की विशेषताएँ
सामान्यतः, सममित एन्क्रिप्शन की निम्नलिखित विशेषताएँ होती हैं：
गति अपेक्षाकृत तेज़：चूँकि एन्क्रिप्शन और डिक्रिप्शन में एक ही कुंजी का उपयोग होता है, इसलिए सममित एन्क्रिप्शन आम तौर पर असममित एन्क्रिप्शन से तेज़ होता है।
कुंजी प्रबंधन：सममित एन्क्रिप्शन की मुख्य चुनौती कुंजियों के वितरण और प्रबंधन में है। कुंजी लीक हो जाने पर एन्क्रिप्शन की सुरक्षा ख़तरे में पड़ जाती है।
बड़ी मात्रा में डेटा के लिए उपयुक्त：तेज़ होने के कारण सममित एन्क्रिप्शन बड़ी मात्रा में डेटा एन्क्रिप्ट करने के लिए उपयुक्त है।
यहाँ से देखा जा सकता है कि सममित एन्क्रिप्शन के मुख्यतः दो लाभ हैं：पहला, गणना तेज होती है；दूसरा, यह बड़ी मात्रा में डेटा के लिए उपयुक्त है।
लेकिन सममित एन्क्रिप्शन में एक घातक समस्या है, और वह है कुंजी प्रबंधन। सर्वर से क्लाइंट तक कुंजी को सुरक्षित ढंग से कैसे पहुँचाया जाए, यह एक समस्या है！इसके अलावा, एक से अनेक के बीच संचार में कुंजी को लीक होने से बचाते हुए उसका प्रबंधन करना भी एक चुनौती है। यह सममित एन्क्रिप्शन की कमी है।
1.3 कोड उदाहरण
अब सोंग भाई आप सभी को दिखाएँगे कि Java कोड से सममित एन्क्रिप्शन और डिक्रिप्शन कैसे किया जाता है।
Java में सममित एन्क्रिप्शन लागू करने के लिए आम तौर पर Java क्रिप्टोग्राफ़ी आर्किटेक्चर（Java Cryptography Architecture, JCA）की प्रदान की हुई क्लास और इंटरफ़ेस का उपयोग किया जाता है।
नीचे AES（उन्नत एन्क्रिप्शन मानक）एल्गोरिदम से सममित एन्क्रिप्शन और डिक्रिप्शन का एक सरल उदाहरण है：
public class SymmetricEncryptionExample { // 生成密钥
public static SecretKey generateKey() throws Exception {
KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
keyGenerator.init(128); // 可以是128, 192或256位
return keyGenerator.generateKey();
}
// 加密方法
public static String encrypt(String data, SecretKey key) throws Exception {
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.ENCRYPT_MODE, key);
byte[] encryptedBytes = cipher.doFinal(data.getBytes());
return Base64.getEncoder().encodeToString(encryptedBytes);
}
// 解密方法
public static String decrypt(String encryptedData, SecretKey key) throws Exception {
Cipher cipher = Cipher.getInstance("AES");
cipher.init(Cipher.DECRYPT_MODE, key);
byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedData));
return new String(decryptedBytes);
}
public static void main(String[] args) {
try {
// 生成密钥
SecretKey key = generateKey();
// 原始数据
String originalData = "Hello, JavaBoy!";
// 加密
String encryptedData = encrypt(originalData, key);
System.out.println("加密数据: " + encryptedData);
// 解密
String decryptedData = decrypt(encryptedData, key);
System.out.println("解密数据: " + decryptedData);
} catch (Exception e) {
e.printStackTrace();
}
}
}कुंजी बनाएँ: उपयोग करें
KeyGeneratorएक AES कुंजी बनाएँ।एन्क्रिप्शन: उपयोग करें
Cipherक्लास से एन्क्रिप्शन करें；डेटा को बाइटों में बदलकर एन्क्रिप्ट करें, फिर Base64 एन्कोडिंग से स्ट्रिंग में बदलें, ताकि उसे संग्रहित करना या भेजना आसान हो।डिक्रिप्शन：एन्क्रिप्ट किए गए स्ट्रिंग को वापस बाइटों में डिकोड करें, फिर उसी कुंजी से डिक्रिप्ट करें।
ऊपर दिए गए कोड में आपको इस बात पर ध्यान देना चाहिए：
कुंजी की लंबाई（जैसे 128 बिट）सुरक्षा आवश्यकताओं के अनुसार चुनी जानी चाहिए।
सुनिश्चित करें कि कुंजियाँ सुरक्षित रूप से संग्रहित हों, उन्हें कोड में हार्डकोड न करें।
उत्पादन परिवेश में अधिक सुरक्षित कुंजी प्रबंधन रणनीति अपनाने पर विचार करना चाहिए।
सुरक्षा को ध्यान में रखते हुए，हम आमतौर पर ऊपर दिए गए तरीके से कुंजी बनाते हैं। इस तरीके से बनी कुंजी की एक विशेषता है कि सिस्टम हर बार पुनः शुरू होने पर बदल जाती है। यदि आप कुंजी के निर्माण को स्वयं नियंत्रित करना चाहते हैं，तो नीचे दिए गए तरीके से कुंजी बना सकते हैं：
public static SecretKey generateKeyFromPassword(String password, int keySize) throws NoSuchAlgorithmException, InvalidKeySpecException {
SecretKeyFactory factory = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
KeySpec spec = new PBEKeySpec(password.toCharArray(), "salt".getBytes(), 65536, keySize);
return new SecretKeySpec(factory.generateSecret(spec).getEncoded(), "AES");
}इस तरह आप स्वयं दिए गए पैरामीटर के माध्यम से कुंजी नियंत्रित कर सकते हैं।
1.4 फ्रंटएंड और बैकएंड का संयोजन
विभिन्न भाषाओं（जैसे JavaScript और Java）के बीच AES एल्गोरिदम से एन्क्रिप्शन और डिक्रिप्शन करते समय मुख्य बात यह सुनिश्चित करना है कि दोनों तरफ समान कुंजी, एल्गोरिदम मोड（जैसे CBC, ECB आदि）, पैडिंग मोड（जैसे PKCS5Padding, PKCS7Padding आदि）और आरंभीकरण वेक्टर（IV, यदि CBC जैसे IV की आवश्यकता वाले मोड का उपयोग हो）इस्तेमाल हों।
पहले एक साथी ने कहा था कि फ्रंटएंड पर एन्क्रिप्शन करने के बाद बैकएंड हमेशा डिक्रिप्ट नहीं कर पाता। इसलिए सोंग भाई यहाँ फ्रंटएंड और बैकएंड के संयोजन का एक उदाहरण भी दे रहे हैं।
फ़्रंटएंड में एन्क्रिप्शन, बैकएंड में डिक्रिप्शन
फ़्रंटएंड कोड：
<!DOCTYPE html><html lang="en"><head>
<meta charset="UTF-8">
<title>AES加密示例</title>
<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/4.0.0/crypto-js.min.js"></script>
</head>
<body>
<script>
function encryptAES(text, secretKey) {
const key = CryptoJS.enc.Utf8.parse(secretKey);
const iv = CryptoJS.lib.WordArray.random(128 / 8);
// 对于CBC模式，需要IV
const encrypted = CryptoJS.AES.encrypt(text, key, {
iv: iv,
mode: CryptoJS.mode.CBC,
padding: CryptoJS.pad.Pkcs7
});
// 返回加密后的文本和IV（Base64格式），实际使用中可能需要安全地传输这些值
return {
ciphertext: encrypted.toString(),
iv: iv.toString(CryptoJS.enc.Base64)
};
}
const secretKey = 'helloworldhelloworldhelloworld11'; /
/ 确保密钥是32个字符长（256位）
const text = 'Hello, javaboy!';
const result = encryptAES(text, secretKey);
console.log(result);
</script>
</body>
</html>बैकएंड कोड：
import javax.crypto.Cipher;import javax.crypto.spec.IvParameterSpec;import javax.crypto.spec.SecretKeySpec;import java.util.Base64;public class AESDecrypt { public static String decryptAES(String encryptedData, String secretKey, String iv) throws Exception { IvParameterSpec ivParameterSpec = new IvParameterSpec(Base64.getDecoder().decode(iv)); SecretKeySpec secretKeySpec = new SecretKeySpec(secretKey.getBytes("UTF-8"), "AES"); Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, ivParameterSpec); byte[] decodedValue = Base64.getDecoder().decode(encryptedData); byte[] decryptedValue = cipher.doFinal(decodedValue); return new String(decryptedValue, "UTF-8");
} public static void main(String[] args) { try { //前端加密后的文本
String encryptedText = "PYANpAjMsRnBIEhovtEXQw=="; String secretKey = "helloworldhelloworldhelloworld11"; //前端 IV，要和加密后的文本一起传到后端
String iv = "y/jUHcgSOpOiyNlsfjNUBg=="; String decryptedText = decryptAES(encryptedText, secretKey, iv);
System.out.println("解密文本: " + decryptedText);
} catch (Exception e) {
e.printStackTrace();
}
}
}ध्यान दें कि यहाँ फ़्रंटएंड पर एन्क्रिप्शन के दौरान एक iv पैरामीटर उत्पन्न होगा，जिसे फ़्रंटएंड के एन्क्रिप्शन परिणाम के साथ बैकएंड को भेजना होगा।
बैकएंड पर एन्क्रिप्शन, फ़्रंटएंड पर डिक्रिप्शन
Java में AES एन्क्रिप्शन और JavaScript में डिक्रिप्शन करते समय भी यह सुनिश्चित करना आवश्यक है कि दोनों ओर समान कुंजी, एल्गोरिदम मोड（जैसे CBC, ECB आदि）, पैडिंग मोड（जैसे PKCS5Padding, PKCS7Padding आदि）और（जहाँ लागू हो）समान आरंभीकरण वेक्टर（IV）इस्तेमाल हो।
बैकएंड कोड：
public class AESEncrypt { public static String encryptAES(String plainText, String secretKey, String iv) throws Exception { KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
keyGenerator.init(256); // 对于AES-256
SecretKey secret = new SecretKeySpec(secretKey.getBytes("UTF-8"), "AES"); IvParameterSpec ivParameterSpec = new IvParameterSpec(Base64.getDecoder().decode(iv)); Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, secret, ivParameterSpec); byte[] encrypted = cipher.doFinal(plainText.getBytes("UTF-8")); return Base64.getEncoder().encodeToString(encrypted);
} public static void main(String[] args) { try { String plainText = "Hello, 江南一点雨!"; String secretKey = "helloworldhelloworldhelloworld11"; // 确保密钥是32个字符长（256位）
String iv = Base64.getEncoder().encodeToString(new byte[16]); // 示例IV，实际应用中应更安全地生成
String encryptedText = encryptAES(plainText, secretKey, iv);
System.out.println("Encrypted text: " + encryptedText);
System.out.println("IV (Base64): " + iv); // 确保将IV发送给解密方
} catch (Exception e) {
e.printStackTrace();
}
}
}फ़्रंटएंड कोड：
<!DOCTYPE html><html lang="en"><head>
<meta charset="UTF-8">
<title>Title</title>
<script src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/4.0.0/crypto-js.min.js"></script>
<script>
function decryptAES(ciphertext, secretKey, iv) { const key = CryptoJS.enc.Utf8.parse(secretKey); const ivParsed = CryptoJS.enc.Base64.parse(iv); const decrypted = CryptoJS.AES.decrypt(
{ ciphertext: CryptoJS.enc.Base64.parse(ciphertext)
},
key,
{ iv: ivParsed, mode: CryptoJS.mode.CBC, padding: CryptoJS.pad.Pkcs7
}
); return decrypted.toString(CryptoJS.enc.Utf8);
} const secretKey = 'helloworldhelloworldhelloworld11'; const iv = 'AAAAAAAAAAAAAAAAAAAAAA=='; // 从Java代码获取
const ciphertext = '1lPNVF1injas78KUWeKp5FusEr6f0pGgcrLAg9ELFr8='; // 从Java代码获取
const decryptedText = decryptAES(ciphertext, secretKey, iv); console.log(decryptedText); </script></head><body></body></html>ऊपर दिए गए फ़्रंटएंड और बैकएंड के बीच संचार के एन्क्रिप्शन और डिक्रिप्शन कोड को सोंग भाई ने स्वयं परखा है और वे सभी ठीक हैं। यदि आपको ऐसी आवश्यकता हो, तो इस लेख को बुकमार्क कर लें; यह संदर्भ के काम आ सकता है।
दो असममित एन्क्रिप्शन
2.1 असममित एन्क्रिप्शन क्या है
असममित एन्क्रिप्शन, जिसे सार्वजनिक कुंजी एन्क्रिप्शन भी कहते हैं, एन्क्रिप्शन की एक विधि है जिसमें दो अलग-अलग कुंजियों（सार्वजनिक कुंजी और निजी कुंजी）का उपयोग होता है।
आम तौर पर, असममित एन्क्रिप्शन की निम्नलिखित विशिष्ट विशेषताएँ होती हैं：
सार्वजनिक कुंजी और निजी कुंजी
सार्वजनिक और निजी कुंजी का निर्माण：असममित एन्क्रिप्शन कुंजियों की एक जोड़ी का उपयोग करता है। सार्वजनिक कुंजी खुली होती है और कोई भी उसे प्राप्त कर सकता है, जबकि निजी कुंजी गोपनीय होती है और केवल उसका धारक उसे प्राप्त कर सकता है। ये दोनों कुंजियाँ गणितीय एल्गोरिदम से बनाई जाती हैं और परस्पर संबंधित होती हैं, लेकिन एक से दूसरी निकाली नहीं जा सकती।
उच्च सुरक्षा
भेदना कठिन：सार्वजनिक और निजी कुंजियों के बीच जटिल गणितीय संबंध के कारण असममित एन्क्रिप्शन की सुरक्षा अपेक्षाकृत अधिक होती है। हमलावर के लिए सार्वजनिक कुंजी से निजी कुंजी का अनुमान लगाना बहुत कठिन होता है, जिससे एन्क्रिप्ट किए गए डेटा की सुरक्षा सुनिश्चित होती है।
क्वांटम कंप्यूटिंग हमलों का प्रतिरोध：कुछ ब्लॉकचेन परियोजनाओं ने भविष्य में क्वांटम कंप्यूटिंग के ख़तरे से निपटने के लिए क्वांटम कंप्यूटिंग हमलों का प्रतिरोध करने वाले एन्क्रिप्शन एल्गोरिदम अपनाने शुरू किए हैं, जैसे एलिप्टिक कर्व डिजिटल सिग्नेचर एल्गोरिदम（ECDSA）के क्वांटम-सुरक्षित रूपांतर।
सार्वजनिक कुंजी का वितरण सुविधाजनक है
सार्वजनिक कुंजी का खुलापन：सार्वजनिक कुंजी किसी के भी साथ साझा की जा सकती है，इसलिए उसका वितरण बहुत आसान है। कोई भी सार्वजनिक कुंजी से डेटा एन्क्रिप्ट कर सकता है，लेकिन केवल निजी कुंजी का धारक ही उसे डिक्रिप्ट कर सकता है।
प्रमाणीकरण और डिजिटल हस्ताक्षर
पहचान सत्यापन：सार्वजनिक कुंजी उपयोगकर्ता के पहचान चिह्न के रूप में काम कर सकती है, और अन्य लोग उसकी निजी कुंजी जाने बिना उसकी पहचान सत्यापित कर सकते हैं। इससे ब्लॉकचेन जैसे विकेंद्रीकृत नेटवर्क में विश्वसनीय पहचान स्थापित करने में मदद मिलती है।
डिजिटल हस्ताक्षर：निजी कुंजी का धारक अपनी निजी कुंजी से संदेश पर हस्ताक्षर कर सकता है, और अन्य लोग सार्वजनिक कुंजी से हस्ताक्षर की प्रामाणिकता जाँच सकते हैं। इससे संदेश की अखंडता और उसके स्रोत की विश्वसनीयता सुनिश्चित होती है।
सुरक्षित संचार
एन्क्रिप्टेड संचार：सार्वजनिक कुंजी से संदेश एन्क्रिप्ट किए जा सकते हैं, और केवल संबंधित निजी कुंजी रखने वाला व्यक्ति उन्हें डिक्रिप्ट कर सकता है। इससे संचार के दौरान डेटा की सुरक्षा सुनिश्चित होती है और अनधिकृत लोगों को जानकारी तक पहुँचने से रोका जाता है।
डिजिटल संपत्ति नियंत्रण
ब्लॉकचेन पता और निजी कुंजी：ब्लॉकचेन पता आम तौर पर सार्वजनिक कुंजी से व्युत्पन्न होता है，और उपयोगकर्ता निजी कुंजी के माध्यम से उस पते से जुड़ी डिजिटल परिसंपत्तियों को नियंत्रित करता है। डिजिटल परिसंपत्तियों की सुरक्षा के लिए निजी कुंजी की सुरक्षा अत्यंत महत्वपूर्ण है।
एन्क्रिप्शन और डिक्रिप्शन की गति
अपेक्षाकृत धीमा：असममित एन्क्रिप्शन में एन्क्रिप्ट और डिक्रिप्ट करने की गति सममित एन्क्रिप्शन से बहुत धीमी होती है, क्योंकि इसमें अधिक जटिल गणितीय गणनाएँ करनी पड़ती हैं। फिर भी इससे सुरक्षित संचार और पहचान सत्यापन जैसे क्षेत्रों में इसके उपयोग पर असर नहीं पड़ता।
2.2 असममित एन्क्रिप्शन के उपयोग
असममित एन्क्रिप्शन के उपयोग की दो पारंपरिक परिस्थितियाँ हैं।
एन्क्रिप्शन：यह वह उपयोग है जिससे हम सबसे अधिक परिचित हैं，अर्थात सार्वजनिक कुंजी से एन्क्रिप्ट करना और निजी कुंजी से डिक्रिप्ट करना।
हस्ताक्षर：नेटवर्क के अविश्वसनीय होने के कारण，संचरण के दौरान डेटा से छेड़छाड़ हो सकती है，ऐसे में सार्वजनिक और निजी कुंजियों का उपयोग उलटे क्रम में किया जा सकता है，निजी कुंजी से डेटा पर हस्ताक्षर करके，सार्वजनिक कुंजी से हस्ताक्षर सत्यापित किए जाते हैं，ताकि डेटा की सुरक्षा और अखंडता सुनिश्चित हो सके।
दूसरे उपयोग के संदर्भ में，कुछ साथी इसे निजी कुंजी से एन्क्रिप्शन और सार्वजनिक कुंजी से डिक्रिप्शन करना बताते हैं，ख़ैर，सब जानते हैं कि बात एक ही चीज़ की हो रही है।
असममित एन्क्रिप्शन एल्गोरिदम，सैद्धांतिक रूप से डेटा एन्क्रिप्शन और डिजिटल हस्ताक्षर के लिए इस्तेमाल किए जा सकते हैं，लेकिन व्यवहार में उनकी उच्च गणनात्मक जटिलता और कम दक्षता प्रमुख बाधाएँ बन जाती हैं।
सममित एन्क्रिप्शन एल्गोरिदम की तुलना में, असममित एन्क्रिप्शन की गणना गति कई परिमाण क्रम धीमी होती है, जिससे बड़ी मात्रा में डेटा संभालने की इसकी क्षमता बहुत प्रभावित होती है। इसके अलावा, असममित एन्क्रिप्शन एल्गोरिदम की एन्क्रिप्शन और डिक्रिप्शन प्रक्रियाएँ कुंजी की लंबाई से निकटता से जुड़ी होती हैं और ब्लॉक एन्क्रिप्शन मोड का समर्थन नहीं करतीं। इसलिए यह केवल कुंजी की लंबाई से अधिक न होने वाला थोड़ा सा डेटा संभाल सकता है और बड़ी मात्रा में डेटा एन्क्रिप्ट नहीं कर सकता।
असममित एन्क्रिप्शन की प्रदर्शन संबंधी कमियों को दूर करने के लिए आधुनिक एन्क्रिप्शन प्रणालियाँ आम तौर पर मिश्रित एन्क्रिप्शन रणनीति अपनाती हैं, जिसमें सममित और असममित एन्क्रिप्शन के लाभ जोड़े जाते हैं। इस रणनीति में असममित एन्क्रिप्शन का उपयोग मुख्यतः सममित एन्क्रिप्शन की एक कुंजी दूसरे पक्ष तक सुरक्षित रूप से पहुँचाने（अर्थात “कुंजी पर सहमति स्थापित करने”）के लिए किया जाता है। जब दोनों पक्ष इस सममित कुंजी को सुरक्षित रूप से साझा कर लेते हैं, तब वे बड़ी मात्रा में डेटा को एन्क्रिप्ट और डिक्रिप्ट करने के लिए कुशल सममित एन्क्रिप्शन एल्गोरिदम का उपयोग कर सकते हैं। दोनों को मिलाकर उपयोग करने की यह विधि एन्क्रिप्शन की दक्षता बढ़ाने के साथ संचार की सुरक्षा भी बढ़ाती है और SSL/TLS जैसे विभिन्न सुरक्षित संचार प्रोटोकॉल में व्यापक रूप से इस्तेमाल होती है।
डिजिटल हस्ताक्षर के क्षेत्र में，असममित एन्क्रिप्शन की दक्षता बढ़ाने के लिए भी कुछ अनुकूलन किए गए हैं। प्रक्रिया यह है कि पहले मूल डेटा का डाइजेस्ट बनाया जाता है（MD5、SHA आदि का उपयोग किया जा सकता है），जिससे निश्चित लंबाई का डाइजेस्ट मान मिलता है। फिर असममित एन्क्रिप्शन एल्गोरिदम से इस डाइजेस्ट मान को एन्क्रिप्ट करके डिजिटल हस्ताक्षर बनाया जाता है। चूँकि डाइजेस्ट एल्गोरिदम किसी भी लंबाई के डेटा को कुशलता से निश्चित लंबाई के डाइजेस्ट में संक्षिप्त कर सकता है，इसलिए मूल डेटा कितना भी बड़ा हो，डाइजेस्ट की लंबाई समान रहती है और हस्ताक्षर प्रक्रिया भी कुशल बनी रहती है। हस्ताक्षर सत्यापित करते समय，केवल मूल डेटा का डाइजेस्ट दोबारा निकालकर उसकी तुलना डिक्रिप्ट किए गए हस्ताक्षर से करनी होती है，जिससे तुरंत पता चल जाता है कि डेटा के साथ छेड़छाड़ हुई है या नहीं।
2.3 एन्क्रिप्शन का उदाहरण
Java कोड में RSA से एन्क्रिप्शन और डिक्रिप्शन का उदाहरण:
public class RsaDemo { public static void main(String[] args) { try { KeyPair keyPair = generateRSAKeyPair(); PublicKey publicKey = keyPair.getPublic(); PrivateKey privateKey = keyPair.getPrivate(); String originalData = "Hello, 江南一点雨!"; String encryptedData = encrypt(publicKey, originalData); String decryptedData = decrypt(privateKey, encryptedData);
System.out.println("加密后的数据: " + encryptedData);
System.out.println("解密后的数据: " + decryptedData);
} catch (Exception e) {
e.printStackTrace();
}
} public static String decrypt(PrivateKey privateKey, String encryptedData) throws Exception { Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.DECRYPT_MODE, privateKey); byte[] decryptedBytes = cipher.doFinal(Base64.getDecoder().decode(encryptedData)); return new String(decryptedBytes);
} public static String encrypt(PublicKey publicKey, String data) throws Exception { Cipher cipher = Cipher.getInstance("RSA");
cipher.init(Cipher.ENCRYPT_MODE, publicKey); byte[] bytes = cipher.doFinal(data.getBytes()); return Base64.getEncoder().encodeToString(bytes);
} public static KeyPair generateRSAKeyPair() throws NoSuchAlgorithmException { KeyPairGenerator keyGen = KeyPairGenerator.getInstance("RSA");
keyGen.initialize(2048); // 可以指定密钥长度，如2048位
return keyGen.generateKeyPair();
}
}2.4 फ़्रंटएंड और बैकएंड का संयोजन
फ़्रंटएंड में एन्क्रिप्शन, बैकएंड में डिक्रिप्शन
बैकएंड कोड ऊपर दिए उदाहरण जैसा ही है। अंतर यह है कि सार्वजनिक कुंजी प्राप्त होने के बाद हम उसे प्रिंट कर सकते हैं; आगे इस सार्वजनिक कुंजी को फ़्रंटएंड तक पहुँचाना होगा：
public static void main(String[] args) { try { KeyPair keyPair = generateRSAKeyPair(); PublicKey publicKey = keyPair.getPublic(); PrivateKey privateKey = keyPair.getPrivate();
System.out.println("公钥: " + Base64.getEncoder().encodeToString(publicKey.getEncoded())); String originalData = "Hello, 江南一点雨!"; String encryptedData = encrypt(publicKey, originalData); String decryptedData = decrypt(privateKey, encryptedData);
System.out.println("加密后的数据: " + encryptedData);
System.out.println("解密后的数据: " + decryptedData);
} catch (Exception e) {
e.printStackTrace();
}
}फ़्रंटएंड कोड इस प्रकार है：
<!DOCTYPE html><html lang="en"><head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>RSA Encryption Example</title> <!-- 引入jsencrypt库 --> <script src="https://cdn.jsdelivr.net/npm/[email protected]/bin/jsencrypt.min.js"></script></head><body><script> // 重写前端加密方法 function encryptData(publicKey, data) { // 创建一个新的JSEncrypt对象 var encryptor = new JSEncrypt(); // 设置公钥 encryptor.setPublicKey(publicKey); // 加密数据 var encrypted = encryptor.encrypt(data); return encrypted; } // 示例公钥（实际使用时应该替换为服务器提供的公钥） var publicKey = `MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnP5FOXIghidLDE2FgFwzi4Y+qTdYjnc0eMoiL5i4gdOeTE+7Uu9YvDB51GcBWKD9lvmZr5rX8z0OBpwe526qsTekNpXoIVk9DB34US0HOrAXEEwpUTVuSR656cJGAwmWBkVaalQynEz4Dlzrm53zExVYueruYUuzFyuZDaQcFnl3rWUH/XDkCIe23z0R1TfT3Q2OYNKft0u56r0S/ko99utXuYJK9yowe7QGT6q4cSJwsITQTomCARAq9q+bSNuGEYa4FlYCKIKWIhKbMhz0FYIMB2fJN10GyZbbvKASqeMkuCoD2Efgd8/6uMwOaMcx9LgEkcFaQ3qgDutsPXNUswIDAQAB`; // 要加密的数据 var data = 'Hello, javaboy!'; // 调用加密方法 var encryptedData = encryptData(publicKey, data); // 输出加密后的数据 console.log('Encrypted Data:', encryptedData);</script></body></html>
बैकएंड पर एन्क्रिप्शन, फ़्रंटएंड पर डिक्रिप्शन
Java में RSA एल्गोरिदम से डेटा एन्क्रिप्ट करना और JavaScript में उसे डिक्रिप्ट करना मतलब सर्वर फ्रंटएंड की सार्वजनिक कुंजी से एन्क्रिप्ट करता है और फ्रंटएंड अपनी निजी कुंजी से डिक्रिप्ट करता है। इस स्थिति में फ्रंटएंड की निजी कुंजी आसानी से चोरी हो सकती है, इसलिए इस तरीके की सलाह नहीं दी जाती। इसलिए मैं इसका उदाहरण भी नहीं दूँगा।
अच्छा, तो दोस्तों के साथ सममित और असममित एन्क्रिप्शन पर एक बार फिर बातचीत हो गई। ऊपर दिए गए सभी उदाहरणों का कोड मैंने, सोंग भाई ने, जाँचकर सफलतापूर्वक चलाया है। आप इन्हें संदर्भ के रूप में इस्तेमाल कर सकते हैं।
