archive

Mon, 01 Jan 0001 00:00:00 +0000

Intro #

原理 #

实现 #

import org.bouncycastle.jce.provider.BouncyCastleProvider;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.AlgorithmParameters;
import java.security.SecureRandom;
import java.security.Security;
import java.util.Base64;

public class AES {

 //加密方式
 private static final String ALGORITHM = "AES";
 //数据填充方式
 private static final String CIPHER_ALGORITHM = "AES/CBC/PKCS7Padding";
 /**
 * 默认编码
 */
 private static final String CHARSET = "utf-8";

 //避免重复new生成多个BouncyCastleProvider对象，因为GC回收不了，会造成内存溢出
 //只在第一次调用decrypt()方法时才new 对象
 public static boolean initialized = false;

 static { Security.addProvider(new BouncyCastleProvider());}

 public static byte[] generateKey() throws Exception {
 KeyGenerator keyGenerator = KeyGenerator.getInstance(ALGORITHM);
 SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG", "SUN");
 secureRandom.setSeed((CIPHER_ALGORITHM + "NEW_BRUSH").getBytes());
 keyGenerator.init(256, secureRandom);//要生成多少位，只需要修改这里即可128, 192或256
 SecretKey originalKey = keyGenerator.generateKey();
 return originalKey.getEncoded();
 }

 public static AlgorithmParameters generateIV(byte[] iv) throws Exception {
 AlgorithmParameters params = AlgorithmParameters.getInstance("AES");
 params.init(new IvParameterSpec(iv));
 return params;
 }

 /**
 * 加密
 */
 public static String encrypt(String content, byte[] key, byte[] iv) {
 try {
 byte[] originalContent = content.getBytes(CHARSET);
 Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
 SecretKeySpec skeySpec = new SecretKeySpec(key, ALGORITHM);
 cipher.init(Cipher.ENCRYPT_MODE, skeySpec, new IvParameterSpec(iv));
 byte[] encrypted = cipher.doFinal(originalContent);
 return Base64.getEncoder().encodeToString(encrypted);
 } catch (Exception e) {
 throw new RuntimeException(e);
 }
 }

 /**
 * AES解密
 * 填充模式AES/CBC/PKCS7Padding
 * 解密模式128
 * @return 目标密文
 */
 public static String decrypt(String content, byte[] key, byte[] iv) {
 try {
 byte[] originalContent = Base64.getDecoder().decode(content);
 Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
 SecretKey sKeySpec = new SecretKeySpec(key, ALGORITHM);
 cipher.init(Cipher.DECRYPT_MODE, sKeySpec, generateIV(iv));// 初始化
 byte[] result = cipher.doFinal(originalContent);
 return new String(result,CHARSET);
 } catch (Exception e) {
 throw new RuntimeException(e);
 }
 }
}

Reference #

Mon, 01 Jan 0001 00:00:00 +0000

Intro #

原理 #

实现 #

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.AlgorithmParameters;
import java.security.Key;
import java.util.Base64;

public class DES {

 /**
 * 偏移变量，固定占8位字节
 */
 private final static String IV_PARAMETER = "12345678";
 /**
 * 密钥算法
 */
 private static final String ALGORITHM = "DES";
 /**
 * 加密/解密算法-工作模式-填充模式
 */
 private static final String CIPHER_ALGORITHM = "DES/CBC/PKCS5Padding";
 /**
 * 默认编码
 */
 private static final String CHARSET = "utf-8";

 /**
 * 生成key
 *
 * @param key
 * @return
 * @throws Exception
 */
 private static SecretKey generateKey(String key) throws Exception {
 DESKeySpec dks = new DESKeySpec(key.getBytes(CHARSET));
 SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(ALGORITHM);
 return keyFactory.generateSecret(dks);
 }

 public static AlgorithmParameters generateIV(byte[] iv) throws Exception {
 AlgorithmParameters params = AlgorithmParameters.getInstance(ALGORITHM);
 params.init(new IvParameterSpec(iv));
 return params;
 }

 /**
 * DES加密字符串
 *
 * @param key 加密密码，长度不能够小于8位
 * @param data 待加密字符串
 * @return 加密后内容
 */
 public static String encrypt(String data, byte[] key, byte[] iv) {
 if (key == null || key.length < 8) {
 throw new RuntimeException("加密失败，key不能小于8位");
 }
 if (data == null)
 return null;
 try {
 SecretKey secretKey = generateKey(new String(key));
 Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
 IvParameterSpec ivParameterSpec = new IvParameterSpec(iv);
 cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivParameterSpec);
 byte[] bytes = cipher.doFinal(data.getBytes(CHARSET));
 return new String(Base64.getEncoder().encode(bytes));

 } catch (Exception e) { e.printStackTrace(); return data;}
 }

 /**
 * DES解密字符串
 *
 * @param key 解密密码，长度不能够小于8位
 * @param data 待解密字符串
 * @return 解密后内容
 */
 public static String decrypt(String data, byte[] key, byte[] iv) {
 if (key== null || key.length < 8) {
 throw new RuntimeException("加密失败，key不能小于8位");
 }
 if (data == null)
 return null;
 try {
 SecretKey secretKey = generateKey(new String(key));
 Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);
 IvParameterSpec ivParameterSpec = new IvParameterSpec(iv);
 cipher.init(Cipher.DECRYPT_MODE, secretKey, ivParameterSpec);
 return new String(cipher.doFinal(Base64.getDecoder().decode(data.getBytes(CHARSET))), CHARSET);
 } catch (Exception e) { e.printStackTrace(); return data;}
 }
}

Reference #

https://blog.csdn.net/gs12software/article/details/83899389

Mon, 01 Jan 0001 00:00:00 +0000

Intro(RSA) #
- 前情提要 #
  - 欧拉函数 #
    
    欧拉函数 \(\varphi(n)\) 是小于等于 n 的正整数中与 n 互质的数的数目。
    例如：\(\varphi(8) = 4\)，因为 1，3，5 和 7 均与 8 互质。
    
    有如下性质：
    1. 欧拉函数是积性函数，即是说若 m,n 互质，则 \(\varphi(m*n) = \varphi(m) * \varphi(n)\)。
    2. 如果 n 为质数，则 \(\varphi(n) = n - 1\)。
  - 同余 #
    
    对某两个整数 a b，若它们除以正整数 m 所得的余数相等，则称 a b 对于模 m 同余，也就是说，存在整数 k 使得 \(a - b = km\)，则称 a,b 对于 m 来说是同余的，一般记作 \(a \equiv b \pmod{m}\)。
    比如 \(26 - 14 = 12 = 1 * 12\)
    记作 \(26 \equiv 14 \pmod{12}\)

archive

Intro #

原理 #

实现 #

Reference #

Intro #

原理 #

实现 #

Reference #

Intro(RSA) #

前情提要 #

欧拉函数 #

同余 #