加密与安全_探索对称加密算法

news2024/11/15 23:33:35

文章目录

  • 概述
  • 常用的对称加密算法
  • AES
    • ECB模式
    • CBC模式 (推荐)
    • ECB VS CBC
  • 附：AES工具类
  • 总结

在这里插入图片描述

概述

对称加密算法是一种加密技术，使用相同的密钥来进行加密和解密数据。在这种算法中，发送方使用密钥将明文（未加密的数据）转换为密文（加密的数据），而接收方使用相同的密钥将密文还原为明文。

对称加密算法的安全性依赖于密钥的保密性，因为任何持有相同密钥的人都能够解密数据。

常见的对称加密算法包括AES（高级加密标准）和DES（数据加密标准）。虽然对称加密算法在性能上通常比非对称加密算法更高效，但在密钥管理和分发方面存在挑战。

通俗来讲，可以这么理解： 对称加密算法就像是一把钥匙可以打开一个锁。在这里，你有一个钥匙（密钥），用它来锁住（加密）你的信息，然后你可以用同样的钥匙（密钥）来解锁（解密）它。这意味着发送方和接收方都使用相同的密钥来加密和解密信息。

常用的对称加密算法

常用的对称加密算法包括：

  1. AES（Advanced Encryption Standard）：这是目前最常用的对称加密算法之一。它使用128、192或256位密钥来加密数据，并已被广泛采用于许多安全应用中。

  2. DES（Data Encryption Standard）：虽然已被AES所取代，但仍然在一些遗留系统中使用。DES使用56位密钥对数据进行加密。

  3. 3DES（Triple Data Encryption Standard）：3DES是DES的改进版本，它对数据应用三次DES算法，提高了安全性。但由于计算成本高昂，现在已经不太常用。

  4. Blowfish：这是一个可扩展的对称加密算法，可以使用变长密钥，从32位到448位。它曾经很流行，但由于一些安全性方面的考虑，现在使用较少。

  5. RC4（Rivest Cipher 4）：尽管曾被广泛使用，但由于存在一些严重的安全漏洞，现在已经不建议使用。

从程序的角度看，所谓加密，就是这样一个函数，它接收密码和明文，然后输出密文：

secret = encrypt(key, message);

而解密则相反，它接收密码和密文，然后输出明文：

plain = decrypt(key, secret);

从程序的角度看，所谓加密，就是这样一个函数，它接收密码和明文，然后输出密文：

secret = encrypt(key, message);

而解密则相反，它接收密码和密文，然后输出明文：

plain = decrypt(key, secret);

加密和解密确实可以被视为类似上面的函数，但实际上，它们可能会更为复杂一些，尤其是在实现对称加密算法时。

在使用对称加密算法时，这两个函数通常被称为加密函数和解密函数。例如，在使用AES算法时，加密函数会接收密钥（key）和明文（message），然后输出密文（ciphertext）。而解密函数则接收密钥（key）和密文（ciphertext），然后输出明文（message）

算法密钥长度工作模式填充模式
AES128/192/256ECB/CBC/PCBC/CTR/…NoPadding/PKCS5Padding/PKCS7Padding/…
DES56/64ECB/CBC/PCBC/CTR/…NoPadding/PKCS5Padding/…
…………

密钥长度直接决定加密强度，而工作模式和填充模式可以看成是对称加密算法的参数和格式选择。

这些对称加密算法在不同的场景中都有各自的优缺点，选择合适的算法取决于安全性需求、性能和应用环境。AES通常被认为是最安全和高效的对称加密算法之一，因此在许多情况下被首选使用。

AES

AES算法是目前应用最广泛的加密算法。

ECB模式

先用ECB模式加密并解密. 代码如下

package com.artisan.securityalgjava.aes;

import java.security.*;
import java.util.Base64;

import javax.crypto.*;
import javax.crypto.spec.*;

/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 */
public class AesECBExample {

    public static void main(String[] args) throws Exception {
        // 原文:
        String message = "Hello, Artisan!";
        System.out.println("Message: " + message);

        // 128位密钥 = 16 bytes Key:
        byte[] key = "1234567890abcdef".getBytes("UTF-8");

        // 加密:
        byte[] data = message.getBytes("UTF-8");
        byte[] encrypted = encrypt(key, data);
        System.out.println("Encrypted: " + Base64.getEncoder().encodeToString(encrypted));

        // 解密:
        byte[] decrypted = decrypt(key, encrypted);
        System.out.println("Decrypted: " + new String(decrypted, "UTF-8"));
    }

