来自大厂面试官的神秘礼物：算法解析大全(1)

于 2024-04-22 05:42:59 发布
阅读量940 收藏 28
点赞数 17
CC 4.0 BY-SA版权
分类专栏： 程序员 文章标签： 算法 java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/a1901149/article/details/138055752
文章介绍了DES、3DES、AES和RSA等加密算法在Java中的实现，包括对称加密和非对称加密的原理、示例代码以及AES的安全性优势。还提到如何选择对称加密算法（如AES128、192、256）和非对称加密（如RSA）在实际开发中的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

// 加密
public static String encrypt(byte[] dataSource, String password){
try {
SecureRandom random = new SecureRandom();
DESKeySpec desKeySpec = new DESKeySpec(password.getBytes());
//创建一个密匙工厂，然后用它把DESKeySpec转换成
SecretKeyFactory secretKeyFactory = SecretKeyFactory.getInstance(“DES”);
SecretKey secretKey = secretKeyFactory.generateSecret(desKeySpec);
//Cipher对象实际完成加密操作
Cipher cipher = Cipher.getInstance(“DES”);
//用密匙初始化Cipher对象
cipher.init(Cipher.ENCRYPT_MODE, secretKey, random);
//正式执行加密操作
return Base64.encodeBase64String(cipher.doFinal(dataSource));
} catch (Throwable e) {
e.printStackTrace();
} return null;
}
// 解密
public static String decrypt(String src, String password) throws Exception{
// DES算法要求有一个可信任的随机数源
SecureRandom random = new SecureRandom();
// 创建一个DESKeySpec对象
DESKeySpec desKeySpec = new DESKeySpec(password.getBytes());
// 创建一个密匙工厂
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(“DES”);
// 将DESKeySpec对象转换成SecretKey对象
SecretKey secretKey = keyFactory.generateSecret(desKeySpec);
// Cipher对象实际完成解密操作
Cipher cipher = Cipher.getInstance(“DES”);
// 用密匙初始化Cipher对象
cipher.init(Cipher.DECRYPT_MODE, secretKey, random);
// 真正开始解密操作
return new String(cipher.doFinal(Base64.decodeBase64(src)));
}

2.2 3DES

3DES（即Triple DES）是DES向AES过渡的加密算法，它使用3条56位的密钥对数据进行三次加密。是DES的一个更安全的变形。它以DES为基本模块，通过组合分组方法设计出分组加密算法。比起最初的DES，3DES更为安全。密钥长度默认为168位，还可以选择128位。

public static String encryptThreeDESECB(String src, String key) {
try{
DESedeKeySpec dks = new DESedeKeySpec(key.getBytes(“UTF-8”));
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(“DESede”);
SecretKey securekey = keyFactory.generateSecret(dks);

Cipher cipher = Cipher.getInstance(“DESede/ECB/PKCS5Padding”);
cipher.init(Cipher.ENCRYPT_MODE, securekey);
byte[] b = cipher.doFinal(src.getBytes(“UTF-8”));

String ss = new String(Base64.encodeBase64(b));
ss = ss.replaceAll(“\+”, “-”);
ss = ss.replaceAll(“/”, “_”);
return ss;
} catch(Exception ex){
ex.printStackTrace();
return src;
}
}

public static String decryptThreeDESECB(String src, String key) {
try{
src = src.replaceAll(“-”, “+”);
src = src.replaceAll(“_”, “/”);
byte[] bytesrc = Base64.decodeBase64(src.getBytes(“UTF-8”));
// --解密的key
DESedeKeySpec dks = new DESedeKeySpec(key.getBytes(“UTF-8”));
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(“DESede”);
SecretKey securekey = keyFactory.generateSecret(dks);

// --Chipher对象解密
Cipher cipher = Cipher.getInstance(“DESede/ECB/PKCS5Padding”);
cipher.init(Cipher.DECRYPT_MODE, securekey);
byte[] retByte = cipher.doFinal(bytesrc);

return new String(retByte, “UTF-8”);
} catch(Exception ex){
ex.printStackTrace();
return src;
}
}

2.3 AES

AES 高级数据加密标准，能够有效抵御已知的针对DES算法的所有攻击，默认密钥长度为128位，还可以供选择192位，256位。这里顺便提一句这个位指的是bit。

private static final String defaultCharset = “UTF-8”;
private static final String KEY_AES = “AES”;
private static final String KEY_MD5 = “MD5”;
private static MessageDigest md5Digest;
static {
try {
md5Digest = MessageDigest.getInstance(KEY_MD5);
} catch (NoSuchAlgorithmException e) {

}
}
/**

  • 加密
    /
    public static String encrypt(String data, String key) {
    return doAES(data, key, Cipher.ENCRYPT_MODE);
    }
    /    *
  • 解密
    */
    public static String decrypt(String data, String key) {
    return doAES(data, key, Cipher.DECRYPT_MODE);
    }

/**

  • 加解密
    */
    private static String doAES(String data, String key, int mode) {
    try {
    boolean encrypt = mode == Cipher.ENCRYPT_MODE;
    byte[] content;
    if (encrypt) {
    content = data.getBytes(defaultCharset);
    } else {
    content = Base64.decodeBase64(data.getBytes());
    }
    SecretKeySpec keySpec = new SecretKeySpec(md5Digest.digest(key.getBytes(defaultCharset))
    , KEY_AES);
    Cipher cipher = Cipher.getInstance(KEY_AES);// 创建密码器
    cipher.init(mode, keySpec);// 初始化
    byte[] result = cipher.doFinal(content);
    if (encrypt) {
    return new String(Base64.encodeBase64(result));
    } else {
    return new String(result, defaultCharset);
    }
    } catch (Exception e) {
    }
    return null;
    }

