Goで安全なAPI通信を実現：cryptoライブラリの活用方法

package main

import (
    "crypto/tls"
    "fmt"
    "net/http"
)

func main() {
    // TLS設定
    tlsConfig := &tls.Config{
        MinVersion: tls.VersionTLS12, // 最低TLSバージョンの設定
    }

    // ハンドラ設定
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprintf(w, "Secure Connection Established")
    })

    // サーバー設定
    server := &http.Server{
        Addr:      ":443", // HTTPSのポート
        TLSConfig: tlsConfig,
    }

    // サーバー起動（証明書と秘密鍵が必要）
    err := server.ListenAndServeTLS("server.crt", "server.key")
    if err != nil {
        fmt.Println("Error starting server:", err)
    }
}

package main

import (
    "crypto/tls"
    "fmt"
    "io/ioutil"
    "net/http"
)

func main() {
    // TLS設定
    tlsConfig := &tls.Config{
        InsecureSkipVerify: true, // 開発用（証明書の検証をスキップ）
    }

    // HTTPクライアント設定
    client := &http.Client{
        Transport: &http.Transport{
            TLSClientConfig: tlsConfig,
        },
    }

    // HTTPSリクエスト
    resp, err := client.Get("https://example.com")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()

    // レスポンスの読み取り
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Error reading response:", err)
        return
    }

    fmt.Println(string(body))
}

package main

import (
    "crypto/hmac"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
)

// HMACを生成する関数
func generateHMAC(message, secret string) string {
    // 共有鍵から新しいHMACインスタンスを作成
    key := []byte(secret)
    h := hmac.New(sha256.New, key)

    // メッセージを追加
    h.Write([]byte(message))

    // ハッシュの結果を返す
    return hex.EncodeToString(h.Sum(nil))
}

// HMACを検証する関数
func verifyHMAC(message, receivedMAC, secret string) bool {
    expectedMAC := generateHMAC(message, secret)
    return hmac.Equal([]byte(expectedMAC), []byte(receivedMAC))
}

func main() {
    message := "Hello, Secure World!"
    secret := "supersecretkey"

    // HMAC生成
    hmacCode := generateHMAC(message, secret)
    fmt.Println("Generated HMAC:", hmacCode)

    // HMAC検証
    isValid := verifyHMAC(message, hmacCode, secret)
    fmt.Println("HMAC is valid:", isValid)
}

package main

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

func main() {
    // 鍵ペアの生成
    privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
    if err != nil {
        fmt.Println("Error generating keys:", err)
        return
    }
    publicKey := &privateKey.PublicKey

    // メッセージ
    message := []byte("Secure Communication with RSA")

    // 公開鍵で暗号化
    ciphertext, err := rsa.EncryptOAEP(sha256.New(), rand.Reader, publicKey, message, nil)
    if err != nil {
        fmt.Println("Error encrypting message:", err)
        return
    }
    fmt.Printf("Encrypted Message: %x\n", ciphertext)

    // 秘密鍵で復号化
    plaintext, err := rsa.DecryptOAEP(sha256.New(), rand.Reader, privateKey, ciphertext, nil)
    if err != nil {
        fmt.Println("Error decrypting message:", err)
        return
    }
    fmt.Printf("Decrypted Message: %s\n", plaintext)
}

package main

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

func encryptAES(key, plaintext []byte) (string, error) {
    // AESブロック暗号の作成
    block, err := aes.NewCipher(key)
    if err != nil {
        return "", err
    }

    // 暗号化のための初期化ベクトル (IV) の生成
    ciphertext := make([]byte, aes.BlockSize+len(plaintext))
    iv := ciphertext[:aes.BlockSize]
    if _, err := io.ReadFull(rand.Reader, iv); err != nil {
        return "", err
    }

    // 暗号化
    stream := cipher.NewCFBEncrypter(block, iv)
    stream.XORKeyStream(ciphertext[aes.BlockSize:], plaintext)

    // 暗号化結果を16進文字列で返す
    return hex.EncodeToString(ciphertext), nil
}

func decryptAES(key []byte, ciphertextHex string) (string, error) {
    // 暗号化データをバイト列に変換
    ciphertext, err := hex.DecodeString(ciphertextHex)
    if err != nil {
        return "", err
    }

    // AESブロック暗号の作成
    block, err := aes.NewCipher(key)
    if err != nil {
        return "", err
    }

    // 初期化ベクトル (IV) の取得
    if len(ciphertext) < aes.BlockSize {
        return "", fmt.Errorf("ciphertext too short")
    }
    iv := ciphertext[:aes.BlockSize]
    ciphertext = ciphertext[aes.BlockSize:]

    // 復号化
    stream := cipher.NewCFBDecrypter(block, iv)
    stream.XORKeyStream(ciphertext, ciphertext)

    return string(ciphertext), nil
}