    // 加密方法
    public static byte[] encrypt(byte[] key, byte[] input) throws GeneralSecurityException {
        // 创建加密对象
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
        // 创建密钥规范
        SecretKey keySpec = new SecretKeySpec(key, "AES");
        // 初始化加密对象
        cipher.init(Cipher.ENCRYPT_MODE, keySpec);
        // 执行加密操作
        return cipher.doFinal(input);
    }

    // 解密方法
    public static byte[] decrypt(byte[] key, byte[] input) throws GeneralSecurityException {
        // 创建解密对象
        Cipher cipher = Cipher.getInstance("AES/ECB/PKCS5Padding");
        // 创建密钥规范
        SecretKey keySpec = new SecretKeySpec(key, "AES");
        // 初始化解密对象
        cipher.init(Cipher.DECRYPT_MODE, keySpec);
        // 执行解密操作
        return cipher.doFinal(input);
    }
}

ECB模式是最简单的AES加密模式，它只需要一个固定长度的密钥，固定的明文会生成固定的密文，这种一对一的加密方式会导致安全性降低

CBC模式 (推荐)

package com.artisan.securityalgjava.aes;

import java.security.*;
import java.util.Base64;

import javax.crypto.*;
import javax.crypto.spec.*;

/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 * @desc: AES CBC模式加解密示例
 */
public class AesCBCExample {

    public static void main(String[] args) throws Exception {
        // 原文:
        String message = "Hello, Artisan!";
        System.out.println("Message: " + message);
        // 256位密钥 = 32 bytes Key:
        byte[] key = "1234567890abcdef1234567890abcdef".getBytes("UTF-8");
        // 加密:
        byte[] data = message.getBytes("UTF-8");
        byte[] encrypted = encrypt(key, data);
        System.out.println("Encrypted: " + Base64.getEncoder().encodeToString(encrypted));
        // 解密:
        byte[] decrypted = decrypt(key, encrypted);
        System.out.println("Decrypted: " + new String(decrypted, "UTF-8"));
    }

    /**
     * 加密
     * @param key
     * @param input
     * @return
     * @throws GeneralSecurityException
     */
    public static byte[] encrypt(byte[] key, byte[] input) throws GeneralSecurityException {
        // 创建AES加密器
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        // 创建密钥规范
        SecretKeySpec keySpec = new SecretKeySpec(key, "AES");
        // CBC模式需要生成一个16 bytes的初始化向量
        SecureRandom sr = SecureRandom.getInstanceStrong();
        byte[] iv = sr.generateSeed(16);
        IvParameterSpec ivps = new IvParameterSpec(iv);
        // 初始化加密器
        cipher.init(Cipher.ENCRYPT_MODE, keySpec, ivps);
        // 执行加密操作
        byte[] data = cipher.doFinal(input);
        // IV不需要保密，把IV和密文一起返回
        return join(iv, data);
    }

    /**
     * 解密
     * @param key
     * @param input
     * @return
     * @throws GeneralSecurityException
     */
    public static byte[] decrypt(byte[] key, byte[] input) throws GeneralSecurityException {
        // 把input分割成IV和密文
        byte[] iv = new byte[16];
        byte[] data = new byte[input.length - 16];
        System.arraycopy(input, 0, iv, 0, 16);
        System.arraycopy(input, 16, data, 0, data.length);
        // 创建AES解密器
        Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
        // 创建密钥规范
        SecretKeySpec keySpec = new SecretKeySpec(key, "AES");
        IvParameterSpec ivps = new IvParameterSpec(iv);
        // 初始化解密器
        cipher.init(Cipher.DECRYPT_MODE, keySpec, ivps);
        // 执行解密操作
        return cipher.doFinal(data);
    }

