Kryptographie in Go (Golang): Verschlüsselung und Hashing

Kryptographie in Go (Golang): Verschlüsselung und Hashing von Daten

Die Sprache Go (Golang) bietet eine leistungsstarke und elegante Standardbibliothek für kryptographische Operationen. Im Gegensatz zu vielen anderen Sprachen, bei denen die Installation von Drittanbieterpaketen erforderlich ist, enthält Go die Unterstützung für symmetrische und asymmetrische Verschlüsselung sowie moderne Hashing-Algorithmen direkt "out of the box". In diesem Artikel werden wir im Detail besprechen, wie man Kryptographie in Go zum Schutz von Daten auf dem Bildungsportal pythonlib.ru verwendet.

Wichtige Kryptographie-Pakete in Go

Die gesamte Kryptographie in Go ist im Paket crypto und seinen Unterpaketen konzentriert. Hier sind die wichtigsten:

• crypto/aes — Implementierung des Advanced Encryption Standard (AES).
• crypto/cipher — Schnittstellen für Verschlüsselungsmodi (CBC, GCM, CTR).
• crypto/rsa — Asymmetrische RSA-Verschlüsselung.
• crypto/sha256, crypto/sha512 — Hash-Funktionen der SHA-2-Familie.
• golang.org/x/crypto/bcrypt — Adaptives Passwort-Hashing (zusätzliches Paket).
• crypto/rand — Kryptographisch sicherer Zufallszahlengenerator.

Symmetrische AES-Verschlüsselung in Go

Symmetrische Verschlüsselung verwendet denselben Schlüssel zum Ver- und Entschlüsseln. Betrachten wir ein Beispiel mit AES-256 im GCM-Modus (Galois/Counter Mode), der eine Datenauthentifizierung bietet.

package main

import (    "crypto/aes"    "crypto/cipher"    "crypto/rand"    "encoding/hex"    "fmt"    "io")

func encryptAES(plaintext []byte, key []byte) ([]byte, error) {    block, err := aes.NewCipher(key)    if err != nil {        return nil, err    }

    // GCM (Galois/Counter Mode) erstellen    gcm, err := cipher.NewGCM(block)    if err != nil {        return nil, err    }

    // Zufälligen Nonce (Number used once) generieren    nonce := make([]byte, gcm.NonceSize())    if _, err := io.ReadFull(rand.Reader, nonce); err != nil {        return nil, err    }

    // Seal fügt den Nonce an den Anfang des Chiffretexts    ciphertext := gcm.Seal(nonce, nonce, plaintext, nil)    return ciphertext, nil}

func decryptAES(ciphertext []byte, key []byte) ([]byte, error) {    block, err := aes.NewCipher(key)    if err != nil {        return nil, err    }

    gcm, err := cipher.NewGCM(block)    if err != nil {        return nil, err    }

    nonceSize := gcm.NonceSize()    if len(ciphertext) < nonceSize {        return nil, fmt.Errorf("ciphertext too short")    }

    nonce, ciphertext := ciphertext[:nonceSize], ciphertext[nonceSize:]    plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)    if err != nil {        return nil, err    }    return plaintext, nil}

func main() {    key := []byte("examplekey123456") // 16 Bytes für AES-128    plaintext := []byte("Geheime Daten für PythonLib")

    encrypted, _ := encryptAES(plaintext, key)    fmt.Println("Verschlüsselt (hex):", hex.EncodeToString(encrypted))

    decrypted, _ := decryptAES(encrypted, key)    fmt.Println("Entschlüsselt:", string(decrypted))}

Beachten Sie: Der Schlüssel muss 16, 24 oder 32 Bytes lang sein für AES-128, AES-192 bzw. AES-256. Der Nonce (IV) wird zufällig generiert und zusammen mit dem Chiffretext gespeichert.

Asymmetrische RSA-Verschlüsselung in Go

RSA verwendet ein Schlüsselpaar: einen öffentlichen (public) Schlüssel zum Verschlüsseln und einen privaten (private) Schlüssel zum Entschlüsseln. Dies ist ideal für den sicheren Datenaustausch zwischen Server und Client.

package main

import (    "crypto/rand"    "crypto/rsa"    "crypto/sha256"    "fmt")

func generateKeyPair(bits int) (*rsa.PrivateKey, error) {