【人人都懂密码学】一篇最易懂的Java密码学入门教程_getencoded(1)

最新推荐文章于 2024-06-29 11:59:11 发布
最新推荐文章于 2024-06-29 11:59:11 发布
阅读量594 收藏 26
点赞数 15
文章标签： java 密码学 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79985178/article/details/139944663
版权 
    String algorithm = "MD5";
    // 获取数字摘要对象
    MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
    // 获取消息数字摘要的字节数组
    byte[] digest = messageDigest.digest(input.getBytes("UTF-8"));
    //        System.out.println(new String(digest));
    // base64编码

// System.out.println(Base64.encode(digest));
// 创建对象用来拼接
StringBuilder sb = new StringBuilder();

    for (byte b : digest) {
        // 转成 16进制
        String s = Integer.toHexString(b & 0xff);
        //System.out.println(s);
        if (s.length() == 1){
            // 如果生成的字符只有一个，前面补0
            s = "0"+s;
        }
        sb.append(s);
    }
    System.out.println(sb.toString());

}

}


运行，结果和在线一致：


![](https://img-blog.csdnimg.cn/img_convert/0e6765d38e3c0da2e27075ae822f32cc.png)


#### **2.2.3 其他消息摘要算法**

/**

  • 功能描述
  • @author cWX970190
  • @since 2020-10-11
    */
    import java.security.MessageDigest;

/**

  • DigestDemo1

  • @Author: 陈志强

  • @CreateTime: 2020-03-17

  • @Description:
    */
    public class DigestDemo1 {

    public static void main(String[] args) throws Exception{
    // 4124bc0a9335c27f086f24ba207a4912 md5 在线校验
    // QSS8CpM1wn8IbyS6IHpJEg== 消息摘要使用的是16进制
    // 原文
    String input = “aa”;
    // 算法
    String algorithm = “MD5”;
    // 获取数字摘要对象
    String md5 = getDigest(input, “MD5”);
    System.out.println(md5);

     String sha1 = getDigest(input, "SHA-1");
 System.out.println(sha1);

 String sha256 = getDigest(input, "SHA-256");
 System.out.println(sha256);

 String sha512 = getDigest(input, "SHA-512");
 System.out.println(sha512);

    }

    private static String toHex(byte[] digest) throws Exception {

// System.out.println(new String(digest));
// base64编码
// System.out.println(Base64.encode(digest));
// 创建对象用来拼接
StringBuilder sb = new StringBuilder();

    for (byte b : digest) {
        // 转成 16进制
        String s = Integer.toHexString(b & 0xff);
        if (s.length() == 1){
            // 如果生成的字符只有一个，前面补0
            s = "0"+s;
        }
        sb.append(s);
    }
    System.out.println("16进制数据的长度：" + sb.toString().getBytes().length);
    return sb.toString();
}

private static String getDigest(String input, String algorithm) throws Exception {
    MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
    // 消息数字摘要
    byte[] digest = messageDigest.digest(input.getBytes());
    System.out.println("密文的字节长度:" + digest.length);

    return toHex(digest);
}

}


运行：


![](https://img-blog.csdnimg.cn/img_convert/dc7a8c82b075e209aead08af7697e524.png)


#### **2.2.4 获取文件消息摘要**

import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.security.MessageDigest;

/**

  • DigestDemo

  • @Author: 陈志强

  • @CreateTime: 2020-10-11

  • @Description:
    */
    public class DigestDemo {

    public static void main(String[] args) throws Exception{
    String input = “aa”;
    String algorithm = “MD5”;

     // sha1 可以实现秒传功能

 String sha1 = getDigestFile("C:\\Users\\cwx970190\\Documents\\apache-tomcat-9.0.38.zip", "SHA-1");
 System.out.println(sha1);

 String sha512 = getDigestFile("C:\\Users\\cwx970190\\Documents\\apache-tomcat-9.0.38.zip", "SHA-512");
 System.out.println(sha512);

// String md5 = getDigest(“aa”, “MD5”);
// System.out.println(md5);
//
// String md51 = getDigest("aa ", “MD5”);
// System.out.println(md51);
}

private static String getDigestFile(String filePath, String algorithm) throws Exception{
    FileInputStream fis = new FileInputStream(filePath);
    int len;
    byte[] buffer = new byte[1024];
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    while ( (len =  fis.read(buffer))!=-1){
        baos.write(buffer,0,len);
    }
    // 获取消息摘要对象
    MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
    // 获取消息摘要
    byte[] digest = messageDigest.digest(baos.toByteArray());
    System.out.println("密文的字节长度："+digest.length);
    return toHex(digest);
}

private static String getDigest(String input, String algorithm) throws Exception{
    MessageDigest messageDigest = MessageDigest.getInstance(algorithm);
    byte[] digest = messageDigest.digest(input.getBytes());
    System.out.println("密文的字节长度："+digest.length);
    return toHex(digest);
}

private static String toHex(byte[] digest) {
    //        System.out.println(new String(digest));
    // 消息摘要进行表示的时候，是用16进制进行表示
    StringBuilder sb = new StringBuilder();
    for (byte b : digest) {
        // 转成16进制

        String s = Integer.toHexString(b & 0xff);
        // 保持数据的完整性，前面不够的用0补齐
        if (s.length()==1){
            s="0"+s;
        }
        sb.append(s);
    }
    System.out.println("16进制数据的长度:"+ sb.toString().getBytes().length);
    return sb.toString();
}

}


运行结果：


![](https://img-blog.csdnimg.cn/img_convert/ae22d57fca09be2e14bbaa156b48f7c2.png)


查看官网上的sha512加密结果，发现一致：


![](https://img-blog.csdnimg.cn/img_convert/67fc8256a2e06d87913dde366c560ba2.png)


使用 sha-1 算法，可以实现秒传功能，只要是同一文件的加密，不管如何修改文件的名字，最后得到的值是一样的，具体可以自己测试。


不过，如果原文不一样，例如，下图上面的原文多两个空格：


![](https://img-blog.csdnimg.cn/img_convert/ce58015e267d48cecfadcfd392483310.png)


运行后：


![](https://img-blog.csdnimg.cn/img_convert/b835ab2be5e05fb8076c1f822ac25b0a.png)


**总结**


* MD5算法 : 摘要结果16个字节, 转16进制后32个字节
* SHA1算法 : 摘要结果20个字节, 转16进制后40个字节
* SHA256算法 : 摘要结果32个字节, 转16进制后64个字节
* SHA512算法 : 摘要结果64个字节, 转16进制后128个字节


### 2.3 非对称加密


**简介：**


① 非对称加密算法又称现代加密算法。


② 非对称加密是计算机通信安全的基石，保证了加密数据不会被破解。


③ 与对称加密算法不同，非对称加密算法需要两个密钥：公开密钥(publickey) 和私有密(privatekey)


④ 公开密钥和私有密钥是一对


⑤ 如果用公开密钥对数据进行加密，只有用对应的私有密钥才能解密。


⑥ 如果用私有密钥对数据进行加密，只有用对应的公开密钥才能解密。


⑦ 因为加密和解密使用的是两个不同的密钥，所以这种算法叫作非对称加密算法。


**示例**


首先生成密钥对, 公钥为(5,14), 私钥为(11,14)


现在A希望将原文2发送给B


A使用公钥加密数据. 2的5次方mod 14 = 4 , 将密文4发送给B


B使用私钥解密数据. 4的11次方mod14 = 2, 得到原文2


**特点**


* 加密和解密使用不同的密钥
* 如果使用私钥加密, 只能使用公钥解密
* 如果使用公钥加密, 只能使用私钥解密
* 处理数据的速度较慢, 因为安全级别高


**常见算法**


RSA


ECC


#### **2.3.1 生成公钥和私钥**

import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.File;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
/**

  • RSAdemo

  • @Author: 陈志强

  • @CreateTime: 2020-10-12

  • @Description:
    */
    public class RSAdemo {
    public static void main(String[] args) throws Exception {

     // 加密算法
 String algorithm = "RSA";
 //  创建密钥对生成器对象
 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);
 // 打印私钥
 System.out.println(privateKeyString);
 // 打印公钥
 System.out.println(publicKeyString);

    }
    }


运行程序，先打印私钥，再打印公钥：


![](https://img-blog.csdnimg.cn/img_convert/eab857afe3483c7f4fa88aba2727ead3.png)


#### **2.3.2 私钥加密**

import com.sun.org.apache.xml.internal.security.utils.Base64;

import javax.crypto.Cipher;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
/**

  • RSAdemo

  • @Author: 陈志强

  • @CreateTime: 2020-10-12

  • @Description:
    */
    public class RSAdemo {
    public static void main(String[] args) throws Exception {
    String input = “华为”;
    // 加密算法
    String algorithm = “RSA”;
    // 创建密钥对生成器对象
    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);

     // 创建加密对象
 // 参数表示加密算法
 Cipher cipher = Cipher.getInstance(algorithm);
 // 初始化加密
 // 第一个参数:加密的模式
 // 第二个参数：使用私钥进行加密
 cipher.init(Cipher.ENCRYPT_MODE,privateKey);
 // 私钥加密
 byte[] bytes = cipher.doFinal(input.getBytes());
 System.out.println(Base64.encode(bytes));

    }
    }


运行程序：


![](https://img-blog.csdnimg.cn/img_convert/a012e901e382907ec66570d5d3adc4b9.png)


#### **2.3.3 私钥加密私钥解密**

public class RSAdemo {
public static void main(String[] args) throws Exception {
String input = “华为”;
// 加密算法
String algorithm = “RSA”;
// 创建密钥对生成器对象
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);
// 创建加密对象
// 参数表示加密算法
Cipher cipher = Cipher.getInstance(algorithm);
// 初始化加密
// 第一个参数:加密的模式
// 第二个参数：使用私钥进行加密
cipher.init(Cipher.ENCRYPT_MODE,privateKey);
// 私钥加密
byte[] bytes = cipher.doFinal(input.getBytes());
System.out.println(Base64.encode(bytes));
// 私钥进行解密
cipher.init(Cipher.DECRYPT_MODE,privateKey);
// 对密文进行解密，不需要使用base64，因为原文不会乱码
byte[] bytes1 = cipher.doFinal(bytes);
System.out.println(new String(bytes1));

}

}


运行结果error，因为私钥加密，只能公钥解密：


![](https://img-blog.csdnimg.cn/img_convert/4155618a504406372b4c357edf5a9d70.png)


#### **2.3.4 私钥加密公钥解密**


修改2.3.3中的代码

// 公钥进行解密
cipher.init(Cipher.DECRYPT_MODE,publicKey);


再次运行


![](https://img-blog.csdnimg.cn/img_convert/e3fb1a27a14f6926cba15bd90037f737.png)


#### **2.3.5 公钥加密和公钥解密**


一样会报错


#### **2.3.6 保存公私钥**


有些情况下需要把加密和解密的方法全部到本地的根目录下面：

/*

  • Copyright © Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
    */

package com.huawei.it.jalor.boot.test;

import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils;

import javax.crypto.Cipher;
import java.io.File;
import java.nio.charset.Charset;
import java.security.Key;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
/**

  • RSAdemo

  • @Author: 陈志强

  • @CreateTime: 2020-10-12

  • @Description:
    */
    public class RSAdemo {
    public static void main(String[] args) throws Exception {
    String input = “硅谷”;
    // 加密算法
    String algorithm = “RSA”;

     //生成密钥对并保存在本地文件中
 generateKeyToFile(algorithm, "a.pub", "a.pri");

 //加密

// String s = encryptRSA(algorithm, privateKey, input);
// 解密
// String s1 = decryptRSA(algorithm, publicKey, s);
// System.out.println(s1);

}

/**
 * 生成密钥对并保存在本地文件中
 *
 * @param algorithm : 算法
 * @param pubPath   : 公钥保存路径
 * @param priPath   : 私钥保存路径
 * @throws Exception
 */
private static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
    // 获取密钥对生成器
    KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
    // 获取密钥对
    KeyPair keyPair = keyPairGenerator.generateKeyPair();
    // 获取公钥
    PublicKey publicKey = keyPair.getPublic();
    // 获取私钥
    PrivateKey privateKey = keyPair.getPrivate();
    // 获取byte数组
    byte[] publicKeyEncoded = publicKey.getEncoded();
    byte[] privateKeyEncoded = privateKey.getEncoded();
    // 进行Base64编码
    String publicKeyString = Base64.encode(publicKeyEncoded);
    String privateKeyString = Base64.encode(privateKeyEncoded);
    // 保存文件
    FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName("UTF-8"));
    FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName("UTF-8"));

}

/**
 * 解密数据
 *
 * @param algorithm      : 算法
 * @param encrypted      : 密文
 * @param key            : 密钥
 * @return : 原文
 * @throws Exception
 */
public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{
    // 创建加密对象
    // 参数表示加密算法
    Cipher cipher = Cipher.getInstance(algorithm);
    // 私钥进行解密
    cipher.init(Cipher.DECRYPT_MODE,key);
    // 由于密文进行了Base64编码, 在这里需要进行解码
    byte[] decode = Base64.decode(encrypted);
    // 对密文进行解密，不需要使用base64，因为原文不会乱码
    byte[] bytes1 = cipher.doFinal(decode);
    System.out.println(new String(bytes1));
    return new String(bytes1);

}
/**
 * 使用密钥加密数据
 *
 * @param algorithm      : 算法
 * @param input          : 原文
 * @param key            : 密钥
 * @return : 密文
 * @throws Exception
 */
public static String encryptRSA(String algorithm,Key key,String input) throws Exception{
    // 创建加密对象
    // 参数表示加密算法
    Cipher cipher = Cipher.getInstance(algorithm);
    // 初始化加密
    // 第一个参数:加密的模式
    // 第二个参数：使用私钥进行加密
    cipher.init(Cipher.ENCRYPT_MODE,key);
    // 私钥加密
    byte[] bytes = cipher.doFinal(input.getBytes());
    // 对密文进行Base64编码
    System.out.println(Base64.encode(bytes));
    return Base64.encode(bytes);
}

}


运行程序后，本地多了两个文件，打开：


![](https://img-blog.csdnimg.cn/img_convert/21a71cbf5ff842b201e18088c98b337e.png)


![](https://img-blog.csdnimg.cn/img_convert/987bc64ac35641702e5782b7cbb59cd4.png)


![](https://img-blog.csdnimg.cn/img_convert/55a81568d7edf2f93d1d7e9e21eecaa5.png)


#### 2.3.7 读取私钥

import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.File;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
/**

  • RSAdemo

  • @Author: 陈志强

  • @CreateTime: 2020-10-12

  • @Description:
    */
    public class RSAdemo {
    public static void main(String[] args) throws Exception {
    String input = “硅谷”;
    // 加密算法
    String algorithm = “RSA”;
    PrivateKey privateKey = getPrivateKey(“a.pri”, algorithm);

    }

    public static PrivateKey getPrivateKey(String priPath,String algorithm) throws Exception{
    // 将文件内容转为字符串
    String privateKeyString = FileUtils.readFileToString(new File(priPath), Charset.defaultCharset());
    // 获取密钥工厂
    KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
    // 构建密钥规范 进行Base64解码
    PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.decode(privateKeyString));
    // 生成私钥
    return keyFactory.generatePrivate(spec);
    }

    /**

    • 生成密钥对并保存在本地文件中
    • @param algorithm : 算法
    • @param pubPath : 公钥保存路径
    • @param priPath : 私钥保存路径
    • @throws Exception
      */
      private static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
      // 获取密钥对生成器
      KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
      // 获取密钥对
      KeyPair keyPair = keyPairGenerator.generateKeyPair();
      // 获取公钥
      PublicKey publicKey = keyPair.getPublic();
      // 获取私钥
      PrivateKey privateKey = keyPair.getPrivate();
      // 获取byte数组
      byte[] publicKeyEncoded = publicKey.getEncoded();
      byte[] privateKeyEncoded = privateKey.getEncoded();
      // 进行Base64编码
      String publicKeyString = Base64.encode(publicKeyEncoded);
      String privateKeyString = Base64.encode(privateKeyEncoded);
      // 保存文件
      FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName(“UTF-8”));
      FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName(“UTF-8”));

    }

    /**

    • 解密数据
    • @param algorithm : 算法
    • @param encrypted : 密文
    • @param key : 密钥
    • @return : 原文
    • @throws Exception
      */
      public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{
      // 创建加密对象
      // 参数表示加密算法
      Cipher cipher = Cipher.getInstance(algorithm);
      // 私钥进行解密
      cipher.init(Cipher.DECRYPT_MODE,key);
      // 由于密文进行了Base64编码, 在这里需要进行解码
      byte[] decode = Base64.decode(encrypted);
      // 对密文进行解密，不需要使用base64，因为原文不会乱码
      byte[] bytes1 = cipher.doFinal(decode);
      System.out.println(new String(bytes1));
      return new String(bytes1);

    }
    /**

    • 使用密钥加密数据
    • @param algorithm : 算法
    • @param input : 原文
    • @param key : 密钥
    • @return : 密文
    • @throws Exception
      */
      public static String encryptRSA(String algorithm,Key key,String input) throws Exception{
      // 创建加密对象
      // 参数表示加密算法
      Cipher cipher = Cipher.getInstance(algorithm);
      // 初始化加密
      // 第一个参数:加密的模式
      // 第二个参数：使用私钥进行加密
      cipher.init(Cipher.ENCRYPT_MODE,key);
      // 私钥加密
      byte[] bytes = cipher.doFinal(input.getBytes());
      // 对密文进行Base64编码
      System.out.println(Base64.encode(bytes));
      return Base64.encode(bytes);
      }
      }

#### **2.3.8 读取公钥**

import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.io.File;
import java.nio.charset.Charset;
import java.security.*;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

/**

  • RSAdemo

  • @Author: 陈志强

  • @CreateTime: 2020-10-12

  • @Description:
    */
    public class RSAdemo {
    public static void main(String[] args) throws Exception {
    String input = “硅谷”;
    // 加密算法
    String algorithm = “RSA”;
    PrivateKey privateKey = getPrivateKey(“a.pri”, algorithm);
    PublicKey publicKey = getPublicKey(“a.pub”, algorithm);

     String s = encryptRSA(algorithm, privateKey, input);
 String s1 = decryptRSA(algorithm, publicKey, s);
 System.out.println(s);
 System.out.println(s1);

    }

    public static PublicKey getPublicKey(String pulickPath,String algorithm) throws Exception{
    // 将文件内容转为字符串
    String publicKeyString = FileUtils.readFileToString(new File(pulickPath), Charset.defaultCharset());
    // 获取密钥工厂
    KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
    // 构建密钥规范 进行Base64解码
    X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.decode(publicKeyString));
    // 生成公钥
    return keyFactory.generatePublic(spec);
    }

    public static PrivateKey getPrivateKey(String priPath,String algorithm) throws Exception{
    // 将文件内容转为字符串
    String privateKeyString = FileUtils.readFileToString(new File(priPath), Charset.defaultCharset());
    // 获取密钥工厂
    KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
    // 构建密钥规范 进行Base64解码
    PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.decode(privateKeyString));
    // 生成私钥
    return keyFactory.generatePrivate(spec);
    }

    /**

    • 生成密钥对并保存在本地文件中
    • @param algorithm : 算法
    • @param pubPath : 公钥保存路径
    • @param priPath : 私钥保存路径
    • @throws Exception
      */
      public static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
      // 获取密钥对生成器
      KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
      // 获取密钥对
      KeyPair keyPair = keyPairGenerator.generateKeyPair();
      // 获取公钥
      PublicKey publicKey = keyPair.getPublic();
      // 获取私钥
      PrivateKey privateKey = keyPair.getPrivate();
      // 获取byte数组
      byte[] publicKeyEncoded = publicKey.getEncoded();
      byte[] privateKeyEncoded = privateKey.getEncoded();
      // 进行Base64编码
      String publicKeyString = Base64.encode(publicKeyEncoded);
      String privateKeyString = Base64.encode(privateKeyEncoded);
      // 保存文件
      FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName(“UTF-8”));
      FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName(“UTF-8”));

    }

    /**

    • 解密数据
    • @param algorithm : 算法
    • @param encrypted : 密文
    • @param key : 密钥
    • @return : 原文
    • @throws Exception
      */
      public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{
      // 创建加密对象
      // 参数表示加密算法
      Cipher cipher = Cipher.getInstance(algorithm);
      // 私钥进行解密
      cipher.init(Cipher.DECRYPT_MODE,key);
      // 由于密文进行了Base64编码, 在这里需要进行解码
      byte[] decode = Base64.decode(encrypted);
      // 对密文进行解密，不需要使用base64，因为原文不会乱码
      byte[] bytes1 = cipher.doFinal(decode);
      return new String(bytes1);

    }
    /**

    • 使用密钥加密数据
    • @param algorithm : 算法
    • @param input : 原文
    • @param key : 密钥
    • @return : 密文
    • @throws Exception
      */
      public static String encryptRSA(String algorithm,Key key,String input) throws Exception{
      // 创建加密对象
      // 参数表示加密算法
      Cipher cipher = Cipher.getInstance(algorithm);
      // 初始化加密
      // 第一个参数:加密的模式
      // 第二个参数：使用私钥进行加密
      cipher.init(Cipher.ENCRYPT_MODE,key);
      // 私钥加密
      byte[] bytes = cipher.doFinal(input.getBytes());
      // 对密文进行Base64编码
      return Base64.encode(bytes);
      }
      }

