第20章 セキュリティ

セキュアなデータの取り扱い

パスワードの安全なハッシュ化や機密データの暗号化は、セキュリティを保つために不可欠です。

package main

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

func hashPassword(password string) (string, error) {
    bytes, err := bcrypt.GenerateFromPassword([]byte(password), 14)
    return string(bytes), err
}

func main() {
    password := "myPassword123"
    hash, err := hashPassword(password)
    if err != nil {
        panic(err)
    }
    fmt.Println("Hashed password:", hash)
}

このコードでは、bcryptライブラリを使用してパスワードをハッシュ化しています。

セキュリティのベストプラクティス

セキュリティヘッダの使用や入力データの検証は、アプリケーションのセキュリティを向上させます。

package main

import (
    "net/http"
)

func secureHeaders(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("X-XSS-Protection", "1; mode=block")
        w.Header().Set("X-Frame-Options", "deny")
        next.ServeHTTP(w, r)
    })
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Hello, World!"))
    })

    http.ListenAndServe(":8080", secureHeaders(mux))
}

このコードは、HTTPレスポンスにセキュリティヘッダを追加するミドルウェア関数を定義しています。

HTTPSの使用

HTTPSは、安全な通信を確立するために不可欠です。

package main

import (
    "log"
    "net/http"
)

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Hello, secure world!"))
    })

    log.Println("Starting HTTPS server on :443")
    err := http.ListenAndServeTLS(":443", "server.crt", "server.key", mux)
    if err != nil {
        log.Fatal(err)
    }
}

このコードでは、ListenAndServeTLS関数を使用してHTTPSサーバーを起動しています。server.crtとserver.keyはそれぞれSSL証明書ファイルと秘密鍵ファイルです。

入力の検証とサニタイズ

ユーザーからの入力は常に不正なコンテンツを含む可能性があるため、信頼してはいけません。データベースクエリに動的に組み込む前に入力を検証・サニタイズする必要があります。

package main

import (
    "fmt"
    "net/http"
    "text/template"
)

func formHandler(w http.ResponseWriter, r *http.Request) {
    if err := r.ParseForm(); err != nil {
        fmt.Fprintf(w, "ParseForm() error: %v", err)
        return
    }
    name := r.FormValue("name")
    // ユーザー入力のサニタイズ
    // ここでサニタイズロジックを実装...
    fmt.Fprintf(w, "Hello, %s!", template.HTMLEscapeString(name))
}

func main() {
    http.HandleFunc("/form", formHandler)
    http.ListenAndServe(":8080", nil)
}

認証と認可の基本概念

認証（Authentication）と認可（Authorization）はセキュリティの基本的な概念であり、WebアプリケーションやAPIの安全性を確保するために不可欠です。以下に、これらの概念をGo言語を使用して説明します。

認証の基本概念

認証は、ユーザーが自分の主張する身元（例えば、ユーザー名やメールアドレス）が正しいことを証明するプロセスです。最も一般的な方法は、ユーザー名とパスワードによる認証です。

Go言語でのHTTPサーバーに基本認証を実装する例です。

package main

import (
    "net/http"
)

// 認証用のユーザー名とパスワード
const Username = "admin"
const Password = "password"

// BasicAuthMiddleware は基本認証を行うミドルウェア関数です。
func BasicAuthMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        user, pass, ok := r.BasicAuth()
        if !ok || user != Username || pass != Password {
            w.Header().Set("WWW-Authenticate", `Basic realm="restricted", charset="UTF-8"`)
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }
        next.ServeHTTP(w, r)
    })
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Hello, World!"))
    })

    wrappedMux := BasicAuthMiddleware(mux)

    http.ListenAndServe(":8080", wrappedMux)
}

このコードでは、BasicAuthMiddleware関数が基本認証を行い、認証されたリクエストのみが処理されます。

認可の基本概念

認可は、認証されたユーザーがアクセスを試みるリソースに対して、どのような操作（例えば、読み取り、書き込み）を許可されているかを決定するプロセスです。

Go言語での簡易的なロールベースのアクセス制御の例です。

package main

import (
    "net/http"
)

// UserRole はユーザーのロールを表します。
var UserRole = "admin"

// CheckRoleMiddleware はユーザーのロールに基づいてアクセス制御を行います。
func CheckRoleMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        if UserRole != "admin" {
            http.Error(w, "Forbidden", http.StatusForbidden)
            return
        }
        next.ServeHTTP(w, r)
    })
}

func main() {
    mux := http.NewServeMux()
    mux.HandleFunc("/admin", func(w http.ResponseWriter, r *http.Request) {
        w.Write([]byte("Welcome, Admin"))
    })

    wrappedMux := CheckRoleMiddleware(mux)

    http.ListenAndServe(":8080", wrappedMux)
}

このコードでは、/adminエンドポイントへのアクセスがadminロールのユーザーにのみ許可されます。

JWT認証

Go言語での認証実装には、多くの方法がありますが、ここではJWT（JSON Web Tokens）を用いた認証システムの構築を例にとって説明します。JWTは、状態をサーバー側で持たずにユーザー認証を行うことができるため、RESTful APIなどでよく使用されます。

JWT認証の基本

JWT認証では、ユーザーがログインすると、サーバーはユーザーの識別情報を含むJWTを生成し、これをクライアントに返します。クライアントはこのJWTを保持しておき、以後のリクエストにJWTを添付してサーバーに送信します。サーバーはJWTを検証し、リクエストが有効であることを確認した上で、要求された操作を実行します。

