CryptoJS AES + PBKDF2 紀錄

原由

在 Browser 沒有讓人心安的密碼存放庫。理想上 Browser 不可存放任何金鑰 Key。但又必需加密，加密需要金錀，在此限制條件下，那金錀就用算的吧。

相應的演算法名為 PBKDF2。

相關文章

CryptoJS AES + PBKDF2

開發平台與相關套件

"react": "^18.3.1",
"crypto-js": "^4.2.0"
"typescript": "^5.6.3",
"webpack": "^5.88.2",
"webpack-cli": "^5.1.4",

原碼紀錄 - 前端加解密

aesHelper.ts

//import CryptoJS from 'crypto-js'
import { PBKDF2, AES, enc, mode, pad, algo } from 'crypto-js'
import { random } from 'crypto-js/lib-typedarrays'

/**
 * AES 256 CBC 加密器
 * @param plaintext 明文
 * @param key 金鑰，需 64 個 HEX 數字
 * @param iv 初始向量，需 32 個 HEX 數字 
 * @returns
 */
function encrypt(plaintext: string, key: string, iv: string) {
  const keyBytes = enc.Hex.parse(key)
  const ivBytes = enc.Hex.parse(iv)

  const encodeAdv = generateRandom32String() + plaintext;
  const plainBlob = enc.Utf8.parse(encodeAdv)
  const cipherBlob = AES.encrypt(plainBlob, keyBytes, { mode: mode.CBC, padding: pad.Pkcs7, iv: ivBytes })
  const ciphertext = cipherBlob.toString()
  return ciphertext
}

/**
 * AES 256 CBC 解密器
 * @param ciphertext 密文
 * @param key 金鑰，需 64 個 HEX 數字
 * @param iv 初始向量，需 32 個 HEX 數字 
 * @returns
 */
function decrypt(ciphertext: string, key: string, iv: string) {
  const keyBytes = enc.Hex.parse(key)
  const ivBytes = enc.Hex.parse(iv)

  const decryptedBlob = AES.decrypt(ciphertext, keyBytes, { mode: mode.CBC, padding: pad.Pkcs7, iv: ivBytes })
  const decryptedText = enc.Utf8.stringify(decryptedBlob)
  const decodeAdv = decryptedText.slice(32)
  return decodeAdv
}

/**
 * 生成一個 32 字元長度的隨機字串
 * @returns
 */
function generateRandom32String() {
  const randomWords = random(24);
  return randomWords.toString(enc.Base64);
}

//-----------------------------------------------------------------------------
/**
 * AES 256 CBC 加密器 + PBKDF2
 */
export function encrypt2(plaintext: string, keySeed: string): string {
  const iterations = 9972
  const salt = enc.Hex.parse('dc8383f5cd494aa9aee4288ae3128aeb')
  const seed = enc.Hex.parse(keySeed)
  const iv = random(128 / 8);
  const ivStr = iv.toString(enc.Hex)

  // 加密
  const key = PBKDF2(seed, salt, { keySize: 256 / 32, iterations, hasher: algo.SHA256 })
  const ciphertext = AES.encrypt(plaintext, key, {
    mode: mode.CBC,
    padding: pad.Pkcs7,
    iv: iv,
  })

  // 加密封包
  //const cipherPackage = ivStr + '.' + ciphertext
  const cipherPackage = ivStr + ciphertext
  return cipherPackage;
}

/**
 * AES 256 CBC 解密器 + PBKDF2
 */
export function decrypt2(cipherPackage: string, keySeed: string): string {
  const iterations = 9972
  const salt = enc.Hex.parse('dc8383f5cd494aa9aee4288ae3128aeb')
  const seed = enc.Hex.parse(keySeed) 
  //const [ivStr, ciphertext] = cipherPackage.split('.')
  const ivStr = cipherPackage.slice(0,32)
  const ciphertext = cipherPackage.slice(32)
  const iv = enc.Hex.parse(ivStr)

  // 解密
  const key = PBKDF2(seed, salt, { keySize: 256 / 32, iterations, hasher: algo.SHA256 })
  const decryptedBlob = AES.decrypt(ciphertext, key, {
    mode: mode.CBC,
    padding: pad.Pkcs7,
    iv: iv
  })

  const decryptedText = enc.Utf8.stringify(decryptedBlob)
  return decryptedText
}

