0
0

目前主流的加密算法的基本实现、特点、适用场景

目前主流的加密算法的基本实现、特点、适用场景

加密算法是信息安全领域中非常重要的一项技术，目前主流的加密算法有对称加密算法和非对称加密算法两类。本文将就这两类加密算法的基本实现、特点、适用场景以及在使用时可能存在的一些坑点进行介绍。

目录

一、对称加密算法

对称加密算法是指加密和解密使用同一把密钥的加密算法，它的基本实现原理是通过密钥将明文转化为密文，在传输过程中保证密文的安全性，接收方通过相同的密钥将密文还原为明文。目前主流的对称加密算法有DES、3DES、AES等。其中，AES是目前最流行的对称加密算法之一。

对称加密算法的特点是加密速度快，加密和解密的效率高，适合用于大型数据加密和解密。由于其使用密钥相同，因此需要保证密钥的保密性。适用场景主要包括网络传输中的数据加密、VPN加密等。

在使用对称加密算法时，主要有以下坑点：

密钥管理：同一把密钥用于多个场景，一旦密钥泄漏，所有数据都会暴露。

密钥交换：在进行通信之前需要安全地协商密钥，保证密钥不会被攻击者截获。

二、非对称加密算法

非对称加密算法是指加密和解密使用不同的密钥的加密算法，其中一把被称为公钥，另外一把被称为私钥。在通信过程中，发送方将数据使用接收方的公钥加密，接收方收到后使用自己的私钥解密。非对称加密算法目前最常用的有RSA算法、ECC算法等。

非对称加密算法的特点是密钥不同，相对于对称加密算法更加安全，使用非对称加密算法的通信过程中不需要进行密钥交换。适用场景主要包括数字签名、加密密钥的传输等。

在使用非对称加密算法时，主要有以下坑点：

密钥长度：密钥长度越长，越安全，但加密解密效率会降低。

单向性：非对称加密算法是单向加密，公钥加密后只能使用私钥解密，私钥加密后只能使用公钥解密。

三、对称加密算法的介绍与实现

DES加密

DES算法（Data Encryption Standard）是美国国家标准局于1977年设计的一个对称加密标准，常用于保护数据传输的安全性。DES采用对称密钥，将明文块加密成密文块。DES密钥长度为56位，因此虽然算法安全，但由于密钥太短，现在已经被认为不够安全。因此通常需要与其他加密技术结合使用。

Java原生实现

publicclassDesDemo{privatestaticfinalString ALGORITHM ="DES";privatestaticbyte[]generateKey()throwsNoSuchAlgorithmException{KeyGenerator keyGenerator =KeyGenerator.getInstance(ALGORITHM);SecureRandom secureRandom =newSecureRandom();
        keyGenerator.init(secureRandom);SecretKey secretKey = keyGenerator.generateKey();return secretKey.getEncoded();}privatestaticSecretKeybyteArrayToSecretKey(byte[] keyBytes){returnnewSecretKeySpec(keyBytes, ALGORITHM);}publicstaticbyte[]encrypt(byte[] plainText,SecretKey secretKey)throwsException{Cipher cipher =Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);return cipher.doFinal(plainText);}publicstaticbyte[]decrypt(byte[] cipherText,SecretKey secretKey)throwsException{Cipher cipher =Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, secretKey);return cipher.doFinal(cipherText);}publicstaticvoidmain(String[] args)throwsException{String plainText ="hello world";System.out.println("Plain text: "+ plainText);byte[] bytes =generateKey();System.out.println(Base64.getEncoder())byte[] cipherText =encrypt(plainText.getBytes(),byteArrayToSecretKey(bytes));System.out.println("Cipher text: "+Arrays.toString(cipherText));byte[] decryptedText =decrypt(cipherText,byteArrayToSecretKey(bytes));System.out.println("Decrypted text: "+newString(decryptedText));}}

3DES加密

3DES算法（Triple DES，或称为DESede）是一种实现了对称密钥加密的标准。它采用了三个DES加密过程来提升安全性。3DES的密钥长度可以是168位或112位，安全性比DES更高，但速度较慢。

Java原生实现