    /**
     * 拼接两个字节数组
     * @param bs1
     * @param bs2
     * @return
     */
    public static byte[] join(byte[] bs1, byte[] bs2) {
        byte[] r = new byte[bs1.length + bs2.length];
        System.arraycopy(bs1, 0, r, 0, bs1.length);
        System.arraycopy(bs2, 0, r, bs1.length, bs2.length);
        return r;
    }

}

在CBC模式下，需要一个随机生成的16字节IV参数，必须使用SecureRandom生成。因为多了一个IvParameterSpec实例，因此，初始化方法需要调用Cipher的一个重载方法并传入IvParameterSpec。

观察输出，可以发现每次生成的IV不同，密文也不同, 如下图所示

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

代码实现了AES CBC模式的加密和解密功能。在加密过程中，生成了一个16字节的初始化向量（IV），在解密时使用了这个IV来确保安全性。

因此，CBC模式，它需要一个随机数作为IV参数，这样对于同一份明文，每次生成的密文都不同 .

ECB VS CBC

AES有几种不同的模式，其中最常见的两种是ECB（Electronic Codebook）模式和CBC（Cipher Block Chaining）模式。

  1. ECB模式（电子密码本模式）：
  • 特点：
    • 将明文分成块，每个块使用相同的密钥进行加密。
    • 相同的明文块在加密后会得到相同的密文块。
    • 每个块的加密是独立的，不受其他块的影响。
  • 优点：
    • 简单，容易并行化处理。
    • 适用于对称加密需求较简单的场景。
  • 缺点：
    • 容易受到重放攻击的影响，因为相同的明文块会产生相同的密文块，没有隐藏明文块之间的关系。
    • 不适合加密大量数据或需要保护隐私的数据，因为无法隐藏明文块之间的模式。
  1. CBC模式（密码块链接模式）：
  • 特点：
    • 在加密前，会对明文块进行异或运算，并与前一个密文块进行混合，然后再加密。
    • 需要一个初始化向量（IV）来增加随机性，防止重放攻击。
    • 密文块的加密依赖于前一个密文块，因此密文块之间存在依赖关系。
  • 优点：
    • 对于相同的明文块，使用不同的IV会产生不同的密文块，增加了安全性。
    • 可以加密大量数据，并且可以隐藏明文块之间的模式。
  • 缺点：
    • 加密速度较ECB模式慢，因为需要依赖前一个密文块。
    • 不太容易并行化处理，因为每个块的加密都依赖于前一个块的加密结果。

综上所述，ECB模式简单快速，适合简单的加密需求，但安全性较差，不适合加密大量数据或需要保护隐私的数据。而CBC模式相对更安全，能够隐藏明文块之间的模式，适合加密大量数据或需要保护隐私的数据，但加密速度较慢。

附：AES工具类

package com.artisan.securityalgjava.aes;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.SecureRandom;
import java.security.spec.KeySpec;
import java.util.Arrays;
import java.util.Base64;

/**
 * @author 小工匠
 * @version 1.0
 * @mark: show me the code , change the world
 * @desc: AES加密解密工具类, 提供了AES加密解密的功能，使用了CBC模式和PBKDF2算法生成密钥
 */
public class AESCipher {

    /**
     * 密钥生成算法
     */
    private static final String SECRET_KEY_ALGORITHM = "PBKDF2WithHmacSHA256";
    /**
     * 加密算法
     */
    private static final String ENCRYPTION_ALGORITHM = "AES/CBC/PKCS5Padding";
    /**
     * 密钥长度
     */
    private static final int KEY_SIZE = 256;
    /**
     * 迭代次数
     */
    private static final int ITERATION_COUNT = 65536;
    /**
     * 初始化向量长度
     */
    private static final int IV_SIZE = 16;

    /**
     * 生成密钥
     *
     * @param password
     * @param salt
     * @return
     * @throws Exception
     */
    private static SecretKeySpec generateKey(String password, byte[] salt) throws Exception {
        SecretKeyFactory factory = SecretKeyFactory.getInstance(SECRET_KEY_ALGORITHM);
        KeySpec spec = new PBEKeySpec(password.toCharArray(), salt, ITERATION_COUNT, KEY_SIZE);
        SecretKey tmp = factory.generateSecret(spec);
        return new SecretKeySpec(tmp.getEncoded(), "AES");
    }