//-----------------------------------------------------------------------------
/**
 * AES 256 CBC 加密器 + PBKDF2
 * 用於本地自身加解密。
 */
export function encrypt3(plaintext: object): string {
  const iterations = 9983
  const salt = enc.Hex.parse('dc8383f5cd494ea9aee4288ae3128aeb')
  const seed = enc.Hex.parse(process.env.AES2_SEED)
  const iv = random(128 / 8);
  const ivStr = iv.toString(enc.Hex)

  // 計算金鑰
  const key = PBKDF2(seed, salt, { keySize: 256 / 32, iterations, hasher: algo.SHA256 })  
  // 加密
  const ciphertext = AES.encrypt(enc.Utf8.parse(JSON.stringify(plaintext)), key, {
    mode: mode.CBC,
    padding: pad.Pkcs7,
    iv: iv,
  })

  // 加密封包
  return ivStr + ciphertext
}

/**
 * AES 256 CBC 解密器 + PBKDF2
 * 用於本地自身加解密。
 */
export function decrypt3(cipherPackage: string): object {
  const iterations = 9983 
  const salt = enc.Hex.parse('dc8383f5cd494ea9aee4288ae3128aeb')
  const seed = enc.Hex.parse(process.env.AES2_SEED)
  //const [ivStr, ciphertext] = cipherPackage.split('.')
  const ivStr = cipherPackage.slice(0, 32)
  const ciphertext = cipherPackage.slice(32)
  const iv = enc.Hex.parse(ivStr)

  // 計算金鑰
  const key = PBKDF2(seed, salt, { keySize: 256 / 32, iterations, hasher: algo.SHA256 })  

  // 解密
  return JSON.parse(enc.Utf8.stringify(AES.decrypt(ciphertext, key, {
    mode: mode.CBC,
    padding: pad.Pkcs7,
    iv: iv
  })))
}

原碼紀錄 - 後端加解密

AesHelper.cs

using System;
using System.Configuration;
using System.IO;
using System.Security.Cryptography;
using System.Text;

