1.安全传输加密算法

最新推荐文章于 2024-04-02 11:55:10 发布
最新推荐文章于 2024-04-02 11:55:10 发布
阅读量1.6k 收藏 2
点赞数
文章标签： 安全 服务器 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/c1776167012/article/details/125530275
版权

一.何为安全传输？

安全传输就是，即使人家从网络监听到我们发送的数据包，也无法破译我们的信息，或者破译的机会十分渺茫。
那么这是如何实现的呢？ 毕竟，我们想要传输加密信息，接收者解密的话则需要密钥，而密钥也是需要通过网络传输的啊！！

1.非对称加密

密钥的安全传输需要用到一种特殊的加密技术： 非对称加密。

1.1 何为非对称加密？

一次非对称加密信息传输包含三个要素： 公钥，私钥，传输报文

  • 公钥： 源服务器生成，通过网络传输到目标服务器
  • 私钥： 源服务器生成，绝对保存在本地，不经过任何传输到任何地方，只存在源服务器本地。
  • 传输报文： 通过公钥或私钥进行加解密
    非对称加密运行流程如下：
    首先，源服务器生成一对密钥： 公钥，私钥。 公钥通过网络明文发送给目标服务器，然后源服务器将要发送的报文用私钥加密后发送给目标服务器，目标服务器拿到密文用公钥解密(这个过程不安全，因为如果其他人监听到公钥了，那么他就可以用公钥对源服务器发出的报文进行解密) ，接着目标服务器用公钥对要发送的报文进行加密，发送到源服务器，源服务器用私钥进行解密即可(这个过程是安全的，因为私钥只有源服务器拥有)

1.2 非对称加密算法RSA实例

典型的非对称加密算法RSA应用实例：

package RSA;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.Charset;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Arrays;
import java.util.Base64;

public class RSADemo {

    private static final String ENCODE = "UTF-8";

    private static final String AES = "AES";
    
    private static final String CIPHER_ALGORITHM = "AES/CBC/PKCS5Padding";


    /**
     * AES加密
     * @param content 加密内容
     * @param AES_IV 加密偏移量
     * @param AES_KEY 加密密钥
     * @return 密文
     * @throws Exception 加密过程中出现的异常
     */
    public static String AESEncryptEncode(String content,String AES_IV,String AES_KEY) throws Exception{
        Base64.Decoder decoder = Base64.getDecoder();
        byte[] keyByte = decoder.decode(AES_KEY);
        int base = 16;
        if (keyByte.length % base != 0) {
            int groups = keyByte.length / base + 1;
            byte[] temp = new byte[groups * base];
            Arrays.fill(temp, (byte) 0);
            System.arraycopy(keyByte, 0, temp, 0, keyByte.length);
            keyByte = temp;
        }
        SecretKeySpec secretKeySpec = new SecretKeySpec(keyByte,AES);

        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);

        cipher.init(Cipher.ENCRYPT_MODE,secretKeySpec,new IvParameterSpec(decoder.decode(AES_IV)));

        byte[] result = cipher.doFinal(content.getBytes(ENCODE));

