mirror of
https://github.com/BaaRai/ARTEX.git
synced 2026-11-20 15:11:01 +08:00
fix(auth): keep the JWT signing key in a dedicated volume
The server wrote jwt.key to the executable's directory, /app in the image, so it lived in the container's writable layer and every container rebuild generated a new key and signed all users out. - ARTEX_JWT_KEY_DIR selects the key directory (default: config.BaseDir(), unchanged for non-Docker installs). docker-compose.yml sets it to /app/keys and bind-mounts ./keys there; the Dockerfile declares the volume. The key stays out of data/, which the file manager browses. - loadOrCreateJWTKey creates the directory (0700). When keyDir/jwt.key is missing it migrates dataDir/jwt.key, then BaseDir()/jwt.key (mode 0600, old file removed), otherwise generates a new key. An existing key is never overwritten; a short one is now a startup error. - .gitignore and .dockerignore exclude keys/. - README and CHANGELOG updated; the 0.5.0 known issue is removed.
This commit is contained in:
+88
-18
@@ -16,6 +16,8 @@ import (
|
||||
|
||||
"github.com/golang-jwt/jwt/v5"
|
||||
"golang.org/x/crypto/bcrypt"
|
||||
|
||||
"github.com/Autumn-27/artex/config"
|
||||
)
|
||||
|
||||
const (
|
||||
@@ -47,28 +49,38 @@ func validatePassword(pw string) string {
|
||||
return ""
|
||||
}
|
||||
|
||||
// jwtLegacyBaseDir is the second legacy key location (the executable's directory,
|
||||
// where releases before ARTEX_JWT_KEY_DIR wrote the key). A var so tests can point it
|
||||
// at a temp dir.
|
||||
var jwtLegacyBaseDir = config.BaseDir
|
||||
|
||||
// loadOrCreateJWTKey reads the 32-byte signing key from keyDir/jwt.key. keyDir is
|
||||
// the project base dir (next to the executable), NOT the browsable workspace root
|
||||
// (dataDir) — the signing key must never be listable/downloadable via the file
|
||||
// manager. Legacy installs kept it at dataDir/jwt.key; if present there and not yet
|
||||
// at the new location, it is migrated (key preserved, so sessions stay valid) and
|
||||
// the old file removed so it disappears from the workspace. On first run a random
|
||||
// key is generated and persisted.
|
||||
// ARTEX_JWT_KEY_DIR (the /app/keys volume in Docker) or the project base dir, NOT
|
||||
// the browsable workspace root (dataDir) — the signing key must never be
|
||||
// listable/downloadable via the file manager. When keyDir/jwt.key is missing, a key
|
||||
// at dataDir/jwt.key, then at BaseDir()/jwt.key, is migrated (key preserved, so
|
||||
// sessions stay valid) and the old file removed. Otherwise a random key is
|
||||
// generated. An existing key file is never overwritten.
|
||||
func loadOrCreateJWTKey(keyDir, dataDir string) ([]byte, error) {
|
||||
if err := os.MkdirAll(keyDir, 0o700); err != nil {
|
||||
return nil, fmt.Errorf("create jwt key dir: %w", err)
|
||||
}
|
||||
path := filepath.Join(keyDir, jwtKeyFilename)
|
||||
// one-time migration out of the old in-workspace location.
|
||||
if legacy := filepath.Join(dataDir, jwtKeyFilename); legacy != path {
|
||||
if _, err := os.Stat(path); os.IsNotExist(err) {
|
||||
if data, rerr := os.ReadFile(legacy); rerr == nil {
|
||||
if werr := os.WriteFile(path, data, 0o600); werr == nil {
|
||||
_ = os.Remove(legacy)
|
||||
log.Printf("[auth] JWT key migrated from %s to %s (moved out of the browsable workspace)", legacy, path)
|
||||
}
|
||||
}
|
||||
if _, err := os.Stat(path); os.IsNotExist(err) {
|
||||
if err := migrateJWTKey(path, dataDir); err != nil {
|
||||
return nil, err
|
||||
}
|
||||
}
|
||||
if data, err := os.ReadFile(path); err == nil && len(strings.TrimSpace(string(data))) >= 32 {
|
||||
return []byte(strings.TrimSpace(string(data))), nil
|
||||
data, err := os.ReadFile(path)
|
||||
if err == nil {
|
||||
key := strings.TrimSpace(string(data))
|
||||
if len(key) < 32 {
|
||||
return nil, fmt.Errorf("jwt key %s is shorter than 32 bytes; fix or remove it (it is never overwritten)", path)
|
||||
}
|
||||
return []byte(key), nil
|
||||
}
|
||||
if !os.IsNotExist(err) {
|
||||
return nil, fmt.Errorf("read jwt key: %w", err)
|
||||
}
|
||||
buf := make([]byte, 32)
|
||||
for i := range buf {
|
||||
@@ -78,13 +90,71 @@ func loadOrCreateJWTKey(keyDir, dataDir string) ([]byte, error) {
|
||||
}
|
||||
buf[i] = keyChars[n.Int64()]
|
||||
}
|
||||
if err := os.WriteFile(path, buf, 0600); err != nil {
|
||||
if err := writeNewJWTKey(path, buf); err != nil {
|
||||
return nil, fmt.Errorf("write jwt key: %w", err)
|
||||
}
|
||||
log.Printf("[auth] new JWT key written to %s", path)
|
||||
return buf, nil
|
||||
}
|
||||
|
||||
// migrateJWTKey copies the first legacy key found (dataDir, then BaseDir) to dst
|
||||
// and removes the old file. Candidates equal to dst are skipped.
|
||||
func migrateJWTKey(dst, dataDir string) error {
|
||||
for _, src := range []string{
|
||||
filepath.Join(dataDir, jwtKeyFilename),
|
||||
filepath.Join(jwtLegacyBaseDir(), jwtKeyFilename),
|
||||
} {
|
||||
if samePath(src, dst) {
|
||||
continue
|
||||
}
|
||||
data, err := os.ReadFile(src)
|
||||
if os.IsNotExist(err) {
|
||||
continue
|
||||
}
|
||||
if err != nil {
|
||||
log.Printf("[auth] cannot read legacy JWT key %s: %v", src, err)
|
||||
continue
|
||||
}
|
||||
if err := writeNewJWTKey(dst, data); err != nil {
|
||||
return fmt.Errorf("migrate jwt key from %s: %w", src, err)
|
||||
}
|
||||
if err := os.Remove(src); err != nil {
|
||||
log.Printf("[auth] JWT key copied to %s but the old file %s could not be removed: %v", dst, src, err)
|
||||
}
|
||||
log.Printf("[auth] JWT key migrated from %s to %s", src, dst)
|
||||
return nil
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
// writeNewJWTKey creates path with mode 0600, failing if it already exists.
|
||||
func writeNewJWTKey(path string, data []byte) error {
|
||||
f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o600)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
if _, err := f.Write(data); err != nil {
|
||||
f.Close()
|
||||
_ = os.Remove(path)
|
||||
return err
|
||||
}
|
||||
if err := f.Close(); err != nil {
|
||||
_ = os.Remove(path)
|
||||
return err
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func samePath(a, b string) bool {
|
||||
if absA, err := filepath.Abs(a); err == nil {
|
||||
a = absA
|
||||
}
|
||||
if absB, err := filepath.Abs(b); err == nil {
|
||||
b = absB
|
||||
}
|
||||
return a == b
|
||||
}
|
||||
|
||||
// signJWT issues a 7-day HS256 token for user ARTEX.
|
||||
func signJWT(key []byte) (string, error) {
|
||||
return jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.RegisteredClaims{
|
||||
|
||||
@@ -3,10 +3,188 @@ package server
|
||||
import (
|
||||
"encoding/json"
|
||||
"net/http/httptest"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"strings"
|
||||
"testing"
|
||||
)
|
||||
|
||||
// jwtKeyDirs returns fresh key, data and legacy base dirs and points
|
||||
// jwtLegacyBaseDir at the latter for the duration of the test. keyDir does not
|
||||
// exist yet, so loadOrCreateJWTKey has to create it.
|
||||
func jwtKeyDirs(t *testing.T) (keyDir, dataDir, baseDir string) {
|
||||
t.Helper()
|
||||
root := t.TempDir()
|
||||
keyDir = filepath.Join(root, "keys")
|
||||
dataDir = filepath.Join(root, "data")
|
||||
baseDir = filepath.Join(root, "base")
|
||||
for _, d := range []string{dataDir, baseDir} {
|
||||
if err := os.MkdirAll(d, 0o755); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
old := jwtLegacyBaseDir
|
||||
jwtLegacyBaseDir = func() string { return baseDir }
|
||||
t.Cleanup(func() { jwtLegacyBaseDir = old })
|
||||
return keyDir, dataDir, baseDir
|
||||
}
|
||||
|
||||
// assertKeyFileMode checks for 0600. Windows has no Unix permission bits (Go
|
||||
// reports 0666 or 0444), so the check is skipped there.
|
||||
func assertKeyFileMode(t *testing.T, path string) {
|
||||
t.Helper()
|
||||
fi, err := os.Stat(path)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if runtime.GOOS == "windows" {
|
||||
t.Logf("mode check skipped on windows (got %v)", fi.Mode().Perm())
|
||||
return
|
||||
}
|
||||
if got := fi.Mode().Perm(); got != 0o600 {
|
||||
t.Fatalf("%s mode=%v want 0600", path, got)
|
||||
}
|
||||
}
|
||||
|
||||
func assertMissing(t *testing.T, path string) {
|
||||
t.Helper()
|
||||
if _, err := os.Stat(path); !os.IsNotExist(err) {
|
||||
t.Fatalf("%s should not exist (stat err=%v)", path, err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadOrCreateJWTKeyMigrates(t *testing.T) {
|
||||
const legacyKey = "legacy-key-0123456789abcdefghijkl"
|
||||
for _, src := range []string{"data", "base"} {
|
||||
t.Run(src, func(t *testing.T) {
|
||||
keyDir, dataDir, baseDir := jwtKeyDirs(t)
|
||||
legacy := filepath.Join(dataDir, jwtKeyFilename)
|
||||
if src == "base" {
|
||||
legacy = filepath.Join(baseDir, jwtKeyFilename)
|
||||
}
|
||||
if err := os.WriteFile(legacy, []byte(legacyKey+"\n"), 0o644); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
|
||||
key, err := loadOrCreateJWTKey(keyDir, dataDir)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if string(key) != legacyKey {
|
||||
t.Fatalf("key=%q want the migrated %q", key, legacyKey)
|
||||
}
|
||||
path := filepath.Join(keyDir, jwtKeyFilename)
|
||||
data, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if string(data) != legacyKey+"\n" {
|
||||
t.Fatalf("migrated file content=%q, want the legacy bytes unchanged", data)
|
||||
}
|
||||
assertKeyFileMode(t, path)
|
||||
assertMissing(t, legacy)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadOrCreateJWTKeyMigratesDataDirFirst(t *testing.T) {
|
||||
keyDir, dataDir, baseDir := jwtKeyDirs(t)
|
||||
dataKey := "data-key-0123456789abcdefghijklmn"
|
||||
baseKey := "base-key-0123456789abcdefghijklmn"
|
||||
if err := os.WriteFile(filepath.Join(dataDir, jwtKeyFilename), []byte(dataKey), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if err := os.WriteFile(filepath.Join(baseDir, jwtKeyFilename), []byte(baseKey), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
key, err := loadOrCreateJWTKey(keyDir, dataDir)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if string(key) != dataKey {
|
||||
t.Fatalf("key=%q want the dataDir key", key)
|
||||
}
|
||||
assertMissing(t, filepath.Join(dataDir, jwtKeyFilename))
|
||||
}
|
||||
|
||||
func TestLoadOrCreateJWTKeyGenerates(t *testing.T) {
|
||||
keyDir, dataDir, _ := jwtKeyDirs(t)
|
||||
key, err := loadOrCreateJWTKey(keyDir, dataDir)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(key) != 32 {
|
||||
t.Fatalf("len(key)=%d want 32", len(key))
|
||||
}
|
||||
path := filepath.Join(keyDir, jwtKeyFilename)
|
||||
data, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if len(data) != 32 || string(data) != string(key) {
|
||||
t.Fatalf("file holds %d bytes, want the 32 returned", len(data))
|
||||
}
|
||||
assertKeyFileMode(t, path)
|
||||
assertMissing(t, filepath.Join(dataDir, jwtKeyFilename))
|
||||
|
||||
again, err := loadOrCreateJWTKey(keyDir, dataDir)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if string(again) != string(key) {
|
||||
t.Fatal("second load returned a different key")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLoadOrCreateJWTKeyNeverOverwrites(t *testing.T) {
|
||||
keyDir, dataDir, baseDir := jwtKeyDirs(t)
|
||||
if err := os.MkdirAll(keyDir, 0o700); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
path := filepath.Join(keyDir, jwtKeyFilename)
|
||||
current := "current-key-0123456789abcdefghijk"
|
||||
if err := os.WriteFile(path, []byte(current), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
// legacy keys must not replace the current one, and are left alone.
|
||||
legacyData := filepath.Join(dataDir, jwtKeyFilename)
|
||||
legacyBase := filepath.Join(baseDir, jwtKeyFilename)
|
||||
for _, p := range []string{legacyData, legacyBase} {
|
||||
if err := os.WriteFile(p, []byte("legacy-key-0123456789abcdefghijkl"), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
key, err := loadOrCreateJWTKey(keyDir, dataDir)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if string(key) != current {
|
||||
t.Fatalf("key=%q want the existing %q", key, current)
|
||||
}
|
||||
for _, p := range []string{legacyData, legacyBase} {
|
||||
if _, err := os.Stat(p); err != nil {
|
||||
t.Fatalf("legacy key %s should be untouched: %v", p, err)
|
||||
}
|
||||
}
|
||||
|
||||
// a short (invalid) key is an error, not a reason to replace it.
|
||||
short := "too-short"
|
||||
if err := os.WriteFile(path, []byte(short), 0o600); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if _, err := loadOrCreateJWTKey(keyDir, dataDir); err == nil {
|
||||
t.Fatal("want an error for a short key")
|
||||
}
|
||||
data, err := os.ReadFile(path)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if string(data) != short {
|
||||
t.Fatalf("short key was overwritten with %d bytes", len(data))
|
||||
}
|
||||
}
|
||||
|
||||
// GetSetting distinguishes "key absent" from "read failed" only through its error:
|
||||
// both return an empty value. If a password handler mistakes the error for "no
|
||||
// password set yet", a database blip opens the init door — authInit would let an
|
||||
|
||||
+1
-1
@@ -44,7 +44,7 @@ type Server struct {
|
||||
ctx context.Context
|
||||
|
||||
skillDir string // root directory for skill subdirectories
|
||||
jwtKey []byte // HS256 signing key loaded from / generated into dataDir/jwt.key
|
||||
jwtKey []byte // HS256 signing key loaded from / generated into keyDir/jwt.key
|
||||
|
||||
scrubSecrets bool // drop ARTEX_PG_DSN and the API keys from the environment once read (binary only)
|
||||
|
||||
|
||||
Reference in New Issue
Block a user