internal static class AesHelper
{
  /// <summary>
  /// AES 256 CBC 加密器 - 暫不公開使用
  /// </summary>
  /// <param name="plaintext">明文</param>
  /// <param name="key">HEX64數字</param>
  /// <param name="iv">HEX32數字</param>
  private static string Encrypt(string plaintext, string key = null, string iv = null)
  {
    byte[] keyBytes = HexStringToByteArray(key ?? ConfigurationManager.AppSettings["AES_KEY"]);
    byte[] ivBytes = HexStringToByteArray(iv ?? ConfigurationManager.AppSettings["AES_IV"]);

    var encodeAdv = GenerateRandom32String() + plaintext;
    byte[] plainBlob = Encoding.UTF8.GetBytes(encodeAdv);

    using (Aes aes = Aes.Create())
    {
      aes.Mode = CipherMode.CBC;
      aes.Padding = PaddingMode.PKCS7;
      aes.Key = keyBytes;
      aes.IV = ivBytes;

      using (ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV))
      using (MemoryStream ms = new MemoryStream())
      using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
      {
        cs.Write(plainBlob, 0, plainBlob.Length);
        cs.FlushFinalBlock();
        return Convert.ToBase64String(ms.ToArray());
      }
    }
  }

  /// <summary>
  /// AES 256 CBC 加密器 - 暫不公開使用
  /// </summary>
  /// <param name="ciphertext">密文</param>
  /// <param name="key">HEX64數字</param>
  /// <param name="iv">HEX32數字</param>
  private static string Decrypt(string ciphertext, string key = null, string iv = null)
  {
    byte[] keyBytes = HexStringToByteArray(key ?? ConfigurationManager.AppSettings["AES_KEY"]);
    byte[] ivBytes = HexStringToByteArray(iv ?? ConfigurationManager.AppSettings["AES_IV"]);

    using (Aes aes = Aes.Create())
    {
      aes.Mode = CipherMode.CBC;
      aes.Padding = PaddingMode.PKCS7;
      aes.Key = keyBytes;
      aes.IV = ivBytes;

      byte[] cipherBytes = Convert.FromBase64String(ciphertext);
      using (ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV))
      using (MemoryStream ms = new MemoryStream(cipherBytes))
      using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
      using (StreamReader reader = new StreamReader(cs, Encoding.UTF8))
      {
        var decryptedText = reader.ReadToEnd();
        var decodeAdv = decryptedText.Substring(32);
        return decodeAdv;
      }
    }
  }

  private static byte[] HexStringToByteArray(string hex)
  {
    int numberChars = hex.Length;
    byte[] bytes = new byte[numberChars / 2];
    for (int i = 0; i < numberChars; i += 2)
      bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);
    return bytes;
  }

  private static string ByteArrayToHexString(byte[] ba)
  {
    StringBuilder hex = new StringBuilder(ba.Length * 2);
    foreach (byte b in ba)
      hex.AppendFormat("{0:x2}", b);
    return hex.ToString();
  }

  private static string GenerateRandom32String()
  {
    using (var rng = new RNGCryptoServiceProvider())
    {
      byte[] byteArray = new byte[24];
      rng.GetBytes(byteArray);
      var randomWords = Convert.ToBase64String(byteArray);
      return randomWords;
    }
  }

  private static byte[] GenerateRandomKey(int length)
  {
    using (var rng = new RNGCryptoServiceProvider())
    {
      byte[] keyBlob = new byte[length];
      rng.GetBytes(keyBlob);
      return keyBlob;
    }
  }

  public static string Encrypt2(string plaintext, string seed = null)
  {
    byte[] saltBlob = HexStringToByteArray("dc8383f5cd494aa9aee4288ae3128aeb");
    byte[] seedBlob = HexStringToByteArray(seed ?? ConfigurationManager.AppSettings["AES1_SEED"]);
    byte[] ivBytes = GenerateRandomKey(16);
    string ivStr = ByteArrayToHexString(ivBytes);
    byte[] plainBlob = Encoding.UTF8.GetBytes(plaintext);

    using (var pbkdf2 = new Rfc2898DeriveBytes(seedBlob, saltBlob, 9972, HashAlgorithmName.SHA256))
    {
      var keyBytes = pbkdf2.GetBytes(32);

      using (Aes aes = Aes.Create())
      {
        aes.Mode = CipherMode.CBC;
        aes.Padding = PaddingMode.PKCS7;
        aes.Key = keyBytes;
        aes.IV = ivBytes;

        using (ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV))
        using (MemoryStream ms = new MemoryStream())
        using (CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write))
        {
          cs.Write(plainBlob, 0, plainBlob.Length);
          cs.FlushFinalBlock();
          var ciphertext = Convert.ToBase64String(ms.ToArray());

          // 加密封包
          //const cipherPackage = ivStr + '.' + ciphertext
          var cipherPackage = ivStr + ciphertext;
          return cipherPackage;
        }
      }
    }
  }

  public static string Decrypt2(string cipherPackage, string seed = null)
  {
    byte[] saltBlob = HexStringToByteArray("dc8383f5cd494aa9aee4288ae3128aeb");
    byte[] seedBlob = HexStringToByteArray(seed ?? ConfigurationManager.AppSettings["AES1_SEED"]);
    string ivStr = cipherPackage.Substring(0, 32);
    string ciphertext = cipherPackage.Substring(32);

    using (var pbkdf2 = new Rfc2898DeriveBytes(seedBlob, saltBlob, 9972, HashAlgorithmName.SHA256))
    {
      var keyBytes = pbkdf2.GetBytes(32);
      byte[] ivBytes = HexStringToByteArray(ivStr);

      using (Aes aes = Aes.Create())
      {
        aes.Mode = CipherMode.CBC;
        aes.Padding = PaddingMode.PKCS7;
        aes.Key = keyBytes;
        aes.IV = ivBytes;

        byte[] cipherBytes = Convert.FromBase64String(ciphertext);
        using (ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV))
        using (MemoryStream ms = new MemoryStream(cipherBytes))
        using (CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read))
        using (StreamReader reader = new StreamReader(cs, Encoding.UTF8))
        {
          var decryptedText = reader.ReadToEnd();
          return decryptedText;
        }
      }
    }
  }
}

小結

此份範例的前端 encrypt2/decrypt2 與後端 Encrypt2/Decrypt2 可以互通。

(EOF)