note/98.Java安全.md at 9307c49a047416e1b2a78a7e2e2aaa933f6d189a - note - Gitea代码仓库: Git respository for mengyxu

个人笔记

19 KiB

Raw Blame History

#Java安全 ##为什么要掌握Java安全？

提升逼格，现在市场上的大部分程序员都对Java安全、数据加密等等一无所知，而现在的面试中很多面试官为了凸显自己的高逼格，总爱问你一些安全相关的问题。只有掌握了Java安全相关知识，才能跟面试官站在同一逼格线，进行愉快滴交流。
项目中到处需要。如：账号密码的加密，订单支付的加密，个人资料的加密等等。
初级工程师向中高级工程师进阶的必经之路。 ##什么是加密？
古老的加密方法：《潜伏》中的余则成，收到密码：12 25 13 15 29 19；《模仿游戏》，二战时期，德国的密码机及图灵为了破解德军密码而研制出第一代计算机（图灵机）。
对称加密和非对称加密等等。
MD5，属于消息摘要（Message Digest）。

学习目标

复习字节与字符、字符编码、进制转换、java里的io
一些基本的安全知识
三大风险：窃听风险、篡改风险、冒充风险
重放攻击（wpe）
常用加密算法（对称/非对称）
消息摘要
数字签名
数字证书
Keytool工具的使用
SSL/TLS的工作原理
Https双向认证原理

#凯撒密码 ##第一个案例，对字符进行简单的加密。

对字符数组中所有的字符做+1处理（后面可以转换成+num这个数由通讯双方来协定） ###代码

/**
- @author Camille *对字符简单的加密 */ public class SimpleEncryptionDemo01 {
  
  public static void main(String[] args) { // 确定加密的内容 String content = "i love you tonight 404 see you z"; //加密 String encryptData = encrypt(content); System.out.println("加密后：" + encryptData); //解密 String decryptData = decrypt(encryptData); System.out.println("解密后：" + decryptData); }
  
  /**
  - 加密方法
  - @param content
  - @return */ public static String encrypt(String content) { // 将内容转换成字符数组 char[] charArray = content.toCharArray(); // 遍历出所有字符 for (int i = 0; i < charArray.length; i++) { // 对所有字符进行 + 1操作 charArray[i] = (char) (charArray[i] + 1); } return new String(charArray); }
  /**
  - 解密方法
  - @param encryptData
  - @return */ public static String decrypt(String encryptData) { // 将内容转换成字符数组 char[] charArray = encryptData.toCharArray(); System.out.println(new String(charArray)); // 解密 for (int i = 0; i < charArray.length; i++) { charArray[i] = (char) (charArray[i] - 1); } return new String(charArray); } }

##第二个案例，对字节进行简单的加密。

字节和字符的区别？

UTF-8编码下，一个英文或数字字符就是一个字节
UTF-8编码下，一个汉字代表三个字节。
为什么new String(bytes)的时候回发生乱码，就是因为加密后得到的字节找不到对应的字符。
Base64的原理

###代码

/**
 * @author Camille
 *对字节进行加密
 */
public class SimpleEncryptionDemo2 {

	public static void main(String[] args) {
        // 测试字节字符
        String content = "中文";
        int key = 80;
        String encryptData = encrypt(content,key);
        System.out.println("＋密后:" + encryptData);
        String decryptData = decrypt(encryptData,key);
        System.out.println("解密后:" + decryptData);
	}

	/**
     * 加密
     * 
     * @param content
     * @return
     */
	public static String encrypt(String content,int key) {
        // 第一步，转换成字节数组
        byte[] bytes = content.getBytes();
        System.out.println("打印未加密的字节数组：");
        Util.printBytes(bytes);
        System.out.println("_________________________________________");
        // 第二步，遍历出所有字节，并做+1处理
        for (int i = 0; i < bytes.length; i++) {
            bytes[i] = (byte) (bytes[i] + key);
        }
        System.out.println("打印加密的字节数组：");
        Util.printBytes(bytes);
        System.out.println("_________________________________________");
//		return new String(bytes);
        return Base64.getEncoder().encodeToString(bytes);
	}

	/**
     * 解密
     * @param encryptData
     * @return
     */
	public static String decrypt(String encryptData,int key) {
        // 第一步，转换成字节数组,加密时使用Base64编码，那解密时也要使用Base64解码
        byte[] bytes = Base64.getDecoder().decode(encryptData);
//		byte[] bytes = encryptData.getBytes();
        System.out.println("打印经过两次转换后的字节数组：");
        Util.printBytes(bytes);
        System.out.println("_________________________________________");
        // 解密
        for (int i = 0; i < bytes.length; i++) {
            bytes[i] = (byte) (bytes[i] - key);
        }
        System.out.println("打印解密后的字节数组：");
        Util.printBytes(bytes);
        System.out.println("_________________________________________");
        return new String(bytes);
	}
}

##对称加密与非对称加密

对称加密与非对称加密的区别
- 对称加密。同一把钥匙进行加密和解密
- 非对称加密，公钥加密，私钥解密。

##对称加密的案例常见算法：AES、DES、3DES、TDEA、Blowfish、RC2、RC4、RC5、IDEA、SKIPJACK
AES:高级加密标准（Advanced Encryption Standard)
DES:数据加密标准(Data Encryption Standard) ###对称加密第一个案例，代码，。 public class SymmetricalEncryptionDemo01 {

    public static void main(String[] args) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
            IllegalBlockSizeException, BadPaddingException {
        // 声明要加密的内容
        String content = "今晚404，不见不散";
        //生成key
        SecretKey key = createKey();
        //加密
        String encryptData = encrypt(content, key);
        System.out.println(encryptData);
        //解密
        String decryptData = decrypt(encryptData, key);
        System.out.println(decryptData);
	}

	/**
     * 生成key
     * @return
     * @throws NoSuchAlgorithmException
     */
	public static SecretKey createKey() throws NoSuchAlgorithmException {
        // 生成key
        KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
        SecretKey secretKey = keyGenerator.generateKey();
        return secretKey;
	}

	/**
     * 加密方法
     * 
     * @param content
     * @return
     * @throws InvalidKeyException
     * @throws NoSuchPaddingException
     * @throws NoSuchAlgorithmException
     * @throws BadPaddingException
     * @throws IllegalBlockSizeException
     */
	public static String encrypt(String content, SecretKey key) throws InvalidKeyException, NoSuchAlgorithmException,
            NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
        // 获取cipher单例对象
        Cipher cipher = Cipher.getInstance("AES");
        // 初始化cipher,设置为加密模式
        cipher.init(Cipher.ENCRYPT_MODE, key);
        // 开始加密
        byte[] encryptBytes = cipher.doFinal(content.getBytes());
        return Base64.getEncoder().encodeToString(encryptBytes);
	}

	/**
     * @param encryptData
     * @return
     */
	public static String decrypt(String encryptData, SecretKey key) throws InvalidKeyException,
            NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
        byte[] encryptBytes = Base64.getDecoder().decode(encryptData);
        // 获取cipher单例对象
        Cipher cipher = Cipher.getInstance("AES");
        // 解密
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] decryptBytes = cipher.doFinal(encryptBytes);
        return new String(decryptBytes);
	}
}