/**
 * 3DES加密工具类
 * @author qzz
 */publicclassThreeDESUtils{/**
     * 加解密统一编码方式
     */privatefinalstaticString ENCODING ="utf-8";/**
     * 加解密方式
     */privatefinalstaticString ALGORITHM  ="DESede";/**
     *加密模式及填充方式
     */privatefinalstaticString PATTERN ="DESede/ECB/pkcs5padding";/**
     * 3DES加密
     *
     * @param plainText 普通文本
     * @param sK 秘钥（24位密码）
     * @return
     * @throws Exception
     */publicstaticStringencode(String plainText,String sK)throwsException{SecretKey secretKey =newSecretKeySpec(sK.getBytes(ENCODING), ALGORITHM);// 3DES加密采用pkcs5padding填充Cipher cipher =Cipher.getInstance(PATTERN);// 用密匙初始化Cipher对象
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);// 执行加密操作byte[] encryptData = cipher.doFinal(plainText.getBytes(ENCODING));returnBase64.getEncoder().encodeToString(encryptData);}/**
     * 3DES解密
     *
     * @param encryptText 加密文本
     * @return
     * @throws Exception
     */publicstaticStringdecode(String encryptText,String sK)throwsException{SecretKey secretKey =newSecretKeySpec(sK.getBytes(ENCODING), ALGORITHM);// 3DES加密采用pkcs5padding填充Cipher cipher =Cipher.getInstance(PATTERN);// 用密匙初始化Cipher对象
        cipher.init(Cipher.DECRYPT_MODE, secretKey);// 正式执行解密操作byte[] decryptData = cipher.doFinal(Base64.getDecoder().decode(encryptText));returnnewString(decryptData, ENCODING);}publicstaticvoidmain(String[] args)throwsException{//加密System.out.println(encode("test-111","111036369260679051122113"));//解密System.out.println(decode(encode("test-111","111036369260679051122113"),"111036369260679051122113"));}}

RC4

RC4（Rivest Cipher 4）是一种流加密算法，广泛应用于安全协议以及各种软件中。RC4算法的输入是一个密钥和明文，输出为密文。

RC4算法是一种对称算法，使用同一个密钥对数据进行加密和解密。RC4算法的加密过程是通过不断重复执行一个加密操作完成，即将状态向量 S 循环移位，然后将 S[i] 与 S[j] 交换，从而生成一个伪随机数。这个伪随机数被用来加密数据。

RC4算法的明文加密过程是通过将明文与密钥进行异或操作（也叫做亦或操作）实现的。加密过程中，明文的每个字符都被依次与伪随机数异或，生成密文。

RC4算法的主要优点是速度快，加密和解密的速度都很快。另外，RC4算法的密钥长度可以根据需要灵活设置。然而，RC4算法因其算法的不安全性而逐渐被替代，使用时需要结合安全的密钥长度、密钥管理等保障算法的安全性。

总之，虽然RC4算法在现代安全标准中已经不再被推荐使用，但它仍然是一个有用的算法，因为它的简单性和速度使它被广泛应用于各种软件程序中。

Java原生实现

publicclass RC4 {publicstaticStringencrypt(String key,String str){int[]S=newint[256];int[]T=newint[256];if(key.length()==0|| str.length()==0){returnnull;}for(int i =0; i <256; i++){S[i]= i;T[i]= key.charAt(i % key.length());}int j =0;for(int i =0; i <256; i++){
            j =(j +S[i]+T[i])%256;int temp =S[i];S[i]=S[j];S[j]= temp;}int i =0, k =0;StringBuilder sb =newStringBuilder();while(k < str.length()){
            i =(i +1)%256;
            j =(j +S[i])%256;int temp =S[i];S[i]=S[j];S[j]= temp;int t =(S[i]+S[j])%256;int c = str.charAt(k)^S[t];
            sb.append((char) c);
            k++;}return sb.toString();}publicstaticStringdecrypt(String key,String str){returnencrypt(key, str);}publicstaticvoidmain(String[] args){String key ="rc4key";String plaintext ="Hello RC4!";String ciphertext = RC4.encrypt(key, plaintext);String decryptedText = RC4.decrypt(key, ciphertext);System.out.println("Plaintext: "+ plaintext);System.out.println("Ciphertext: "+ ciphertext);System.out.println("Decrypted Text: "+ decryptedText);}}

Blowfish

Blowfish是一种对称加密算法，由Bruce Schneier于1993年设计，作为DES算法的替代方案。它使用一种称为Feistel结构的迭代块密码，可以加密64位数据块，使用变长的密钥进行加密，密钥长度可以介于32位到448位之间（但位数必须为8的倍数），因此比DES更加安全。

安全性高。Blowfish算法在1994年的时候被选为第一代AES候选加密算法，尽管没有最终被评选为标准算法，但是它已经被广泛应用于网络应用和计算机安全领域。
高效性。Blowfish算法的加密和解密速度比DES要快，同时由于它不是一个分组密码，因此它可以生成加密和解密的密钥流，因此可以在实时加密数据时更加高效。
算法简单。Blowfish算法的底层算法非常简单，在实现时也比较容易，因此可以用于软件和硬件实现。
作为一种经典的块加密算法，Blowfish被广泛用于安全协议、SSL、SSH和虚拟私人网络等网络用途。同时，由于其安全性和高效性，Blowfish算法也常常被用于加密数据库、文件系统、磁盘映像和加密算法等。

Java原生实现

publicclassBlowfishExample{// 密钥数组，根据需要可以更改privatestaticfinalbyte[] KEY ="ThisIsASecretKey".getBytes(StandardCharsets.UTF_8);publicstaticvoidmain(String[] args)throwsException{String text ="Hello World!";// 待加密的字符串byte[] encrypted =encrypt(text);String decrypted =decrypt(encrypted);System.out.println("原文: "+ text);System.out.println("加密后: "+Arrays.toString(encrypted));System.out.println("解密后: "+ decrypted);}// 加密函数publicstaticbyte[]encrypt(String str)throwsException{SecretKeySpec secretKeySpec =newSecretKeySpec(KEY,"Blowfish");Cipher cipher =Cipher.getInstance("Blowfish/ECB/PKCS5Padding");
        cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec);return cipher.doFinal(str.getBytes(StandardCharsets.UTF_8));}// 解密函数publicstaticStringdecrypt(byte[] bytes)throwsException{SecretKeySpec secretKeySpec =newSecretKeySpec(KEY,"Blowfish");Cipher cipher =Cipher.getInstance("Blowfish/ECB/PKCS5Padding");
        cipher.init(Cipher.DECRYPT_MODE, secretKeySpec);byte[] decrypted = cipher.doFinal(bytes);returnnewString(decrypted,StandardCharsets.UTF_8);}}