    /**
     * 加密
     *
     * @param plaintext
     * @param password
     * @return
     * @throws Exception
     */
    public static String encrypt(String plaintext, String password) throws Exception {
        // 生成盐
        byte[] salt = new byte[16];
        // 生成初始化向量
        byte[] iv = new byte[IV_SIZE];
        byte[] encryptedBytes;

        // 生成盐和初始化向量
        SecureRandom random = new SecureRandom();
        random.nextBytes(salt);
        random.nextBytes(iv);

        // 生成密钥
        SecretKeySpec keySpec = generateKey(password, salt);
        Cipher cipher = Cipher.getInstance(ENCRYPTION_ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, keySpec, new IvParameterSpec(iv));

        // 执行加密操作
        encryptedBytes = cipher.doFinal(plaintext.getBytes());

        // 将盐、初始化向量和密文拼接并返回Base64编码字符串
        byte[] combined = new byte[salt.length + iv.length + encryptedBytes.length];
        System.arraycopy(salt, 0, combined, 0, salt.length);
        System.arraycopy(iv, 0, combined, salt.length, iv.length);
        System.arraycopy(encryptedBytes, 0, combined, salt.length + iv.length, encryptedBytes.length);

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

    /**
     * 解密
     *
     * @param encryptedText
     * @param password
     * @return
     * @throws Exception
     */
    public static String decrypt(String encryptedText, String password) throws Exception {
        // 解析Base64编码字符串并分离盐、初始化向量和密文
        byte[] combined = Base64.getDecoder().decode(encryptedText);
        byte[] salt = Arrays.copyOfRange(combined, 0, 16);
        byte[] iv = Arrays.copyOfRange(combined, 16, 32);
        byte[] encryptedBytes = Arrays.copyOfRange(combined, 32, combined.length);

        // 生成密钥
        SecretKeySpec keySpec = generateKey(password, salt);
        Cipher cipher = Cipher.getInstance(ENCRYPTION_ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, keySpec, new IvParameterSpec(iv));

        // 执行解密操作并返回明文字符串
        byte[] decryptedBytes = cipher.doFinal(encryptedBytes);
        return new String(decryptedBytes);
    }

    /**
     * 测试方法
     *
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception {
        // 测试加密解密功能
        String encrypted = encrypt("组热么共和国的啥范德萨", "dddd");
        System.out.println("Encrypted: " + encrypted);
        String decrypted = decrypt(encrypted, "dddd");
        System.out.println("Decrypted: " + decrypted);
    }
}

总结

对称加密算法使用同一个密钥进行加密和解密，适用于需要高效加解密的场景。常见的对称加密算法包括DES、AES和3DES等。

对称加密算法使用同一个密钥进行加密和解密，常用的算法包括DES、AES和3DES等。

  • DES（Data Encryption Standard）：DES是一种较早的对称加密算法，使用56位密钥进行加密和解密。由于密钥长度较短，DES已经不再被推荐使用，因为它容易受到穷举攻击。

  • AES（Advanced Encryption Standard）：AES是目前广泛使用的对称加密算法之一。它使用128位、192位或256位密钥进行加密和解密。AES算法的安全性和性能较高，因此被广泛应用于各种安全领域。

  • 3DES（Triple Data Encryption Standard）：3DES是对DES算法的改进，通过对数据应用三次DES算法来提高安全性。3DES使用的密钥长度为56位，因此它的安全性较DES提高了很多。但由于AES的出现和3DES的计算复杂性，3DES的使用逐渐减少。

密钥长度由算法设计决定。对于AES算法，它支持的密钥长度为128位、192位和256位。一般来说，密钥长度越长，加密的安全性越高，但同时也带来了更高的计算成本。

在使用对称加密算法时，需要指定以下参数：

  • 算法名称：即使用的加密算法，例如DES、AES和3DES等。
  • 工作模式：指定了加密算法在加密大块数据时的工作模式，常见的工作模式包括ECB、CBC、CFB、OFB等。
  • 填充模式：指定了在加密数据块大小不足时如何填充数据，常见的填充模式包括PKCS5Padding、NoPadding等。

选择合适的算法名称、工作模式和填充模式，可以根据具体的安全需求和性能要求进行调整。

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1483177.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

腾讯云幻兽帕鲁服务器中，如何检查并确保所有必要的配置文件（如PalWorldSettings.ini和WorldOption.sav）正确配置？

腾讯云幻兽帕鲁服务器中，如何检查并确保所有必要的配置文件（如PalWorldSettings.ini和WorldOption.sav）正确配置？

腾讯云幻兽帕鲁服务器中，如何检查并确保所有必要的配置文件（如PalWorldSettings.ini和WorldOption.sav）正确配置？ 登录腾讯云控制台：登录轻量云控制台，找到部署了幻兽帕鲁的服务器，单击实例卡片…
阅读更多...
二维码门楼牌管理系统技术服务的深度解析

二维码门楼牌管理系统技术服务的深度解析

文章目录 前言一、标准地址名称的定义与重要性二、二维码门楼牌管理系统的核心技术三、标准地址名称在二维码门楼牌管理中的应用四、二维码门楼牌管理系统的优势与挑战五、展望未来 前言 在数字化浪潮中，二维码门楼牌管理系统以其高效、便捷的特性，正逐…
阅读更多...
46、WEB攻防——通用漏洞PHP反序列化原生类漏洞绕过公私有属性

46、WEB攻防——通用漏洞PHP反序列化原生类漏洞绕过公私有属性

文章目录 几种常用的魔术方法1、__destruct()2、__tostring()3、__call()4、__get()5、__set()6、__sleep()7、__wakeup()8、__isset()9、__unset()9、__invoke() 三种变量属性极客2019 PHPphp原生类 几种常用的魔术方法 1、__destruct() 当删除一个对象或对象操作终止时被调…
阅读更多...
Android13 Audio框架

Android13 Audio框架

一、Android 13音频代码结构 1、framework: android/frameworks/base 1.AudioManager.java ：音频管理器，音量调节、音量UI、设置和获取参数等控制流的对外API 2.AudioService.java ：音频系统服务（java层）&#xff0c…
阅读更多...
Tuning Language Models by Proxy

Tuning Language Models by Proxy

1、写作动机： 调整大语言模型已经变得越来越耗资源，或者在模型权重是私有的情况下是不可能的。作者引入了代理微调，这是一种轻量级的解码时算法，它在黑盒 大语言模型 之上运行，以达到直接微调模型的结果，但…
阅读更多...
【数据结构】之优先级队列(堆)

【数据结构】之优先级队列(堆)

文章目录 一、优先级队列的概念二、优先级队列的模拟实现1.堆的存储2.堆的创建3.代码的实现 一、优先级队列的概念 队列是一种先进先出(FIFO)的数据结构，但有些情况下，操作的数据可能带有优先级，一般出队列时，可能需要优先级高的…
阅读更多...
wireshark抓取localhost(127.0.0.1)数据包

wireshark抓取localhost(127.0.0.1)数据包

打开wireshark中，在"capture"菜单中，选择"interfaces"子菜单，在列出的接口中选中"Adapter for loopback traffic capture"即可。 必须安装了Npcap才有此选项，否则需要重新安装wireshark。 抓包截图…
阅读更多...
Windows 10 合并磁盘分区 (G and H)

Windows 10 合并磁盘分区 (G and H)

Windows 10 合并磁盘分区 [G and H] 1. 设备和驱动器2. 计算机 -> 管理 -> 存储 -> 磁盘管理3. 删除卷4. 新建简单卷5. 设备和驱动器References 1. 设备和驱动器 2. 计算机 -> 管理 -> 存储 -> 磁盘管理 3. 删除卷 H: -> right-click -> 删除卷 H: 变…
阅读更多...
c语言经典测试题10

c语言经典测试题10

1.题1 int fun( int x) {int n 0;while (x 1){n;x x | (x 1);}return n; } int main() {int ret fun(2014);printf("%d", ret);return 0; } 上述代码运行结果是什么呢？ 我们来分析一下：这里的fun函数有一个while循环，其判断…
阅读更多...
uniApp 调整小程序 单个/全部界面横屏展示效果

uniApp 调整小程序 单个/全部界面横屏展示效果

我们打开uni项目 小程序端运行 默认是竖着的一个效果 我们打开项目的 pages.json 给需要横屏的界面 的 style 属性 加上 "mp-weixin": {"pageOrientation": "landscape" }界面就横屏了 如果是要所有界面都横屏的话 就直接在pages.json 的 gl…
阅读更多...
14-Linux部署Hadoop集群

14-Linux部署Hadoop集群

Linux部署Hadoop集群 简介 1）Hadoop是一个由Apache基金会所开发的分布式系统基础架构。 2）主要解决，海量数据的存储和海量数据的分析计算问题。 Hadoop HDFS 提供分布式海量数据存储能力 Hadoop YARN 提供分布式集群资源管理能力 Hadoop…
阅读更多...
Django后端开发——cookies和session

Django后端开发——cookies和session

文章目录 参考资料会话保持Cookiesviews.pyurls.py Sessionviews.pyurls.py Cookies和session对比 参考资料 B站网课：点击蓝色字体跳转 或复制链接至浏览器：https://www.bilibili.com/video/BV1vK4y1o7jH/?p29&spm_id_from333.1007.top_right_bar_…
阅读更多...
Android Gradle开发与应用 (四) : Gradle构建与生命周期

Android Gradle开发与应用 (四) : Gradle构建与生命周期

1. 前言 前几篇文章，我们对Gradle中的基本知识，包括Gradle项目结构、Gradle Wrapper、GradleUserHome、Groovy基础语法、Groovy语法概念、Groovy闭包等知识点，这篇文章我们接着来介绍Gradle构建过程中的知识点。 2. Project : Gradle中构建…
阅读更多...
Linux - 基本开发工具

Linux - 基本开发工具

1、软件包管理器 yum 1.1、什么是软件包 在Linux下安装软件, 一个通常的办法是下载到程序的源代码, 并进行编译, 得到可执行程序但是这样太麻烦了, 于是有些人把一些常用的软件提前编译好, 做成软件包(可以理解成windows上的安装程序)放在一个服务器上, 通过包管理器可以很方…
阅读更多...
接口测试（全）

接口测试（全）

🍅 视频学习：文末有免费的配套视频可观看 🍅 关注公众号【互联网杂货铺】，回复 1 ，免费获取软件测试全套资料，资料在手，涨薪更快 大多数人对于接口测试都觉得是一种高大上的测试，觉得…
阅读更多...
Flutter开发之CupertinoApp

Flutter开发之CupertinoApp

Flutter开发之CupertinoApp 最近由于使用Flutter编程更多，使用Flutter更顺手，相对于其他前端框架来说，Flutter在跨平台、响应式UI、自绘引擎、即插即用的组件和庞大的社区生态支持方面有更大的优势；Flutter拥有更低的学习成本&am…
阅读更多...
前端monorepo大仓共享复杂业务组件最佳实践

前端monorepo大仓共享复杂业务组件最佳实践

一、背景 在 Monorepo 大仓模式中，我们把组件放在共享目录下，就能通过源码引入的方式实现组件共享。越来越多的应用愿意走进大仓，正是为了享受这种组件复用模式带来的开发便利。这种方式可以满足大部分代码复用的诉求，但对于复杂…
阅读更多...
AutoEncoder和 Denoising AutoEncoder学习笔记

AutoEncoder和 Denoising AutoEncoder学习笔记

参考： 【1】 https://lilianweng.github.io/posts/2018-08-12-vae/ 写在前面： 只是直觉上的认识，并没有数学推导。后面会写一篇（抄）大一统文章（概率角度理解为什么AE要选择MSE Loss） TOC 1 Au…
阅读更多...
Java进阶-IO（1）

Java进阶-IO（1）

进入java IO部分的学习，首先学习IO基础，内容如下。需要了解流的概念、分类还有其他一些如集合与文件的转换，字符编码问题等，这次先学到字节流的读写数据，剩余下次学完。 一、IO基础 1、背景 1.1 数据存储问题 变量…
阅读更多...
Day21-磁盘管理之raid及分区

Day21-磁盘管理之raid及分区

Day21-磁盘管理之raid及分区 1 Raid技术1.1 什么是Raid?1.2 为什么服务器需要Raid?1.3 什么是Raid级别?1.4 Raid有哪些实现方式？1.5 什么是RAID0？（图）1.6 什么是RAID1？（图）1.7 什么是RAID5&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023