###对称加密的第二个案例，将生成的key保存到本地，然后解密时和下一次加密时就只需要到本地读取即可。。

/**
 * @author Camille
 *保存key到本地
 */
public class SymmetricalEncryptionDemo02 {

	public static void main(String[] args) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
            IllegalBlockSizeException, BadPaddingException, IOException, ClassNotFoundException {
        // 声明要加密的内容
        String content = "今晚404，不见不散";
        //第一次生成key,并序列化到本地
//		SecretKey key = createKey();
//		SerializableUtil.saveObject2File("heima.key", key);
        //从文件中读取key
        SecretKey key = (SecretKey) SerializableUtil.readObjectFromFile("heima.key");
        System.out.println(key);
        //加密
        String encryptData = encrypt(content, key);
        System.out.println(encryptData);
        //解密
        String decryptData = decrypt(encryptData, key);
        System.out.println(decryptData);
	}

	/**
     * 生成key
     * @return
     * @throws NoSuchAlgorithmException
     */
	public static SecretKey createKey() throws NoSuchAlgorithmException {
        // 生成key
        KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
        SecretKey secretKey = keyGenerator.generateKey();
        return secretKey;
	}

	/**
     * 加密方法
     * 
     * @param content
     * @return
     * @throws InvalidKeyException
     * @throws NoSuchPaddingException
     * @throws NoSuchAlgorithmException
     * @throws BadPaddingException
     * @throws IllegalBlockSizeException
     */
	public static String encrypt(String content, SecretKey key) throws InvalidKeyException, NoSuchAlgorithmException,
            NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
        // 获取cipher单例对象
        Cipher cipher = Cipher.getInstance("AES");
        // 初始化cipher,设置为加密模式
        cipher.init(Cipher.ENCRYPT_MODE, key);
        // 开始加密
        byte[] encryptBytes = cipher.doFinal(content.getBytes());
        return Base64.getEncoder().encodeToString(encryptBytes);
	}

	/**
     * @param encryptData
     * @return
     */
	public static String decrypt(String encryptData, SecretKey key) throws InvalidKeyException,
            NoSuchAlgorithmException, NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException {
        byte[] encryptBytes = Base64.getDecoder().decode(encryptData);
        // 获取cipher单例对象
        Cipher cipher = Cipher.getInstance("AES");
        // 解密
        cipher.init(Cipher.DECRYPT_MODE, key);
        byte[] decryptBytes = cipher.doFinal(encryptBytes);
        return new String(decryptBytes);
	}
}