推荐使用对称加密算法有：AES128、AES192、AES256。

三、非对称加密算法

非对称加密算法有两个密钥，这两个密钥完全不同但又完全匹配。只有使用匹配的一对公钥和私钥，才能完成对明文的加密和解密过程。常见的非对称加密有RSA、SM2等。

3.1 RSA

RSA密钥至少为500位长，一般推荐使用1024位。

//非对称密钥算法
public static final String KEY_ALGORITHM = “RSA”;

/**

  • 密钥长度，DH算法的默认密钥长度是1024
  • 密钥长度必须是64的倍数，在512到65536位之间
    /
    private static final int KEY_SIZE = 1024;
    //公钥
    private static final String PUBLIC_KEY = “RSAPublicKey”;
    //私钥
    private static final String PRIVATE_KEY = “RSAPrivateKey”;
    /    *
  • 初始化密钥对
  • @return Map 甲方密钥的Map
    /
    public static Map<String, Object> initKey() throws Exception {
    //实例化密钥生成器
    KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);
    //初始化密钥生成器
    keyPairGenerator.initialize(KEY_SIZE);
    //生成密钥对
    KeyPair keyPair = keyPairGenerator.generateKeyPair();
    //甲方公钥
    RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
    //甲方私钥
    RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
    //将密钥存储在map中
    Map<String, Object> keyMap = new HashMap<String, Object>();
    keyMap.put(PUBLIC_KEY, publicKey);
    keyMap.put(PRIVATE_KEY, privateKey);
    return keyMap;
    }
    /    *
  • 私钥加密
  • @param data 待加密数据
  • @param key 密钥
  • @return byte[] 加密数据
    */
    public static byte[] encryptByPrivateKey(byte[] data, byte[] key) throws Exception {

//取得私钥
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
//生成私钥
PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
//数据加密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, privateKey);
return cipher.doFinal(data);
}

/**

  • 公钥加密
  • @param data 待加密数据
  • @param key 密钥
  • @return byte[] 加密数据
    */
    public static byte[] encryptByPublicKey(byte[] data, byte[] key) throws Exception {

//实例化密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
//初始化公钥
//密钥材料转换
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
//产生公钥
PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
//数据加密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, pubKey);
return cipher.doFinal(data);
}

/**

  • 私钥解密
  • @param data 待解密数据
  • @param key 密钥
  • @return byte[] 解密数据
    */
    public static byte[] decryptByPrivateKey(byte[] data, byte[] key) throws Exception {
    //取得私钥
    PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key);
    KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
    //生成私钥
    PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
    //数据解密
    Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
    cipher.init(Cipher.DECRYPT_MODE, privateKey);
    return cipher.doFinal(data);
    }

/**

  • 公钥解密
  • @param data 待解密数据
  • @param key 密钥
  • @return byte[] 解密数据
    */
    public static byte[] decryptByPublicKey(byte[] data, byte[] key) throws Exception {

//实例化密钥工厂
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
//初始化公钥
//密钥材料转换
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key);
//产生公钥
PublicKey pubKey = keyFactory.generatePublic(x509KeySpec);
//数据解密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.DECRYPT_MODE, pubKey);
return cipher.doFinal(data);
}

/**

  • 取得私钥
  • @param keyMap 密钥map
  • @return byte[] 私钥
    */
    public static byte[] getPrivateKey(Map<String, Object> keyMap) {
    Key key = (Key) keyMap.get(PRIVATE_KEY);
    return key.getEncoded();
    }

/**

  • 取得公钥
  • @param keyMap 密钥map
  • @return byte[] 公钥
    */
    public static byte[] getPublicKey(Map<String, Object> keyMap) throws Exception {
    Key key = (Key) keyMap.get(PUBLIC_KEY);
    return key.getEncoded();
    自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。img

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注Java获取）

img

总结

机会是留给有准备的人，大家在求职之前应该要明确自己的态度，熟悉求职流程，做好充分的准备，把一些可预见的事情做好。

对于应届毕业生来说，校招更适合你们，因为绝大部分都不会有工作经验，企业也不会有工作经验的需求。同时，你也不需要伪造高大上的实战经验，以此让自己的简历能够脱颖而出，反倒会让面试官有所怀疑。

你在大学时期应该明确自己的发展方向，如果你在大一就确定你以后想成为Java工程师，那就不要花太多的时间去学习其他的技术语言，高数之类的，不如好好想着如何夯实Java基础。下图涵盖了应届生乃至转行过来的小白要学习的Java内容：

请转发本文支持一下

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！
展方向，如果你在大一就确定你以后想成为Java工程师，那就不要花太多的时间去学习其他的技术语言，高数之类的，不如好好想着如何夯实Java基础。下图涵盖了应届生乃至转行过来的小白要学习的Java内容：

请转发本文支持一下

[外链图片转存中…(img-c4ZOs4ZM-1713735764562)]

[外链图片转存中…(img-KjfXvm5R-1713735764563)]

《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值