AES加密

高级加密标准（AES算法）是一种对称加密算法，于2001年由比利时密码学家Joan Daemen和Vincent Rijmen所研制。AES算法的密钥长度可以是128位、192位或256位，其中128位密钥版本是最为常用的。

AES算法采用分组密码机制，将明文分成128位的数据块，使用密钥和算法对每个数据块进行加密。它是一种非常安全可靠的加密技术，目前被广泛应用于文件加密、虚拟私人网络、电子邮件、数据库加密等领域。

AES算法的安全性是由其密钥长度来保证的。AES-128算法使用一个128位的密钥，而AES-192和AES-256使用192位和256位的密钥，其中AES-256算法的安全强度最高，但速度较慢。然而，由于AES算法的算法设计非常高效，因此它能够在现代计算机系统上快速而安全地加密和解密数据。

Java原生实现

publicclassAesDemo{privatestaticfinalString ALGORITHM ="AES/CBC/PKCS5Padding";privatestaticfinalString KEY ="mySecretKey12345";// 16-byte secret keyprivatestaticfinalString IV ="12345987654321";// 16-byte initialization vectorpublicstaticvoidmain(String[] args){String plaintext ="Hello, world!";byte[] encrypted =encrypt(plaintext);System.out.println("Encrypted message: "+newString(encrypted));String decrypted =decrypt(encrypted);System.out.println("Decrypted message: "+ decrypted);}publicstaticbyte[]encrypt(String plaintext){try{Cipher cipher =Cipher.getInstance(ALGORITHM);SecretKeySpec key =newSecretKeySpec(KEY.getBytes("UTF-8"),"AES");IvParameterSpec iv =newIvParameterSpec(IV.getBytes("UTF-8"));
            cipher.init(Cipher.ENCRYPT_MODE, key, iv);return cipher.doFinal(plaintext.getBytes());}catch(Exception e){thrownewRuntimeException("Encryption failed", e);}}publicstaticStringdecrypt(byte[] encrypted){try{Cipher cipher =Cipher.getInstance(ALGORITHM);SecretKeySpec key =newSecretKeySpec(KEY.getBytes("UTF-8"),"AES");IvParameterSpec iv =newIvParameterSpec(IV.getBytes("UTF-8"));
            cipher.init(Cipher.DECRYPT_MODE, key, iv);byte[] decrypted = cipher.doFinal(encrypted);returnnewString(decrypted);}catch(Exception e){thrownewRuntimeException("Decryption failed", e);}}}