保存对象到文件

/**
 * 保存对象到本地
 * 
 * @param obj
 * @throws IOException
 */
public static void saveObject2File(String fileName, Object obj) throws IOException {
	FileOutputStream fos = new FileOutputStream(new File(fileName));
	ObjectOutputStream oos = new ObjectOutputStream(fos);
	oos.writeObject(obj);
}

从文件中读取对象

/**
 * 从文件中读取对象
 * @param fileName
 * @return
 * @throws IOException
 * @throws ClassNotFoundException
 */
public static Object readObjectFromFile(String fileName) throws IOException, ClassNotFoundException {
	FileInputStream fis = new FileInputStream(new File(fileName));
	ObjectInputStream ois = new ObjectInputStream(fis);
	Object object = ois.readObject();
	return object;
}

###第三个案例——自定义秘钥，代码

/**
     * 生成key
     * @return
     * @throws NoSuchAlgorithmException
     */
	public static SecretKey createKey(String keyword) throws NoSuchAlgorithmException {
        // 生成key
        KeyGenerator keyGenerator = KeyGenerator.getInstance("AES");
        keyGenerator.init(new SecureRandom(keyword.getBytes()));
        SecretKey secretKey = keyGenerator.generateKey();
        return secretKey;
	}

###应用场景

##非对称加密的案例常见算法：RSA、Elgamal、背包算法、Rabin、D-H、ECC（椭圆曲线加密算法）等应用场景：银行和电商网站，他就采用非对称加密，将公钥给所有人，你们就用这个公钥加密，私钥我自己留着，谁也不知道，所以除了我，谁也解密不了。 ###第一个案例（数据量不大的情况下可用，加密数据小于117个字节，解密数据小于128个字节） public class AysmmetricEncryptionDemo {

    public static void main(String[] args) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException,
            IllegalBlockSizeException, BadPaddingException {
        String content = "今晚小树林，等你哦";
        //生成密钥对
        KeyPair keyPair = createKeyypair();
        //获取公钥私钥
        PublicKey publicKey = keyPair.getPublic();
        PrivateKey privateKey = keyPair.getPrivate();
        //加密
        String encryptData = encrypt(content, publicKey);
        System.out.println("加密后：" + encryptData);
        //解密
        String decryptData = decrypt(encryptData, privateKey);
        System.out.println("解密后：" + decryptData);
	}
	/**
     * 生成秘钥对
     * @return
     * @throws NoSuchAlgorithmException
     */
	public static KeyPair createKeyypair() throws NoSuchAlgorithmException{
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        return keyPair;
	}
	/**
     * 加密
     * 
     * @param content
     * @return
     * @throws NoSuchPaddingException
     * @throws NoSuchAlgorithmException
     * @throws BadPaddingException
     * @throws IllegalBlockSizeException
     * @throws InvalidKeyException
     */
	public static String encrypt(String content, PublicKey publicKey) throws NoSuchAlgorithmException,
            NoSuchPaddingException, IllegalBlockSizeException, BadPaddingException, InvalidKeyException {
        // 获取cipher对象
        Cipher cipher = Cipher.getInstance("RSA");
        // 初始化cipher，指定模式为加密，传入公钥
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        byte[] encryptBytes = cipher.doFinal(content.getBytes());
        return Base64.getEncoder().encodeToString(encryptBytes);
	}

	/**
     * 解密方法
     * 
     * @param encryptData
     * @param privateKey
     * @return
     * @throws NoSuchPaddingException 
     * @throws NoSuchAlgorithmException 
     * @throws InvalidKeyException 
     * @throws BadPaddingException 
     * @throws IllegalBlockSizeException 
     * @throws Exception
     */
	public static String decrypt(String encryptData, PrivateKey privateKey) throws NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException{
        byte[] encryptBytes = Base64.getDecoder().decode(encryptData);
        // 获取cipher对象
        Cipher cipher = Cipher.getInstance("RSA");
        // 小芝解密
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        byte[] decryptBytes = cipher.doFinal(encryptBytes);
        return new String(decryptBytes);
	}
}

