認可ライブラリCasbinでABACを実装してみる。


# はじめに
認可専用のライブラリである[Casbin](https://casbin.org/)を使って、[ABAC](https://en.wikipedia.org/wiki/Attribute-based_access_control)を実装してみる。Casbinでは、単純にルールを羅列するのではなく、[eval()という組み込み関数](https://casbin.org/ja/docs/abac#scaling-the-model-for-complex-and-large-numbers-of-abac-rules)を使用することで、任意の認可ロジックを簡潔に組み込むことができる。なお、CasbinそのものやRBAC/ABAC等の認可の概念に関する説明は本記事ではしない。

eval()では、[公式ドキュメントの例](https://casbin.org/ja/docs/abac/#scaling-the-model-for-complex-and-large-numbers-of-abac-rules)のように直接ロジックを渡すこともできるし、[`AddFunction`というAPI](https://casbin.org/ja/docs/management-api#addfunction)を使ってGoで記述した任意の関数を登録し、それをポリシー内で呼び出すこともできる。今回は後者の方法を使い、DBへのアクセスが必要な権限管理のロジック、という想定で実装してみる。

# 実装するシナリオ
今回は、病院で使用するシステムを想定し、「自分が担当している患者のデータにのみアクセスできる」という要件を実装する。

# 実装
## モデルの定義
`model.conf`ファイルにモデルを定義する。

```shell
[request_definition]
r = user, obj, method

[policy_definition]
p = path, method, rule

[policy_effect]
e = some(where (p.eft == allow))

[matchers]
m = keyMatch5(r.obj.Path, p.path) && (r.method == p.method || p.method == "*") && eval(p.rule)
```

## ポリシー
`policy.csv`にポリシーを記述する。

```csv
p, /patient/{patient_id}/record, *, "is_assigned_patient(r.user.ID, r.obj.ID)"
```

## APIと認可用ミドルウェア
```go
package main

import (
	"fmt"
	"net/http"
	"strconv"

	"github.com/casbin/casbin/v2"
	"github.com/labstack/echo/v4"
)

var enforcer *casbin.Enforcer

func main() {
	e := echo.New()

	var err error
	enforcer, err = casbin.NewEnforcer("model.conf", "policy.csv")
	if err != nil {
		panic(err)
	}

	enforcer.EnableLog(true)

	// 任意の関数をCasbinに登録する
	enforcer.AddFunction("is_assigned_patient", func(args ...interface{}) (interface{}, error) {
		// NOTE: Casbinは文字列型のみ対応している https://github.com/casbin/casbin/issues/113
		doctorIDStr, ok := args[0].(string)
		if !ok {
			return false, fmt.Errorf("failed to get doctorID from casbin policy")
		}

		patientIDStr, ok := args[1].(string)
		if !ok {
			return false, fmt.Errorf("failed to get patientID from casbin policy")
		}

		doctorID, err := strconv.ParseUint(doctorIDStr, 10, 64)
		if err != nil {
			return false, fmt.Errorf("failed to parse doctorID: %w", err)
		}

		patientID, err := strconv.ParseUint(patientIDStr, 10, 64)
		if err != nil {
			return false, fmt.Errorf("failed to parse patientID: %w", err)
		}

        // DBから、リクエストを送った医者が担当している患者かどうかを取得する(今回はモック)
		return isPatientAssignedToDoctor(int(doctorID), int(patientID)), nil
	})

	e.Use(authorize)
	e.GET("/patient/:patient_id/record", func(c echo.Context) error {
		return c.String(http.StatusOK, "Access Allowed\n\n")
	})
	e.Logger.Fatal(e.Start(":1323"))
}

type User struct {
	ID int
}

type Object struct {
	ID   int
	Path string
}

// 認可をミドルウェアで実施する
func authorize(next echo.HandlerFunc) echo.HandlerFunc {
	return func(c echo.Context) error {
		path := c.Request().URL.Path
		method := c.Request().Method

		userIDStr := c.QueryParam("user_id")
		userID, err := strconv.Atoi(userIDStr)
		if err != nil {
			return echo.NewHTTPError(http.StatusBadRequest, err.Error())
		}

		objectIDStr := c.Param("patient_id")
		objectID, err := strconv.Atoi(objectIDStr)
		if err != nil {
			return echo.NewHTTPError(http.StatusBadRequest, err.Error())
		}

		obj := Object{ID: objectID, Path: path}

		ok, err := enforcer.Enforce(User{ID: userID}, obj, method)
		if err != nil {
			return echo.NewHTTPError(http.StatusInternalServerError, err.Error())
		}
		if ok {
			return next(c)
		}
		return c.String(http.StatusForbidden, "Access denied\n\n")
	}
}

func isPatientAssignedToDoctor(doctorID int, patientID int) bool {
	if doctorID == 1 && patientID == 1 {
		return true
	}
	return false
}
```

注意点として、[CasbinのポリシーはString型にしか対応していない](https://github.com/casbin/casbin/issues/113)。文字列型以外を渡すと正しく判定できないことがあるので注意が必要。

# 動作確認
```shell
// 自分が担当している患者の情報は取得できる
$ curl 'http://localhost:1323/patient/1/record?user_id=1'
Access Allowed

// 自分が担当していない患者の情報は取得できない
$ curl 'http://localhost:1323/patient/2/record?user_id=1'
Access denied
```

# 参考文献
- https://casbin.org/ja/docs/abac
- https://future-architect.github.io/articles/20221004a/

GolangとCasbinでABACを実装する

Goのforループで同一アドレスに値が格納される挙動と、それがクロージャに与える影響についての概要と解決策


# 3行で
- Golang1.21まででは、ループ変数は同じアドレスに値が格納される。
- そのため、ループ内でクロージャを定義して呼び出す等の特定のケースで、全てのループで毎回同じ値になることがある。
- これは、ループ内で変数を定義し直すのが1.21までの標準的な解決策。[1.22で修正される予定](https://github.com/golang/go/wiki/LoopvarExperiment)らしい。[1.21でもexperimentalで使える](https://github.com/golang/go/discussions/56010)。

# Go1.21までの仕様と発生しうる問題
以下のコード例で、iの値とアドレスが表示されるが、Go1.21までの挙動では全てのイテレーションでiのアドレスが同じである。これがクロージャを使用した際に問題を引き起こす。

```go
package main

import "fmt"

func main() {
    for i := 0; i < 3; i++ {
        fmt.Printf("iの値: %d, iのアドレス: %p\n", i, &i)
    }
}
```
https://go.dev/play/p/5X09tR5MNec

```shell
iの値: 0, iのアドレス: 0xc000012028
iの値: 1, iのアドレス: 0xc000012028
iの値: 2, iのアドレス: 0xc000012028

Program exited.
```

そのため、ループ内でクロージャを定義して呼び出す等のケースでは、全てのループで毎回同じ値になってしまう。これは気づきにくいバグの原因になりがちだと思う。

```go
package main

import "fmt"

func main() {
	var funcs []func()

	for i := 0; i < 3; i++ {
		funcs = append(funcs, func() {
			fmt.Println(i)
		})
	}

	for _, f := range funcs {
		f()
	}
}
```
https://go.dev/play/p/hn-5RCih2yP

```shell
3
3
3

Program exited.
```

# その他同様の問題が発生しうるケース
クロージャだけでなく、goroutineやt.parallelを使用する場合にも同様の問題が生じ得る。これらの状況でも変数のスコープには注意が必要である。

# 対応策
この問題[Goのバージョン1.22で修正されることが予定](https://github.com/golang/go/wiki/LoopvarExperiment)されている。それまでは、イテレーションごとにループ変数をローカル変数に代入し直すことで問題を解決できる。

```go
package main

import "fmt"

func main() {
	var funcs []func()

	for i := 0; i < 3; i++ {
		i := i // ここで i のコピーを作成する
		funcs = append(funcs, func() {
			fmt.Println(i)
		})
	}

	for _, f := range funcs {
		f()
	}
}
```
https://go.dev/play/p/JSWkYlucoZs


```shell
0
1
2

Program exited.
```

# 参考
- [【Go 1.21】ループ変数が共有される問題への対策（プレビュー）が公開されました](https://moneyforward-dev.jp/entry/2023/08/15/150000)
- [Go Wiki LoopvarExperiment](https://github.com/golang/go/wiki/LoopvarExperiment)

Golangのループ内でクロージャを定義して使用する場合の注意点

Golangで、プロジェクト内で独自に定めたコーディング規約が遵守されていることを確認する


## 概要

チームやプロジェクトで独自に定めたコーディング規約が遵守されていることを確認するために、OPA・Regoを使ってコードを検査する。Golangでの実装を想定している。

## 仕組み

まず、検査対象のコードをASTに変換する。ASTは、抽象構文木のことで、コードの構造を表現したデータ構造のこと。ASTを使うことで、コードの構造をプログラムで扱えるようになる。
Regoで記述したコーディング規約をポリシーとして、ASTをインプットとしてOPAに渡すことで、コーディング規約に違反している箇所を検出することができる。

## goast

上記を簡単に実現するために、[goast](https://github.com/m-mizutani/goast)というツールを使用する。goastはユーザが定義したポリシーをもとに上記をまとめて行ってくれる。出力した結果に`pos`という名前でPos値を渡すことで、出力に違反しているコードを表示することもできる。

```rego
res := {
    "msg": "fmt.Println is not allowed",
    "pos": input.Node.X.Fun.X.NamePos,
    "sev": "ERROR"
}
```

## 実装
goastを使って以下のようなルールを記述してみる。

### 1. メソッドのレシーバは1文字とする
- 検査対象のGoコード(main.go)
```go
package main

func main() {}

type Test struct{}

func (t Test) Valid() {}

func (tt Test) Invalid() {}
```

- ポリシー(policy.rego)
```rego
# メソッドのレシーバ名は1文字とする
fail[res] {
    input.Kind == "FuncDecl"
    input.Node.Recv != null
    count(input.Node.Recv.List[x].Names[y].Name) != 1

    res := {
        "msg": "method receiver name should be 1 character",
        "pos": input.Node.Recv.List[x].Names[y].NamePos,
        "sev": "ERROR"
    }
}
```

- 実行結果
```shell
$ goast eval -p ./policy.rego main.go
[main.go:9] - method receiver name should be 1 character

func (tt Test) Invalid() {}
      ~~~~~~~~~~~~~~~~~~~~~


        Detected 1 violations
```

- テスト(policy_test.rego)をテーブル駆動テスト風に記述してみる

```rego
package goast

test_policy {
    not _test_policy
}

_test_policy {
    testCases := [
        {
            "name": "レシーバがない",
            "wantErr": false,
            "data": {
                  "Path": "main.go",
                  "FileName": "main.go",
                  "DirName": ".",
                  "Node": {
                    "Doc": null,
                    "Recv": null,
                    "Name": {
                      "NamePos": 20,
                      "Name": "main",
                      "Obj": null
                    },
                    "Type": {
                      "Func": 15,
                      "TypeParams": null,
                      "Params": {
                        "Opening": 24,
                        "List": [],
                        "Closing": 25
                      },
                      "Results": null
                    },
                    "Body": {
                      "Lbrace": 27,
                      "List": [],
                      "Rbrace": 28
                    }
                  },
                  "Kind": "FuncDecl"
            }
        },
        {
            "name": "レシーバが1文字",
            "wantErr": false,
            "data": {
                  "Path": "main.go",
                  "FileName": "main.go",
                  "DirName": ".",
                  "Node": {
                    "Doc": null,
                    "Recv": {
                      "Opening": 56,
                      "List": [
                        {
                          "Doc": null,
                          "Names": [
                            {
                              "NamePos": 57,
                              "Name": "t",
                              "Obj": null
                            }
                          ],
                          "Type": {
                            "NamePos": 59,
                            "Name": "Test",
                            "Obj": null
                          },
                          "Tag": null,
                          "Comment": null
                        }
                      ],
                      "Closing": 63
                    },
                    "Name": {
                      "NamePos": 65,
                      "Name": "Valid",
                      "Obj": null
                    },
                    "Type": {
                      "Func": 51,
                      "TypeParams": null,
                      "Params": {
                        "Opening": 70,
                        "List": [],
                        "Closing": 71
                      },
                      "Results": null
                    },
                    "Body": {
                      "Lbrace": 73,
                      "List": [],
                      "Rbrace": 74
                    }
                  },
                  "Kind": "FuncDecl"
            }
        },
        {
            "name": "レシーバが2文字",
            "wantErr": true,
            "data": {
                  "Path": "main.go",
                  "FileName": "main.go",
                  "DirName": ".",
                  "Node": {
                    "Doc": null,
                    "Recv": {
                      "Opening": 106,
                      "List": [
                        {
                          "Doc": null,
                          "Names": [
                            {
                              "NamePos": 107,
                              "Name": "tt",
                              "Obj": null
                            }
                          ],
                          "Type": {
                            "NamePos": 110,
                            "Name": "Test",
                            "Obj": null
                          },
                          "Tag": null,
                          "Comment": null
                        }
                      ],
                      "Closing": 114
                    },
                    "Name": {
                      "NamePos": 116,
                      "Name": "Invalid",
                      "Obj": null
                    },
                    "Type": {
                      "Func": 101,
                      "TypeParams": null,
                      "Params": {
                        "Opening": 123,
                        "List": [],
                        "Closing": 124
                      },
                      "Results": null
                    },
                    "Body": {
                      "Lbrace": 126,
                      "List": [],
                      "Rbrace": 127
                    }
                  },
                  "Kind": "FuncDecl"
            }
        }
    ]

    tc := testCases[_]
    out := fail with input as tc.data
    tc.wantErr != (count(out) > 0)
}
```

実行
```shell
$ opa test -v .
policy_test.rego:
data.goast.test_policy: PASS (687.958µs)
--------------------------------------------------------------------------------
PASS: 1/1
```

### 2. Publicな関数にはコメントをつける
- Goコード
```go
package main

func main() {}

// Valid is valid
func Valid()   {}
func valid()   {}
func Invalid() {}
```

- ポリシー
```rego
# Publicな関数にはコメントをつける
fail[res] {
    input.Kind == "FuncDecl"
    is_uppercase(substring(input.Node.Name.Name, 0, 1))
    input.Node.Doc == null

    res := {
        "msg": "public function should have comment",
        "pos": input.Node.Name.NamePos,
        "sev": "ERROR"
    }
}

is_uppercase(str) {
    str == upper(str)
}
```

- 実行
```shell
goast eval -p ./policy.rego main.go
[main.go:8] - public function should have comment

func Invalid() {}
     ~~~~~~~~~~~~


        Detected 1 violations
```

### 3. handler pkg以外がhttp pkgに依存することを禁止する
- ディレクトリ構成
```shell
internal
├── handler
│   └── handler.go
└── service
    └── service.go

3 directories, 2 files
```

- handler.go
```go
package handler

import "net/http"

func handler() {
	_, _ = http.Get("http://example.com/")
}
```

- service.go
```go
package service

import "net/http"

func service() {
	_, _ = http.Get("http://example.com/")
}
```

- ポリシー
```rego
# handler pkg以外がhttp pkgに依存することを禁止する
fail[res] {
    input.Kind == "File"
    input.DirName != "internal/handler"
    input.Node.Imports[x].Path.Value == "\"net/http\""

    res := {
        "msg": "handler pkg should not depend on http pkg",
        "pos": input.Node.Imports[x].Path.ValuePos,
        "sev": "ERROR"
    }
}
```

- 実行結果
```shell
$ goast eval -p ./policy.rego internal
[internal/service/service.go:3] - handler pkg should not depend on http pkg

import "net/http"
       ~~~~~~~~~~


        Detected 1 violations
```

## 参考

- https://zenn.dev/mizutani/articles/go-static-analysis-with-rego
- https://zenn.dev/mizutani/articles/go-static-analysis-with-rego-ex
- https://pkg.go.dev/go/ast

OPA・Regoでコーディング規約が守られている事を検査する

Go標準の構造化ロガーライブラリ、slogの使い方


# slog
[Go1.21](https://tip.golang.org/doc/go1.21)で構造化ロガー[slog](https://pkg.go.dev/golang.org/x/exp/slog)が標準ライブラリとして追加された。1.20以前にもlogパッケージは存在したが、テキストでしか出力できず、ログレベルの設定等もできなかった。そのためZap等のサードパーティライブラリを使用する事が多かった。
slogは構造化ログとログレベルを提供する。

## 基本的な使い方
ごく簡単に使うことができる。
```go
slog.Info("hello", "count", 3)
```
出力は以下。
```go
2022/11/08 15:28:26 INFO hello count=3
```

## アーキテクチャ
[![Image from Gyazo](https://i.gyazo.com/211e1610903895836e0d6ac0da81bebe.png)](https://gyazo.com/211e1610903895836e0d6ac0da81bebe)
- Logger: ロガーのフロントエンド。ログ出力のためのメソッドを提供する。呼び出しの度にRecordを作成する。
- Record: RecordはHandlerに渡されて出力される。
- Handler: ロガーのバックエンド。出力形式や出力先などを制御する。

## JSON形式で出力する
JSONHandlerを使用することで、JSON形式でログを出力できる。
```go
logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
logger.Info("hello", "count", 3)
```

```go
{"time":"2022-11-08T15:28:26.000000000-05:00","level":"INFO","msg":"hello","count":3}
```

## ログレベルのカスタマイズ
slogのログレベルはデフォルトでDebug,Info,Warn,Errorの4種類定義されている。
```go
type Level int

const (
LevelDebug Level = -4
LevelInfo  Level = 0
LevelWarn  Level = 4
LevelError Level = 8
)
```

Levelはint型で-4から4刻みで定義されているので、独自のレベルを定義してフィルタすることもできる。
```go
const LevelFatal = slog.Level(12)
logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
    Level: LevelFatal,
}))
logger.Log(context.Background(), LevelFatal, "test")
```

ただし、上記だと以下のようにログレベルがいい感じに表示されない。

```go
{"time":"2023-09-24T02:31:00.353259+09:00","level":"ERROR+4","msg":"test"}
```

独自に定義したログレベル名を表示するには以下のようにする。
```go
logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
    ReplaceAttr: func(groups []string, a slog.Attr) slog.Attr {
        // NOTE: slogにログレベル`FATAL`を追加
        if a.Key != slog.LevelKey {
            return a
        }
        if level := a.Value.Any().(slog.Level); level == LevelFatal.ToSlogLevel() {
            a.Value = slog.StringValue("FATAL")
        }
        return a
    },
}))
```

# 参考
- [プロポーザル](https://go.googlesource.com/proposal/+/master/design/56345-structured-logging.md)
- [A consistent logging format for Go](https://www.youtube.com/watch?v=gd_Vyb5vEw0)
- [Goの新しい構造化ロガーを体験しよう](https://gihyo.jp/article/2023/02/tukinami-go-04)
- [Go 1.21連載始まります＆slogをどう使うべきか ](https://future-architect.github.io/articles/20230731a/)
- [Go1.21 log/slogパッケージ超入門](https://zenn.dev/88888888_kota/articles/7e97ff874083cf)

slogの使い方


# 概要
gocsvで生成するCSVのすべてのセルをダブルクォーテーションで囲みたかった。
[ネットで見つけた記事](https://qiita.com/developer-kikikaikai/items/af278f52cb06cc0f430d)とは別パターンの実装をしてみた。

# 実装

## 方針
ネットで見つけた記事では、生成したCSVをデコードして、各セルをダブルクォーテーションで囲った後、もう一度エンコードしている。

自分は、以下の方法で実装してみた。
gocsvでは、デフォルトでは内部でencoding/csvのWriter構造体を使用している。そこで、
1. gocsvのCSVWriterインターフェイスを実装する構造体を作成する
2. ↑で作成した構造体に、encoding/csvのWriterの実装を参考に、すべてのセルをダブルクォーテーションで囲むWriteメソッドを生やす
3. ↑をgocsvのMarshalCSVメソッドに渡す

### [gocsvのCSVWriterインターフェイス](https://github.com/gocarina/gocsv/blob/ad3251f9fa25/safe_csv.go#L9)

```go
type CSVWriter interface {
	Write(row []string) error
	Flush()
	Error() error
}
```

### ↑を実装するカスタム構造体

```go
type customCSVWriter struct {
	w *bufio.Writer
}

func NewCustomCSVWriter(w io.Writer) gocsv.CSVWriter {
	return &customCSVWriter{
		w: bufio.NewWriter(w),
	}
}

// Write writes すべてのセルをダブルクォーテーションで囲んだCSV
// encoding/csvのWriteメソッド(https://cs.opensource.google/go/go/+/refs/tags/go1.19.2:src/encoding/csv/writer.go;l=48)を一部改修したもの
// 違いは以下
// 1. すべてのセルをダブルクォーテーションで囲む
// 2. 区切り文字は`,`固定
// 3. 改行文字に`\r\n`を使用するオプションは無効
func (w *customCSVWriter) Write(record []string) error {
	for n, field := range record {
		if n > 0 {
			if _, err := w.w.WriteRune(','); err != nil {
				return err
			}
		}

		if err := w.w.WriteByte('"'); err != nil {
			return err
		}
		for len(field) > 0 {
			// Search for special characters.
			i := strings.IndexAny(field, "\"\r\n")
			if i < 0 {
				i = len(field)
			}

			// Copy verbatim everything before the special character.
			if _, err := w.w.WriteString(field[:i]); err != nil {
				return err
			}
			field = field[i:]

			// Encode the special character.
			if len(field) > 0 {
				var err error
				switch field[0] {
				case '"':
					_, err = w.w.WriteString(`""`)
        case '\r':
          err = w.w.WriteByte('\r')
				case '\n':
          err = w.w.WriteByte('\n')
				}
				field = field[1:]
				if err != nil {
					return err
				}
			}
		}
		if err := w.w.WriteByte('"'); err != nil {
			return err
		}
	}

	err := w.w.WriteByte('\n')
	return err
}

func (w *customCSVWriter) Flush() {
	w.w.Flush()
}

func (w *customCSVWriter) Error() error {
	_, err := w.w.Write(nil)
	return err
}

```

### ↑を呼び出すコード
```go
buffer := bytes.Buffer{}
csvWriter := NewCustomCSVWriter(&buffer)
err := gocsv.MarshalCSV(&(CSVにしたい構造体など), csvWriter)
```


# 参考
- [gocsv](https://github.com/gocarina/gocsv)
- [ネットで見つけた記事](https://qiita.com/developer-kikikaikai/items/af278f52cb06cc0f430d)


masatora.net