在该示例代码中，AES算法使用CBC模式和PKCS5Padding填充。密钥和初始化向量的长度都为16字节。encrypt方法使用给定的密钥和向量来加密明文字符串，返回加密后的字节数组。decrypt方法使用相同的密钥和向量来解密字节数组，并返回明文字符串。

在上面的main方法中，演示了如何使用encrypt和decrypt方法来加密和解密一个字符串。加密后的字节数组可以使用任何适合的方式进行传输，例如存储在数据库中或通过网络传输。解密字节数组时只需调用decrypt方法即可。

四、非对称加密算法的介绍与实现

ECC加密

ECC加密算法全称是椭圆曲线加密算法。它是一种公钥加密算法，其安全性基于椭圆曲线离散对数问题。ECC比RSA使用更短的密钥长度，具有更快的处理速度，并且可在低功率设备上轻松运行。ECC加密算法适用于各种用途，包括电子邮箱、虚拟专用网络（VPN）、移动设备等。

需要引入依赖

<dependency><groupId>org.bouncycastle</groupId><artifactId>bcprov-jdk15on</artifactId><version>1.61</version></dependency>

publicclassECCUtil{privatestaticfinalString PROVIDER_NAME ="BC";privatestaticfinalString ECC_CURVE_NAME ="secp256r1";// 生成公私钥对publicstaticKeyPairgenerateKeyPair(){try{Security.addProvider(newBouncyCastleProvider());KeyPairGenerator keyPairGenerator =KeyPairGenerator.getInstance("EC", PROVIDER_NAME);ECGenParameterSpec ecGenParameterSpec =newECGenParameterSpec(ECC_CURVE_NAME);
            keyPairGenerator.initialize(ecGenParameterSpec,newSecureRandom());return keyPairGenerator.generateKeyPair();}catch(NoSuchAlgorithmException|NoSuchProviderException|InvalidAlgorithmParameterException e){
            e.printStackTrace();}returnnull;}// 加密 publicstaticStringencrypt(String plainText,PublicKey publicKey){try{Security.addProvider(newBouncyCastleProvider());Cipher cipher =Cipher.getInstance("ECIES", PROVIDER_NAME);
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);byte[] encrypted = cipher.doFinal(plainText.getBytes());returnBase64.getEncoder().encodeToString(encrypted);}catch(Exception e){
            e.printStackTrace();}returnnull;}// 解密publicstaticStringdecrypt(String cipherText,PrivateKey privateKey){try{Security.addProvider(newBouncyCastleProvider());Cipher cipher =Cipher.getInstance("ECIES", PROVIDER_NAME);
            cipher.init(Cipher.DECRYPT_MODE, privateKey);byte[] cipherBytes =Base64.getDecoder().decode(cipherText);byte[] decrypted = cipher.doFinal(cipherBytes);returnnewString(decrypted);}catch(Exception e){
            e.printStackTrace();}returnnull;}publicstaticvoidmain(String[] args)throwsNoSuchAlgorithmException,InvalidKeySpecException{// 生成公私钥对KeyPair keyPair =ECCUtil.generateKeyPair();byte[] publicKeys = keyPair.getPublic().getEncoded();byte[] privateKeys = keyPair.getPrivate().getEncoded();System.out.println(Arrays.toString(publicKeys));String privateKey1 =newBASE64Encoder().encode(privateKeys);String publicKey1 =newBASE64Encoder().encode(publicKeys);System.out.println(privateKey1);System.out.println(Arrays.toString(newString(publicKeys,StandardCharsets.UTF_8).getBytes(StandardCharsets.UTF_8)));KeyFactory factory =KeyFactory.getInstance("EC");X509EncodedKeySpec publicSpec =newX509EncodedKeySpec(publicKeys);PublicKey publicKey = factory.generatePublic(publicSpec);PKCS8EncodedKeySpec privateSpec =newPKCS8EncodedKeySpec(privateKeys);PrivateKey privateKey = factory.generatePrivate(privateSpec);String plainText ="Hello, world!";String cipherText =ECCUtil.encrypt(plainText, publicKey);System.out.println("Cipher text: "+ cipherText);String decryptedText =ECCUtil.decrypt(cipherText, privateKey);System.out.println("Decrypted text: "+ decryptedText);}}

RSA加密

RSA算法又称为Rivest-Shamir-Adleman算法，是一种基于大素数分解的公钥加密算法。其加密过程是将明文通过公钥加密产生密文，再将密文通过私钥解密还原为明文。RSA算法具有可靠的安全性，但是随着计算机性能的提升，需要使用更长的密钥长度来保证安全性。RSA算法在数字签名、身份验证、加密通信等方面被广泛应用，在传统的电子商务、金融、网络安全等领域具有重要作用

Java原生实现

publicclassRSAEncryptionDemo{privatestaticfinalString ALGORITHM ="RSA";publicstaticvoidmain(String[] args)throwsException{String originalText ="Hello world";KeyPair keyPair =generateRSAKeyPair();PublicKey publicKey = keyPair.getPublic();PrivateKey privateKey = keyPair.getPrivate();byte[] encryptedText =encryptText(originalText, publicKey);String decryptedText =decryptText(encryptedText, privateKey);System.out.println("Original text: "+ originalText);System.out.println("Encrypted text: "+newString(encryptedText));System.out.println("Decrypted text: "+ decryptedText);}privatestaticKeyPairgenerateRSAKeyPair()throwsNoSuchAlgorithmException{KeyPairGenerator keyPairGenerator =KeyPairGenerator.getInstance(ALGORITHM);
        keyPairGenerator.initialize(2048);return keyPairGenerator.generateKeyPair();}privatestaticbyte[]encryptText(String text,PublicKey publicKey)throwsException{Cipher cipher =Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);return cipher.doFinal(text.getBytes());}privatestaticStringdecryptText(byte[] ciphertext,PrivateKey privateKey)throwsException{Cipher cipher =Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, privateKey);returnnewString(cipher.doFinal(ciphertext));}}