###如果数据量大的话，则要对要加密、解密的数据进行分块处理，代码如下：

    /**
         * 处理大量数据时，分块加密/解密
         * @param content
         * @param cipher
         * @param max
         * @return
         * @throws IllegalBlockSizeException
         * @throws BadPaddingException
         * @throws IOException
         */
        private static byte[] doFinalWithBlock(byte[] bytes, Cipher cipher,int max)
                throws IllegalBlockSizeException, BadPaddingException, IOException {
            int len = bytes.length;//3000
            //加密数据长度不能超过117个byte
            int inputOffset = 0;//2700
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            while (len > inputOffset) {
                //特殊情况，最后一次剩下的数据不足117
                if ((len - inputOffset) >= max) {
                    byte[] encryptBytes = cipher.doFinal(bytes, inputOffset, max);
                    baos.write(encryptBytes);
                    inputOffset += max;
                }else {
                    byte[] encryptBytes = cipher.doFinal(bytes, inputOffset, len - inputOffset);
                    baos.write(encryptBytes);
                    inputOffset = len;
                }
            }
            byte[] byteArray = baos.toByteArray();
            return byteArray;
        }

##消息摘要消息摘要是一个不可逆的过程。常用来防篡改。

常见算法：MD5、SHA、CRC等

###byte数组和16进制字符串的互转

/**
     * byte数组转16进制字符串
     * @param bytes
     * @return
     */
	public static String bytes2Hex(byte[] bytes){
        StringBuffer sBuffer = new StringBuffer();
        for (int i = 0; i < bytes.length; i++) {
            //取高位
            int high = (bytes[i] & 0xf0) >> 4;
            //取低位
            int low = bytes[i] & 0x0f;
            sBuffer.append(HEXSTR[high]).append(HEXSTR[low]);
        }
        return sBuffer.toString();
	}

/**
     * 16进制字符串转字节数组
     * @param hex
     * @return
     */
	public static byte[] hex2Bytes(String hex){
        int len = hex.length()/2;
        //声明一个字节数组用于接收转换后的字节
        byte[] bytes = new byte[len];
        for (int i = 0; i < len; i++) {
            //首先取高位,取偶数位
            String highStr = hex.substring(2 * i, 2 * i + 1);
            String lowStr = hex.substring(2 * i + 1, 2 * i + 2);
            int high = Integer.parseInt(highStr, 16) << 4;
            int low = Integer.parseInt(lowStr, 16);
            bytes[i] = (byte) (high + low);
        }
        return bytes;
	}

##数字签名

签名过程

        String content = "404房卡";
        Signature signature = Signature.getInstance("MD5withRSA");
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        PrivateKey privateKey = keyPair.getPrivate();
        PublicKey publicKey = keyPair.getPublic();
        signature.initSign(privateKey);
        signature.update(content.getBytes());
        byte[] sign = signature.sign();

###数字签名的流程(画图理解) ###Signature**

//小芝认证
        signature.initVerify(publicKey);
        //我们要对房卡进行认证
//		String content2 = "505的房卡";
        signature.update(content.getBytes());
        boolean verify = signature.verify(sign);
        Util.printBytes(sign);
        System.out.println(verify);

##keytool的使用。

生成keyPair keytool -genkeypair
修改别名 keytool -changealias -alias mykey -destalias heima1
导出证书 keytool -exportcert
导入证书 keytool -importcert

获取文件中的证书

    // 获取证书工厂的实例
            CertificateFactory cf = CertificateFactory.getInstance("X.509");
            FileInputStream inStream = new FileInputStream(new File("heima.cer"));
            X509Certificate certificate = (X509Certificate) cf.generateCertificate(inStream);

##SSl 双向认证的原理 代码访问12306

    public class HttpsDemo {
	
        public static void main(String[] args) throws IOException, NoSuchAlgorithmException, KeyManagementException, KeyStoreException, CertificateException {
            //第一种方式，我所有的证书都不检查
            SSLContext sslContext = SSLContext.getInstance("TLS");//TLS 是transport Layer safe
            //获取信任管理者工厂
            TrustManagerFactory trustManagerFactory = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
            //获取keyStore
            KeyStore ks = KeyStore.getInstance(KeyStore.getDefaultType());
            ks.load(null);
            //从文件中读取证书
            CertificateFactory cf = CertificateFactory.getInstance("X.509");
            FileInputStream inStream = new FileInputStream(new File("srca.cer"));
            X509Certificate cert = (X509Certificate) cf.generateCertificate(inStream);
            //给keyStore设置证书
            ks.setCertificateEntry("12306", cert);
            trustManagerFactory.init(ks);
            TrustManager[] tm = trustManagerFactory.getTrustManagers();
            sslContext.init(null, tm, null);
            SSLSocketFactory socketFactory = sslContext.getSocketFactory();
            HttpsURLConnection.setDefaultSSLSocketFactory(socketFactory);
            // TODO Auto-generated method stub
            URL url = new URL("https://kyfw.12306.cn/otn/");
            //第二步，获取coon
            HttpsURLConnection coon = (HttpsURLConnection) url.openConnection();
            InputStream inputStream = coon.getInputStream();
            String response = Util.inputStream2String(inputStream);
            System.out.println(response);
        }
	}

19 KiB Raw Blame History

学习目标

19 KiB

Raw Blame History