Java密码学相关知识梳理

ASCII编码

public static void main(String[] args) {
 char a = 'A';
 int code = a;
 System.out.println(code);
 String s = "frank";
 char[] chars = s.toCharArray();
 for (char c : chars) {
 int num = c;
 System.out.println(num);
 }
}

凯撒加密

public static void main(String[] args) {
 String s = "frank";
 int key = 3;
 String encriptData = KaiserEncrypt(s, key);
 System.out.println("encriptData="+encriptData);
 String decriptData = KaiserDecrypt(encriptData, key);
 System.out.println("decriptData="+decriptData);
 /**
 * result as below:
 * encriptData=iudqn
 * decriptData=frank
 */
 }
 /**
 *
 * @param orignal:原文
 * @param key:秘钥
 * @return:返回值
 */
 private static String KaiserEncrypt(String orignal, int key) {
 char[] chars = orignal.toCharArray();
 StringBuilder sb = new StringBuilder();
 for (char aChar : chars) {
 // 获取字符的ASCII编码
 int asciiCode = aChar;
 // 偏移数据
 asciiCode += key;
 // 将偏移后的数据转为字符
 char result = (char) asciiCode;
 // 拼接数据
 sb.append(result);
 }
 return sb.toString();
 }
 /**
 *
 * @param encryptedData 密文
 * @param key 秘钥
 * @return
 */
 private static String KaiserDecrypt(String encryptedData, int key) {
 char[] chars = encryptedData.toCharArray();
 StringBuilder sb = new StringBuilder();
 for (char aChar : chars) {
 int asciiCode = aChar;
 asciiCode -= key;
 char result = (char) asciiCode;
 sb.append(result);
 }
 return sb.toString();
 }

频度分析法破解恺撒加密

对称加密

public class DESDemo {
 // DES加密算法,key的大小必须是8个字节
 public static void main(String[] args) throws Exception {
 String input = "frank";
 String key = "12345678";
 // 指定获取Cipher的算法,如果没有指定分组密码模式和填充模式,ECB/PKCS5Padding就是默认值
 // CBC模式,必须指定初始向量,初始向量中密钥的长度必须是8个字节
 // NoPadding模式,原文的长度必须是8个字节的整倍数
// String transformation = "DES";
 String transformation = "DES/CBC/PKCS5Padding";
 // 指定获取密钥的算法
 String algorithm = "DES";
 String encryptDES = DESEncrypt(input, key, transformation, algorithm);
 System.out.println("加密:" + encryptDES);
 String s = DESDecrypt(encryptDES, key, transformation, algorithm);
 System.out.println("解密:" + s);
 }
 /**
 *
 * @param input 明文
 * @param key 密钥(DES,密钥的长度必须是8个字节)
 * @param transformation 获取Cipher对象的算法
 * @param algorithm 获取密钥的算法
 * @return 返回密文
 * @throws Exception
 */
 private static String DESEncrypt(String input, String key, String transformation, String algorithm) throws Exception {
 // 1,获取Cipher对象
 Cipher cipher = Cipher.getInstance(transformation);
 // 指定密钥规则
 SecretKeySpec sks = new SecretKeySpec(key.getBytes(), algorithm);
 // 2.初始化向量的秘钥长度需要根据算法而定,des 8个字节长度 aes 16个字节长度
 //这里为了方便,统一使用传来的秘钥
 IvParameterSpec iv = new IvParameterSpec(key.getBytes());
 cipher.init(Cipher.ENCRYPT_MODE, sks, iv);
// cipher.init(Cipher.ENCRYPT_MODE, sks);
 // 3. 加密
 byte[] bytes = cipher.doFinal(input.getBytes());
 // 对数据进行Base64编码
 String encode = Base64.encode(bytes);
 return encode;
 }
 
 private static String DESDecrypt(String input, String key, String transformation, String algorithm) throws Exception {
 Cipher cipher = Cipher.getInstance(transformation);
 SecretKeySpec sks = new SecretKeySpec(key.getBytes(), algorithm);
 IvParameterSpec iv = new IvParameterSpec(key.getBytes());
 cipher.init(Cipher.DECRYPT_MODE, sks, iv);
// cipher.init(Cipher.DECRYPT_MODE, sks);
 byte[] bytes = cipher.doFinal(Base64.decode(input));
 return new String(bytes);
 }
}