        return Base64.getEncoder().encodeToString(result);
    }

    /**
     * AES解密
     * @param content 密文
     * @param AES_IV 解密偏移量
     * @param AES_KEY 解密密钥
     * @return 解密后明文
     * @throws Exception 异常
     */
    public static String AESDecodeDecrypt(String content,String AES_IV,String AES_KEY) throws Exception{

        Base64.Decoder decoder = Base64.getDecoder();
        byte[] keyByte = decoder.decode(AES_KEY);
        int base = 16;
        if (keyByte.length % base != 0) {
            int groups = keyByte.length / base + 1;
            byte[] temp = new byte[groups * base];
            Arrays.fill(temp, (byte) 0);
            System.arraycopy(keyByte, 0, temp, 0, keyByte.length);
            keyByte = temp;
        }
        SecretKeySpec secretKeySpec = new SecretKeySpec(keyByte,AES);

        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);

        cipher.init(Cipher.DECRYPT_MODE,secretKeySpec,new IvParameterSpec(decoder.decode(AES_IV)));

        byte[] base64 = decoder.decode(content);

        byte[] result = cipher.doFinal(base64);

        return new String(result, Charset.forName(ENCODE));
    }

    /**
     * Rsa生成公钥，密钥
     * @return 返回公钥，密钥字符串数组 0--密钥 1--公钥
     * @throws NoSuchAlgorithmException 异常信息
     */
    public static String[] RsaGenera() throws NoSuchAlgorithmException {
        // 1.初始化发送方密钥
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(512);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
        String[] results = new String[2];
        results[0] = Base64.getEncoder().encodeToString(rsaPrivateKey.getEncoded());
        results[1] = Base64.getEncoder().encodeToString(rsaPublicKey.getEncoded());
        return results;
    }

    /**
     * Rsa私钥加密
     * @param privateKey 私钥
     * @param content 明文
     * @return 返回密文
     * @throws Exception 异常
     */
    public static String RsaPrivateEncrypt(String privateKey,String content) throws Exception {
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKey));
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey1 = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, privateKey1);
        byte[] result = cipher.doFinal(content.getBytes(ENCODE));
        //System.out.println("私钥加密、公钥解密 ---- 加密:" + Arrays.toString(result));
        return Base64.getEncoder().encodeToString(result);
    }

    /**
     * Rsa公钥解密
     * @param publicKey 公钥
     * @param content 密文
     * @return 明文
     * @throws Exception 异常
     */
    public static String RsaPublicUnEncrypt(String publicKey,String content) throws Exception{
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(publicKey));
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey1 = keyFactory.generatePublic(x509EncodedKeySpec);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, publicKey1);
        byte[] result = cipher.doFinal(Base64.getDecoder().decode(content));
        //System.out.println("私钥加密、公钥解密 ---- 解密:" + Base64.getEncoder().encodeToString(result));
        return Base64.getEncoder().encodeToString(result);
    }

    /**
     * Rsa公钥加密
     * @param publicKey 公钥
     * @param content 明文
     * @return 密文
     * @throws Exception 异常
     */
    public static String RsaPublicEncrypt(String publicKey,String content) throws Exception{
        X509EncodedKeySpec x509EncodedKeySpec2 = new X509EncodedKeySpec(Base64.getDecoder().decode(publicKey));
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey1 = keyFactory.generatePublic(x509EncodedKeySpec2);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey1);
        byte[] result = cipher.doFinal(content.getBytes(ENCODE));
        //System.out.println("公钥加密、私钥解密 ---- 加密: "+Base64.getEncoder().encodeToString(result2));
        return Base64.getEncoder().encodeToString(result);
    }

    /**
     * Rsa私钥解密
     * @param privateKey 私钥
     * @param content 密文
     * @return 解密后明文
     * @throws Exception 异常
     */
    public static String RsaPrivateUnEncrypt(String privateKey,String content) throws Exception{
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec5 = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKey));
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey1 = keyFactory.generatePrivate(pkcs8EncodedKeySpec5);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, privateKey1);
        byte[] result = cipher.doFinal(Base64.getDecoder().decode(content));
        //System.out.println("公钥加密、私钥解密 ---- 解密:" + new String(result));
        return new String(result);
    }

    public static void main(String[] args) throws Exception {

        String[] keys = RsaGenera();
        System.out.println("RSA生成密钥对:");
        System.out.println("公钥："+keys[1]);
        System.out.println("私钥："+keys[0]);
        
        String test = RsaPublicEncrypt(keys[1],"今天打老虎");
        System.out.println("公钥加密：今天打老虎-->"+test);

        String test2 = RsaPrivateUnEncrypt(keys[0],test);
        System.out.println("私钥解密："+test+"-->"+test2);

    }

}

运行结果：
在这里插入图片描述