JWT認証システムの構築例

以下の例では、JWTを生成・検証する簡単な認証システムを構築します。まず、JWTを扱うためにgithub.com/dgrijalva/jwt-goパッケージを使用します。

go get -u github.com/dgrijalva/jwt-go

JWT生成と検証の関数

package main

import (
    "fmt"
    "time"
    "github.com/dgrijalva/jwt-go"
)

var mySigningKey = []byte("secret")

// GenerateJWT は新しいJWTトークンを生成します。
func GenerateJWT() (string, error) {
    token := jwt.New(jwt.SigningMethodHS256)
    claims := token.Claims.(jwt.MapClaims)

    claims["authorized"] = true
    claims["user"] = "John Doe"
    claims["exp"] = time.Now().Add(time.Minute * 30).Unix()

    tokenString, err := token.SignedString(mySigningKey)

    if err != nil {
        fmt.Errorf("Something Went Wrong: %s", err.Error())
        return "", err
    }

    return tokenString, nil
}

// IsAuthorized はJWTトークンを検証します。
func IsAuthorized(tokenString string) (bool, error) {
    token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
        if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
            return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"])
        }
        return mySigningKey, nil
    })

    if err != nil {
        return false, err
    }

    if claims, ok := token.Claims.(jwt.MapClaims); ok && token.Valid {
        fmt.Println(claims["user"])
        return true, nil
    } else {
        return false, err
    }
}

JWTを用いた認証の例

package main

import (
    "fmt"
    "net/http"
)

func handleLogin(w http.ResponseWriter, r *http.Request) {
    tokenString, err := GenerateJWT()
    if err != nil {
        fmt.Fprintf(w, "Error Generating JWT")
        return
    }
    fmt.Fprintf(w, tokenString)
}

func handleProtected(w http.ResponseWriter, r *http.Request) {
    tokenString := r.Header.Get("Authorization")
    isValid, err := IsAuthorized(tokenString)
    if err != nil || !isValid {
        fmt.Fprintf(w, "Not Authorized")
        return
    }
    fmt.Fprintf(w, "Hello, Protected Area")
}

func main() {
    http.HandleFunc("/login", handleLogin)
    http.HandleFunc("/protected", handleProtected)

    fmt.Println("Starting server on :8080")
    http.ListenAndServe(":8080", nil)
}

この例では、/loginエンドポイントにアクセスするとJWTが生成され、それを使って/protectedエンドポイントにアクセスする際の認証に使用します。これにより、Go言語での認証システムの基本的な構造を理解することができます。

ロールベースのアクセス制御

認可（Authorization）は、認証済みのユーザーがアプリケーション内の特定のリソースや操作にアクセスできるかどうかを管理するプロセスです。ロールベースのアクセス制御（RBAC）は認可を実装する一般的な方法の一つであり、ユーザーにロールを割り当て、それぞれのロールに特定のアクセス権を与えることで動作します。以下に、Go言語を使用して簡単なRBACを実装する例を示します。

ロールベースのアクセス制御（RBAC）の実装例

この例では、adminとuserの2つのロールを想定し、それぞれのロールに応じて異なるアクセス権を設定します。

package main

import (
    "fmt"
    "net/http"
)

// UserRoleMap は各ユーザーのロールを格納します。
var UserRoleMap = map[string]string{
    "john": "admin",
    "jane": "user",
}

// RolePermissions は各ロールの許可されたアクションを格納します。
var RolePermissions = map[string][]string{
    "admin": {"create", "read", "update", "delete"},
    "user":  {"read"},
}

// CheckPermission は特定のユーザーがアクションを実行できるかどうかをチェックします。
func CheckPermission(userName string, action string) bool {
    role := UserRoleMap[userName]
    permissions := RolePermissions[role]
    for _, a := range permissions {
        if a == action {
            return true
        }
    }
    return false
}

// ProtectedHandler は保護されたリソースへのリクエストを処理します。
func ProtectedHandler(w http.ResponseWriter, r *http.Request) {
    userName := r.URL.Query().Get("user")
    action := r.URL.Query().Get("action")

    if CheckPermission(userName, action) {
        fmt.Fprintf(w, "Access granted for %s to %s", userName, action)
    } else {
        fmt.Fprintf(w, "Access denied for %s to %s", userName, action)
    }
}

func main() {
    http.HandleFunc("/protected", ProtectedHandler)
    fmt.Println("Server is running on port 8080...")
    http.ListenAndServe(":8080", nil)
}

この例では、各ユーザーにロールが割り当てられ、ProtectedHandler関数を通じて特定のアクションを実行しようとしたときに認可チェックが行われます。クエリパラメータでユーザー名（user）と実行しようとしているアクション（action）を指定することで、アクセス制御のデモンストレーションが可能です。

練習問題1.

Go言語を使用して、ユーザーから入力されたパスワードをハッシュ化し、それを安全に保存するプログラムを書いてください。また、保存されたハッシュ値とユーザーからの再入力パスワードを検証する機能も実装してください。

練習問題2.

Go言語を使用して、HTTPSプロトコルを用いた簡単なWebサーバーを構築してください。このサーバーは、ブラウザから安全な接続を介してアクセスできる必要があります。

練習問題3.

Go言語と任意のSQLデータベースを使用して、ユーザー入力に基づくデータベースクエリを実行する簡単なアプリケーションを作成してください。この際、SQLインジェクション攻撃を防ぐための対策を講じること。