func main() {
    key := []byte("mysecretaeskey123") // 16バイト鍵（128ビット）
    plaintext := "Hello, AES Encryption!"

    // 暗号化
    ciphertext, err := encryptAES(key, []byte(plaintext))
    if err != nil {
        fmt.Println("Error encrypting:", err)
        return
    }
    fmt.Println("Encrypted Text:", ciphertext)

    // 復号化
    decryptedText, err := decryptAES(key, ciphertext)
    if err != nil {
        fmt.Println("Error decrypting:", err)
        return
    }
    fmt.Println("Decrypted Text:", decryptedText)
}

package main

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

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

    ciphertext := make([]byte, aes.BlockSize+len(plaintext))
    iv := ciphertext[:aes.BlockSize]
    if _, err := io.ReadFull(rand.Reader, iv); err != nil {
        return nil, err
    }

    stream := cipher.NewCFBEncrypter(block, iv)
    stream.XORKeyStream(ciphertext[aes.BlockSize:], plaintext)

    return ciphertext, nil
}

func main() {
    key := []byte("thisis32bitlongpassphrase!") // 鍵は32バイト (AES-256)
    plaintext := []byte("Sensitive Data")

    encrypted, err := secureEncrypt(key, plaintext)
    if err != nil {
        fmt.Println("Encryption error:", err)
        return
    }
    fmt.Printf("Encrypted data: %x\n", encrypted)
}

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/hmac"
    "crypto/rand"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "io"
    "net/http"
)

// 共通鍵（32バイトのAES鍵とHMAC鍵を共有）
var encryptionKey = []byte("thisis32bitlongpassphrase!") // AES-256鍵
var hmacKey = []byte("supersecrethmackey1234567890")     // HMAC鍵

// AES暗号化
func encryptData(data []byte) ([]byte, []byte, error) {
    block, err := aes.NewCipher(encryptionKey)
    if err != nil {
        return nil, nil, err
    }

    ciphertext := make([]byte, aes.BlockSize+len(data))
    iv := ciphertext[:aes.BlockSize]
    if _, err := io.ReadFull(rand.Reader, iv); err != nil {
        return nil, nil, err
    }

    stream := cipher.NewCFBEncrypter(block, iv)
    stream.XORKeyStream(ciphertext[aes.BlockSize:], data)

    return ciphertext, iv, nil
}

// HMAC生成
func generateHMAC(data []byte) string {
    h := hmac.New(sha256.New, hmacKey)
    h.Write(data)
    return hex.EncodeToString(h.Sum(nil))
}

// サーバー側のHMAC検証と復号化
func decryptData(ciphertext, iv, mac []byte) ([]byte, error) {
    // HMAC検証
    expectedMAC := generateHMAC(ciphertext)
    if !hmac.Equal([]byte(expectedMAC), mac) {
        return nil, fmt.Errorf("HMAC validation failed")
    }

    // AES復号化
    block, err := aes.NewCipher(encryptionKey)
    if err != nil {
        return nil, err
    }

    data := ciphertext[aes.BlockSize:]
    stream := cipher.NewCFBDecrypter(block, iv)
    stream.XORKeyStream(data, data)

    return data, nil
}

// サーバー側ハンドラー
func serverHandler(w http.ResponseWriter, r *http.Request) {
    ciphertext, _ := hex.DecodeString(r.Header.Get("Ciphertext"))
    iv, _ := hex.DecodeString(r.Header.Get("IV"))
    mac, _ := hex.DecodeString(r.Header.Get("HMAC"))

    plaintext, err := decryptData(ciphertext, iv, mac)
    if err != nil {
        http.Error(w, "Invalid request", http.StatusBadRequest)
        return
    }

    fmt.Fprintf(w, "Decrypted data: %s", plaintext)
}

// クライアント側のリクエスト送信
func clientRequest(data string) {
    ciphertext, iv, _ := encryptData([]byte(data))
    mac := generateHMAC(ciphertext)

    client := &http.Client{}
    req, _ := http.NewRequest("GET", "http://localhost:8080", nil)
    req.Header.Set("Ciphertext", hex.EncodeToString(ciphertext))
    req.Header.Set("IV", hex.EncodeToString(iv))
    req.Header.Set("HMAC", mac)

    resp, _ := client.Do(req)
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

func main() {
    // サーバー起動
    go func() {
        http.HandleFunc("/", serverHandler)
        http.ListenAndServe(":8080", nil)
    }()

    // クライアントリクエスト
    clientRequest("Secure API Communication")
}