2.对称加密

对称加密技术是一种很广泛的加密技术。

2.1 何为对称加密

对称加密的元素主要有两个： 密钥，报文

  • 密钥： 通信双方提前约定好的密钥
  • 报文： 用相同的密钥进行加密和解密的报文

对称加密的运行流程如下：
首先通信双方约定好密钥，然后源服务器发送到目标服务器的密文用密钥加密，目标服务器用密钥解密密文即可。（如果密钥还是通过网络传输，则这种通信还是不安全的，除非双方线下约定且保证没有第三个人知道）

2.2 对称加密AES/CBC加密实例

package RSA;

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.Base64;

public class AESDemo {

    private static final String ENCODE = "UTF-8";

    private static final String AES = "AES";

    private static final String AES_IV = "49U2GlzcrBmS9UVz+mEE3Q==";

    private static final String AES_KEY = "D8M1+eb6mzq0Oc23K+YQYQ==";

    private static final String CIPHER_ALGORITHM = "AES/CBC/PKCS5Padding";


    /**
     * AES加密
     * @param content 加密内容
     * @param AES_IV 加密偏移量
     * @param AES_KEY 加密密钥
     * @return 密文
     * @throws Exception 加密过程中出现的异常
     */
    public static String AESEncryptEncode(String content,String AES_IV,String AES_KEY) throws Exception{
        Base64.Decoder decoder = Base64.getDecoder();
        byte[] keyByte = decoder.decode(AES_KEY);
        int base = 16;
        if (keyByte.length % base != 0) {
            int groups = keyByte.length / base + 1;
            byte[] temp = new byte[groups * base];
            Arrays.fill(temp, (byte) 0);
            System.arraycopy(keyByte, 0, temp, 0, keyByte.length);
            keyByte = temp;
        }
        SecretKeySpec secretKeySpec = new SecretKeySpec(keyByte,AES);

        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);

        cipher.init(Cipher.ENCRYPT_MODE,secretKeySpec,new IvParameterSpec(decoder.decode(AES_IV)));

        byte[] result = cipher.doFinal(content.getBytes(ENCODE));

        return Base64.getEncoder().encodeToString(result);
    }

    /**
     * AES解密
     * @param content 密文
     * @param AES_IV 解密偏移量
     * @param AES_KEY 解密密钥
     * @return 解密后明文
     * @throws Exception 异常
     */
    public static String AESDecodeDecrypt(String content,String AES_IV,String AES_KEY) throws Exception{

        Base64.Decoder decoder = Base64.getDecoder();
        byte[] keyByte = decoder.decode(AES_KEY);
        int base = 16;
        if (keyByte.length % base != 0) {
            int groups = keyByte.length / base + 1;
            byte[] temp = new byte[groups * base];
            Arrays.fill(temp, (byte) 0);
            System.arraycopy(keyByte, 0, temp, 0, keyByte.length);
            keyByte = temp;
        }
        SecretKeySpec secretKeySpec = new SecretKeySpec(keyByte,AES);

        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);

        cipher.init(Cipher.DECRYPT_MODE,secretKeySpec,new IvParameterSpec(decoder.decode(AES_IV)));

        byte[] base64 = decoder.decode(content);

        byte[] result = cipher.doFinal(base64);

        return new String(result, Charset.forName(ENCODE));
    }



    public static void main(String[] args) throws Exception {
        String m = AESEncryptEncode("今天打老虎",AES_IV,AES_KEY);
        System.out.println("AES对称加密： "+m);
        System.out.println("AES对称解密："+AESDecodeDecrypt(m,AES_IV,AES_KEY));
    }

}

运行结果：
在这里插入图片描述

3. 通过非对称+对称加密实现网络安全传输

通过前面的学习我们知道，安全传输的关键在于密钥不能被泄露，我们可以试想一下，我们能不能先用非对称加密传输密钥，然后用对称加密进行报文传输，这样的话不久实现了，加密传输。