public class AESDemo {
 // AES加密算法,key的大小必须是16个字节
 public static void main(String[] args) throws Exception {
 String input = "frank";
 String key = "1234567887654321";
 // 指定获取Cipher的算法,如果没有指定分组密码模式和填充模式,ECB/PKCS5Padding就是默认值
 // CBC模式,必须指定初始向量,初始向量中密钥的长度必须是16个字节
 // NoPadding模式,原文的长度必须是16个字节的整倍数
// String transformation = "AES";
 String transformation = "AES/CBC/PKCS5Padding";
 // 指定获取密钥的算法
 String algorithm = "AES";
 String encryptAES = AESEncrypt(input, key, transformation, algorithm);
 System.out.println("加密:" + encryptAES);
 String s = AESDecrypt(encryptAES, key, transformation, algorithm);
 System.out.println("解密:" + s);
 }
 /**
 *
 * @param input 明文
 * @param key 密钥(AES,密钥的长度必须是16个字节)
 * @param transformation 获取Cipher对象的算法
 * @param algorithm 获取密钥的算法
 * @return 返回密文
 * @throws Exception
 */
 private static String AESEncrypt(String input, String key, String transformation, String algorithm) throws Exception {
 // 1,获取Cipher对象
 Cipher cipher = Cipher.getInstance(transformation);
 // 指定密钥规则
 SecretKeySpec sks = new SecretKeySpec(key.getBytes(), algorithm);
 // 2.初始化向量的秘钥长度需要根据算法而定,des 8个字节长度 aes 16个字节长度
 //这里为了方便,统一使用传来的秘钥
 IvParameterSpec iv = new IvParameterSpec(key.getBytes());
 cipher.init(Cipher.ENCRYPT_MODE, sks, iv);
// cipher.init(Cipher.ENCRYPT_MODE, sks);
 // 3. 加密
 byte[] bytes = cipher.doFinal(input.getBytes());
 // 对数据进行Base64编码
 String encode = Base64.encode(bytes);
 return encode;
 }
 private static String AESDecrypt(String input, String key, String transformation, String algorithm) throws Exception {
 Cipher cipher = Cipher.getInstance(transformation);
 SecretKeySpec sks = new SecretKeySpec(key.getBytes(), algorithm);
 IvParameterSpec iv = new IvParameterSpec(key.getBytes());
 cipher.init(Cipher.DECRYPT_MODE, sks, iv);
// cipher.init(Cipher.DECRYPT_MODE, sks);
 byte[] bytes = cipher.doFinal(Base64.decode(input));
 return new String(bytes);
 }
}

非对称加密

1. 对称加密的弊端

2. 非对称加密的秘钥

2.1 场景分析

3. 使用RSA非对称加密通信流程

4. 生成RSA的秘钥对

4.1 一些概念

5. 常见算法

 //后端用私钥加密过的数据
 String eText = "ETLPedgx7vR9E9JGNIj4pLhvurcOM26oo4RgJhmeF5RvDXVdl3qQ+5H6hmUx3dV2K8jPxi5aKSVs1xnjuMgSfK32fjrqzYBULFaBCmnN1HbpcwYFNMA3enWiVwT3TAWFKA9ReJ2DWh0lkCzaHruOmcWCY3f2tjuEE9X9L0DN7m5R9iy2qgEEDPgfzImYYl8wltYdudryz2fQ7UNGdIUPc75EMqdvHEUrxIi5A7cM0BDGQI2aXD+39ijQCOVBtai/9ohF7YXtGmbsocPBKarhe8qpVIcvXza6fBbOWxBC6Z68uRGcljTVkhvNjWrEmRuu5pc3C41bx4OK9FD8kPgITg==";
 //后端给的公钥
 String pkey = "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAmpz9g5IX3ElRtXFo2+9nwD4+amqhEH4Rz1FI2cXeSiQeLPfdCoSsflLovdJ21NxvcKGw9IvmjWkLESCVU/pxDeP2UkVXFAjC2KhZvoQO4v0x4Yn3/55bAAQ9O3qoGatjPlDbzr1CEAi+ZA7NY1Oz2TtOSq8Odc7wc3Sq6U1gZBf87w5jq0GwQwgLrQjaVf5oTgKmavyf6g8Uq8U0QnktXCJpJUsSSZdeWTwAhtKk+MDkd5VRHIynLklOgeAhjG7xzEAad/Q32qLGcCwY+ySiZWLZ5q5uZAys4rj98LiwV6zLyk8CYYclUDUtBPLLXDRN8DUEe4uKAucFC4IlkrXQ0wIDAQAB";
 //获取公钥对象
 KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
 X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.decode(pkey, Base64.DEFAULT));
 PublicKey publicKey = keyFactory.generatePublic(spec);
 //指定解密algorithm = "RSA/ECB/PKCS1Padding"; Cipher cipher = Cipher.getInstance(algorithm);
 algorithm = "RSA/ECB/PKCS1Padding";
 String decrypt = RSADemo.RSADecrypt(algorithm, publicKey, eText, 256);
 System.out.println("decript###" + decrypt + "###");

