对称加密：密码学的秘密握手，Go Crypto 4

嘿，加密货币爱好者！准备好进入对称加密的世界了吗？将其视为数字世界的秘密握手 - 两方共享只有他们才能理解的信息的方式。让我们分解一下，看看 Go 如何帮助我们实现这些数字秘密握手！

分组密码：构建块

首先，我们有分组密码。它们就像数字时代的密码轮——它们处理固定大小的数据块。这里的明星是 AES（高级加密标准）。

AES：重量级冠军

AES 就像加密领域的瑞士军刀 - 它用途广泛、功能强大且用途广泛。以下是在 Go 中的设置方法：

import (
    "crypto/aes"
    "crypto/rand"
    "fmt"
)

func main() {
    // Let's create a 256-bit key (32 bytes)
    key := make([]byte, 32)
    if _, err := rand.Read(key); err != nil {
        panic("Oops, the universe's randomness machine broke!")
    }

    block, err := aes.NewCipher(key)
    if err != nil {
        panic("AES threw a tantrum!")
    }

    fmt.Printf("Our AES block size: %d bytes\n", block.BlockSize())
}

这设置了 AES，但请记住，单独的分组密码就像一辆没有轮子的汽车 - 功能齐全，但还不是很有用。这就是操作模式的用武之地，但我们稍后会讨论它。

流密码：加密的流动之河

接下来，我们有流密码。这些就像一个永无止境的随机位流，我们将其与数据进行异或以对其进行加密。 Go 给我们带来了 ChaCha20，一种现代的、快速的流密码。

ChaCha20：街区新来的孩子

以下是使用 ChaCha20 的方法：

import (
    "fmt"
    "golang.org/x/crypto/chacha20"
)

func main() {
    key := make([]byte, chacha20.KeySize)
    nonce := make([]byte, chacha20.NonceSize)

    cipher, err := chacha20.NewUnauthenticatedCipher(key, nonce)
    if err != nil {
        panic("ChaCha20 isn't feeling chatty today!")
    }

    secretMessage := []byte("ChaCha20 is my new dance move!")
    encrypted := make([]byte, len(secretMessage))
    cipher.XORKeyStream(encrypted, secretMessage)

    fmt.Printf("Our secret dance move, encrypted: %x\n", encrypted)
}

当您需要速度时，ChaCha20 非常有用，尤其是在没有 AES 硬件加速的平台上。

运作模式：将它们放在一起

现在我们来谈谈操作方式。这些就像游戏规则 - 它们定义了我们如何使用密码安全地加密数据。

GCM（伽罗瓦/计数器模式）：瑞士军刀

GCM 就像加密模式中的瑞士军刀。它提供保密性和完整性，这就是为什么在大多数用例中强烈推荐它。使用方法如下：

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "fmt"
)

func main() {
    key := make([]byte, 32)
    if _, err := rand.Read(key); err != nil {
        panic("The random number generator went on strike!")
    }

    block, err := aes.NewCipher(key)
    if err != nil {
        panic("AES is having an existential crisis!")
    }

    nonce := make([]byte, 12)
    if _, err := rand.Read(nonce); err != nil {
        panic("Nonce generator is feeling noncommittal!")
    }

    aesgcm, err := cipher.NewGCM(block)
    if err != nil {
        panic("GCM mode is feeling moody!")
    }

    secretMessage := []byte("AES-GCM: Making encryption great again!")
    encrypted := aesgcm.Seal(nil, nonce, secretMessage, nil)

    fmt.Printf("Our encrypted message: %x\n", encrypted)

    // Let's decrypt it to make sure it worked
    decrypted, err := aesgcm.Open(nil, nonce, encrypted, nil)
    if err != nil {
        panic("Decryption failed! Did someone tamper with our message?")
    }

    fmt.Printf("Decrypted message: %s\n", decrypted)
}

CTR（计数器模式）：Streamifier

CTR 模式就像一根魔杖，可以将分组密码变成流密码。当您需要流密码的灵活性但又想坚持使用分组密码算法时，它非常有用：

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "fmt"
)

func main() {
    key := make([]byte, 32)
    if _, err := rand.Read(key); err != nil {
        panic("Random number generator is feeling random about its job!")
    }

    block, err := aes.NewCipher(key)
    if err != nil {
        panic("AES is having a block party, and we're not invited!")
    }

    iv := make([]byte, aes.BlockSize)
    if _, err := rand.Read(iv); err != nil {
        panic("IV generator is feeling too independent!")
    }

    stream := cipher.NewCTR(block, iv)

    secretMessage := []byte("CTR mode: Turning blocks into streams since 1979!")
    encrypted := make([]byte, len(secretMessage))
    stream.XORKeyStream(encrypted, secretMessage)

    fmt.Printf("Our streamed secret: %x\n", encrypted)

    // Let's decrypt it
    decrypted := make([]byte, len(encrypted))
    stream = cipher.NewCTR(block, iv) // Reset the stream
    stream.XORKeyStream(decrypted, encrypted)

    fmt.Printf("Decrypted message: %s\n", decrypted)
}

对称加密的黄金法则

现在您已经拥有了这些闪亮的新加密工具，请记住以下一些黄金规则：

1. GCM 是你的朋友：大多数情况下，使用 AES-GCM。它就像您数据的保镖 - 它既保护机密性又保证完整性。

2. 随机数是生活的调味品：每次加密操作始终使用唯一的随机数（使用过一次的数字）。它就像每条秘密消息的唯一标识符。

3. 随机性是关键：使用加密/随机生成密钥。使用弱密钥就像在您的银行帐户中使用“password123”一样。

4. CTR 需要一个伙伴：如果您使用 CTR 模式，请记住它不能保护完整性。如果您需要完整性保护，请考虑将其与 MAC 配对。

5. 错误处理不是可选的：始终处理错误，尤其是在密钥生成和初始化期间。忽略加密代码中的错误就像忽略汽车上的“检查引擎”灯一样。

6. 保守你的秘密：永远不要在源代码中硬编码密钥。这就像把你家的钥匙藏在迎宾垫下 - 攻击者首先会看到的地方！

接下来是什么？

恭喜！您刚刚将对称加密添加到您的加密工具包中。当双方共享密钥时，这些技术非常适合保护数据。

但是如果您需要与以前从未见过的人建立安全连接怎么办？这就是公钥密码学的用武之地，我们将在下一节中探讨它。这就像秘密握手和公开签名之间的区别 - 两者都很有用，但适用于不同的场景。

请记住，在密码学领域，理解这些基础知识至关重要。这就像在建造城堡之前学会锁门一样。掌握这些，您将能够顺利地在 Go 中创建安全、强大的应用程序。

那么，您尝试加密给自己的消息怎么样？或者也许使用 AES-GCM 实现一个简单的安全笔记应用程序？安全通信的世界触手可及！快乐编码，加密冠军！

以上是对称加密：密码学的秘密握手，Go Crypto 4的详细内容。更多信息请关注PHP中文网其他相关文章！