流程如下：
首先源服务器生成私钥，公钥，将公钥发送给目标服务器，然后目标服务器用公钥加密对称密钥发送给源服务器，接着源服务器将密文解密得到对称密钥，这样就只有双方知道对称密钥了，不存在第三方知道了。
然后以后的信息传输就用对称密钥加解密即可。

3.1 结合RSA和AES/CBC实现安全传输Demo

非对称加密进行对称密钥传输，对称加密实现报文安全传输。

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.security.*;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Arrays;
import java.util.Base64;

public class EncryptUtil {

    private static final String ENCODE = "UTF-8";

    private static final String AES = "AES";

    private static final String AES_IV = "49U2GlzcrBmS9UVz+mEE3Q==";

    private static final String AES_KEY = "D8M1+eb6mzq0Oc23K+YQYQ==";

    private static final String CIPHER_ALGORITHM = "AES/CBC/PKCS5Padding";


    /**
     * AES加密
     * @param content 加密内容
     * @param AES_IV 加密偏移量
     * @param AES_KEY 加密密钥
     * @return 密文
     * @throws Exception 加密过程中出现的异常
     */
    public static String AESEncryptEncode(String content,String AES_IV,String AES_KEY) throws Exception{
       Base64.Decoder decoder = Base64.getDecoder();
        byte[] keyByte = decoder.decode(AES_KEY);
        int base = 16;
        if (keyByte.length % base != 0) {
            int groups = keyByte.length / base + 1;
            byte[] temp = new byte[groups * base];
            Arrays.fill(temp, (byte) 0);
            System.arraycopy(keyByte, 0, temp, 0, keyByte.length);
            keyByte = temp;
        }
        SecretKeySpec secretKeySpec = new SecretKeySpec(keyByte,AES);

        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);

        cipher.init(Cipher.ENCRYPT_MODE,secretKeySpec,new IvParameterSpec(decoder.decode(AES_IV)));

        byte[] result = cipher.doFinal(content.getBytes(ENCODE));

