對稱加密：密碼學的秘密握手，Go Crypto 4-Golang-PHP中文網

Symmetric Encryption: The Secret Handshake of Cryptography, 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)
}

登入後複製