Files
pipelines/internal/server/webauth_hash.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

149 lines
4.5 KiB
Go

package server
import (
"crypto/sha256"
"crypto/subtle"
"encoding/base64"
"encoding/json"
"errors"
"fmt"
"io"
"os"
"path/filepath"
"strconv"
"strings"
)
// The web sign-in password file (web-auth.json) is written by the installer,
// ./password and the web proxy. This server only reads it, to verify step-up
// re-authentication against the same password the operator signs in with.
//
// password_hash is "scrypt$N$r$p$<salt>$<key>" with unpadded base64url salt and
// key; a file not yet migrated by the proxy still holds a plaintext
// "password", which is compared in constant time through SHA-256 digests.
// webAuthMaxBytes bounds the file read; real files are a few hundred bytes.
const webAuthMaxBytes = 64 << 10
// DefaultWebAuthFile is where the installer keeps the web sign-in password.
func DefaultWebAuthFile() string {
if explicit := os.Getenv("PIPELINES_WEB_AUTH_FILE"); explicit != "" {
return explicit
}
home, err := os.UserHomeDir()
if err != nil {
return ""
}
return filepath.Join(home, ".config", "pipelines", "web-auth.json")
}
type webAuthVerifier struct {
hash string
password string
}
var errWebAuthMissing = errors.New("no web sign-in password file")
// readWebAuth loads the verifier from path. A missing file is
// errWebAuthMissing; anything unsafe or malformed is another error, and the
// caller then fails closed.
func readWebAuth(path string) (webAuthVerifier, error) {
info, err := os.Lstat(path)
if errors.Is(err, os.ErrNotExist) {
return webAuthVerifier{}, errWebAuthMissing
}
if err != nil {
return webAuthVerifier{}, err
}
if !info.Mode().IsRegular() {
return webAuthVerifier{}, errors.New("web sign-in password file is not a regular file")
}
if info.Mode().Perm()&0o077 != 0 {
return webAuthVerifier{}, errors.New("web sign-in password file is not private (chmod 600)")
}
if !ownedByCurrentUser(info) {
return webAuthVerifier{}, errors.New("web sign-in password file belongs to another user")
}
file, err := os.Open(path)
if err != nil {
return webAuthVerifier{}, err
}
defer file.Close()
body, err := io.ReadAll(io.LimitReader(file, webAuthMaxBytes+1))
if err != nil {
return webAuthVerifier{}, err
}
if len(body) > webAuthMaxBytes {
return webAuthVerifier{}, errors.New("web sign-in password file is too large")
}
var parsed struct {
PasswordHash string `json:"password_hash"`
Password string `json:"password"`
}
if err := json.Unmarshal(body, &parsed); err != nil {
return webAuthVerifier{}, errors.New("web sign-in password file is malformed")
}
if parsed.PasswordHash != "" {
if _, err := parseScryptHash(parsed.PasswordHash); err != nil {
return webAuthVerifier{}, err
}
return webAuthVerifier{hash: parsed.PasswordHash}, nil
}
if len(parsed.Password) >= 8 {
return webAuthVerifier{password: parsed.Password}, nil
}
return webAuthVerifier{}, errors.New("web sign-in password file has no password")
}
type scryptHash struct {
n, r, p int
salt, key []byte
}
func parseScryptHash(value string) (scryptHash, error) {
invalid := errors.New("web sign-in password hash is malformed")
parts := strings.Split(value, "$")
if len(parts) != 6 || parts[0] != "scrypt" {
return scryptHash{}, invalid
}
var numbers [3]int
for i, limit := range [3]int{1 << 20, 32, 16} {
number, err := strconv.Atoi(parts[i+1])
if err != nil || number < 1 || number > limit {
return scryptHash{}, invalid
}
numbers[i] = number
}
salt, err := base64.RawURLEncoding.DecodeString(parts[4])
if err != nil || len(salt) < 8 {
return scryptHash{}, invalid
}
key, err := base64.RawURLEncoding.DecodeString(parts[5])
if err != nil || len(key) < 16 || len(key) > 64 {
return scryptHash{}, invalid
}
if numbers[0] < 2 || numbers[0]&(numbers[0]-1) != 0 {
return scryptHash{}, invalid
}
return scryptHash{n: numbers[0], r: numbers[1], p: numbers[2], salt: salt, key: key}, nil
}
// verify reports whether candidate is the stored password, in constant time
// with respect to the candidate's content.
func (v webAuthVerifier) verify(candidate string) (bool, error) {
if v.hash == "" {
given := sha256.Sum256([]byte(candidate))
want := sha256.Sum256([]byte(v.password))
return subtle.ConstantTimeCompare(given[:], want[:]) == 1 && v.password != "", nil
}
parsed, err := parseScryptHash(v.hash)
if err != nil {
return false, err
}
derived, err := scryptKey([]byte(candidate), parsed.salt, parsed.n, parsed.r, parsed.p, len(parsed.key))
if err != nil {
return false, fmt.Errorf("verify password: %w", err)
}
return subtle.ConstantTimeCompare(derived, parsed.key) == 1, nil
}