        return Base64.getEncoder().encodeToString(result);
    }

    /**
     * AES解密
     * @param content 密文
     * @param AES_IV 解密偏移量
     * @param AES_KEY 解密密钥
     * @return 解密后明文
     * @throws Exception 异常
     */
    public static String AESDecodeDecrypt(String content,String AES_IV,String AES_KEY) throws Exception{

       Base64.Decoder decoder = Base64.getDecoder();
        byte[] keyByte = decoder.decode(AES_KEY);
        int base = 16;
        if (keyByte.length % base != 0) {
            int groups = keyByte.length / base + 1;
            byte[] temp = new byte[groups * base];
            Arrays.fill(temp, (byte) 0);
            System.arraycopy(keyByte, 0, temp, 0, keyByte.length);
            keyByte = temp;
        }
        SecretKeySpec secretKeySpec = new SecretKeySpec(keyByte,AES);

        Cipher cipher = Cipher.getInstance(CIPHER_ALGORITHM);

        cipher.init(Cipher.DECRYPT_MODE,secretKeySpec,new IvParameterSpec(decoder.decode(AES_IV)));

        byte[] base64 = decoder.decode(content);

        byte[] result = cipher.doFinal(base64);

        return new String(result, Charset.forName(ENCODE));
    }

    /**
     * Rsa生成公钥，密钥
     * @return 返回公钥，密钥字符串数组 0--密钥 1--公钥
     * @throws NoSuchAlgorithmException 异常信息
     */
    public static String[] RsaGenera() throws NoSuchAlgorithmException {
        // 1.初始化发送方密钥
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
        keyPairGenerator.initialize(512);
        KeyPair keyPair = keyPairGenerator.generateKeyPair();
        RSAPublicKey rsaPublicKey = (RSAPublicKey) keyPair.getPublic();
        RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) keyPair.getPrivate();
        String[] results = new String[2];
        results[0] = Base64.getEncoder().encodeToString(rsaPrivateKey.getEncoded());
        results[1] = Base64.getEncoder().encodeToString(rsaPublicKey.getEncoded());
        return results;
    }

    /**
     * Rsa私钥加密
     * @param privateKey 私钥
     * @param content 明文
     * @return 返回密文
     * @throws Exception 异常
     */
    public static String RsaPrivateEncrypt(String privateKey,String content) throws Exception {
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKey));
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey1 = keyFactory.generatePrivate(pkcs8EncodedKeySpec);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, privateKey1);
        byte[] result = cipher.doFinal(content.getBytes(ENCODE));
        //System.out.println("私钥加密、公钥解密 ---- 加密:" + Arrays.toString(result));
        return Base64.getEncoder().encodeToString(result);
    }

    /**
     * Rsa公钥解密
     * @param publicKey 公钥
     * @param content 密文
     * @return 明文
     * @throws Exception 异常
     */
    public static String RsaPublicUnEncrypt(String publicKey,String content) throws Exception{
        X509EncodedKeySpec x509EncodedKeySpec = new X509EncodedKeySpec(Base64.getDecoder().decode(publicKey));
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey1 = keyFactory.generatePublic(x509EncodedKeySpec);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, publicKey1);
        byte[] result = cipher.doFinal(Base64.getDecoder().decode(content));
        //System.out.println("私钥加密、公钥解密 ---- 解密:" + Base64.getEncoder().encodeToString(result));
        return Base64.getEncoder().encodeToString(result);
    }

    /**
     * Rsa公钥加密
     * @param publicKey 公钥
     * @param content 明文
     * @return 密文
     * @throws Exception 异常
     */
    public static String RsaPublicEncrypt(String publicKey,String content) throws Exception{
        X509EncodedKeySpec x509EncodedKeySpec2 = new X509EncodedKeySpec(Base64.getDecoder().decode(publicKey));
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PublicKey publicKey1 = keyFactory.generatePublic(x509EncodedKeySpec2);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey1);
        byte[] result = cipher.doFinal(content.getBytes(ENCODE));
        //System.out.println("公钥加密、私钥解密 ---- 加密: "+Base64.getEncoder().encodeToString(result2));
        return Base64.getEncoder().encodeToString(result);
    }

    /**
     * Rsa私钥解密
     * @param privateKey 私钥
     * @param content 密文
     * @return 解密后明文
     * @throws Exception 异常
     */
    public static String RsaPrivateUnEncrypt(String privateKey,String content) throws Exception{
        PKCS8EncodedKeySpec pkcs8EncodedKeySpec5 = new PKCS8EncodedKeySpec(Base64.getDecoder().decode(privateKey));
        KeyFactory keyFactory = KeyFactory.getInstance("RSA");
        PrivateKey privateKey1 = keyFactory.generatePrivate(pkcs8EncodedKeySpec5);
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.DECRYPT_MODE, privateKey1);
        byte[] result = cipher.doFinal(Base64.getDecoder().decode(content));
        //System.out.println("公钥加密、私钥解密 ---- 解密:" + new String(result));
        return new String(result);
    }

    public static void main(String[] args) throws Exception {
        String[] keys = RsaGenera();

        String aes_key = RsaPublicEncrypt(keys[1],AES_KEY);
        String aes_iv = RsaPublicEncrypt(keys[1],AES_IV);

        String AES_KEY = RsaPrivateUnEncrypt(keys[0],aes_key);
        String AES_IV = RsaPrivateUnEncrypt(keys[0],aes_iv);

        String m = AESEncryptEncode("今天打老虎",AES_IV,AES_KEY);
        System.out.println("AES对称加密： "+m);
        System.out.println("AES对称解密："+AESDecodeDecrypt(m,AES_IV,AES_KEY));
    }
}

在这里插入图片描述

