Eins Symmetrische Verschlüsselung
Symmetrische und asymmetrische Verschlüsselung sind zwei unterschiedliche Verschlüsselungsverfahren, die bei der Datensicherheit und Informationsübertragung eine wichtige Rolle spielen. Im Folgenden stelle ich beide Verschlüsselungstechniken einzeln vor:
1.1 Symmetrische Verschlüsselung
Symmetrische Verschlüsselung bedeutet, dass zum Ver- und Entschlüsseln derselbe Schlüssel verwendet wird. Sender und Empfänger müssen also beide über diesen Schlüssel verfügen, um Daten ver- und entschlüsseln zu können.
Gängige symmetrische Verschlüsselungsalgorithmen:
AES（Advanced Encryption Standard, fortgeschrittener Verschlüsselungsstandard）
DES（Datenverschlüsselungsstandard）
3DES (dreifacher Datenverschlüsselungsalgorithmus)
1.2 Eigenschaften symmetrischer Verschlüsselung
Im Allgemeinen hat die symmetrische Verschlüsselung folgende Eigenschaften：
Relativ schnell：Da beim Ver- und Entschlüsseln derselbe Schlüssel verwendet wird, ist symmetrische Verschlüsselung gewöhnlich schneller als asymmetrische Verschlüsselung.
Schlüsselverwaltung：Die größte Herausforderung bei symmetrischer Verschlüsselung liegt in der Verteilung und Verwaltung der Schlüssel. Wird ein Schlüssel offengelegt, ist die Sicherheit der Verschlüsselung gefährdet.
Für große Datenmengen geeignet：Aufgrund ihrer hohen Geschwindigkeit eignet sich die symmetrische Verschlüsselung zum Verschlüsseln großer Datenmengen.
Daran lässt sich erkennen, dass symmetrische Verschlüsselung zwei wesentliche Vorteile hat: Erstens ist sie schnell in der Berechnung; zweitens eignet sie sich für große Datenmengen.
Die symmetrische Verschlüsselung hat jedoch ein entscheidendes Problem: die Schlüsselverwaltung. Wie lässt sich der Schlüssel sicher vom Server zum Client übertragen? Auch bei der Kommunikation mit mehreren Empfängern ist es eine Herausforderung, die Schlüssel so zu verwalten, dass sie nicht offengelegt werden. Das sind die Schwächen der symmetrischen Verschlüsselung.
1.3 Codebeispiel
Als Nächstes zeigt euch Song-ge, wie man mit Java-Code symmetrisch ver- und entschlüsselt.
Für die Implementierung symmetrischer Verschlüsselung in Java verwendet man üblicherweise die Klassen und Schnittstellen der Java Cryptography Architecture（JCA）.
Hier ist ein einfaches Beispiel für symmetrische Ver- und Entschlüsselung mit dem AES-Algorithmus（Advanced Encryption Standard）:
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();
}
}
}Schlüssel generieren：Verwendung von
KeyGeneratorEinen AES-Schlüssel generieren.Verschlüsselung：Verwendung von
CipherKlasse zur Verschlüsselung verwenden, die Daten in Bytes umwandeln und verschlüsseln und anschließend mittels Base64-Kodierung in eine Zeichenfolge umwandeln, um die Speicherung oder Übertragung zu erleichtern.Entschlüsselung: Die verschlüsselte Zeichenfolge wieder in Bytes dekodieren und anschließend mit demselben Schlüssel entschlüsseln.
Beim obigen Code solltet ihr Folgendes beachten:
Die Schlüssellänge (beispielsweise 128 Bit) sollte entsprechend den Sicherheitsanforderungen gewählt werden.
Stellen Sie sicher, dass Schlüssel sicher gespeichert werden, und hinterlegen Sie sie nicht fest im Code.
Für Produktionsumgebungen sollte eine sicherere Strategie zur Schlüsselverwaltung in Betracht gezogen werden.
Aus Sicherheitsgründen verwenden wir normalerweise das oben beschriebene Verfahren zur Schlüsselerzeugung. Ein Merkmal der so erzeugten Schlüssel ist, dass sie sich bei jedem Systemneustart ändern. Wenn du die Schlüsselerzeugung selbst steuern möchtest, kannst du Schlüssel folgendermaßen erzeugen:
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");
}So lässt sich der Schlüssel über selbst übergebene Parameter steuern.
1.4 Zusammenspiel von Frontend und Backend
Bei der sprachübergreifenden Ver- und Entschlüsselung mit AES（etwa zwischen JavaScript und Java）muss sichergestellt werden, dass beide Seiten denselben Schlüssel, denselben Betriebsmodus（z. B. CBC, ECB）, dasselbe Padding-Verfahren（z. B. PKCS5Padding, PKCS7Padding）und denselben Initialisierungsvektor（IV, sofern ein Modus wie CBC verwendet wird, der einen IV benötigt）verwenden.
Zuvor hatte jemand berichtet, dass das Backend seine im Frontend verschlüsselten Daten nie entschlüsseln könne. Deshalb gebe ich, Song Ge, hier auch ein Beispiel für das Zusammenspiel von Frontend und Backend.
Verschlüsselung im Frontend, Entschlüsselung im Backend
Frontend-Code：
<!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>Backend-Code:
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();
}
}
}Beachtet, dass bei der Verschlüsselung im Frontend ein iv-Parameter erzeugt wird, der zusammen mit dem Verschlüsselungsergebnis des Frontends an das Backend übergeben werden muss.
Verschlüsselung im Backend, Entschlüsselung im Frontend
Wenn AES-Verschlüsselung in Java und die Entschlüsselung in JavaScript erfolgt, muss ebenfalls sichergestellt werden, dass beide Seiten denselben Schlüssel, denselben Betriebsmodus wie CBC oder ECB, dasselbe Paddingverfahren wie PKCS5Padding oder PKCS7Padding sowie gegebenenfalls denselben Initialisierungsvektor (IV) verwenden.
Backend-Code:
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();
}
}
}Frontend-Code：
<!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>Den obigen Code zur Ver- und Entschlüsselung bei der Kommunikation zwischen Frontend und Backend habe ich, Song Ge, persönlich getestet；er funktioniert einwandfrei. Wenn ihr so etwas benötigt, setzt euch am besten gleich ein Lesezeichen für diesen Artikel, damit ihr ihn als Referenz nutzen könnt.
II Asymmetrische Verschlüsselung
2.1 Was ist asymmetrische Verschlüsselung?
Asymmetrische Verschlüsselung, auch als Public-Key-Verschlüsselung bezeichnet, ist ein Verschlüsselungsverfahren, das zwei unterschiedliche Schlüssel verwendet（einen öffentlichen und einen privaten Schlüssel）.
Im Allgemeinen weist die asymmetrische Verschlüsselung die folgenden unterschiedlichen Merkmale auf：
Öffentlicher und privater Schlüssel
Erzeugung des öffentlichen und des privaten Schlüssels: Bei der asymmetrischen Verschlüsselung wird ein Schlüsselpaar verwendet. Der öffentliche Schlüssel ist öffentlich zugänglich, sodass jeder darauf zugreifen kann. Der private Schlüssel hingegen ist geheim und nur für seinen Inhaber zugänglich. Diese beiden Schlüssel werden durch mathematische Algorithmen erzeugt und stehen miteinander in Beziehung, doch keiner lässt sich aus dem anderen ableiten.
Hohe Sicherheit
Schwer zu knacken: Wegen der komplexen mathematischen Beziehung zwischen öffentlichem und privatem Schlüssel bietet asymmetrische Verschlüsselung eine hohe Sicherheit. Für Angreifer ist es sehr schwierig, aus dem öffentlichen Schlüssel den privaten abzuleiten, wodurch die Sicherheit der verschlüsselten Daten gewährleistet wird.
Widerstand gegen Angriffe durch Quantencomputer: Einige Blockchain-Projekte beginnen, Verschlüsselungsalgorithmen einzusetzen, die Angriffen durch Quantencomputer standhalten, etwa quantensichere Varianten des Elliptic Curve Digital Signature Algorithm (ECDSA), um künftigen Bedrohungen durch Quantencomputer zu begegnen.
Öffentliche Schlüssel lassen sich bequem verteilen
Öffentlichkeit des öffentlichen Schlüssels：Der öffentliche Schlüssel kann jedem zugänglich gemacht werden und lässt sich daher sehr einfach verteilen. Jeder kann damit Daten verschlüsseln, aber nur der Besitzer des privaten Schlüssels kann sie entschlüsseln.
Authentifizierung und digitale Signaturen
Identitätsprüfung：Der öffentliche Schlüssel kann als Identitätsmerkmal eines Nutzers dienen. Andere können dessen Identität überprüfen, ohne seinen privaten Schlüssel zu kennen. Dies hilft dabei, in dezentralen Netzwerken wie Blockchains vertrauenswürdige Identitäten aufzubauen.
Digitale Signatur: Der Besitzer des privaten Schlüssels kann damit Nachrichten signieren, während andere mit dem öffentlichen Schlüssel die Echtheit der Signatur überprüfen können. Dies gewährleistet die Integrität der Nachricht und die Verlässlichkeit ihrer Herkunft.
Sichere Kommunikation
Verschlüsselte Kommunikation: Mit dem öffentlichen Schlüssel lassen sich Nachrichten verschlüsseln; nur Personen mit dem zugehörigen privaten Schlüssel können sie entschlüsseln. Dies gewährleistet die Datensicherheit während der Kommunikation und verhindert den Zugriff Unbefugter auf die Informationen.
Kontrolle über digitale Vermögenswerte
Blockchain-Adresse und privater Schlüssel: Eine Blockchain-Adresse wird gewöhnlich aus dem öffentlichen Schlüssel abgeleitet. Über den privaten Schlüssel kontrollieren Nutzer die mit dieser Adresse verknüpften digitalen Vermögenswerte. Die Sicherheit des privaten Schlüssels ist für die Sicherheit digitaler Vermögenswerte entscheidend.
Geschwindigkeit der Ver- und Entschlüsselung
Vergleichsweise langsam: Die Ver- und Entschlüsselung mit asymmetrischen Verfahren ist wesentlich langsamer als mit symmetrischen Verfahren, da sie komplexere mathematische Berechnungen erfordert. Dies beeinträchtigt jedoch nicht ihren Einsatz in Bereichen wie sicherer Kommunikation und Authentifizierung.
2.2 Einsatzgebiete asymmetrischer Verschlüsselung
Für asymmetrische Verschlüsselung gibt es zwei klassische Anwendungsszenarien.
Verschlüsselung: Dies ist die uns vertrauteste Anwendung: Verschlüsselung mit dem öffentlichen Schlüssel und Entschlüsselung mit dem privaten Schlüssel.
Signatur: Da das Netzwerk nicht vertrauenswürdig ist, können Daten während der Übertragung manipuliert werden. In diesem Fall lassen sich privater und öffentlicher Schlüssel in umgekehrter Richtung einsetzen: Die Daten werden mit dem privaten Schlüssel signiert und die Signatur mit dem öffentlichen Schlüssel geprüft, um Sicherheit und Integrität der Daten zu gewährleisten.
Bei der zweiten Verwendung beschreiben manche das als Verschlüsselung mit dem privaten Schlüssel und Entschlüsselung mit dem öffentlichen Schlüssel. Jedenfalls wissen alle, dass damit dasselbe gemeint ist.
Obwohl asymmetrische Verschlüsselungsalgorithmen theoretisch zur Datenverschlüsselung und für digitale Signaturen verwendet werden können, stellen ihr hoher Rechenaufwand und ihre geringe Effizienz in der Praxis die größten Hindernisse dar.
Im Vergleich zu symmetrischen Verschlüsselungsalgorithmen ist die Rechengeschwindigkeit asymmetrischer Verschlüsselung um mehrere Größenordnungen niedriger, was ihre Fähigkeit zur Verarbeitung großer Datenmengen erheblich beeinträchtigt. Da außerdem die Ver- und Entschlüsselung asymmetrischer Algorithmen eng mit der Schlüssellänge verknüpft ist und keine Blockverschlüsselungsmodi unterstützt werden, können sie nur kleine Datenmengen verarbeiten, die die Schlüssellänge nicht überschreiten, und keine großen Datenmengen verschlüsseln.
Um die Leistungsnachteile asymmetrischer Verschlüsselung zu überwinden, verwenden moderne Verschlüsselungssysteme üblicherweise eine hybride Verschlüsselungsstrategie, welche die Vorteile symmetrischer und asymmetrischer Verschlüsselung verbindet. Dabei dient die asymmetrische Verschlüsselung hauptsächlich dazu, der anderen Partei sicher einen Schlüssel für die symmetrische Verschlüsselung zu übermitteln（also zur „Schlüsselaushandlung“）. Sobald beide Parteien diesen symmetrischen Schlüssel sicher miteinander teilen, können sie mit effizienten symmetrischen Verschlüsselungsalgorithmen große Datenmengen ver- und entschlüsseln. Dieses kombinierte Vorgehen erhöht sowohl die Effizienz der Verschlüsselung als auch die Sicherheit der Kommunikation und wird in zahlreichen Protokollen für sichere Kommunikation wie SSL/TLS eingesetzt.
Auch im Bereich digitaler Signaturen wurden Anpassungen vorgenommen, um die Effizienz asymmetrischer Verschlüsselung zu erhöhen. Konkret wird zunächst aus den ursprünglichen Daten ein Hashwert fester Länge gebildet（etwa mit MD5 oder SHA）. Anschließend wird dieser Hashwert mit einem asymmetrischen Verschlüsselungsalgorithmus verschlüsselt, wodurch die digitale Signatur entsteht. Da Hashalgorithmen Daten beliebiger Länge effizient auf einen Hashwert fester Länge verdichten können, ist dessen Länge unabhängig von der Größe der ursprünglichen Daten immer gleich, und auch der Signaturvorgang bleibt effizient. Zur Überprüfung der Signatur muss lediglich der Hashwert der ursprünglichen Daten erneut berechnet und mit der entschlüsselten Signatur verglichen werden. So lässt sich schnell feststellen, ob die Daten manipuliert wurden.
2.3 Verschlüsselungsbeispiel
Beispiel für die Ver- und Entschlüsselung mit RSA in Java:
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 Zusammenspiel von Frontend und Backend
Verschlüsselung im Frontend, Entschlüsselung im Backend
Der Backend-Code entspricht dem obigen Beispiel. Der Unterschied besteht darin, dass wir den öffentlichen Schlüssel nach seinem Erhalt ausgeben können. Dieser Schlüssel muss später an das Frontend übergeben werden:
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();
}
}Der Frontend-Code lautet wie folgt：
<!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>
Verschlüsselung im Backend, Entschlüsselung im Frontend
Daten in Java mit dem RSA-Algorithmus zu verschlüsseln und anschließend in JavaScript zu entschlüsseln bedeutet, dass der Server mit dem öffentlichen Schlüssel des Frontends verschlüsselt und das Frontend mit seinem eigenen privaten Schlüssel entschlüsselt. In diesem Szenario kann der private Schlüssel des Frontends sehr leicht gestohlen werden, weshalb diese Verwendung nicht empfohlen wird. Daher verzichte ich auch auf ein Beispiel.
So, damit habe ich mit euch noch einmal über symmetrische und asymmetrische Verschlüsselung gesprochen. Ich, Song Ge, habe den obigen Beispielcode erfolgreich getestet; ihr könnt ihn als Referenz verwenden.
