Security & Compliance

Event History เก็บ ทุก input และ output ของ workflow กับ activity ไว้ถาวรตลอด retention และเปิดดูได้จาก Web UI ถ้าใครสักคนเผลอส่งเลขบัตรเข้าไปเป็น argument มันจะนอนอยู่ในนั้นเป็นเดือนโดยที่ไม่มีใครรู้

บทนี้ว่าด้วยการปิดช่องเหล่านั้น

ข้อมูลของเราไปอยู่ที่ไหนบ้าง#

System map

Payload Codec — เข้ารหัส history#

Codec ทำงานเป็นชั้นห่อ data converter: encode ก่อนส่งออกไป server, decode ตอนรับกลับมา Server จึงเห็นแค่ byte ที่อ่านไม่ออก

const encodingEncrypted = "binary/encrypted"

type Codec struct {
	keyID string
	aead  cipher.AEAD // AES-256-GCM
}

func (c *Codec) Encode(payloads []*commonpb.Payload) ([]*commonpb.Payload, error) {
	result := make([]*commonpb.Payload, len(payloads))
	for i, p := range payloads {
		plain, err := p.Marshal()
		if err != nil {
			return payloads, err
		}

		nonce := make([]byte, c.aead.NonceSize())
		if _, err := rand.Read(nonce); err != nil {
			return payloads, err
		}
		sealed := c.aead.Seal(nonce, nonce, plain, nil)

		result[i] = &commonpb.Payload{
			Metadata: map[string][]byte{
				converter.MetadataEncoding: []byte(encodingEncrypted),
				// เก็บ key ID ไว้ด้วย เพื่อให้ rotate key แล้วยังถอดของเก่าได้
				"encryption-key-id": []byte(c.keyID),
			},
			Data: sealed,
		}
	}
	return result, nil
}

func (c *Codec) Decode(payloads []*commonpb.Payload) ([]*commonpb.Payload, error) {
	result := make([]*commonpb.Payload, len(payloads))
	for i, p := range payloads {
		if string(p.Metadata[converter.MetadataEncoding]) != encodingEncrypted {
			result[i] = p // ไม่ได้เข้ารหัสไว้ ปล่อยผ่าน
			continue
		}

		aead, err := c.aeadForKey(string(p.Metadata["encryption-key-id"]))
		if err != nil {
			return payloads, err
		}

		nonceSize := aead.NonceSize()
		if len(p.Data) < nonceSize {
			return payloads, fmt.Errorf("ciphertext too short")
		}
		plain, err := aead.Open(nil, p.Data[:nonceSize], p.Data[nonceSize:], nil)
		if err != nil {
			return payloads, err
		}

		result[i] = &commonpb.Payload{}
		if err := result[i].Unmarshal(plain); err != nil {
			return payloads, err
		}
	}
	return result, nil
}

ต่อเข้ากับ client — ต้องตั้งค่าเดียวกันทั้งฝั่ง client และ worker ไม่งั้นถอดรหัสไม่ออก

dataConverter := converter.NewCodecDataConverter(
	converter.GetDefaultDataConverter(),
	codec,
)

c, err := client.Dial(client.Options{
	HostPort:      os.Getenv("TEMPORAL_ADDRESS"),
	Namespace:     "wallet-prod",
	DataConverter: dataConverter,
})

Codec Server — ให้ ops อ่าน history ได้#

พอเข้ารหัสแล้ว Web UI จะแสดงเป็น byte อ่านไม่ออก ซึ่งทำให้ ops ทำงานไม่ได้ ทางแก้คือ Codec Server: HTTP service ในเครือข่ายเราที่มี endpoint /encode และ /decode Web UI จะเรียกไปถอดรหัสให้ตอนแสดงผล — ตัว key ไม่เคยออกจากเครือข่ายเรา

func main() {
	handler := converter.NewPayloadCodecHTTPHandler(codec)

	mux := http.NewServeMux()
	mux.Handle("/", withAuth(handler)) // ต้องมีการยืนยันตัวตน ห้ามเปิดโล่ง

	_ = http.ListenAndServe("127.0.0.1:8081", mux)
}

ความปลอดภัยของการเชื่อมต่อ#

Temporal Cloud ด้วย API key#

c, err := client.Dial(client.Options{
	HostPort:  "<namespace>.<account>.tmprl.cloud:7233",
	Namespace: "wallet-prod.<account>",
	Credentials: client.NewAPIKeyStaticCredentials(os.Getenv("TEMPORAL_API_KEY")),
	ConnectionOptions: client.ConnectionOptions{
		TLS: &tls.Config{MinVersion: tls.VersionTLS12},
	},
})

