devbox
运维做开发
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

密码学进阶（一）：浅谈常见的七种加密算法及实现_常用加密算法(1)_密码学 加密算法 项目

作者：运维做开发 | 2024-07-06 17:06:20

赞

踩

密码学 加密算法 项目

文末

逆水行舟不进则退，所以大家要有危机意识。

同样是干到35岁，普通人写业务代码划水，榜样们深度学习拓宽视野晋升管理。

这也是为什么大家都说35岁是程序员的门槛，很多人迈不过去，其实各行各业都是这样都会有个坎，公司永远都缺的高级人才，只用这样才能在大风大浪过后，依然闪耀不被公司淘汰不被社会淘汰。

为了帮助大家更好温习重点知识、更高效的准备面试，特别整理了《前端工程师核心知识笔记》电子稿文件。

内容包括html，css，JavaScript，ES6，计算机网络，浏览器，工程化，模块化，Node.js，框架，数据结构，性能优化，项目等等。

269页《前端大厂面试宝典》

包含了腾讯、字节跳动、小米、阿里、滴滴、美团、58、拼多多、360、新浪、搜狐等一线互联网公司面试被问到的题目，涵盖了初中级前端技术点。

开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】

前端面试题汇总

    }
    keySpec = new SecretKeySpec(aesKey, "AES");
    this.iv = new IvParameterSpec(Md5Util.compute(aesKey));
}