运行程序


![](https://img-blog.csdnimg.cn/img_convert/4637669afaf36b1dea5d1523fefb59d8.png)


### 2.4 数字签名


我们经常会用到数字签名，只是大家平时不太注意，比如我们访问银行 ，证券公司，基金公司，金融类的公司网站全部都是 https 协议，如果是 https 协议，那么都需要有一个证书。签名可以用来验证网络传输数据的时候，数据是否被人篡改。


签名的作用简单来说就是证明某个文件上的内容确实是我写的，别人不能冒充我的签名（不可伪造），我也不能否认上面的签名是我的（不可抵赖）。


我们知道，手写签名之所以不能伪造，是因为每一个人的笔迹都是独一无二的，即使模仿，也可以通过专家鉴定分别出来。而不可抵赖，是因为每个人的笔迹都有固定特征，这些特征是很难摆脱的。


正是这两点特性使得手写签名在日常生活中被广泛承认，比如签合同、借条等等。


数字签名的要求是，只有我自己能签我的名字，其他人能验证我的签名，但是不能伪造我的签名。


#### **2.4.1 网页加密**


我们看一个应用“数字证书”的实例：https协议。这个协议主要用于网页加密


首先，客户端向服务器发出加密请求。


![](https://img-blog.csdnimg.cn/img_convert/03b99c3cce859492855919aa173047c0.png)


服务器用自己的私钥加密网页以后，连同本身的数字证书，一起发送给客户端。


![](https://img-blog.csdnimg.cn/img_convert/7930a7194f7e0d1af281e06ee642ffdc.png)


客户端（浏览器）的“证书管理器”，有“受信任的根证书颁发机构”列表。客户端会根据这张列表，查看解开数字证书的公钥是否在列表之内。


![](https://img-blog.csdnimg.cn/img_convert/85e2dde2b38a2aea521d6223e6699a8b.png)


如果数字证书记载的网址，与你正在浏览的网址不一致，就说明这张证书可能被冒用，浏览器会发出警告。


![](https://img-blog.csdnimg.cn/img_convert/15f0eb229a48d0ceb6abe08c66258dc0.png)


如果这张数字证书不是由受信任的机构颁发的，浏览器会发出另一种警告。


![](https://img-blog.csdnimg.cn/img_convert/c1fbd328ee10356522616f786a691fb3.png)


如果数字证书是可靠的，客户端就可以使用证书中的服务器公钥，对信息进行加密，然后与服务器交换加密信息。


![](https://img-blog.csdnimg.cn/img_convert/9b806a21afe5c0b8e62aba1ffb152c86.png)


#### **2.4.2 证书从哪里来**


“证书中心”（certificate authority，简称CA），为公钥做认证。证书中心用自己的私钥，对公钥和一些相关信息一起加密，生成“数字证书”（Digital Certificate）。


拿到数字证书以后，就可以放心了。以后只要在签名的同时，再附上数字证书就行了。


用CA的公钥解开数字证书，就可以拿到真实的公钥了，然后就能证明“数字签名”是否真的是公司签的。


修改之前的RSAdemo代码:

/*

  • Copyright © Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
    */

package com.huawei.it.jalor.boot.test;

import com.sun.org.apache.xml.internal.security.utils.Base64;
import org.apache.commons.io.FileUtils;

import javax.crypto.Cipher;
import java.io.File;
import java.nio.charset.Charset;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

/**

  • RSAdemo

  • @Author: 陈志强

  • @CreateTime: 2020-10-12

  • @Description:
    */
    public class RSAdemo {
    public static void main(String[] args) throws Exception {
    String input = “硅谷”;
    // 加密算法
    String algorithm = “RSA”;
    PrivateKey privateKey = getPrivateKey(“a.pri”, algorithm);
    PublicKey publicKey = getPublicKey(“a.pub”, algorithm);
    String s = encryptRSA(algorithm, privateKey, input);
    String s1 = decryptRSA(algorithm, publicKey, s);
    System.out.println(s);
    System.out.println(s1);

    }

    public static PublicKey getPublicKey(String pulickPath,String algorithm) throws Exception{
    // 将文件内容转为字符串
    String publicKeyString = FileUtils.readFileToString(new File(pulickPath), Charset.defaultCharset());
    // 获取密钥工厂
    KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
    // 构建密钥规范 进行Base64解码
    X509EncodedKeySpec spec = new X509EncodedKeySpec(Base64.decode(publicKeyString));
    // 生成公钥
    return keyFactory.generatePublic(spec);
    }

    public static PrivateKey getPrivateKey(String priPath,String algorithm) throws Exception{
    // 将文件内容转为字符串
    String privateKeyString = FileUtils.readFileToString(new File(priPath), Charset.defaultCharset());
    // 获取密钥工厂
    KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
    // 构建密钥规范 进行Base64解码
    PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(Base64.decode(privateKeyString));
    // 生成私钥
    return keyFactory.generatePrivate(spec);
    }

    /**

    • 生成密钥对并保存在本地文件中
    • @param algorithm : 算法
    • @param pubPath : 公钥保存路径
    • @param priPath : 私钥保存路径
    • @throws Exception
      */
      public static void generateKeyToFile(String algorithm, String pubPath, String priPath) throws Exception {
      // 获取密钥对生成器
      KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
      // 获取密钥对
      KeyPair keyPair = keyPairGenerator.generateKeyPair();
      // 获取公钥
      PublicKey publicKey = keyPair.getPublic();
      // 获取私钥
      PrivateKey privateKey = keyPair.getPrivate();
      // 获取byte数组
      byte[] publicKeyEncoded = publicKey.getEncoded();
      byte[] privateKeyEncoded = privateKey.getEncoded();
      // 进行Base64编码
      String publicKeyString = Base64.encode(publicKeyEncoded);
      String privateKeyString = Base64.encode(privateKeyEncoded);
      // 保存文件
      FileUtils.writeStringToFile(new File(pubPath), publicKeyString, Charset.forName(“UTF-8”));
      FileUtils.writeStringToFile(new File(priPath), privateKeyString, Charset.forName(“UTF-8”));

    }

    /**

    • 解密数据
    • @param algorithm : 算法
    • @param encrypted : 密文
    • @param key : 密钥
    • @return : 原文
    • @throws Exception
      */
      public static String decryptRSA(String algorithm,Key key,String encrypted) throws Exception{
      // 创建加密对象
      // 参数表示加密算法
      Cipher cipher = Cipher.getInstance(algorithm);
      // 私钥进行解密
      cipher.init(Cipher.DECRYPT_MODE,key);
      // 由于密文进行了Base64编码, 在这里需要进行解码
      byte[] decode = Base64.decode(encrypted);
      // 对密文进行解密，不需要使用base64，因为原文不会乱码
      byte[] bytes1 = cipher.doFinal(decode);
      return new String(bytes1);

    }
    /**

    • 使用密钥加密数据
    • @param algorithm : 算法
    • @param input : 原文
    • @param key : 密钥
    • @return : 密文
    • @throws Exception
      */
      public static String encryptRSA(String algorithm,Key key,String input) throws Exception{
      // 创建加密对象
      // 参数表示加密算法
      Cipher cipher = Cipher.getInstance(algorithm);
      // 初始化加密
      // 第一个参数:加密的模式
      // 第二个参数：使用私钥进行加密
      cipher.init(Cipher.ENCRYPT_MODE,key);
      // 私钥加密
      byte[] bytes = cipher.doFinal(input.getBytes());
      // 对密文进行Base64编码
      return Base64.encode(bytes);
      }

    /**

    • 从文件中加载公钥

    • @param algorithm : 算法

    • @param filePath : 文件路径

    • @return : 公钥

    • @throws Exception
      */
      public static PublicKey loadPublicKeyFromFile(String algorithm, String filePath) throws Exception {
      // 将文件内容转为字符串
      String keyString = FileUtils.readFileToString(new File(filePath), Charset.forName(“UTF-8”));

      return loadPublicKeyFromString(algorithm, keyString);

    }

    /**

    • 从字符串中加载公钥
    • @param algorithm : 算法
    • @param keyString : 公钥字符串
    • @return : 公钥
    • @throws Exception
      */
      public static PublicKey loadPublicKeyFromString(String algorithm, String keyString) throws Exception {
      // 进行Base64解码
      byte[] decode = Base64.decode(keyString);
      // 获取密钥工厂
      KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
      // 构建密钥规范
      X509EncodedKeySpec keyspec = new X509EncodedKeySpec(decode);
      // 获取公钥
      return keyFactory.generatePublic(keyspec);

    }

    /**

    • 从文件中加载私钥
    • @param algorithm : 算法
    • @param filePath : 文件路径
    • @return : 私钥
    • @throws Exception
      */
      public static PrivateKey loadPrivateKeyFromFile(String algorithm, String filePath) throws Exception {
      // 将文件内容转为字符串
      String keyString = FileUtils.readFileToString(new File(filePath), Charset.forName(“UTF-8”));
      return loadPrivateKeyFromString(algorithm, keyString);

    }

    /**

    • 从字符串中加载私钥
    • @param algorithm : 算法
    • @param keyString : 私钥字符串
    • @return : 私钥
    • @throws Exception
      */
      public static PrivateKey loadPrivateKeyFromString(String algorithm, String keyString) throws Exception {
      // 进行Base64解码
      byte[] decode = Base64.decode(keyString);
      // 获取密钥工厂
      KeyFactory keyFactory = KeyFactory.getInstance(algorithm);
      // 构建密钥规范
      PKCS8EncodedKeySpec keyspec = new PKCS8EncodedKeySpec(decode);
      // 生成私钥
      return keyFactory.generatePrivate(keyspec);

    }
    }


写一个验证数字签名的类：

/*

  • Copyright © Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
    */

package com.huawei.it.jalor.boot.test;

import com.sun.org.apache.xml.internal.security.utils.Base64;

import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;

/**

  • 功能描述: 验证数字签名

  • @author cWX970190

  • @since 2020-10-11
    */
    public class SignatureDemo {
    public static void main(String[] args) throws Exception {
    String a = “123”;
    PublicKey publicKey =RSAdemo.loadPublicKeyFromFile(“RSA”, “a.pub”);
    PrivateKey privateKey = RSAdemo.loadPrivateKeyFromFile(“RSA”, “a.pri”);
    String signaturedData = getSignature(a, “sha256withrsa”, privateKey);
    boolean b = verifySignature(a, “sha256withrsa”, publicKey, signaturedData);
    System.out.println(b);
    }

    /**

    • 生成签名
    • @param input : 原文
    • @param algorithm : 算法
    • @param privateKey : 私钥
    • @return : 签名
    • @throws Exception
      */
      private static String getSignature(String input, String algorithm, PrivateKey privateKey) throws Exception {
      // 获取签名对象
      Signature signature = Signature.getInstance(algorithm);
      // 初始化签名
      signature.initSign(privateKey);
      // 传入原文
      signature.update(input.getBytes());
      // 开始签名
      byte[] sign = signature.sign();
      // 对签名数据进行Base64编码
      return Base64.encode(sign);
      }

    /**

    • 校验签名
    • @param input : 原文
    • @param algorithm : 算法
    • @param publicKey : 公钥
    • @param signaturedData : 签名
    • @return : 数据是否被篡改
    • @throws Exception
      */
      private static boolean verifySignature(String input, String algorithm, PublicKey publicKey, String signaturedData) throws Exception {
      // 获取签名对象
      Signature signature = Signature.getInstance(algorithm);
      // 初始化签名
      signature.initVerify(publicKey);
      // 传入原文
      signature.update(input.getBytes());
      // 校验数据
      return signature.verify(Base64.decode(signaturedData));

    }
    }


运行，验证成功：


![](https://img-blog.csdnimg.cn/img_convert/a2cc47bc3af8f0ff727bb6116bdd9fb4.png)


### 拓展： 2.5 Byte和bit


**Byte :**字节. 数据存储的基本单位，比如移动硬盘1T ， 单位是byte


**bit :**比特, 又叫位. 一个位要么是0要么是1. 数据传输的单位 , 比如家里的宽带100MB，下载速度并没有达到100MB，一般都是12-13MB，那么是因为需要使用 100 / 8


**关系:**1Byte = 8bit


#### **2.5.1 获取字符串byte**

/**

  • ByteBit
  • @Author: 陈志强
  • @CreateTime: 2020-10-12
  • @Description:
    */
    public class ByteBit {
    public static void main(String[] args) {
    String a = “a”;
    byte[] bytes = a.getBytes();
    for (byte b : bytes) {
    int c=b;
    // 打印发现byte实际上就是ascii码
    System.out.println©;
    }
    }
    }

运行结果：


![](https://img-blog.csdnimg.cn/img_convert/16da71d373eee931835f813a2745a345.png)


和ascii码表一致


![](https://img-blog.csdnimg.cn/img_convert/cbb0f5e9b5285d9ad34d9b32a8490dac.png)


#### **2.5.2 byte对应bit**

public class ByteBit {
public static void main(String[] args) {

还有兄弟不知道网络安全面试可以提前刷题吗？费时一周整理的160+网络安全面试题，金九银十，做网络安全面试里的显眼包！

王岚嵚工程师面试题（附答案），只能帮兄弟们到这儿了！如果你能答对70%，找一个安全工作，问题不大。

对于有1-3年工作经验，想要跳槽的朋友来说，也是很好的温习资料！

【完整版领取方式在文末！！】

93道网络安全面试题

内容实在太多，不一一截图了

黑客学习资源推荐

最后给大家分享一份全套的网络安全学习资料，给那些想学习 网络安全的小伙伴们一点帮助！

对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。

1️⃣零基础入门
① 学习路线

对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。

image

② 路线对应学习视频

同时每个成长路线对应的板块都有配套的视频提供：

image-20231025112050764

2301_79985178
关注
  • 15
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java 密码学算法
一切有为法，如梦亦如幻，如露亦如电，应作如是观。
02-03 896
Java 密码学算法 候捷老师在《深入浅出MFC 2e(电子版)》中引用林语堂先生的一句话： 只用一样东西，不明白它的道理，实在不高明 只知道How，不知道Why，出了一点小问题时就无能为力了。我们课上鼓励大家在Linux下学习编程，尽量在命令行中编辑/编译/调试程序，Git的使用，数据库的管理都先会命令方式下使用，这样在IDE中，在GUI界面中出了问题，我们有更好的方法查找。 现在我们遇到另外一个极端，不会用一样东西，却想要明白它的道理，这实在太难了。比如有的同学连Linux都没用过，却想弄.
Java密码学对称加密Demo
12-27
在Java密码学中，对称加密是一种常见的数据保护方法，它涉及到使用相同的密钥进行数据的加密和解密。这个"Java密码学对称加密Demo"可能是为了展示如何在Java应用程序中实现这一过程。Java Cryptography Architecture...
2024年【人人都懂密码学】一篇最易懂的Java密码学入门教程_getencoded
2401_84265650的博客
05-02 19
/ System.out.println(“解密” + new String(decode, “UTF-8”));Basic编码是标准的BASE64编码，用于处理常规的需求：输出的内容不添加换行符，而且输出的内容由字母加数字组成。基本：输出被映射到一组字符A-Za-z0-9+/，编码不添加任何行标，输出的解码仅支持A-Za-z0-9+/。URL：输出被映射到一组字符A-Za-z0-9+_，输出是URL和文件。// 初始向量，参数表示跟谁进行异或，初始向量的长度必须是8位。
【人人都懂密码学】一篇最易懂的Java密码学入门教程
华为云官方博客
10-16 6224
密码与我们的生活息息相关，远到国家机密，近到个人账户，我们每天都在跟密码打交道： 那么，密码从何而来？生活中常见的加密是怎么实现的？怎么保证个人信息安全？本文将从这几方面进行浅谈，如有纰漏，敬请各位大佬指正。 代码部分从第二章节——常见加密算法开始，对代码比较感兴趣的铁子们可以从第二章节开始看。 一、 密码学发展史 密码学是网络安全、信息安全、区块链等产品的基础，常见的非对称加密、对称加密、散列函数等，都属于密码学范畴。 密码学有数千年的历史，从最开始的替换法到如今的非对称加密算法，经历了古典
【人人都懂密码学】一篇最易懂的Java密码学入门教程_getencoded(2)
2401_84132496的博客
05-13 880
在结束之际，我想重申的是，学习并非如攀登险峻高峰，而是如滴水穿石般的持久累积。尤其当我们步入工作岗位之后，持之以恒的学习变得愈发不易，如同在茫茫大海中独自划舟，稍有松懈便可能被巨浪吞噬。然而，对于我们程序员而言，学习是生存之本，是我们在激烈市场竞争中立于不败之地的关键。一旦停止学习，我们便如同逆水行舟，不进则退，终将被时代的洪流所淘汰。因此，不断汲取新知识，不仅是对自己的提升，更是对自己的一份珍贵投资。让我们不断磨砺自己，与时代共同进步，书写属于我们的辉煌篇章。需要完整版PDF学习资源私我。
【Java万花筒】Java安全卫士：从密码学到Web应用攻击
记录我的学习历程
01-10 1292
本文系统地介绍了Java开发者可以利用的多个安全与加密库，涵盖了密码学算法、身份管理、认证授权、加密解密以及防范Web应用攻击等方面。从Bouncy Castle的强大密码学算法到Jasypt的简化加密方法，再到Keycloak的身份与访问管理，Apache Shiro的全面安全框架，以及JCE和OWASP Java Encoder的实用性，本文将为读者提供丰富的选择和实用的功能。
密码学之美——密码学总结和对外开放接口实现
纪大侠博客
12-24 1963
在实现具体功能前，先对密码学做个简要介绍。密码学一共分成：对称密码（AES）、公钥密码（RSA,椭圆曲线密码）、单向散列函数（MD5,SHA256） 、随机数生成器实际上会对以上密码分类混合扩展出以下两个分类：消息认证码（HMAC）：单向散列函数+密钥，数字签名：单向散列函数+公钥密码以上就是对密码学的接口以及开放接口验签和加密的实现，这边写这边博客其一是对密码学做个总结方便加深印象。其二是将开放接口实现公开，可以让大家看看是否有安全漏洞。
密码学【java】初探究之springboo集成mybatis,swagger,数字签名
缘友一世的博客
05-07 957
OpenAPI规范（OpenAPI Specification 简称OAS）是Linux基金会的一个项目，试图通过定义一种用来描述API格式或API定义的语言，来规范RESTful服务开发过程，目前版本是V3.0，并且已经发布并开源在github上。Swagger是全球最大的OpenAPI规范（OAS）API开发工具框架，支持从设计和文档到测试和部署的整个API生命周期的开发。
密码学-java信息安全,摘要算法,对称加密(AES)/非对称加密(RSA)
qq_43427354的博客
03-14 522
又叫Hash算法、散列函数、数字摘要、消息摘要。它是一种单向算法，用户可以通过hash算法对目标信息生成一段特定长度的唯一hash值，但不能通过这个hash值重新获得目标信息。也叫单密钥加密，所谓单密钥，指的是加密和解密的过程使用相同的密钥，相比非对称加密，因只有一把钥匙，因而速度更快，更适合加解密大文件加密和解密使用的是两个不同的密钥 (public key 和 private key)。公钥可以给任何人，私钥总是自己保留。
密码学进阶（一）：浅谈常见的七种加密算法及实现_常用加密算法
2401_85124192的博客
06-25 365
无论是多长的输入，
AESJAVA实现（源码）___128、196、254位key
01-21
总的来说，AES在Java中的实现涉及到了密码学的基本概念，包括密钥生成、加密解密过程，以及对加密模式和填充方式的选择。理解这些概念对于安全地存储和传输数据至关重要。在实际应用中，还需要注意密钥管理、加密...
加密算法 ASE ECC
06-14
本文将深入探讨两种重要的加密算法——AES（高级加密标准）和ECC（椭圆曲线密码学），以及它们在Java环境下的实现。 **AES（高级加密标准）** AES，全称为Advanced Encryption Standard，是一种广泛使用的对称加密...
java，RSA算法加密文件
06-05
Java中的RSA算法是一种广泛使用的非对称加密技术，它的全称是Rivest-Shamir-Adleman，由三位密码学专家在1977年提出。这种算法基于大整数因子分解的数学难题，提供了相对较高的安全性。在Java中，我们可以利用`java....
java rsa加密算法实现
06-26
RSA是一种非对称加密算法，它是公钥密码学的一个重要里程碑。在Java中实现RSA加密算法，主要涉及以下几个核心概念和步骤： 1. **RSA原理**：RSA算法基于数论中的大数因子分解难题，由两个大素数P和Q相乘得到N，然后...
配置系统PATH环境变量
最新发布
weixin_44626980的博客
06-29 208
PATH环境变量在操作系统中起着非常重要的作用，特别是在命令行或脚本中执行程序时，系统会根据PATH环境变量中定义的路径查找可执行文件。当用户在命令行或脚本中输入一个命令时，系统会根据PATH环境变量中定义的路径依次查找对应的可执行文件，如果找到则执行。本文详细介绍了如何配置系统的PATH环境变量，包括在Windows和Linux系统中的操作步骤。在Linux系统中，可以通过编辑shell配置文件来配置PATH环境变量，常用的shell配置文件包括.bashrc、.bash_profile等。
【C#】找不到属性集方法。get只读属性用了反射设置setValue肯定报错
小5聊的博客
06-26 1345
找不到属性集方法。get只读属性用了反射设置setValue肯定报错
Java面试题:Redis为什么速度快
qq_55630615的博客
06-25 448
因为Redis是纯内存操作,执行速度非常快,性能的瓶颈是网络延迟而非执行速度I/O多路复用模型主要就是实现了高效的网络请求。
解决Java中的数组越界异常的技术
weixin_44627014的博客
06-26 287
通过本文的讨论，我们了解了如何有效地处理Java中的数组越界异常。预防异常的发生，合理使用异常处理机制以及考虑使用集合类来替代数组，是确保Java应用程序稳定性和可靠性的关键步骤。
密码学工程实践java
05-22
密码学工程实践是一个非常重要的领域，涉及到数据安全、信息保护等方面。在Java中，有很多密码学相关的API和库可以使用，如JCE（Java Cryptography Extension）、Bouncy Castle、Apache Commons Codec等。 下面简单...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值