Temporal Cloud ด้วย mTLS#

cert, err := tls.LoadX509KeyPair(
	os.Getenv("TEMPORAL_TLS_CERT"),
	os.Getenv("TEMPORAL_TLS_KEY"),
)
if err != nil {
	return err
}

c, err := client.Dial(client.Options{
	HostPort:  "<namespace>.<account>.tmprl.cloud:7233",
	Namespace: "wallet-prod.<account>",
	ConnectionOptions: client.ConnectionOptions{
		TLS: &tls.Config{
			Certificates: []tls.Certificate{cert},
			MinVersion:   tls.VersionTLS12,
		},
	},
})

Namespace isolation#

Namespace เป็นขอบเขตแยกที่แข็งแรงที่สุดใน Temporal — workflow ข้าม namespace มองไม่เห็นกัน มี retention แยก และให้สิทธิ์แยกได้

temporal operator namespace create \
  --namespace wallet-prod \
  --retention 30d

temporal operator namespace describe --namespace wallet-prod

แนวทางที่ใช้กันในระบบการเงิน:

แนวปฏิบัติในการออกแบบ payload#

หลักการเดียวที่ต้องจำ: workflow ควรรู้จักข้อมูลอ่อนไหวให้น้อยที่สุด

// อย่าทำ — ข้อมูลบัตรเข้าไปอยู่ใน history ตลอด retention
type TopUpRequest struct {
	CardNumber string
	CVV        string
	HolderName string
	NationalID string
}

// ทำแบบนี้ — workflow เห็นแค่ token ที่ใช้แทนกันได้
type TopUpRequest struct {
	TransactionID  string // idempotency key
	WalletID       string // ตัวระบุภายใน ไม่สื่อตัวตน
	PaymentToken   string // token จาก payment vault ใช้ได้ครั้งเดียว
	AmountSatang   int64
	CardLast4      string // เท่าที่จำเป็นต่อการแสดงผลและ support
}

Activity เป็นที่เดียวที่ควรแตะข้อมูลจริง เพราะเนื้อในของ activity ไม่ถูกบันทึกลง history มีแต่ input กับ output เท่านั้น — ดึงข้อมูลจริงจาก vault ในนั้น ใช้ แล้วคืนเฉพาะผลลัพธ์ที่ปลอดภัย

func (a *Activities) ChargeCard(ctx context.Context, req TopUpRequest) (string, error) {
	// ดึงข้อมูลจริงในนี้ — ไม่ไหลออกไปเป็น input/output ของ workflow
	card, err := a.Vault.Resolve(ctx, req.PaymentToken)
	if err != nil {
		return "", err
	}
	defer card.Zeroize()

	ref, err := a.Bank.Charge(ctx, card, req.AmountSatang, req.TransactionID)
	if err != nil {
		// ระวัง error จากระบบปลายทางที่อาจแนบข้อมูลกลับมา — อย่าส่งต่อดิบๆ
		return "", fmt.Errorf("charge failed: %w", sanitize(err))
	}
	return ref, nil // คืนแค่ reference
}

ตารางเชื่อมโยงกับข้อกำหนด#

ตารางนี้ช่วยจัดระเบียบการคุยกับทีม compliance — ไม่ใช่ข้อสรุปว่าทำแล้วผ่าน

Checklist ด้านความปลอดภัย#

• Payload Codec เปิดใช้บนทุก environment ที่มีข้อมูลจริง และตั้งค่าตรงกันทั้ง client/worker
• กุญแจมาจาก KMS มีแผน rotation และ payload เก็บ key ID ไว้ถอดของเก่าได้
• Codec Server มี authentication, authorization และ audit log และไม่เปิดออกอินเทอร์เน็ต
• Workflow ID ไม่มีข้อมูลส่วนบุคคล
• Search Attributes ไม่มีข้อมูลส่วนบุคคล (ย้ำ: ไม่ผ่าน codec)
• ข้อความ error ถูก sanitize ก่อนคืนออกจาก activity
• ไม่มีข้อมูลบัตรเต็มใน input/output ของ workflow — ใช้ token เท่านั้น
• แยก namespace ระหว่าง environment เป็นอย่างน้อย
• Credential ไม่อยู่ใน repo และแยกตาม environment
• มี alert เมื่อ certificate ใกล้หมดอายุ
• Retention ของแต่ละ namespace ถูกตั้งตามที่ตกลงกับทีม compliance