程序员小牧之
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
传输与存储的加密方案
weixin_52345129的博客
01-18 1836
出于信息保密的目的，在信息传输或存储中，采用密码技术对需要保密的信息进行处理，使得处理后的信息不能被非受权者（含非法者）读懂或解读，这一过程称为加密。在加密处理过程中，需要保密的信息称为“明文”，经加密处理后的信息称为“密文”。加密即是将“明文”变为“密文”的过程；与此类似，将“密文”变为“明文”的过程被称为解密。
理解网络数据传输加密
weixin_45876097的博客
10-11 4286
什么是加密 加密是对明文数据按某种特殊的算法进行加工处理，使其成为不可被直接读取的数据，即密文数据，而密文数据可以通过特定的秘钥解密后还原出明文数据； 为什么需要加密 网络中数据的传输如果是明文的话，在经过WiFi、交换机、路由器、网络服务运营商等物理节点时可能被监听和篡改，从而带来信息丢失是的风险或损失，所以需要对数据进行加密处理后再传输，以确保数据的安全性； 加密方式 加密方式主要分为对称加密和非对称加密； 对称加密 对称加密描述： 对称加密简单，速度快； 常用对称加密方法 AES； 对称加密秘钥只
数据传输加密
qq_43893277的博客
07-08 1662
数据传输加密
文件传输加密
最新发布
m0_63224448的博客
04-02 2055
一种文件传输过程的加密方法
JAVA架构之路（数据加密与常见加密算法）
JAVA领域优质创作者，基于分片网络查询方法专利发明者。
11-09 721
MD5（安全级别较高，一般不用做加密，常用在校验文件）DES（安全级别不高，消耗性能 较小）常见加密算法以及安全级别和使用场景。RSA（安全级别特别高，消耗性能大）SHA（不可解密，一般用在签名）AES（安全级别较高）
thqs.rar_加密算法
09-24
加密算法是信息安全领域的一个关键组成部分，它用于保护数据的隐私性和安全性，确保信息在传输或存储时不被未经授权的用户访问。 【描述】：“伏特加大发明家放到点击点击输入身体如何说人话爱而已 WTE我”这段描述...
网络安全 对称加密算法.doc
05-08
网络安全中的对称加密算法是确保数据安全的重要技术之一。对称加密是指加密和解密使用相同密钥的加密算法，它的主要特点是效率高，适用于大量数据的加密处理。本实验旨在帮助学生深入理解和掌握对称加密算法的原理，...
HTTPS工作流程 传输协议、加密算法
04-14
由于公钥和私钥是分开的，非对称加密算法安全级别高，加密密文长度有限制，适用于对少量数据进行加密，速度较慢。 HTTPS的流程： 1. 客户端向服务端发送请求，客户端主要向服务器提供以下信息：支持的协议版本，...
C语言常用加密算法.rar
09-16
本资源包"**C语言常用加密算法.rar**"可能包含了多个C语言实现的经典加密算法源代码，帮助开发者深入理解和应用这些算法。 首先，我们来看看几种常见的加密算法： 1. **DES（Data Encryption Standard）数据加密...
RSA.rar_RSA算法_rsa加密算法
09-22
RSA算法是一种非对称加密算法，由Ron Rivest、Adi Shamir和Leonard Adleman在1977年提出，因此得名RSA。它在信息安全领域有着广泛的应用，如数字签名、数据加密和安全网络通信等。在这个项目中，你已经编程实现了RSA...
CipherAlgorithm:适用于IT安全级别的自己的加密算法
04-17
密码算法 用于计算机安全性类的自己的加密算法。 编译为：g ++ roceto.cpp -oa
一个数据传输加密方案的设计与实现
09-01
一个数据传输加密方案的设计与实现 一个数据传输加密方案的设计与实现
网络安全——常用的数据加密算法介绍
热门推荐
qq_65192671的博客
03-29 1万+
常用加密算法有两类：对称加密算法和非对称加密算法(公开密钥加密)。对称加密算法用来对敏感数据等信息进行加密，常用的算法包括： DES：数据加密标准，速度较快，适用于加密大量数据的场合。 3DES：是基于DES，对一块数据用三个不同的密钥进行三次加密,强度更高。 AES：高级加密标准，是下一代的加密算法标准,速度快,安全级别高。 常见的非对称加密算法如下： RSA：由 RSA 公司发明,是一个支持变长密钥的公共密钥算法，需要加密的文件块的长度也是可变的。 ECC：椭圆曲线密码编码学。 对称密钥
数据传输的加密过程
weixin_33924220的博客
09-09 2082
加密技术是为了保护敏感数据在网络传输中的安全，就像日常生活中使用的淘宝、支付宝、微信等等软件，如果涉及到金额的数据在网络中不加密传输，那是极易被别人窃取、篡改的，通信中的数据加密技术就显得尤为重要。各类加密工具的原理都是大同小异，这里对常见加密原理进行解读。 *** 一、对称加密 加密数据与解密数据使用相同的密钥，这种加密方法称为对称加密 特...
Java加密与解密的艺术-----Cipher类
u012598738的专栏
04-10 2549
Cipher类为加密和解密提供密码功能。它构成了Java Cryptographic Extension（JCE）框架的核心。在本章的上述内容中，只完成了密钥的处理，并未完成加密与解密的操作。这些核心操作需要通过Cipher类来实现。 // 此类为加密和解密提供密码功能 public class Cipher extends Object  Cipher类是一个引擎类，它需要通过getIn
cipher 加密解密
blfjvkwfn
04-25 2493
cipher 加密解密 import javax.crypto.Cipher; import javax.crypto.SecretKeyFactory; import javax.crypto.spec.DESKeySpec; import javax.crypto.spec.IvParameterSpec; import java.security.Key; import java....
加密系列 | DES加密和解密算法详解&代码示例
挖坑埋你
04-30 4718
算法简介 对称加密也就是密钥加密。对称加密和解密使用同一个密钥： 加密时，我们用这个密钥初始化密码算法，密码算法对经过它的数据进行加密； 解密时，密码算法用同一个密钥初始化，密码算法对经过它的数据进行解密。 加密的强度依赖于密钥的长度。一般的对称密钥长度在40-128位之间，有些算法可能更长。 建议使用128位以上的对称加密算法，如：DESede(TripleDES)、Blowfish、AE...
信息安全第三篇（网络传输的加密与解密）
胡耕永的专栏
08-14 1万+
由于互联网早期并没有考虑到数据报文安全的问题，早期的理念都是基于进行通信的。现在随着网络兴起，互联网上慢慢有很多“犯罪团体”，用较低的犯罪成本通常是基于一个网络通信协议的一个小的漏洞来完成窃取、篡改、重播其他人的数据报文。 而往往计算机网络安全维护者和那些恶意攻击者玩的就是一个类似猫鼠游戏，网络安全维护者处处考虑对计算机的安全负责，而恶意攻击者处处找安全的漏洞。而对于那些恶意攻击方式大体...
(一)关于网络传输中的加密和加签的问题
程序员XW
10-23 8705
开发中经常会存在不同系统之间的数据共享，那么通过接口方式传输数据就是一件很方便的方式了。现在还有很多公司是用的http传输的数据，那么数据是不安全的存在着数据在传输过程中发生泄漏的风险，所以现在数据传输常用的就是加密和加签的方式来保证数据的安全。 加密和加签中用到了非对称性加密（RSA）,而非对称性加密需要两个秘钥来进行加密和解密，这两个秘钥是公钥(publickey)和私钥(privateke
基于python的RSA加密算法软件设计与实现.docx
08-17
"本文档详细介绍了基于Python的RSA加密算法软件的设计与实现，旨在保障网络信息安全。RSA是一种公钥密码体制，常用于数据加密，具有高度安全性。通过Python实现RSA算法，可以开发出一款有效保护网络中数据安全的加密...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员小牧之

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值