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:
BaaRai
2026-11-04 09:18:11 +01:00
parent fc35dddee8
commit 65bdc5d73c
11 changed files with 300 additions and 27 deletions
+88 -18
View File
@@ -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{
+178
View File
@@ -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
View File
@@ -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)