public class RSADemo {
 private static int MAX_ENCRIPT_SIZE = 200;
 public static void main(String[] args) throws Exception {
 String algorithm = "RSA";
 String input = "frank";
// generateKeys(algorithm, "test.pri", "test.pub");
 PrivateKey privateKey = getPrivateKey("test.pri", algorithm);
 PublicKey publicKey = getPublicKey("test.pub", algorithm);
 String encryptData = RSAEncrypt(algorithm, privateKey, input, MAX_ENCRIPT_SIZE);
 System.out.println("encryptData=" + encryptData);
 String decryptData = RSADecrypt(algorithm, publicKey, encryptData, 256);
 System.out.println("decryptData=" + decryptData);
 }
 public static PrivateKey getPrivateKey(String priPath, String algorithm) throws Exception {
 String privateKeyString = FileUtils.readFileToString(new File(priPath), Charset.defaultCharset());
 KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
 PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.decode(privateKeyString));
 return keyFactory.generatePrivate(spec);
 }
 public static PublicKey getPublicKey(String pubPath, String algorithm) throws Exception {
 String publicKeyString = FileUtils.readFileToString(new File(pubPath), Charset.defaultCharset());
 KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
 X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.decode(publicKeyString));
 return keyFactory.generatePublic(spec);
 }
 public static void generateKeys(String algorithm, String priPath, String pubPath) throws Exception {
 // 获取密钥对生成器
 KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
 // 获取密钥对
 KeyPair keyPair = keyPairGenerator.generateKeyPair();
 // 获取公私钥
 PrivateKey privateKey = keyPair.getPrivate();
 PublicKey publicKey = keyPair.getPublic();
 // 获取公私钥的字节数组
 byte[] privateKeyEncoded = privateKey.getEncoded();
 byte[] publicKeyEncoded = publicKey.getEncoded();
 // 对公私钥进行Base64的编码
 String privateKeyString = Base64.encode(privateKeyEncoded);
 String publicKeyString = Base64.encode(publicKeyEncoded);
 FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.defaultCharset());
 FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.defaultCharset());
 }
 public static String RSAEncrypt(String algorithm, Key key, String input, int maxEncryptSize) throws Exception {
 Cipher cipher = Cipher.getInstance(algorithm);
 cipher.init(Cipher.ENCRYPT_MODE, key);
 byte[] data = input.getBytes();
 int total = data.length;
 int offset = 0;
 ByteArrayOutputStream baos = new ByteArrayOutputStream();
 byte[] bytes;
 while (total - offset > 0) {
 if (total - offset >= maxEncryptSize) {
 bytes = cipher.doFinal(data, offset, maxEncryptSize);
 offset += maxEncryptSize;
 } else {
 bytes = cipher.doFinal(data, offset, total - offset);
 offset = total;
 }
 baos.write(bytes);
 }
 return Base64.encode(baos.toByteArray());
 }
 public static String RSADecrypt(String algorithm, Key key, String input, int maxEncryptSize) throws Exception {
 Cipher cipher = Cipher.getInstance(algorithm);
 cipher.init(Cipher.DECRYPT_MODE, key);
 byte[] data = Base64.decode(input);
 int total = data.length;
 int offset = 0;
 ByteArrayOutputStream baos = new ByteArrayOutputStream();
 byte[] bytes;
 while (total - offset > 0) {
 if (total - offset >= maxEncryptSize) {
 bytes = cipher.doFinal(data, offset, maxEncryptSize);
 offset += maxEncryptSize;
 } else {
 bytes = cipher.doFinal(data, offset, total - offset);
 offset = total;
 }
 baos.write(bytes);
 }
 return baos.toString();
 }
}