Files
pipelines/internal/server/elevation.go
T
alan f11ff8650d Require step-up password confirmation for shells, terminals and file changes
A new elevate request verifies the web sign-in password (scrypt hash, read-only,
rate-limited, constant time) and elevates that connection for 15 minutes.
chat_shell_run/input, rename/move/delete, terminal_open/input and POST /files
(via a per-connection upload token) are refused with code elevation_required
until then.
2026-11-10 01:21:15 +00:00

293 lines
8.0 KiB
Go

package server
import (
"crypto/rand"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"errors"
"fmt"
"log"
"sync"
"time"
"git.a-wan.net/alan/pipelines/internal/protocol"
)
// Step-up re-authentication (see internal/protocol/elevation.go). A web
// session is enough to read, but the requests below act as the operator's
// shell, so each connection must also confirm the sign-in password recently.
// The gate is on whenever the web sign-in password file exists; a server run
// without the web proxy (tests, a bare loopback server) has nothing to verify
// against and keeps its previous behaviour. A file that exists but cannot be
// read safely keeps the gate on and every elevate fails (fail closed).
// DefaultElevationTTL is how long one confirmation lasts on a connection.
const DefaultElevationTTL = 15 * time.Minute
// Elevation attempt limits: a connection waits elevationBackoffBase doubled
// for each consecutive wrong password (at most elevationBackoffMax), and the
// whole server refuses attempts after elevationGlobalFailures wrong passwords
// within elevationGlobalWindow.
const (
elevationBackoffBase = time.Second
elevationBackoffMax = time.Minute
elevationGlobalFailures = 10
elevationGlobalWindow = 5 * time.Minute
elevationTokenLimit = 256
)
var elevationGated = map[string]bool{
protocol.ChatShellRun: true,
protocol.ChatShellInput: true,
protocol.RenamePath: true,
protocol.MovePath: true,
protocol.DeletePath: true,
protocol.TerminalOpen: true,
protocol.TerminalInput: true,
}
type elevationGate struct {
authFile string
ttl time.Duration
now func() time.Time
// verify serializes scrypt work: one 32 MiB derivation at a time.
verify sync.Mutex
mu sync.Mutex
until map[string]time.Time // client -> elevation end
tokens map[string]elevationToken
failures map[string]elevationFailures
recent []time.Time // wrong passwords, server-wide, oldest first
reported bool
}
type elevationToken struct {
client string
until time.Time
}
type elevationFailures struct {
count int
until time.Time
}
func newElevationGate(authFile string, ttl time.Duration) *elevationGate {
if ttl <= 0 {
ttl = DefaultElevationTTL
}
return &elevationGate{
authFile: authFile,
ttl: ttl,
now: time.Now,
until: map[string]time.Time{},
tokens: map[string]elevationToken{},
failures: map[string]elevationFailures{},
}
}
// enabled reports whether gated requests need elevation.
func (g *elevationGate) enabled() bool {
if g == nil || g.authFile == "" {
return false
}
_, err := readWebAuth(g.authFile)
if errors.Is(err, errWebAuthMissing) {
return false
}
if err != nil {
g.mu.Lock()
if !g.reported {
log.Printf("elevation: web sign-in password file unusable, every elevate fails: %v", err)
g.reported = true
}
g.mu.Unlock()
}
return true
}
func (g *elevationGate) elevated(client string) bool {
g.mu.Lock()
defer g.mu.Unlock()
until, ok := g.until[client]
if ok && !g.now().Before(until) {
g.dropLocked(client)
return false
}
return ok
}
// allows reports whether client may perform a gated request now.
func (g *elevationGate) allows(client string) bool {
return g.elevated(client) || !g.enabled()
}
// refuse answers a gated request on a connection that is not elevated with a
// typed error and reports true; any other request passes (false).
func (g *elevationGate) refuse(request protocol.Message, client string, write func(protocol.Message) error) bool {
if !elevationGated[request.Type] || g.allows(client) {
return false
}
_ = write(protocol.Message{
Type: protocol.Error,
ID: request.ID,
Code: protocol.ErrorElevationRequired,
Error: "Confirm your password to run commands, change files or use a terminal on this machine.",
})
return true
}
// handle answers an elevate request and reports true; other requests pass.
func (g *elevationGate) handle(request protocol.Message, client string, write func(protocol.Message) error) bool {
if request.Type != protocol.Elevate {
return false
}
reply, err := g.elevate(client, request.Password)
if err != nil {
code := protocol.ErrorElevationFailed
if errors.Is(err, errWebAuthMissing) {
code = protocol.ErrorElevationUnavailable
}
_ = write(protocol.Message{Type: protocol.Error, ID: request.ID, Code: code, Error: err.Error()})
return true
}
_ = write(protocol.Message{Type: protocol.Elevated, ID: request.ID, Elevation: reply})
return true
}
func (g *elevationGate) elevate(client, password string) (*protocol.Elevation, error) {
if g == nil || g.authFile == "" {
return nil, fmt.Errorf("this server has no web sign-in password to confirm: %w", errWebAuthMissing)
}
if wait := g.blocked(client); wait > 0 {
return nil, fmt.Errorf("too many wrong passwords; try again in %d seconds", int((wait+time.Second-1)/time.Second))
}
verifier, err := readWebAuth(g.authFile)
if errors.Is(err, errWebAuthMissing) {
return nil, fmt.Errorf("this server has no web sign-in password to confirm: %w", err)
}
if err != nil {
log.Printf("elevation: web sign-in password file unusable: %v", err)
return nil, errors.New("the server's sign-in password file is unusable; see the server log")
}
g.verify.Lock()
ok, err := verifier.verify(password)
g.verify.Unlock()
if err != nil {
log.Printf("elevation: verify: %v", err)
return nil, errors.New("the password could not be checked; see the server log")
}
if !ok {
g.noteFailure(client)
return nil, errors.New("wrong password")
}
return g.grant(client)
}
func (g *elevationGate) blocked(client string) time.Duration {
g.mu.Lock()
defer g.mu.Unlock()
now := g.now()
g.pruneLocked(now)
if len(g.recent) >= elevationGlobalFailures {
return g.recent[0].Add(elevationGlobalWindow).Sub(now)
}
if entry, ok := g.failures[client]; ok && now.Before(entry.until) {
return entry.until.Sub(now)
}
return 0
}
func (g *elevationGate) pruneLocked(now time.Time) {
keep := 0
for keep < len(g.recent) && !now.Before(g.recent[keep].Add(elevationGlobalWindow)) {
keep++
}
g.recent = g.recent[keep:]
}
func (g *elevationGate) noteFailure(client string) {
g.mu.Lock()
defer g.mu.Unlock()
now := g.now()
g.recent = append(g.recent, now)
entry := g.failures[client]
entry.count++
delay := elevationBackoffBase << min(entry.count-1, 6)
entry.until = now.Add(min(delay, elevationBackoffMax))
g.failures[client] = entry
}
func (g *elevationGate) grant(client string) (*protocol.Elevation, error) {
raw := make([]byte, 32)
if _, err := rand.Read(raw); err != nil {
return nil, err
}
token := base64.RawURLEncoding.EncodeToString(raw)
g.mu.Lock()
defer g.mu.Unlock()
now := g.now()
until := now.Add(g.ttl)
g.dropLocked(client)
delete(g.failures, client)
for key, entry := range g.tokens {
if !now.Before(entry.until) {
delete(g.tokens, key)
}
}
if len(g.tokens) >= elevationTokenLimit {
return nil, errors.New("too many elevated connections on this server")
}
g.until[client] = until
g.tokens[tokenKey(token)] = elevationToken{client: client, until: until}
return &protocol.Elevation{
ExpiresAt: until.UTC().Format(time.RFC3339),
Seconds: int(g.ttl / time.Second),
Token: token,
}, nil
}
func tokenKey(token string) string {
sum := sha256.Sum256([]byte(token))
return hex.EncodeToString(sum[:])
}
// dropLocked ends client's elevation and its upload token.
func (g *elevationGate) dropLocked(client string) {
delete(g.until, client)
for key, entry := range g.tokens {
if entry.client == client {
delete(g.tokens, key)
}
}
}
// forget ends a closed connection's elevation and attempt history.
func (g *elevationGate) forget(client string) {
if g == nil {
return
}
g.mu.Lock()
defer g.mu.Unlock()
g.dropLocked(client)
delete(g.failures, client)
}
// tokenValid reports whether token belongs to a still elevated connection.
func (g *elevationGate) tokenValid(token string) bool {
if token == "" {
return false
}
g.mu.Lock()
defer g.mu.Unlock()
entry, ok := g.tokens[tokenKey(token)]
if !ok {
return false
}
if !g.now().Before(entry.until) {
g.dropLocked(entry.client)
return false
}
return true
}