Android關於RSA加密和解密
新APP用了RSA加密進行傳輸
本來除錯的時候,本地加密解密很愉快
加密方法
解密方法public static byte[] encryptData(byte[] data, PublicKey publicKey) { try { Cipher cipher = Cipher.getInstance("RSA"); cipher.init(Cipher.ENCRYPT_MODE, publicKey); return cipher.doFinal(data); } catch (Exception e) { e.printStackTrace(); return null; } }
public static byte[] decryptData(byte[] encryptedData, PrivateKey privateKey) { try { Cipher cipher = Cipher.getInstance("RSA"); cipher.init(Cipher.DECRYPT_MODE, privateKey); return cipher.doFinal(encryptedData); } catch (Exception e) { return null; } }
轉著花樣玩,把自己私鑰轉成字串然後再通過生成的私鑰字串轉成私鑰把剛才通過公鑰加密後的內容進行解密以模仿資料真實傳輸.
自己用公鑰加密後的密文是這樣的
DFxJrPu6z1hrlLZQoO7NWXehX350QPt9phkELuGi37780RHzEZYYNP6ZeA98Vo5d/e6RCVkopSJM+X1V/+Jsm8Pzcbm
EkzefCXISkshD4D3to7NAOuxwk7emKi8QZDAEYazI9nTbivKI/92UqYdMKGOxYa6V6kY7jcKxV8qhMDg=
然後自己用私鑰進行解密也是很愉快的 完全沒有問題
後來和服務端聯調的時候出現點小問題
臺給我們傳過來的密文是16進位制的字串
95578b364f62d4c7ea24c9891fa41e407debfcab2098e08fb34faa8a55576e99f0d1bab31026f6e42db883de648ddd
43a5a7de51bb0b7b568d9b46a975ffce127a3997035a10e0203ea87c5d3a8281a7de3f2eee568247e093548fc092
a62b9c26db990c24f8cf4f2c11c589212799079cf93d9ae83bbf51ee97a925bfedee43
我的內心毫無波動,據說是後臺生成的密文是一堆亂碼,我也沒功夫研究後臺日至輸出,猜測是編碼問題,反正不能直接給可以直接解密的字串了,然後就進行了小型轉換,輸出的密文先是進行了Base64的decode,得到的二進位制陣列再轉變成16進位制字串,然後把字串給我們傳過來了
然後我們就需要轉回去,把16進位制的字串轉成2進位制陣列,再進行Base64的encode,得到的就是可以直接用私鑰進行解密的字串了. 同樣,我們向伺服器傳輸的時候需要用同樣的方法,得到的密文先進行decode變成2進位制陣列,然後再轉成16進位制字串,把字串傳遞給後臺
就是這樣,本來挺簡單的,還要多寫很多方法 不去深究了,要是後臺能直接用加密字串就可直接略過這一段,能用就可以
解密除錯中還出現了亂碼問題 後臺和Android端都出現過
解密後的內容還附帶了一堆亂碼,像病毒一樣,真實資料混在亂碼裡面 如圖
"這是明文" 是正確的解密內容,但是多了很多亂碼 iOS貌似沒出問題
後臺和Android都是這樣,後來一起研究發現是解密出現問題 因為iOS解密沒問題 需要在解密方法中做一些修整
Cipher cipher = Cipher.getInstance("RSA"); Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");基本就這樣.沒有寫Demo,其實就兩個工具類
public class RSAUtils {
// private static String RSA = "RSA/ECB/PKCS1Padding";
private static String RSA = "RSA";
/**
* 隨機生成RSA金鑰對(預設金鑰長度為1024)
*
* @return
*/
public static KeyPair generateRSAKeyPair() {
return generateRSAKeyPair(1024);
}
/**
* 隨機生成RSA金鑰對
*
* @param keyLength 金鑰長度，範圍：512～2048<br>
* 一般1024
* @return
*/
public static KeyPair generateRSAKeyPair(int keyLength) {
try {
KeyPairGenerator kpg = KeyPairGenerator.getInstance(RSA);
kpg.initialize(keyLength);
return kpg.genKeyPair();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
return null;
}
}
/**
* 用公鑰加密 <br>
* 每次加密的位元組數，不能超過金鑰的長度值減去11
*
* @param data 需加密資料的byte資料
* @param publicKey 公鑰
* @return 加密後的byte型資料
*/
public static byte[] encryptData(byte[] data, PublicKey publicKey) {
try {
Cipher cipher = Cipher.getInstance(RSA);
// 編碼前設定編碼方式及金鑰
cipher.init(Cipher.ENCRYPT_MODE, publicKey);
// 傳入編碼資料並返回編碼結果
return cipher.doFinal(data);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
/**
* 用私鑰解密
*
* @param encryptedData 經過encryptedData()加密返回的byte資料
* @param privateKey 私鑰
* @return
*/
public static byte[] decryptData(byte[] encryptedData, PrivateKey privateKey) {
try {
Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
cipher.init(Cipher.DECRYPT_MODE, privateKey);
return cipher.doFinal(encryptedData);
} catch (Exception e) {
return null;
}
}
/**
* 通過公鑰byte[](publicKey.getEncoded())將公鑰還原，適用於RSA演算法
*
* @param keyBytes
* @return
* @throws NoSuchAlgorithmException
* @throws InvalidKeySpecException
*/
public static PublicKey getPublicKey(byte[] keyBytes) throws NoSuchAlgorithmException,
InvalidKeySpecException {
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(RSA);
PublicKey publicKey = keyFactory.generatePublic(keySpec);
return publicKey;
}
/**
* 通過私鑰byte[]將公鑰還原，適用於RSA演算法
*
* @param keyBytes
* @return
* @throws NoSuchAlgorithmException
* @throws InvalidKeySpecException
*/
public static PrivateKey getPrivateKey(byte[] keyBytes) throws NoSuchAlgorithmException,
InvalidKeySpecException {
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(RSA);
PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
return privateKey;
}
/**
* 使用N、e值還原公鑰
*
* @param modulus
* @param publicExponent
* @return
* @throws NoSuchAlgorithmException
* @throws InvalidKeySpecException
*/
public static PublicKey getPublicKey(String modulus, String publicExponent)
throws NoSuchAlgorithmException, InvalidKeySpecException {
BigInteger bigIntModulus = new BigInteger(modulus);
BigInteger bigIntPrivateExponent = new BigInteger(publicExponent);
RSAPublicKeySpec keySpec = new RSAPublicKeySpec(bigIntModulus, bigIntPrivateExponent);
KeyFactory keyFactory = KeyFactory.getInstance(RSA);
PublicKey publicKey = keyFactory.generatePublic(keySpec);
return publicKey;
}
/**
* 使用N、d值還原私鑰
*
* @param modulus
* @param privateExponent
* @return
* @throws NoSuchAlgorithmException
* @throws InvalidKeySpecException
*/
public static PrivateKey getPrivateKey(String modulus, String privateExponent)
throws NoSuchAlgorithmException, InvalidKeySpecException {
BigInteger bigIntModulus = new BigInteger(modulus);
BigInteger bigIntPrivateExponent = new BigInteger(privateExponent);
RSAPublicKeySpec keySpec = new RSAPublicKeySpec(bigIntModulus, bigIntPrivateExponent);
KeyFactory keyFactory = KeyFactory.getInstance(RSA);
PrivateKey privateKey = keyFactory.generatePrivate(keySpec);
return privateKey;
}
/**
* 從字串中載入公鑰
*
* @param publicKeyStr 公鑰資料字串
* @throws Exception 載入公鑰時產生的異常
*/
public static PublicKey loadPublicKey(String publicKeyStr) throws Exception {
try {
byte[] buffer = Base64Utils.decode(publicKeyStr);
KeyFactory keyFactory = KeyFactory.getInstance(RSA);
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
return (RSAPublicKey) keyFactory.generatePublic(keySpec);
} catch (NoSuchAlgorithmException e) {
throw new Exception("無此演算法");
} catch (InvalidKeySpecException e) {
throw new Exception("公鑰非法");
} catch (NullPointerException e) {
throw new Exception("公鑰資料為空");
}
}
/**
* 從字串中載入私鑰<br>
* 載入時使用的是PKCS8EncodedKeySpec（PKCS#8編碼的Key指令）。
*
* @param privateKeyStr
* @return
* @throws Exception
*/
public static PrivateKey loadPrivateKey(String privateKeyStr) throws Exception {
try {
byte[] buffer = Base64Utils.decode(privateKeyStr);
// X509EncodedKeySpec keySpec = new X509EncodedKeySpec(buffer);
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(buffer);
KeyFactory keyFactory = KeyFactory.getInstance(RSA);
return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);
} catch (NoSuchAlgorithmException e) {
throw new Exception("無此演算法");
} catch (InvalidKeySpecException e) {
throw new Exception("私鑰非法");
} catch (NullPointerException e) {
throw new Exception("私鑰資料為空");
}
}
/**
* 從檔案中輸入流中載入公鑰
*
* @param in 公鑰輸入流
* @throws Exception 載入公鑰時產生的異常
*/
public static PublicKey loadPublicKey(InputStream in) throws Exception {
try {
return loadPublicKey(readKey(in));
} catch (IOException e) {
throw new Exception("公鑰資料流讀取錯誤");
} catch (NullPointerException e) {
throw new Exception("公鑰輸入流為空");
}
}
/**
* 從檔案中載入私鑰
*
* @param in 私鑰檔名
* @return 是否成功
* @throws Exception
*/
public static PrivateKey loadPrivateKey(InputStream in) throws Exception {
try {
return loadPrivateKey(readKey(in));
} catch (IOException e) {
throw new Exception("私鑰資料讀取錯誤");
} catch (NullPointerException e) {
throw new Exception("私鑰輸入流為空");
}
}
/**
* 讀取金鑰資訊
*
* @param in
* @return
* @throws IOException
*/
private static String readKey(InputStream in) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(in));
String readLine = null;
StringBuilder sb = new StringBuilder();
while ((readLine = br.readLine()) != null) {
if (readLine.charAt(0) == '-') {
continue;
} else {
sb.append(readLine);
sb.append('\r');
}
}
return sb.toString();
}
/**
* 列印公鑰資訊
*
* @param publicKey
*/
public static void printPublicKeyInfo(PublicKey publicKey) {
RSAPublicKey rsaPublicKey = (RSAPublicKey) publicKey;
System.out.println("----------RSAPublicKey----------");
System.out.println("Modulus.length=" + rsaPublicKey.getModulus().bitLength());
System.out.println("Modulus=" + rsaPublicKey.getModulus().toString());
System.out.println("PublicExponent.length=" + rsaPublicKey.getPublicExponent().bitLength());
System.out.println("PublicExponent=" + rsaPublicKey.getPublicExponent().toString());
}
public static void printPrivateKeyInfo(PrivateKey privateKey) {
RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) privateKey;
System.out.println("----------RSAPrivateKey ----------");
System.out.println("Modulus.length=" + rsaPrivateKey.getModulus().bitLength());
System.out.println("Modulus=" + rsaPrivateKey.getModulus().toString());
System.out.println("PrivateExponent.length=" + rsaPrivateKey.getPrivateExponent().bitLength());
System.out.println("PrivatecExponent=" + rsaPrivateKey.getPrivateExponent().toString());
}
/**
* 得到金鑰字串（經過base64編碼）
*
* @return
*/
public static String getKeyString(Key key) throws Exception {
byte[] keyBytes = key.getEncoded();
String s = Base64Utils.encode(keyBytes);
return s;
}
/**
* 16進位制字串轉位元組陣列
* @param src
* 16進位制字串
* @return 位元組陣列
* @throws
*/
public static byte[] hexString2Bytes(String src) {
int l = src.length() / 2;
byte[] ret = new byte[l];
for (int i = 0; i < l; i++) {
ret[i] = (byte) Integer
.valueOf(src.substring(i * 2, i * 2 + 2), 16).byteValue();
}
return ret;
}
/**
* 16進位制字串轉字串
* @param src
* 16進位制字串
* @return 位元組陣列
* @throws
*/
public static String hexString2String(String src) {
String temp = "";
for (int i = 0; i < src.length() / 2; i++) {
temp = temp
+ (char) Integer.valueOf(src.substring(i * 2, i * 2 + 2),
16).byteValue();
}
return temp;
}
/**
* 字串轉16進位制字串
* @param strPart
* 字串
* @return 16進位制字串
* @throws
*/
public static String string2HexString(String strPart) {
StringBuffer hexString = new StringBuffer();
for (int i = 0; i < strPart.length(); i++) {
int ch = (int) strPart.charAt(i);
String strHex = Integer.toHexString(ch);
hexString.append(strHex);
}
return hexString.toString();
}
/**
* 位元組陣列轉16進位制字串
* @param b
* 位元組陣列
* @return 16進位制字串
* @throws
*/
public static String bytes2HexString(byte[] b) {
StringBuffer result = new StringBuffer();
String hex;
for (int i = 0; i < b.length; i++) {
hex = Integer.toHexString(b[i] & 0xFF);
if (hex.length() == 1) {
hex = '0' + hex;
}
result.append(hex.toUpperCase());
}
return result.toString();
}
}
還有個Base64的
public class Base64Utils {
private static char[] base64EncodeChars = new char[]
{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T',
'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5',
'6', '7', '8', '9', '+', '/'};
private static byte[] base64DecodeChars = new byte[]
{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, 52, 53,
54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29,
30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1,
-1, -1, -1};
/**
* 加密
*
* @param data
* @return
*/
public static String encode(byte[] data) {
StringBuffer sb = new StringBuffer();
int len = data.length;
int i = 0;
int b1, b2, b3;
while (i < len) {
b1 = data[i++] & 0xff;
if (i == len) {
sb.append(base64EncodeChars[b1 >>> 2]);
sb.append(base64EncodeChars[(b1 & 0x3) << 4]);
sb.append("==");
break;
}
b2 = data[i++] & 0xff;
if (i == len) {
sb.append(base64EncodeChars[b1 >>> 2]);
sb.append(base64EncodeChars[((b1 & 0x03) << 4) | ((b2 & 0xf0) >>> 4)]);
sb.append(base64EncodeChars[(b2 & 0x0f) << 2]);
sb.append("=");
break;
}
b3 = data[i++] & 0xff;
sb.append(base64EncodeChars[b1 >>> 2]);
sb.append(base64EncodeChars[((b1 & 0x03) << 4) | ((b2 & 0xf0) >>> 4)]);
sb.append(base64EncodeChars[((b2 & 0x0f) << 2) | ((b3 & 0xc0) >>> 6)]);
sb.append(base64EncodeChars[b3 & 0x3f]);
}
return sb.toString();
}
/**
* 解密
*
* @param str
* @return
*/
public static byte[] decode(String str) {
try {
return decodePrivate(str);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
return new byte[]
{};
}
private static byte[] decodePrivate(String str) throws UnsupportedEncodingException {
StringBuffer sb = new StringBuffer();
byte[] data = null;
data = str.getBytes("US-ASCII");
int len = data.length;
int i = 0;
int b1, b2, b3, b4;
while (i < len) {
do {
b1 = base64DecodeChars[data[i++]];
} while (i < len && b1 == -1);
if (b1 == -1)
break;
do {
b2 = base64DecodeChars[data[i++]];
} while (i < len && b2 == -1);
if (b2 == -1)
break;
sb.append((char) ((b1 << 2) | ((b2 & 0x30) >>> 4)));
do {
b3 = data[i++];
if (b3 == 61)
return sb.toString().getBytes("iso8859-1");
b3 = base64DecodeChars[b3];
} while (i < len && b3 == -1);
if (b3 == -1)
break;
sb.append((char) (((b2 & 0x0f) << 4) | ((b3 & 0x3c) >>> 2)));
do {
b4 = data[i++];
if (b4 == 61)
return sb.toString().getBytes("iso8859-1");
b4 = base64DecodeChars[b4];
} while (i < len && b4 == -1);
if (b4 == -1)
break;
sb.append((char) (((b3 & 0x03) << 6) | b4));
}
return sb.toString().getBytes("iso8859-1");
}
}
最後應用
加密
String source = "3月2日";
byte[] encryptByte = RSAUtils.encryptData(source.getBytes(), publicKey111);
String afterencrypt = Base64Utils.encode(encryptByte);最後的字串就是 加密後的密文
解密
String encryptContent = Body.getCode();
byte[] decryptByte = RSAUtils.decryptData(Base64Utils.decode(encryptContent), privateKey);
String decryptStr = new String(decryptByte);最後的decryptStr是解密後的字串
大概就是這樣了 RSA只適合用作登入時候加密 正常的資料傳輸用AES就差不多了
相關推薦
什麽是私有密鑰密碼技術——密鑰加密算法采用同一把密鑰進行加密和解密
解密 網絡安全 位操作 線性復雜 對稱 大量 控制 全局 相位 什麽是私有密鑰密碼技術 私有密鑰(Symmetric Key)，又叫對稱密鑰。密鑰加密算法采用同一把密鑰進行加密和解密。它的優點是加密和解密速度非常快，但密鑰的分發和管理比較困難。信息的發送者和接收者必須明確同
關於簡單的加密和解密算法
sss 建議 ace class 算法 dsm length pac data 加密解密 最簡單的就是簡單的字符串連接和運算，可是直接對字符串操作比較麻煩，所以建議一般做法是先把string轉換為byte數組後再進行簡單的異或運算或者其它運算進行加密和解密，終於比對
運維學習之加密和解密
運維 網絡 安全 運維學習之加密與解密： 眾所周知，在網絡的世界裏不存在絕對的安全性。各種釣魚網站，病毒等等危害著我們的網絡環境。所以，作為一個運維人員，在我們利用網絡進行通信時，保證通信的機密性、完整性、可用性是必要的。 我們的日常生活中有以下三點威脅網絡安全的行為： 1.威脅
Java DES 加密和解密源碼
ex18 detail r文件 index nco keyword [] 接口 crypto Java密碼學結構設計遵循兩個原則: 1) 算法的獨立性和可靠性。 2) 實現的獨立性和相互作用性。 算法的獨立性是通過定義密碼服務類來獲得。用戶只需了解密碼算法的概念,而不用
node加密和解密字符串
string 引入 created require ring 地址 var final 變量 參考地址： http://www.cnblogs.com/laogai/p/4664917.html 第一步：引入模塊 var crypto = require(‘crypto‘)
使用Python進行AES加密和解密
Coding color www tor 修改 1年 add 思想 href 摘錄於：http://blog.csdn.net/nurke/article/details/77267081 另外參考：http://www.cnblogs.com/kaituorensheng
shell整理（38）===凱撒加密和解密
加密 凱撒 實現如下圖所示：[[email protected] shell]# bash zong.sh ==================凱撒加密解密============================== 1)輸入字符串，進行凱撒加密（輸入的字符串只能是字母、數字、空格） 2)已
JavaScript前端和Java後端的AES加密和解密
proto creat eight prop pen 保持 超出範圍 system creator 在實際開發項目中，有些數據在前後端的傳輸過程中需要進行加密，那就需要保證前端和後端的加解密需要統一。這裏給大家簡單演示AES在JavaScript前端和Java後端是如何實現
springcloud-加密和解密
之前 endpoint soft security nload network class 處理器 end Spring Cloud具有一個用於在本地解密屬性值的Environment預處理器。它遵循與Config Server相同的規則，並通過encrypt.*具有相
密碼加密和解密
加密 代碼 cnblogs void logs tint image () com 1.程序設計思路 設置兩個功能，加密和解密，加密時先算ASCII值，然後根據規則改變ASCII值，輸出對應的加密字符串，解密時，同樣算出字符串的ASCII，根據規則改變ASCII值，輸出對應
php和java中的加密和解密
padding 而不是 bsp enc openss 解密 div des算法 -c 遇到的java代碼如下： Cipher cipher=Cipher.getInstance("DESede/CBC/PKCS5Padding"); 在php中使用des算法 始終校驗不
h5棋牌源碼租用Java的MD5加密和解密類
哈希函數 網絡問題 pri rgs update array 重要 和數 下載 理解MD5MD5的應用非常廣泛h5棋牌源碼租用(h5.hxforum.com)聯系170618633533企鵝2952777280(http://yhgj8004.com)源碼出售 房卡出售
lua之base64加密和解密算法。
nco 解密 data def group onu PQ html num local function encodeBase64(source_str) local b64chars = ‘ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijk
EOJ 3000 ROT13加密和解密
i++ 出現 put inf OS 小寫字母 註意 順序 tput 應用 ROT13 到一段文字上僅僅只需要檢查字母順序並取代它在 13 位之後的對應字母，有需要超過時則重新繞回 26 英文字母開頭即可。A 換成 N、B 換成 O、依此類推到 M 換成 Z，然後串行反轉：N
加密和解密基礎
加密 解密 密鑰交換1. 互聯網通信為什麽需要加密？ 2. 加密算法 3. 加密協議 1. 互聯網通信為什麽需要加密？ ??互聯網通信的安全要求：??通訊數據的保密性、可靠性、可用性。影響互聯網通信安全性的攻擊：??影響保密性：竊聽、通信量分析??影響可靠性：更改、偽裝、重放（截取雙方通信的報文，並重復發送
系統安全之數據的加密和解密、CA的介紹、SSL或TLS協議簡介及握手過程
網絡運維 網絡通信需要安全 所謂的網絡通信就是進程與進程之間的通信 然而進程的通信一般可以分成兩類：1、同一主機之間的進程通信
數據的加密和解密
系統 運維 數據加密和解密： 安全實現的目標： 機密性：，保證數據信息不泄露； 完整性：integrety，保證信息不被篡改； 可用性：availability，保證數據信息的內在價值； 威脅安全的行為： 威脅機密性的攻擊行為：竊聽，網絡嗅探，通信量分析； 威
Spring Cloud Config 加密和解密
spring Spring Cloud Config 先決條件：要使用加密和解密功能，您需要在JVM中安裝全面的JCE（默認情況下不存在）。您可以從Oracle下載“Java加密擴展（JCE）無限強度管理策略文件”，並按照安裝說明（實際上將JRE lib / security目錄中的2個策略文件替
RSA加密和解密工具類
min ktr pan util 解密工具 verify 生成器 ace dmi 1 import org.apache.commons.codec.binary.Base64; 2 3 import javax.crypto.Cipher; 4 imp
VUE中的 AES加密和解密
加密 pad aes加密 加密和解密 解密 如果 name con ase import CryptoJS from ‘crypto-js/crypto-js‘ // 默認的 KEY 與 iv 如果沒有給 const KEY = CryptoJS.enc.Utf8.pa