Auth0 で Workload Identity 連携

Client ID と Client Secret は、 Application の Settings > Basic Information から取得します。

app/internal/constants/constants.go
1
package constants
2

3
...
4

5
const (
6
    AUTH_URL = "https://app.jp.auth0.com/"
7
    PORT     = "3000"
8
)
9

10
var (
11
    AUTH0_CLIENT_ID     = os.Getenv("AUTH0_CLIENT_ID")
12
    AUTH0_CLIENT_SECRET = os.Getenv("AUTH0_CLIENT_SECRET")
13
    AUTH0_CALLBACK_URL  = fmt.Sprintf("http://localhost:%s/callback", PORT)
14
)

OAuth2 & OpenID Connect クライアントを返す関数と、ID トークンを検証する関数を定義します。

app/internal/auth/authenticator/authenticator.go
1
package authenticator
2

3
import (
4
    "context"
5
    "fmt"
6
    "app/internal/constants"
7

8
    "github.com/coreos/go-oidc/v3/oidc"
9
    "golang.org/x/oauth2"
10
)
11

12
// Authenticator is used to authenticate our users.
13
type Authenticator struct {
14
    *oidc.Provider
15
    oauth2.Config
16
}
17

18
// New instantiates the *Authenticator.
19
func New() (*Authenticator, error) {
20
    provider, err := oidc.NewProvider(context.Background(), constants.AUTH_URL)
21
    if err != nil {
22
        return nil, fmt.Errorf("Authenticator.New: %w", err)
23
    }
24

25
    conf := oauth2.Config{
26
        ClientID:     constants.AUTH0_CLIENT_ID,
27
        ClientSecret: constants.AUTH0_CLIENT_SECRET,
28
        RedirectURL:  constants.AUTH0_CALLBACK_URL,
29
        Endpoint:     provider.Endpoint(),
30
        Scopes:       []string{oidc.ScopeOpenID},
31
    }
32

33
    return &Authenticator{
34
        Provider: provider,
35
        Config:   conf,
36
    }, nil
37
}
38

39
// VerifyIDToken verifies that an *oauth2.Token is a valid *oidc.IDToken.
40
func (a *Authenticator) VerifyIDToken(ctx context.Context, rawIDToken string) (*oidc.IDToken, error) {
41
    oidcConfig := &oidc.Config{
42
        ClientID: a.ClientID,
43
    }
44

45
    return a.Verifier(oidcConfig).Verify(ctx, rawIDToken)
46
}

認証用にサーバを立て、認証が終わったらサーバを閉じるという処理を書きます。

サーバの起動を goroutine で実行し、認証の完了を待ちます。

認証が完了した後に、サーバを閉じます。

app/internal/auth/server/server.go
1
package server
2

3
import (
4
    "context"
5
    "fmt"
6
    "net/http"
7
    "app/internal/auth/authenticator"
8
    "app/internal/auth/handler"
9
    "app/internal/constants"
10
    "time"
11

12
    "github.com/gorilla/sessions"
13
    "github.com/labstack/echo-contrib/session"
14
    "github.com/labstack/echo/v4"
15
    "github.com/labstack/gommon/log"
16
)
17

18
func RunServer(auth *authenticator.Authenticator) {
19
    authenticated := make(chan bool, 1)
20

21
    // Setup
22
    e := echo.New()
23

24
    e.HideBanner = true
25
    e.HidePort = true
26

27
    loginURL := fmt.Sprintf("http://localhost:%s", constants.PORT)
28
    fmt.Printf("➡️ Visit \x1b[4m%s\x1b[m to authenticate.\n", loginURL)
29

30
    e.Use(session.Middleware(sessions.NewCookieStore([]byte("secret"))))
31

32
    e.GET("/", handler.HandleLogin(auth))
33
    e.GET("/callback", handler.HandleCallback(auth, authenticated))
34

35
    // Start server
36
    addr := fmt.Sprintf(":%s", constants.PORT)
37
    go func() {
38
        if err := e.Start(addr); err != nil && err != http.ErrServerClosed {
39
            e.Logger.Fatal(err)
40
        }
41
        e.Logger.Info("shutting down the server")
42
    }()
43

44
    // Wait for authentication completion
45
    <-authenticated
46

47
    // Shutdown the server
48
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
49
    defer cancel()
50
    if err := e.Shutdown(ctx); err != nil {
51
        e.Logger.Fatal(err)
52
    }
53
}

ログイン URL にアクセスしたときの処理を書きます。

ここでは、state という値をセッションに保存し、 Auth0 の認証 URL にリダイレクトします。

state はランダムな文字列で、 Callback URL に戻ったときに同じ値が渡されることをチェックします。

app/internal/auth/handler/login.go
1
package handler
2

3
import (
4
    "crypto/rand"
5
    "encoding/base64"
6
    "fmt"
7
    "net/http"
8
    "app/internal/auth/authenticator"
9

10
    "github.com/labstack/echo-contrib/session"
11
    "github.com/labstack/echo/v4"
12
)
13