public byte[] encrypt(byte[] data) {
    byte[] result = null;
    Cipher cipher = null;
    try {
        cipher = Cipher.getInstance("AES/CFB/NoPadding");
        cipher.init(Cipher.ENCRYPT_MODE, keySpec, iv);
        result = cipher.doFinal(data);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    return result;
}

public byte[] decrypt(byte[] secret) {
    byte[] result = null;
    Cipher cipher = null;
    try {
        cipher = Cipher.getInstance("AES/CFB/NoPadding");
        cipher.init(Cipher.DECRYPT_MODE, keySpec, iv);
        result = cipher.doFinal(secret);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    return result;
}

public static byte[] randomKey(int size) {
    byte[] result = null;
    try {
        KeyGenerator gen = KeyGenerator.getInstance("AES");
        gen.init(size, new SecureRandom());
        result = gen.generateKey().getEncoded();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    return result;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42

}


#### 5.5 RSA算法


**RSA 加密算法是目前最有影响力的公钥加密算法，并且被普遍认为是目前最优秀的公钥方案之一。RSA 是第一个能同时用于加密和数字签名的算法，它能够抵抗到目前为止已知的所有密码攻击，已被 ISO 推荐为公钥数据加密标准。**


RSA 加密算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。




  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

import net.pocrd.annotation.NotThreadSafe;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.security.KeyFactory;
import java.security.Security;
import java.security.Signature;
import java.security.interfaces.RSAPrivateCrtKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

@NotThreadSafe
public class RsaHelper {
private static final Logger logger = LoggerFactory.getLogger(RsaHelper.class);
private RSAPublicKey publicKey;
private RSAPrivateCrtKey privateKey;

static {
    Security.addProvider(new BouncyCastleProvider()); //使用bouncycastle作为加密算法实现
}

public RsaHelper(String publicKey, String privateKey) {
    this(Base64Util.decode(publicKey), Base64Util.decode(privateKey));
}

public RsaHelper(byte[] publicKey, byte[] privateKey) {
    try {
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        if (publicKey != null && publicKey.length > 0) {
            this.publicKey = (RSAPublicKey)keyFactory.generatePublic(new X509EncodedKeySpec(publicKey));
        }
        if (privateKey != null && privateKey.length > 0) {
            this.privateKey = (RSAPrivateCrtKey)keyFactory.generatePrivate(new PKCS8EncodedKeySpec(privateKey));
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

public RsaHelper(String publicKey) {
    this(Base64Util.decode(publicKey));
}

public RsaHelper(byte[] publicKey) {
    try {
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        if (publicKey != null && publicKey.length > 0) {
            this.publicKey = (RSAPublicKey)keyFactory.generatePublic(new X509EncodedKeySpec(publicKey));
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

public byte[] encrypt(byte[] content) {
    if (publicKey == null) {
        throw new RuntimeException("public key is null.");
    }

    if (content == null) {
        return null;
    }

    try {
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        int size = publicKey.getModulus().bitLength() / 8 - 11;
        ByteArrayOutputStream baos = new ByteArrayOutputStream((content.length + size - 1) / size \* (size + 11));
        int left = 0;
        for (int i = 0; i < content.length; ) {
            left = content.length - i;
            if (left > size) {
                cipher.update(content, i, size);
                i += size;
            } else {
                cipher.update(content, i, left);
                i += left;
            }
            baos.write(cipher.doFinal());
        }
        return baos.toByteArray();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

public byte[] decrypt(byte[] secret) {
    if (privateKey == null) {
        throw new RuntimeException("private key is null.");
    }

    if (secret == null) {
        return null;
    }

    try {
        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        int size = privateKey.getModulus().bitLength() / 8;
        ByteArrayOutputStream baos = new ByteArrayOutputStream((secret.length + size - 12) / (size - 11) \* size);
        int left = 0;
        for (int i = 0; i < secret.length; ) {
            left = secret.length - i;
            if (left > size) {
                cipher.update(secret, i, size);
                i += size;
            } else {
                cipher.update(secret, i, left);
                i += left;
            }
            baos.write(cipher.doFinal());
        }
        return baos.toByteArray();
    } catch (Exception e) {
        logger.error("rsa decrypt failed.", e);
    }
    return null;
}

public byte[] sign(byte[] content) {
    if (privateKey == null) {
        throw new RuntimeException("private key is null.");
    }
    if (content == null) {
        return null;
    }
    try {
        Signature signature = Signature.getInstance("SHA1WithRSA");
        signature.initSign(privateKey);
        signature.update(content);
        return signature.sign();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

public boolean verify(byte[] sign, byte[] content) {
    if (publicKey == null) {
        throw new RuntimeException("public key is null.");
    }
    if (sign == null || content == null) {
        return false;
    }
    try {
        Signature signature = Signature.getInstance("SHA1WithRSA");
        signature.initVerify(publicKey);
        signature.update(content);
        return signature.verify(sign);
    } catch (Exception e) {
        logger.error("rsa verify failed.", e);
    }
    return false;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136

}


#### 5.6 ECC算法


`ECC` 也是一种非对称加密算法，主要优势是在某些情况下，它比其他的方法使用更小的密钥，比如 RSA 加密算法，提供相当的或更高等级的安全级别。不过一个缺点是加密和解密操作的实现比其他机制时间长 (相比 RSA 算法，该算法对 CPU 消耗严重)。




  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

import net.pocrd.annotation.NotThreadSafe;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPrivateKey;
import org.bouncycastle.jcajce.provider.asymmetric.ec.BCECPublicKey;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.crypto.Cipher;
import java.io.ByteArrayOutputStream;
import java.security.KeyFactory;
import java.security.Security;
import java.security.Signature;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

@NotThreadSafe
public class EccHelper {
private static final Logger logger = LoggerFactory.getLogger(EccHelper.class);
private static final int SIZE = 4096;
private BCECPublicKey publicKey;
private BCECPrivateKey privateKey;

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

public EccHelper(String publicKey, String privateKey) {
    this(Base64Util.decode(publicKey), Base64Util.decode(privateKey));
}

public EccHelper(byte[] publicKey, byte[] privateKey) {
    try {
        KeyFactory keyFactory = KeyFactory.getInstance("EC", "BC");
        if (publicKey != null && publicKey.length > 0) {
            this.publicKey = (BCECPublicKey)keyFactory.generatePublic(new X509EncodedKeySpec(publicKey));
        }
        if (privateKey != null && privateKey.length > 0) {
            this.privateKey = (BCECPrivateKey)keyFactory.generatePrivate(new PKCS8EncodedKeySpec(privateKey));
        }
    } catch (ClassCastException e) {
        throw new RuntimeException("", e);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

public EccHelper(String publicKey) {
    this(Base64Util.decode(publicKey));
}

public EccHelper(byte[] publicKey) {
    try {
        KeyFactory keyFactory = KeyFactory.getInstance("EC", "BC");
        if (publicKey != null && publicKey.length > 0) {
            this.publicKey = (BCECPublicKey)keyFactory.generatePublic(new X509EncodedKeySpec(publicKey));
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

public byte[] encrypt(byte[] content) {
    if (publicKey == null) {
        throw new RuntimeException("public key is null.");
    }
    try {
        Cipher cipher = Cipher.getInstance("ECIES", "BC");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);
        int size = SIZE;
        ByteArrayOutputStream baos = new ByteArrayOutputStream((content.length + size - 1) / size \* (size + 45));
        int left = 0;
        for (int i = 0; i < content.length; ) {
            left = content.length - i;
            if (left > size) {
                cipher.update(content, i, size);
                i += size;
            } else {
                cipher.update(content, i, left);
                i += left;
            }
            baos.write(cipher.doFinal());
        }
        return baos.toByteArray();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

public byte[] decrypt(byte[] secret) {
    if (privateKey == null) {
        throw new RuntimeException("private key is null.");
    }
    try {
        Cipher cipher = Cipher.getInstance("ECIES", "BC");
        cipher.init(Cipher.DECRYPT_MODE, privateKey);
        int size = SIZE + 45;
        ByteArrayOutputStream baos = new ByteArrayOutputStream((secret.length + size + 44) / (size + 45) \* size);
        int left = 0;
        for (int i = 0; i < secret.length; ) {
            left = secret.length - i;
            if (left > size) {
                cipher.update(secret, i, size);
                i += size;
            } else {
                cipher.update(secret, i, left);
                i += left;
            }
            baos.write(cipher.doFinal());
        }
        return baos.toByteArray();
    } catch (Exception e) {
        logger.error("ecc decrypt failed.", e);
    }
    return null;
}

public byte[] sign(byte[] content) {
    if (privateKey == null) {
        throw new RuntimeException("private key is null.");
    }
    try {
        Signature signature = Signature.getInstance("SHA1withECDSA", "BC");
        signature.initSign(privateKey);
        signature.update(content);
        return signature.sign();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

public boolean verify(byte[] sign, byte[] content) {
    if (publicKey == null) {
        throw new RuntimeException("public key is null.");
    }
    try {
        Signature signature = Signature.getInstance("SHA1withECDSA", "BC");
        signature.initVerify(publicKey);
        signature.update(content);
        return signature.verify(sign);
    } catch (Exception e) {
        logger.error("ecc verify failed.", e);
    }
    return false;
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122

}


### 六、各种加密算法对比


#### 6.1 散列算法比较


![在这里插入图片描述](https://img-blog.csdnimg.cn/20191126164623602.png)


#### 6.2 对称加密算法比较


![在这里插入图片描述](https://img-blog.csdnimg.cn/20191126164638537.png)


#### 6.3 非对称加密算法比较


![在这里插入图片描述](https://img-blog.csdnimg.cn/20191126164726235.png)


#### 6.4 对称算法与非对称加密算法


##### 6.4.1 对称算法


密钥管理：比较难，不适合互联网，一般用于内部系统  
 安全性：中  
 加密速度：快好 几个数量级 (软件加解密速度至少快 100 倍，每秒可以加解密数 M 比特 数据)，适合大数据量的加解密处理


##### 6.4.2 非对称算法


密钥管理：密钥容易管理  
 安全性：高  
 加密速度：比较慢，适合小数据量加解密或数据签名。



### 结尾

学习html5、css、javascript这些基础知识，学习的渠道很多，就不多说了，例如，一些其他的优秀博客。但是本人觉得看书也很必要，可以节省很多时间，常见的javascript的书，例如：javascript的高级程序设计，是每位前端工程师必不可少的一本书，边看边用，了解js的一些基本知识，基本上很全面了，如果有时间可以读一些，js性能相关的书籍，以及设计者模式，在实践中都会用的到。

**[开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】](https://bbs.csdn.net/topics/618166371)**

![html5](https://img-blog.csdnimg.cn/img_convert/b59ab008214a9b2e771299a52a98d242.webp?x-oss-process=image/format,png)

数 M 比特 数据)，适合大数据量的加解密处理


##### 6.4.2 非对称算法


密钥管理：密钥容易管理  
 安全性：高  
 加密速度：比较慢，适合小数据量加解密或数据签名。



### 结尾

学习html5、css、javascript这些基础知识，学习的渠道很多，就不多说了，例如，一些其他的优秀博客。但是本人觉得看书也很必要，可以节省很多时间，常见的javascript的书，例如：javascript的高级程序设计，是每位前端工程师必不可少的一本书，边看边用，了解js的一些基本知识，基本上很全面了，如果有时间可以读一些，js性能相关的书籍，以及设计者模式，在实践中都会用的到。

**[开源分享：【大厂前端面试题解析+核心总结学习笔记+真实项目实战+最新讲解视频】](https://bbs.csdn.net/topics/618166371)**

[外链图片转存中...(img-ATuTpBoI-1715232739360)]


  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/运维做开发/article/detail/793493
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号