在这个Demo中，首先生成了一个RSA密钥对，然后使用公钥加密了文本，并使用私钥解密了文本，最后输出了原文、加密后的文本、解密后的文本。您可以根据自己的需要修改文本和密钥长度。

ESA加密

判断签名是否正确，非加解密

Java原生实现

publicclassDSAEncryptionExample{publicstaticvoidmain(String[] args)throwsException{// 创建一个用于DSA加密签名的密钥对，包括公钥和私钥KeyPairGenerator keyGen =KeyPairGenerator.getInstance("DSA");SecureRandom random =newSecureRandom();
        keyGen.initialize(1024, random);KeyPair pair = keyGen.generateKeyPair();PrivateKey privateKey = pair.getPrivate();PublicKey publicKey = pair.getPublic();// 使用私钥对数据进行签名String plainText ="Hello, world!";Signature dsa =Signature.getInstance("SHA1withDSA","SUN");
        dsa.initSign(privateKey);
        dsa.update(plainText.getBytes());byte[] signature = dsa.sign();// 输出十六进制格式的签名结果System.out.println("Signature: "+Base64.getEncoder().encodeToString(signature));// 使用公钥对签名的数据进行验证Signature dsaVerify =Signature.getInstance("SHA1withDSA","SUN");
        dsaVerify.initVerify(publicKey);
        dsaVerify.update(plainText.getBytes());boolean verified = dsaVerify.verify(signature);// 输出验证结果System.out.println("Verified: "+ verified);}}

五、总结

安全的加密策略通常通过对称加密来加密明文信息，通过非对称加密方式用来加密对称加密的密钥，一种加密策略使用两种加密方式；推荐使用AES+RSA加密策略用来实现。

标签： 网络 安全 java
本文转载自: https://blog.csdn.net/chen2iu/article/details/129840169
版权归原作者 爱编程的夹心 所有， 如有侵权，请联系我们删除。
登录后发布评论

“目前主流的加密算法的基本实现、特点、适用场景”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

机器人技术在安全领域的重要作用

安全学习记录——网络篇（一）

图腾柱PFC：HP1010为您的电动两轮车之旅提供绿色，高效，安全的动力

单元测试数据库回滚问题

这才是单元测试，之前我们都错了

【C语言基础】：字符函数和字符串函数

ChatGPT-Next-Web SSRF漏洞+XSS漏洞复现(CVE-2023-49785)

文章导航