14
func HandleLogin(auth *authenticator.Authenticator) echo.HandlerFunc {
15
    return func(c echo.Context) error {
16
        state, err := generateRandomState()
17
        if err != nil {
18
            return c.String(http.StatusInternalServerError, err.Error())
19
        }
20

21
        // Save the state inside the session.
22
        sess, err := session.Get("state", c)
23
        if err != nil {
24
            return c.String(http.StatusInternalServerError, err.Error())
25
        }
26

27
        sess.Values["state"] = state
28
        if err := sess.Save(c.Request(), c.Response()); err != nil {
29
            return c.String(http.StatusInternalServerError, err.Error())
30
        }
31

32
        return c.Redirect(http.StatusTemporaryRedirect, auth.AuthCodeURL(state))
33
    }
34
}
35

36
func generateRandomState() (string, error) {
37
    b := make([]byte, 32)
38
    _, err := rand.Read(b)
39
    if err != nil {
40
        return "", fmt.Errorf("generateRandomState: %w", err)
41
    }
42

43
    state := base64.StdEncoding.EncodeToString(b)
44

45
    return state, nil
46
}

このエンドポイント (localhost:3000) にアクセスすると、 Auth0 の認証画面が表示されます。

ここで使用する認証方法 (パスワードレス認証、多要素認証など) は Auth0 のダッシュボードから設定できます。

Auth0 の画面での認証が成功すると、 Callback URL にリダイレクトします。

Callback URL にアクセスしたときの処理を書きます。

ここでは state と ID トークンの検証を行ったあとに、ID トークンをファイルに保存します。

また、認証が完了したことを channel に通知します。

app/internal/auth/handler/callback.go
1
package handler
2

3
import (
4
    "net/http"
5
    "app/internal/auth/authenticator"
6
    "app/internal/auth/token"
7
    "app/internal/constants"
8

9
    "github.com/labstack/echo-contrib/session"
10
    "github.com/labstack/echo/v4"
11
)
12

13
func HandleCallback(auth *authenticator.Authenticator, authenticated chan<- bool) echo.HandlerFunc {
14
    return func(c echo.Context) error {
15
        sess, err := session.Get("state", c)
16
        if err != nil {
17
            return c.String(http.StatusInternalServerError, err.Error())
18
        }
19

20
        if c.QueryParam("state") != sess.Values["state"] {
21
            return c.String(http.StatusBadRequest, "Invalid state parameter.")
22
        }
23

24
        // Exchange an authorization code for a token.
25
        tk, err := auth.Exchange(c.Request().Context(), c.QueryParam("code"))
26
        if err != nil {
27
            return c.String(http.StatusUnauthorized, "Failed to exchange an authorization code for a token.")
28
        }
29

30
        rawIDToken, ok := tk.Extra("id_token").(string)
31
        if !ok {
32
            return c.String(http.StatusBadRequest, "No id_token field in oauth2 token.")
33
        }
34

35
        _, err = auth.VerifyIDToken(c.Request().Context(), rawIDToken)
36
        if err != nil {
37
            return c.String(http.StatusInternalServerError, "Failed to verify ID Token.")
38
        }
39

40
        if err := token.SaveTokenToFile(rawIDToken); err != nil {
41
            return c.String(http.StatusInternalServerError, "Failed to save access token.")
42
        }
43

44
        authenticated <- true
45

46
        return c.String(http.StatusOK, "Authentication succeeded!")
47
    }
48
}

注意点として、auth.Exchange によって得られた tk から tk.AccessToken を取得できるのですが、 これが JWE 形式のトークンで、 Cloud クライアントライブラリが使用するトークンの要件を満たさないため動作しません。

Cloud クライアントライブラリ用に使用するのは tk.Extra("id_token") から取得した ID トークンとなります。

ID トークンをファイルに保存したり削除したりする関数を定義します。

tokenFilePath のパスは、 GCP 側で設定する際に同じものを指定します。

app/internal/auth/token/token.go
1
package token
2

3
import (
4
    "fmt"
5
    "os"
6
)
7

8
const tokenFilePath = "./tmp/app-token"
9

10
func SaveTokenToFile(token string) error {
11
    f, err := os.Create(tokenFilePath)
12
    if err != nil {
13
        return fmt.Errorf("SaveTokenToFile: %w", err)
14
    }
15
    defer f.Close()
16

17
    _, err = f.WriteString(token)
18
    if err != nil {
19
        return fmt.Errorf("SaveTokenToFile: %w", err)
20
    }
21

22
    return nil
23
}
24

25
func WithToken(f func() error) error {
26
    if err := f(); err != nil {
27
        if rmErr := removeToken(); rmErr != nil {
28
            return fmt.Errorf("WithToken: %w\nWithToken: %w", err, rmErr)
29
        }
30
        return fmt.Errorf("WithToken: %w", err)
31
    }
32

33
    if err := removeToken(); err != nil {
34
        return fmt.Errorf("WithToken: %w", err)
35
    }
36

37
    return nil
38
}
39

40
func removeToken() error {
41
    if err := os.Remove(tokenFilePath); err != nil {
42
        return fmt.Errorf("removeToken: %w", err)
43
    }
44
    return nil
45
}